Adding upstream version 2.9.0dev.12.upstream/2.9.0dev.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

103 files changed, 77384 insertions, 0 deletions

diff --git a/WWW/Library/Implementation/HTAABrow.c b/WWW/Library/Implementation/HTAABrow.c
new file mode 100644
index 0000000..c963acd
--- /dev/null
+++ b/WWW/Library/Implementation/HTAABrow.c
@@ -0,0 +1,1354 @@
+/*
+ * $LynxId: HTAABrow.c,v 1.43 2018/05/11 22:54:19 tom Exp $
+ *
+ * MODULE							HTAABrow.c
+ *		BROWSER SIDE ACCESS AUTHORIZATION MODULE
+ *
+ *	Contains the code for keeping track on server hostnames,
+ *	port numbers, scheme names, usernames, passwords
+ *	(and servers' public keys).
+ *
+ * IMPORTANT:
+ *	Routines in this module use dynamic allocation, but free
+ *	automatically all the memory reserved by them.
+ *
+ *	Therefore the caller never has to (and never should)
+ *	free() any object returned by these functions.
+ *
+ *	Therefore also all the strings returned by this package
+ *	are only valid until the next call to the same function
+ *	is made.  This approach is selected, because of the nature
+ *	of access authorization: no string returned by the package
+ *	needs to be valid longer than until the next call.
+ *
+ *	This also makes it easy to plug the AA package in:
+ *	you don't have to ponder whether to free() something
+ *	here or is it done somewhere else (because it is always
+ *	done somewhere else).
+ *
+ *	The strings that the package needs to store are copied
+ *	so the original strings given as parameters to AA
+ *	functions may be freed or modified with no side effects.
+ *
+ *	The AA package does not free() anything else than what
+ *	it has itself allocated.
+ *
+ * AUTHORS:
+ *	AL	Ari Luotonen	luotonen@dxcern.cern.ch
+ *
+ * HISTORY:
+ *	Oct 17	AL	Made corrections suggested by marca:
+ *			Added  if (!realm->username) return NULL;
+ *			Changed some ""s to NULLs.
+ *			Now doing calloc() to init uuencode source;
+ *			otherwise HTUU_encode() reads uninitialized memory
+ *			every now and then (not a real bug but not pretty).
+ *			Corrected the formula for uuencode destination size.
+ *
+ * 28 Apr 1997	AJL	Do Proxy Authorisation.
+ *
+ * BUGS:
+ *
+ *
+ */
+
+#include <HTUtils.h>
+#include <HTString.h>
+#include <HTParse.h>		/* URL parsing function         */
+#include <HTList.h>		/* HTList object                */
+#include <HTAlert.h>		/* HTConfirm(), HTPrompt()      */
+#include <HTAAUtil.h>		/* AA common to both sides      */
+#include <HTAssoc.h>		/* Assoc list                   */
+#include <HTAccess.h>		/* Are we using an HTTP gateway? */
+#include <HTAABrow.h>		/* Implemented here             */
+#include <HTUU.h>		/* Uuencoding and uudecoding    */
+
+#include <LYLeaks.h>
+
+/*
+ *  Local datatype definitions
+ *
+ *  HTAAServer contains all the information about one server.
+ */
+typedef struct {
+
+    char *hostname;		/* Host's name                  */
+    int portnumber;		/* Port number                  */
+    BOOL IsProxy;		/* Is it a proxy?               */
+    HTList *setups;		/* List of protection setups 
+				   on this server; i.e., valid
+				   authentication schemes and
+				   templates when to use them.
+				   This is actually a list of
+				   HTAASetup objects.           */
+    HTList *realms;		/* Information about passwords  */
+} HTAAServer;
+
+/*
+ *  HTAASetup contains information about one server's one
+ *  protected tree of documents.
+ */
+typedef struct {
+    HTAAServer *server;		/* Which server serves this tree             */
+    char *ctemplate;		/* Template for this tree                    */
+    HTList *valid_schemes;	/* Valid authentic.schemes                   */
+    HTAssocList **scheme_specifics;	/* Scheme specific params                  */
+    BOOL retry;			/* Failed last time -- reprompt (or whatever) */
+} HTAASetup;
+
+/*
+ *  Information about usernames and passwords in
+ *  Basic and Pubkey authentication schemes;
+ */
+typedef struct {
+    char *realmname;		/* Password domain name         */
+    char *username;		/* Username in that domain      */
+    char *password;		/* Corresponding password       */
+} HTAARealm;
+
+/*
+ *  To free off all globals. - FM
+ */
+static void free_HTAAGlobals(void);
+static BOOL free_HTAAGlobalsSet = FALSE;
+static char *HTAA_composeAuthResult = NULL;
+static char *compose_auth_stringResult = NULL;	/* Uuencoded presentation */
+
+/*
+ *  Module-wide global variables
+ */
+static HTList *server_table = NULL;	/* Browser's info about servers      */
+static char *secret_key = NULL;	/* Browser's latest secret key       */
+static HTAASetup *current_setup = NULL;		/* The server setup we are currently */
+
+					/* talking to                        */
+static char *current_hostname = NULL;	/* The server's name and portnumber  */
+static int current_portnumber = 80;	/* where we are currently trying to  */
+
+					/* connect.                          */
+static char *current_docname = NULL;	/* The document's name we are        */
+
+					/* trying to access.                 */
+static char *HTAAForwardAuth = NULL;	/* Authorization: line to forward    */
+
+					/* (used by gateway httpds)          */
+static HTAASetup *proxy_setup = NULL;	/* Same as above, but for Proxy -AJL */
+static char *proxy_hostname = NULL;
+static char *proxy_docname = NULL;
+static int proxy_portnumber = 80;
+
+/*** HTAAForwardAuth for enabling gateway-httpds to forward Authorization ***/
+
+void HTAAForwardAuth_set(const char *scheme_name,
+			 const char *scheme_specifics)
+{
+    size_t len = (20
+		  + (scheme_name ? strlen(scheme_name) : 0)
+		  + (scheme_specifics ? strlen(scheme_specifics) : 0));
+
+    FREE(HTAAForwardAuth);
+    if ((HTAAForwardAuth = typecallocn(char, len)) == 0)
+	  outofmem(__FILE__, "HTAAForwardAuth_set");
+
+    strcpy(HTAAForwardAuth, "Authorization: ");
+    if (scheme_name) {
+	strcat(HTAAForwardAuth, scheme_name);
+	strcat(HTAAForwardAuth, " ");
+	if (scheme_specifics) {
+	    strcat(HTAAForwardAuth, scheme_specifics);
+	}
+    }
+}
+
+void HTAAForwardAuth_reset(void)
+{
+    FREE(HTAAForwardAuth);
+}
+
+/**************************** HTAAServer ***********************************/
+
+static void HTAASetup_delete(HTAASetup * killme);	/* Forward */
+
+/* static						HTAAServer_new()
+ *		ALLOCATE A NEW NODE TO HOLD SERVER INFO
+ *		AND ADD IT TO THE LIST OF SERVERS
+ * ON ENTRY:
+ *	hostname	is the name of the host that the server
+ *			is running in.
+ *	portnumber	is the portnumber which the server listens.
+ *	IsProxy		should be TRUE if this is a proxy.
+ *
+ * ON EXIT:
+ *	returns		the newly-allocated node with all the strings
+ *			duplicated.
+ *			Strings will be automatically freed by
+ *			the function HTAAServer_delete(), which also
+ *			frees the node itself.
+ */
+static HTAAServer *HTAAServer_new(const char *hostname,
+				  int portnumber,
+				  int IsProxy)
+{
+    HTAAServer *server;
+
+    if ((server = typecalloc(HTAAServer)) == 0)
+	  outofmem(__FILE__, "HTAAServer_new");
+
+    server->hostname = NULL;
+    server->portnumber = (portnumber > 0 ? portnumber : 80);
+    server->IsProxy = (BOOLEAN) IsProxy;
+    server->setups = HTList_new();
+    server->realms = HTList_new();
+
+    if (hostname)
+	StrAllocCopy(server->hostname, hostname);
+
+    if (!server_table)
+	server_table = HTList_new();
+
+    HTList_addObject(server_table, (void *) server);
+
+    return server;
+}
+
+/* static						HTAAServer_delete()
+ *
+ *	DELETE THE ENTRY FOR THE SERVER FROM THE HOST TABLE,
+ *	AND FREE THE MEMORY USED BY IT.
+ *
+ * ON ENTRY:
+ *	killme		points to the HTAAServer to be freed.
+ *
+ * ON EXIT:
+ *	returns		nothing.
+ */
+static void HTAAServer_delete(HTAAServer *killme)
+{
+    int n, i;
+    HTAASetup *setup;
+    HTAARealm *realm;
+    HTList *cur;
+
+    if (killme) {
+	if (killme->setups != NULL) {
+	    n = HTList_count(killme->setups);
+	    for (i = (n - 1); i >= 0; i--) {
+		if ((setup = (HTAASetup *) HTList_objectAt(killme->setups,
+							   i)) != NULL) {
+		    HTAASetup_delete(setup);
+		    setup = NULL;
+		}
+	    }
+	    HTList_delete(killme->setups);
+	    killme->setups = NULL;
+	}
+
+	cur = killme->realms;
+	while (NULL != (realm = (HTAARealm *) HTList_nextObject(cur))) {
+	    FREE(realm->realmname);
+	    FREE(realm->username);
+	    FREE(realm->password);
+	    FREE(realm);
+	}
+	HTList_delete(killme->realms);
+	killme->realms = NULL;
+
+	FREE(killme->hostname);
+
+	HTList_removeObject(server_table, (void *) killme);
+	FREE(killme);
+    }
+}
+
+/* static						HTAAServer_lookup()
+ *		LOOK UP SERVER BY HOSTNAME AND PORTNUMBER
+ * ON ENTRY:
+ *	hostname	obvious.
+ *	portnumber	if non-positive defaults to 80.
+ *	IsProxy		should be TRUE if this is a proxy.
+ *
+ *	Looks up the server in the module-global server_table.
+ *
+ * ON EXIT:
+ *	returns		pointer to a HTAAServer structure
+ *			representing the looked-up server.
+ *			NULL, if not found.
+ */
+static HTAAServer *HTAAServer_lookup(const char *hostname,
+				     int portnumber,
+				     int IsProxy)
+{
+    if (hostname) {
+	HTList *cur = server_table;
+	HTAAServer *server;
+
+	if (portnumber <= 0)
+	    portnumber = 80;
+
+	while (NULL != (server = (HTAAServer *) HTList_nextObject(cur))) {
+	    if (server->portnumber == portnumber &&
+		0 == strcmp(server->hostname, hostname) &&
+		server->IsProxy == IsProxy)
+		return server;
+	}
+    }
+    return NULL;		/* NULL parameter, or not found */
+}
+
+/*************************** HTAASetup *******************************/
+
+/* static						HTAASetup_lookup()
+ *	FIGURE OUT WHICH AUTHENTICATION SETUP THE SERVER
+ *	IS USING FOR A GIVEN FILE ON A GIVEN HOST AND PORT
+ *
+ * ON ENTRY:
+ *	hostname	is the name of the server host machine.
+ *	portnumber	is the port that the server is running in.
+ *	docname		is the (URL-)pathname of the document we
+ *			are trying to access.
+ *	IsProxy		should be TRUE if this is a proxy.
+ *
+ *	This function goes through the information known about
+ *	all the setups of the server, and finds out if the given
+ *	filename resides in one of the protected directories.
+ *
+ * ON EXIT:
+ *	returns		NULL if no match.
+ *			Otherwise, a HTAASetup structure representing
+ *			the protected server setup on the corresponding
+ *			document tree.
+ *
+ */
+static HTAASetup *HTAASetup_lookup(const char *hostname,
+				   int portnumber,
+				   const char *docname,
+				   int IsProxy)
+{
+    HTAAServer *server;
+    HTAASetup *setup;
+
+    if (portnumber <= 0)
+	portnumber = 80;
+
+    if (hostname && docname && *hostname && *docname &&
+	NULL != (server = HTAAServer_lookup(hostname,
+					    portnumber,
+					    IsProxy))) {
+
+	HTList *cur = server->setups;
+
+	CTRACE((tfp, "%s %s (%s:%d:%s)\n",
+		"HTAASetup_lookup: resolving setup for",
+		(IsProxy ? "proxy" : "server"),
+		hostname, portnumber, docname));
+
+	while (NULL != (setup = (HTAASetup *) HTList_nextObject(cur))) {
+	    if (HTAA_templateMatch(setup->ctemplate, docname)) {
+		CTRACE((tfp, "%s `%s' %s `%s'\n",
+			"HTAASetup_lookup:", docname,
+			"matched template", setup->ctemplate));
+		return setup;
+	    } else {
+		CTRACE((tfp, "%s `%s' %s `%s'\n",
+			"HTAASetup_lookup:", docname,
+			"did NOT match template", setup->ctemplate));
+	    }
+	}			/* while setups remain */
+    }
+    /* if valid parameters and server found */
+    CTRACE((tfp, "%s `%s' %s\n",
+	    "HTAASetup_lookup: No template matched",
+	    NONNULL(docname),
+	    "(so probably not protected)"));
+
+    return NULL;		/* NULL in parameters, or not found */
+}
+
+/* static						HTAASetup_new()
+ *			CREATE A NEW SETUP NODE
+ * ON ENTRY:
+ *	server		is a pointer to a HTAAServer structure
+ *			to which this setup belongs.
+ *	ctemplate	documents matching this template
+ *			are protected according to this setup.
+ *	valid_schemes	a list containing all valid authentication
+ *			schemes for this setup.
+ *			If NULL, all schemes are disallowed.
+ *	scheme_specifics is an array of assoc lists, which
+ *			contain scheme specific parameters given
+ *			by server in Authenticate: fields.
+ *			If NULL, all scheme specifics are
+ *			set to NULL.
+ * ON EXIT:
+ *	returns		a new HTAASetup node, and also adds it as
+ *			part of the HTAAServer given as parameter.
+ */
+static HTAASetup *HTAASetup_new(HTAAServer *server, char *ctemplate,
+				HTList *valid_schemes,
+				HTAssocList **scheme_specifics)
+{
+    HTAASetup *setup;
+
+    if (!server || isEmpty(ctemplate))
+	return NULL;
+
+    if ((setup = typecalloc(HTAASetup)) == 0)
+	outofmem(__FILE__, "HTAASetup_new");
+
+    setup->retry = NO;
+    setup->server = server;
+    setup->ctemplate = NULL;
+    if (ctemplate)
+	StrAllocCopy(setup->ctemplate, ctemplate);
+    setup->valid_schemes = valid_schemes;
+    setup->scheme_specifics = scheme_specifics;
+
+    HTList_addObject(server->setups, (void *) setup);
+
+    return setup;
+}
+
+/* static						HTAASetup_delete()
+ *			FREE A HTAASetup STRUCTURE
+ * ON ENTRY:
+ *	killme		is a pointer to the structure to free().
+ *
+ * ON EXIT:
+ *	returns		nothing.
+ */
+static void HTAASetup_delete(HTAASetup * killme)
+{
+    int scheme;
+
+    if (killme) {
+	FREE(killme->ctemplate);
+	if (killme->valid_schemes) {
+	    HTList_delete(killme->valid_schemes);
+	    killme->valid_schemes = NULL;
+	}
+	for (scheme = 0; scheme < HTAA_MAX_SCHEMES; scheme++)
+	    if (killme->scheme_specifics[scheme])
+		HTAssocList_delete(killme->scheme_specifics[scheme]);
+	FREE(killme->scheme_specifics);
+	FREE(killme);
+    }
+}
+
+/* static					HTAASetup_updateSpecifics()
+ *		COPY SCHEME SPECIFIC PARAMETERS
+ *		TO HTAASetup STRUCTURE
+ * ON ENTRY:
+ *	setup		destination setup structure.
+ *	specifics	string array containing scheme
+ *			specific parameters for each scheme.
+ *			If NULL, all the scheme specific
+ *			parameters are set to NULL.
+ *
+ * ON EXIT:
+ *	returns		nothing.
+ */
+static void HTAASetup_updateSpecifics(HTAASetup * setup, HTAssocList **specifics)
+{
+    int scheme;
+
+    if (setup) {
+	if (setup->scheme_specifics) {
+	    for (scheme = 0; scheme < HTAA_MAX_SCHEMES; scheme++) {
+		if (setup->scheme_specifics[scheme])
+		    HTAssocList_delete(setup->scheme_specifics[scheme]);
+	    }
+	    FREE(setup->scheme_specifics);
+	}
+	setup->scheme_specifics = specifics;
+    }
+}
+
+/*************************** HTAARealm **********************************/
+
+/* static						HTAARealm_lookup()
+ *		LOOKUP HTAARealm STRUCTURE BY REALM NAME
+ * ON ENTRY:
+ *	realm_table	a list of realm objects.
+ *	realmname	is the name of realm to look for.
+ *
+ * ON EXIT:
+ *	returns		the realm.  NULL, if not found.
+ */
+static HTAARealm *HTAARealm_lookup(HTList *realm_table,
+				   const char *realmname)
+{
+    if (realm_table && realmname) {
+	HTList *cur = realm_table;
+	HTAARealm *realm;
+
+	while (NULL != (realm = (HTAARealm *) HTList_nextObject(cur))) {
+	    if (0 == strcmp(realm->realmname, realmname))
+		return realm;
+	}
+    }
+    return NULL;		/* No table, NULL param, or not found */
+}
+
+/* static						HTAARealm_new()
+ *		CREATE A NODE CONTAINING USERNAME AND
+ *		PASSWORD USED FOR THE GIVEN REALM.
+ *		IF REALM ALREADY EXISTS, CHANGE
+ *		USERNAME/PASSWORD.
+ * ON ENTRY:
+ *	realm_table	a list of realms to where to add
+ *			the new one, too.
+ *	realmname	is the name of the password domain.
+ *	username	and
+ *	password	are what you can expect them to be.
+ *
+ * ON EXIT:
+ *	returns		the created realm.
+ */
+static HTAARealm *HTAARealm_new(HTList *realm_table,
+				const char *realmname,
+				const char *username,
+				const char *password)
+{
+    HTAARealm *realm;
+
+    realm = HTAARealm_lookup(realm_table, realmname);
+
+    if (!realm) {
+	if ((realm = typecalloc(HTAARealm)) == 0)
+	      outofmem(__FILE__, "HTAARealm_new");
+
+	realm->realmname = NULL;
+	realm->username = NULL;
+	realm->password = NULL;
+	StrAllocCopy(realm->realmname, realmname);
+	if (realm_table)
+	    HTList_addObject(realm_table, (void *) realm);
+    }
+    if (username)
+	StrAllocCopy(realm->username, username);
+    if (password)
+	StrAllocCopy(realm->password, password);
+
+    return realm;
+}
+
+BOOL HTAA_HaveUserinfo(const char *hostname)
+{
+    int gen_delims = 0;
+    BOOL result = FALSE;
+    char *my_info = NULL;
+
+    if (StrAllocCopy(my_info, hostname) != NULL) {
+	char *at_sign = HTSkipToAt(my_info, &gen_delims);
+
+	free(my_info);
+	if (at_sign != NULL && gen_delims == 0)
+	    result = TRUE;
+    }
+    return result;
+}
+
+/*
+ * If there is userinfo in the hostname string, update the realm to use that
+ * information.  The command-line "-auth" option will override this.
+ */
+static void fill_in_userinfo(HTAARealm *realm, const char *hostname)
+{
+    int gen_delims = 0;
+    char *my_info = NULL;
+    char *at_sign = HTSkipToAt(StrAllocCopy(my_info, hostname), &gen_delims);
+
+    if (at_sign != NULL && gen_delims == 0) {
+	char *colon;
+
+	*at_sign = '\0';
+	if ((colon = StrChr(my_info, ':')) != 0) {
+	    *colon++ = '\0';
+	}
+	if (non_empty(my_info)) {
+	    char *msg;
+	    BOOL prior = non_empty(realm->username);
+
+	    if (prior && strcmp(realm->username, my_info)) {
+		msg = 0;
+		HTSprintf0(&msg,
+			   gettext("username for realm %s changed from %s to %s"),
+			   realm->realmname,
+			   realm->username,
+			   my_info);
+		HTAlert(msg);
+		free(msg);
+		FREE(realm->username);
+		StrAllocCopy(realm->username, my_info);
+	    } else if (!prior) {
+		StrAllocCopy(realm->username, my_info);
+	    }
+	    if (non_empty(colon)) {
+		prior = non_empty(realm->password);
+		if (prior && strcmp(realm->password, colon)) {
+		    msg = 0;
+		    HTSprintf0(&msg,
+			       gettext("password for realm %s user %s changed"),
+			       realm->realmname,
+			       realm->username);
+		    HTAlert(msg);
+		    free(msg);
+		    FREE(realm->password);
+		    StrAllocCopy(realm->password, colon);
+		} else if (!prior) {
+		    StrAllocCopy(realm->password, colon);
+		}
+	    }
+	}
+    }
+    free(my_info);
+}
+
+/***************** Basic and Pubkey Authentication ************************/
+
+/* static						compose_auth_string()
+ *
+ *		COMPOSE Basic OR Pubkey AUTHENTICATION STRING;
+ *		PROMPTS FOR USERNAME AND PASSWORD IF NEEDED
+ *
+ * ON ENTRY:
+ *	hostname	may include user- and password information
+ *	scheme		is either HTAA_BASIC or HTAA_PUBKEY.
+ *	setup		is the current server setup.
+ *	IsProxy		should be TRUE if this is a proxy.
+ *
+ * ON EXIT:
+ *	returns		a newly composed authorization string,
+ *			(with, of course, a newly generated secret
+ *			key and fresh timestamp, if Pubkey-scheme
+ *			is being used).
+ *			NULL, if something fails.
+ * NOTE:
+ *	Like throughout the entire AA package, no string or structure
+ *	returned by AA package needs to (or should) be freed.
+ *
+ */
+static char *compose_auth_string(const char *hostname,
+				 HTAAScheme scheme,
+				 HTAASetup * setup,
+				 int IsProxy)
+{
+    char *cleartext = NULL;	/* Cleartext presentation */
+    char *ciphertext = NULL;	/* Encrypted presentation */
+    size_t len;
+    char *msg = NULL;
+    char *username = NULL;
+    char *password = NULL;
+    char *realmname = NULL;
+    char *theHost = NULL;
+    char *proxiedHost = NULL;
+    char *thePort = NULL;
+    HTAARealm *realm;
+    const char *i_net_addr = "0.0.0.0";		/* Change... @@@@ */
+    const char *timestamp = "42";	/* ... these @@@@ */
+
+    FREE(compose_auth_stringResult);	/* From previous call */
+
+    if ((scheme != HTAA_BASIC && scheme != HTAA_PUBKEY) ||
+	!(setup &&
+	  setup->scheme_specifics &&
+	  setup->scheme_specifics[scheme] &&
+	  setup->server &&
+	  setup->server->realms))
+	return NULL;
+
+    realmname = HTAssocList_lookup(setup->scheme_specifics[scheme], "realm");
+    if (!realmname)
+	return NULL;
+
+    realm = HTAARealm_lookup(setup->server->realms, realmname);
+    setup->retry |= HTAA_HaveUserinfo(hostname);
+
+    if (!(realm &&
+	  non_empty(realm->username) &&
+	  non_empty(realm->password)) || setup->retry) {
+	if (!realm) {
+	    CTRACE((tfp, "%s `%s' %s\n",
+		    "compose_auth_string: realm:", realmname,
+		    "not found -- creating"));
+	    realm = HTAARealm_new(setup->server->realms,
+				  realmname, NULL, NULL);
+	}
+	fill_in_userinfo(realm, hostname);
+	/*
+	 * The template should be either the '*' global for everything on the
+	 * server (always true for proxy authorization setups), or a path for
+	 * the start of a protected limb, with no host field, but we'll check
+	 * for a host anyway in case a WWW-Protection-Template header set an
+	 * absolute URL instead of a path.  If we do get a host from this, it
+	 * will include the port.  - FM
+	 */
+	if ((!IsProxy) && using_proxy && setup->ctemplate) {
+	    proxiedHost = HTParse(setup->ctemplate, "", PARSE_HOST);
+	    if (proxiedHost && *proxiedHost != '\0') {
+		theHost = proxiedHost;
+	    }
+	}
+	/*
+	 * If we didn't get a host field from the template, set up the host
+	 * name and port from the setup->server elements.  - FM
+	 */
+	if (!theHost)
+	    theHost = setup->server->hostname;
+	if (setup->server->portnumber > 0 &&
+	    setup->server->portnumber != 80) {
+	    HTSprintf0(&thePort, ":%d", setup->server->portnumber);
+	}
+
+	HTSprintf0(&msg, gettext("Username for '%s' at %s '%s%s':"),
+		   realm->realmname,
+		   (IsProxy ? "proxy" : "server"),
+		   (theHost ? theHost : "??"),
+		   NonNull(thePort));
+	FREE(proxiedHost);
+	FREE(thePort);
+	if (non_empty(realm->username)) {
+	    StrAllocCopy(username, realm->username);
+	}
+	if (non_empty(realm->password)) {
+	    StrAllocCopy(password, realm->password);
+	}
+	HTPromptUsernameAndPassword(msg, &username, &password, IsProxy);
+
+	FREE(msg);
+	FREE(realm->username);
+	FREE(realm->password);
+
+	realm->username = username;
+	realm->password = password;
+
+	if (!realm->username || !realm->password) {
+	    /*
+	     * Signals to retry.  - FM
+	     */
+	    return NULL;
+	} else if (*realm->username == '\0') {
+	    /*
+	     * Signals to abort.  - FM
+	     */
+	    StrAllocCopy(compose_auth_stringResult, "");
+	    return compose_auth_stringResult;
+	}
+    }
+
+    len = (strlen(NonNull(realm->username)) +
+	   strlen(NonNull(realm->password)) + 3);
+
+    if (scheme == HTAA_PUBKEY) {
+#ifdef PUBKEY
+	/* Generate new secret key */
+	StrAllocCopy(secret_key, HTAA_generateRandomKey());
+#endif /* PUBKEY */
+	/* Room for secret key, timestamp and inet address */
+	len += strlen(NonNull(secret_key)) + 30;
+    } else {
+	FREE(secret_key);
+    }
+
+    if ((cleartext = typecallocn(char, len)) == 0)
+	  outofmem(__FILE__, "compose_auth_string");
+
+    if (realm->username)
+	strcpy(cleartext, realm->username);
+    else
+	*cleartext = '\0';
+
+    strcat(cleartext, ":");
+
+    if (realm->password)
+	strcat(cleartext, realm->password);
+
+    if (scheme == HTAA_PUBKEY) {
+	strcat(cleartext, ":");
+	strcat(cleartext, i_net_addr);
+	strcat(cleartext, ":");
+	strcat(cleartext, timestamp);
+	strcat(cleartext, ":");
+	if (secret_key)
+	    strcat(cleartext, secret_key);
+
+	if (!((ciphertext = typecallocn(char, 2 * len)) &&
+	        (compose_auth_stringResult = typecallocn(char, 3 * len))))
+	      outofmem(__FILE__, "compose_auth_string");
+
+#ifdef PUBKEY
+	HTPK_encrypt(cleartext, ciphertext, server->public_key);
+	HTUU_encode((unsigned char *) ciphertext, strlen(ciphertext),
+		    compose_auth_stringResult);
+#endif /* PUBKEY */
+	FREE(cleartext);
+	FREE(ciphertext);
+    } else {			/* scheme == HTAA_BASIC */
+	if (!(compose_auth_stringResult =
+	      typecallocn(char, (4 * ((len + 2) / 3)) + 1)))
+	      outofmem(__FILE__, "compose_auth_string");
+
+	HTUU_encode((unsigned char *) cleartext, strlen(cleartext),
+		    compose_auth_stringResult);
+	FREE(cleartext);
+    }
+    return compose_auth_stringResult;
+}
+
+/* BROWSER static					HTAA_selectScheme()
+ *		SELECT THE AUTHENTICATION SCHEME TO USE
+ * ON ENTRY:
+ *	setup	is the server setup structure which can
+ *		be used to make the decision about the
+ *		used scheme.
+ *
+ *	When new authentication methods are added to library
+ *	this function makes the decision about which one to
+ *	use at a given time.  This can be done by inspecting
+ *	environment variables etc.
+ *
+ *	Currently only searches for the first valid scheme,
+ *	and if nothing found suggests Basic scheme;
+ *
+ * ON EXIT:
+ *	returns	the authentication scheme to use.
+ */
+static HTAAScheme HTAA_selectScheme(HTAASetup * setup)
+{
+    int scheme;
+
+    if (setup && setup->valid_schemes) {
+	for (scheme = HTAA_BASIC; scheme < HTAA_MAX_SCHEMES; scheme++) {
+	    void *object = (void *) (intptr_t) scheme;
+
+	    if (-1 < HTList_indexOf(setup->valid_schemes, object))
+		return (HTAAScheme) scheme;
+	}
+    }
+    return HTAA_BASIC;
+}
+
+/*
+ *  Purpose:	Free off all module globals.
+ *  Arguments:	void
+ *  Return Value:	void
+ *  Remarks/Portability/Dependencies/Restrictions:
+ *	To be used at program exit.
+ *  Revision History:
+ *	06-19-96	created - FM
+ */
+static void free_HTAAGlobals(void)
+{
+    HTAAServer *server;
+    int n, i;
+
+    if (server_table != NULL) {
+	n = HTList_count(server_table);
+	for (i = (n - 1); i >= 0; i--) {
+	    if ((server = (HTAAServer *) HTList_objectAt(server_table,
+							 i)) != NULL) {
+		HTAAServer_delete(server);
+		server = NULL;
+	    }
+	}
+	HTList_delete(server_table);
+	server_table = NULL;
+    }
+
+    HTAAForwardAuth_reset();
+    FREE(HTAA_composeAuthResult);
+    FREE(current_hostname);
+    FREE(current_docname);
+    FREE(proxy_hostname);
+    FREE(proxy_docname);
+    FREE(compose_auth_stringResult);
+    FREE(secret_key);
+}
+
+/* BROWSER PUBLIC					HTAA_composeAuth()
+ *
+ *	SELECT THE AUTHENTICATION SCHEME AND
+ *	COMPOSE THE ENTIRE AUTHORIZATION HEADER LINE
+ *	IF WE ALREADY KNOW THAT THE HOST REQUIRES AUTHENTICATION
+ *
+ * ON ENTRY:
+ *	hostname	is the hostname of the server.
+ *	portnumber	is the portnumber in which the server runs.
+ *	docname		is the pathname of the document (as in URL)
+ *	IsProxy		should be TRUE if this is a proxy.
+ *
+ * ON EXIT:
+ *	returns	NULL, if no authorization seems to be needed, or
+ *		if it is the entire Authorization: line, e.g.
+ *
+ *		   "Authorization: Basic username:password"
+ *
+ *		As usual, this string is automatically freed.
+ */
+char *HTAA_composeAuth(const char *hostname,
+		       const int portnumber,
+		       const char *docname,
+		       int IsProxy)
+{
+    char *auth_string;
+    BOOL retry;
+    HTAAScheme scheme;
+    size_t len;
+
+    /*
+     * Setup atexit() freeing if not done already.  - FM
+     */
+    if (!free_HTAAGlobalsSet) {
+#ifdef LY_FIND_LEAKS
+	atexit(free_HTAAGlobals);
+#endif
+	free_HTAAGlobalsSet = TRUE;
+    }
+
+    /*
+     * Make gateway httpds pass authorization field as it was received.  (This
+     * still doesn't really work because Authenticate:  headers from remote
+     * server are not forwarded to client yet so it cannot really know that it
+     * should send authorization; I will not implement it yet because I feel we
+     * will soon change radically the way requests are represented to allow
+     * multithreading on server-side.  Life is hard.)
+     */
+    if (HTAAForwardAuth) {
+	CTRACE((tfp, "HTAA_composeAuth: %s\n",
+		"Forwarding received authorization"));
+	StrAllocCopy(HTAA_composeAuthResult, HTAAForwardAuth);
+	HTAAForwardAuth_reset();	/* Just a precaution */
+	return HTAA_composeAuthResult;
+    }
+
+    FREE(HTAA_composeAuthResult);	/* From previous call */
+
+    if (IsProxy) {
+	/*
+	 * Proxy Authorization required.  - AJL
+	 */
+
+	CTRACE((tfp, "Composing Proxy Authorization for %s:%d/%s\n",
+		hostname, portnumber, docname));
+
+	if (proxy_portnumber != portnumber ||
+	    !proxy_hostname || !proxy_docname ||
+	    !hostname || !docname ||
+	    0 != strcmp(proxy_hostname, hostname) ||
+	    0 != strcmp(proxy_docname, docname)) {
+
+	    retry = NO;
+
+	    proxy_portnumber = portnumber;
+
+	    if (hostname)
+		StrAllocCopy(proxy_hostname, hostname);
+	    else
+		FREE(proxy_hostname);
+
+	    if (docname)
+		StrAllocCopy(proxy_docname, docname);
+	    else
+		FREE(proxy_docname);
+	} else {
+	    retry = YES;
+	}
+
+	if (!proxy_setup || !retry)
+	    proxy_setup = HTAASetup_lookup(hostname, portnumber,
+					   docname, IsProxy);
+
+	if (!proxy_setup)
+	    return NULL;
+
+	switch (scheme = HTAA_selectScheme(proxy_setup)) {
+	case HTAA_BASIC:
+	case HTAA_PUBKEY:
+	    auth_string = compose_auth_string(hostname, scheme, proxy_setup, IsProxy);
+	    break;
+	case HTAA_KERBEROS_V4:
+	    /* OTHER AUTHENTICATION ROUTINES ARE CALLED HERE */
+	default:
+	    {
+		char *msg = NULL;
+
+		HTSprintf0(&msg, "%s `%s'",
+			   gettext("This client doesn't know how to compose proxy authorization information for scheme"),
+			   HTAAScheme_name(scheme));
+		HTAlert(msg);
+		FREE(msg);
+		auth_string = NULL;
+	    }
+	}			/* switch scheme */
+
+	proxy_setup->retry = NO;
+
+	if (!auth_string)
+	    /*
+	     * Signal a failure.  - FM
+	     */
+	    return NULL;	/* Added by marca. */
+	if (*auth_string == '\0') {
+	    /*
+	     * Signal an abort.  - FM
+	     */
+	    StrAllocCopy(HTAA_composeAuthResult, "");
+	    return (HTAA_composeAuthResult);
+	}
+	len = strlen(auth_string) + strlen(HTAAScheme_name(scheme)) + 26;
+	if ((HTAA_composeAuthResult = typecallocn(char, len)) == 0)
+	      outofmem(__FILE__, "HTAA_composeAuth");
+
+	strcpy(HTAA_composeAuthResult, "Proxy-Authorization: ");
+
+    } else {
+	/*
+	 * Normal WWW authorization.
+	 */
+	CTRACE((tfp, "Composing Authorization for %s:%d/%s\n",
+		hostname, portnumber, docname));
+
+	if (current_portnumber != portnumber ||
+	    !current_hostname || !current_docname ||
+	    !hostname || !docname ||
+	    0 != strcmp(current_hostname, hostname) ||
+	    0 != strcmp(current_docname, docname)) {
+
+	    retry = NO;
+
+	    current_portnumber = portnumber;
+
+	    if (hostname)
+		StrAllocCopy(current_hostname, hostname);
+	    else
+		FREE(current_hostname);
+
+	    if (docname)
+		StrAllocCopy(current_docname, docname);
+	    else
+		FREE(current_docname);
+	} else {
+	    retry = YES;
+	}
+
+	if (!current_setup || !retry)
+	    current_setup = HTAASetup_lookup(hostname, portnumber,
+					     docname, IsProxy);
+
+	if (!current_setup)
+	    return NULL;
+
+	switch (scheme = HTAA_selectScheme(current_setup)) {
+	case HTAA_BASIC:
+	case HTAA_PUBKEY:
+	    auth_string = compose_auth_string(hostname, scheme, current_setup, IsProxy);
+	    break;
+	case HTAA_KERBEROS_V4:
+	    /* OTHER AUTHENTICATION ROUTINES ARE CALLED HERE */
+	default:
+	    {
+		char *msg = 0;
+
+		HTSprintf0(&msg, "%s `%s'",
+			   gettext("This client doesn't know how to compose authorization information for scheme"),
+			   HTAAScheme_name(scheme));
+		HTAlert(msg);
+		FREE(msg);
+		auth_string = NULL;
+	    }
+	}			/* switch scheme */
+
+	current_setup->retry = NO;
+
+	if (!auth_string)
+	    /*
+	     * Signal a failure.  - FM
+	     */
+	    return NULL;	/* Added by marca. */
+	if (*auth_string == '\0') {
+	    /*
+	     * Signal an abort.  - FM
+	     */
+	    StrAllocCopy(HTAA_composeAuthResult, "");
+	    return (HTAA_composeAuthResult);
+	}
+
+	len = strlen(auth_string) + strlen(HTAAScheme_name(scheme)) + 20;
+	if ((HTAA_composeAuthResult = typecallocn(char, len)) == 0)
+	      outofmem(__FILE__, "HTAA_composeAuth");
+
+	strcpy(HTAA_composeAuthResult, "Authorization: ");
+    }
+
+    strcat(HTAA_composeAuthResult, HTAAScheme_name(scheme));
+    strcat(HTAA_composeAuthResult, " ");
+    strcat(HTAA_composeAuthResult, auth_string);
+    return HTAA_composeAuthResult;
+}
+
+/* BROWSER PUBLIC				HTAA_shouldRetryWithAuth()
+ *
+ *		DETERMINES IF WE SHOULD RETRY THE SERVER
+ *		WITH AUTHORIZATION
+ *		(OR IF ALREADY RETRIED, WITH A DIFFERENT
+ *		USERNAME AND/OR PASSWORD (IF MISSPELLED))
+ * ON ENTRY:
+ *	start_of_headers is the first block already read from socket,
+ *			but status line skipped; i.e., points to the
+ *			start of the header section.
+ *	length		is the remaining length of the first block.
+ *	soc		is the socket to read the rest of server reply.
+ *	IsProxy		should be TRUE if this is a proxy.
+ *
+ *			This function should only be called when
+ *			server has replied with a 401 (Unauthorized)
+ *			status code.
+ * ON EXIT:
+ *	returns		YES, if connection should be retried.
+ *			     The node containing all the necessary
+ *			     information is
+ *				* either constructed if it does not exist
+ *				* or password is reset to NULL to indicate
+ *				  that username and password should be
+ *				  reprompted when composing Authorization:
+ *				  field (in function HTAA_composeAuth()).
+ *			NO, otherwise.
+ */
+BOOL HTAA_shouldRetryWithAuth(char *start_of_headers,
+			      size_t length,
+			      int soc,
+			      int IsProxy)
+{
+    HTAAScheme scheme;
+    char *line = NULL;
+    int num_schemes = 0;
+    HTList *valid_schemes = HTList_new();
+    HTAssocList **scheme_specifics = NULL;
+    char *ctemplate = NULL;
+    char *temp = NULL;
+    BOOL result = NO;
+
+    /*
+     * Setup atexit() freeing if not done already.  - FM
+     */
+    if (!free_HTAAGlobalsSet) {
+#ifdef LY_FIND_LEAKS
+	atexit(free_HTAAGlobals);
+#endif
+	free_HTAAGlobalsSet = TRUE;
+    }
+
+    /*
+     * Read server reply header lines
+     */
+    CTRACE((tfp, "Server reply header lines:\n"));
+
+    HTAA_setupReader(start_of_headers, length, soc);
+    while (NULL != (line = HTAA_getUnfoldedLine()) && *line != '\0') {
+	CTRACE((tfp, "%s\n", line));
+
+	if (StrChr(line, ':')) {	/* Valid header line */
+
+	    char *p = line;
+	    char *fieldname = HTNextField(&p);
+	    char *arg1 = HTNextField(&p);
+	    char *args = p;
+
+	    if ((IsProxy &&
+		 0 == strcasecomp(fieldname, "Proxy-Authenticate:")) ||
+		(!IsProxy &&
+		 0 == strcasecomp(fieldname, "WWW-Authenticate:"))) {
+		if (isEmpty(arg1) || isEmpty(args)) {
+		    HTSprintf0(&temp, gettext("Invalid header '%s%s%s%s%s'"), line,
+			       (non_empty(arg1) ? " " : ""),
+			       NonNull(arg1),
+			       (non_empty(args) ? " " : ""),
+			       NonNull(args));
+		    HTAlert(temp);
+		    FREE(temp);
+		} else if (HTAA_UNKNOWN != (scheme = HTAAScheme_enum(arg1))) {
+		    HTList_addObject(valid_schemes, (void *) scheme);
+		    if (!scheme_specifics) {
+			int i;
+
+			scheme_specifics =
+			    typecallocn(HTAssocList *, HTAA_MAX_SCHEMES);
+
+			if (!scheme_specifics)
+			    outofmem(__FILE__, "HTAA_shouldRetryWithAuth");
+
+			for (i = 0; i < HTAA_MAX_SCHEMES; i++)
+			    scheme_specifics[i] = NULL;
+		    }
+		    scheme_specifics[scheme] = HTAA_parseArgList(args);
+		    num_schemes++;
+		} else {
+		    CTRACE((tfp, "Unknown scheme `%s' %s\n",
+			    NONNULL(arg1),
+			    (IsProxy ?
+			     "in Proxy-Authenticate: field" :
+			     "in WWW-Authenticate: field")));
+		}
+	    }
+
+	    else if (!IsProxy &&
+		     0 == strcasecomp(fieldname, "WWW-Protection-Template:")) {
+		CTRACE((tfp, "Protection template set to `%s'\n", arg1));
+		StrAllocCopy(ctemplate, arg1);
+	    }
+
+	} else {
+	    CTRACE((tfp, "Invalid header line `%s' ignored\n", line));
+	}
+
+	FREE(line);
+    }				/* while header lines remain */
+    FREE(line);
+
+    /*
+     * So should we retry with authorization?
+     */
+    if (IsProxy) {
+	if (num_schemes == 0) {
+	    /*
+	     * No proxy authorization valid
+	     */
+	    proxy_setup = NULL;
+	    result = NO;
+	}
+	/*
+	 * Doing it for proxy.  -AJL
+	 */
+	else if (proxy_setup && proxy_setup->server) {
+	    /*
+	     * We have already tried with proxy authorization.  Either we don't
+	     * have access or username or password was misspelled.
+	     *
+	     * Update scheme-specific parameters (in case they have expired by
+	     * chance).
+	     */
+	    HTAASetup_updateSpecifics(proxy_setup, scheme_specifics);
+
+	    if (NO == HTConfirm(AUTH_FAILED_PROMPT)) {
+		proxy_setup = NULL;
+		result = NO;
+	    } else {
+		/*
+		 * Re-ask username+password (if misspelled).
+		 */
+		HTList_delete(valid_schemes);
+		proxy_setup->retry = YES;
+		result = YES;
+	    }
+	} else {
+	    /*
+	     * proxy_setup == NULL, i.e., we have a first connection to a
+	     * protected server or the server serves a wider set of documents
+	     * than we expected so far.
+	     */
+	    HTAAServer *server = HTAAServer_lookup(proxy_hostname,
+						   proxy_portnumber,
+						   IsProxy);
+
+	    if (!server) {
+		server = HTAAServer_new(proxy_hostname,
+					proxy_portnumber,
+					IsProxy);
+	    }
+	    if (!ctemplate)	/* Proxy matches everything  -AJL */
+		StrAllocCopy(ctemplate, "*");
+	    proxy_setup = HTAASetup_new(server,
+					ctemplate,
+					valid_schemes,
+					scheme_specifics);
+	    FREE(ctemplate);
+
+	    HTAlert(gettext("Proxy authorization required -- retrying"));
+	    result = YES;
+	}
+    }
+    /*
+     * Normal WWW authorization.
+     */
+    else if (num_schemes == 0) {
+	/*
+	 * No authorization valid.
+	 */
+	current_setup = NULL;
+	result = NO;
+    } else if (current_setup && current_setup->server) {
+	/*
+	 * So we have already tried with WWW authorization.  Either we don't
+	 * have access or username or password was misspelled.
+	 *
+	 * Update scheme-specific parameters (in case they have expired by
+	 * chance).
+	 */
+	HTAASetup_updateSpecifics(current_setup, scheme_specifics);
+
+	if (NO == HTConfirm(AUTH_FAILED_PROMPT)) {
+	    current_setup = NULL;
+	    result = NO;
+	} else {
+	    /*
+	     * Re-ask username+password (if misspelled).
+	     */
+	    current_setup->retry = YES;
+	    result = YES;
+	}
+    } else {
+	/*
+	 * current_setup == NULL, i.e., we have a first connection to a
+	 * protected server or the server serves a wider set of documents than
+	 * we expected so far.
+	 */
+	HTAAServer *server = HTAAServer_lookup(current_hostname,
+					       current_portnumber,
+					       IsProxy);
+
+	if (!server) {
+	    server = HTAAServer_new(current_hostname,
+				    current_portnumber,
+				    IsProxy);
+	}
+	if (!ctemplate)
+	    ctemplate = HTAA_makeProtectionTemplate(current_docname);
+	current_setup = HTAASetup_new(server,
+				      ctemplate,
+				      valid_schemes,
+				      scheme_specifics);
+	FREE(ctemplate);
+
+	HTAlert(gettext("Access without authorization denied -- retrying"));
+	result = YES;
+    }
+
+    if (result == NO) {
+	HTList_delete(valid_schemes);
+    }
+    return result;
+}
+
+/*
+ *  This function clears all authorization information by
+ *  invoking the free_HTAAGlobals() function, which normally
+ *  is invoked at exit.  It allows a browser command to do
+ *  this at any time, for example, if the user is leaving
+ *  the terminal for a period of time, but does not want
+ *  to end the current session.  - FM
+ */
+void HTClearHTTPAuthInfo(void)
+{
+    /*
+     * Need code to check cached documents against the protection templates,
+     * and do something to ensure that any protected documents no longer can be
+     * accessed without a new retrieval.  - FM
+     */
+
+    /*
+     * Now free all of the authorization info, and reset the
+     * free_HTAAGlobalsSet flag.  - FM
+     */
+    free_HTAAGlobals();
+    free_HTAAGlobalsSet = FALSE;
+}
diff --git a/WWW/Library/Implementation/HTAABrow.h b/WWW/Library/Implementation/HTAABrow.h
new file mode 100644
index 0000000..f151deb
--- /dev/null
+++ b/WWW/Library/Implementation/HTAABrow.h
@@ -0,0 +1,142 @@
+/*
+ * $LynxId: HTAABrow.h,v 1.17 2016/11/24 23:32:22 tom Exp $
+ *
+ *                          BROWSER SIDE ACCESS AUTHORIZATION MODULE
+
+   This module is the browser side interface to Access Authorization (AA) package.  It
+   contains code only for browser.
+
+   Important to know about memory allocation:
+
+   Routines in this module use dynamic allocation, but free automatically all the memory
+   reserved by them.
+
+   Therefore the caller never has to (and never should) free() any object returned by
+   these functions.
+
+   Therefore also all the strings returned by this package are only valid until the next
+   call to the same function is made.  This approach is selected, because of the nature of
+   access authorization: no string returned by the package needs to be valid longer than
+   until the next call.
+
+   This also makes it easy to plug the AA package in: you don't have to ponder whether to
+   free()something here or is it done somewhere else (because it is always done somewhere
+   else).
+
+   The strings that the package needs to store are copied so the original strings given as
+   parameters to AA functions may be freed or modified with no side effects.
+
+   Also note:The AA package does not free() anything else than what it has itself
+   allocated.
+
+ */
+
+#ifndef HTAABROW_H
+#define HTAABROW_H
+
+#include <HTAAUtil.h>		/* Common parts of AA */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+   Routines for Browser Side Recording of AA Info
+
+   Most of the browser-side AA is done by the following two functions (which are called
+   from file HTTP.c so the browsers using libwww only need to be linked with the new
+   library and not be changed at all):
+
+      HTAA_composeAuth() composes the Authorization: line contents, if the AA package
+      thinks that the given document is protected. Otherwise this function returns NULL.
+      This function also calls the functions HTPrompt(),HTPromptPassword() and HTConfirm()
+      to get the username, password and some confirmation from the user.
+
+      HTAA_shouldRetryWithAuth() determines whether to retry the request with AA or with a
+      new AA (in case username or password was misspelled).
+
+ */
+/* PUBLIC                                               HTAA_composeAuth()
+ *
+ *      COMPOSE THE ENTIRE AUTHORIZATION HEADER LINE IF WE
+ *      ALREADY KNOW, THAT THE HOST MIGHT REQUIRE AUTHORIZATION
+ *
+ * ON ENTRY:
+ *      hostname        is the hostname of the server.
+ *      portnumber      is the portnumber in which the server runs.
+ *      docname         is the pathname of the document (as in URL)
+ *
+ * ON EXIT:
+ *      returns NULL, if no authorization seems to be needed, or
+ *              if it is the entire Authorization: line, e.g.
+ *
+ *                 "Authorization: basic username:password"
+ *
+ *              As usual, this string is automatically freed.
+ */
+    extern char *HTAA_composeAuth(const char *hostname,
+				  const int portnumber,
+				  const char *docname,
+				  int IsProxy);
+
+/* BROWSER PUBLIC                               HTAA_shouldRetryWithAuth()
+ *
+ *              DETERMINES IF WE SHOULD RETRY THE SERVER
+ *              WITH AUTHORIZATION
+ *              (OR IF ALREADY RETRIED, WITH A DIFFERENT
+ *              USERNAME AND/OR PASSWORD (IF MISSPELLED))
+ * ON ENTRY:
+ *      start_of_headers is the first block already read from socket,
+ *                      but status line skipped; i.e., points to the
+ *                      start of the header section.
+ *      length          is the remaining length of the first block.
+ *      soc             is the socket to read the rest of server reply.
+ *
+ *                      This function should only be called when
+ *                      server has replied with a 401 (Unauthorized)
+ *                      status code.
+ * ON EXIT:
+ *      returns         YES, if connection should be retried.
+ *                           The node containing all the necessary
+ *                           information is
+ *                              * either constructed if it does not exist
+ *                              * or password is reset to NULL to indicate
+ *                                that username and password should be
+ *                                reprompted when composing Authorization:
+ *                                field (in function HTAA_composeAuth()).
+ *                      NO, otherwise.
+ */
+    extern BOOL HTAA_shouldRetryWithAuth(char *start_of_headers,
+					 size_t length,
+					 int soc,
+					 int IsProxy);
+
+/*
+ *  Function to allow clearing of all Authorization info
+ *  via a browser command. - FM
+ */
+    extern void HTClearHTTPAuthInfo(void);
+
+/*
+ * Check if a hostname-string contains user information.
+ */
+    extern BOOL HTAA_HaveUserinfo(const char *hostname);
+
+/*
+
+Enabling Gateway httpds to Forward Authorization
+
+   These functions should only be called from daemon code, and HTAAForwardAuth_reset()
+   must be called before the next request is handled to make sure that authorization
+   string isn't cached in daemon so that other people can access private files using
+   somebody else's previous authorization information.
+
+ */
+
+    extern void HTAAForwardAuth_set(const char *scheme_name,
+				    const char *scheme_specifics);
+    extern void HTAAForwardAuth_reset(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* NOT HTAABROW_H */
diff --git a/WWW/Library/Implementation/HTAAProt.c b/WWW/Library/Implementation/HTAAProt.c
new file mode 100644
index 0000000..d5117f1
--- /dev/null
+++ b/WWW/Library/Implementation/HTAAProt.c
@@ -0,0 +1,738 @@
+/*
+ * $LynxId: HTAAProt.c,v 1.34 2016/11/24 15:29:50 tom Exp $
+ *
+ * MODULE							HTAAProt.c
+ *		PROTECTION FILE PARSING MODULE
+ *
+ * AUTHORS:
+ *	AL	Ari Luotonen	luotonen@dxcern.cern.ch
+ *	MD	Mark Donszelmann    duns@vxdeop.cern.ch
+ *
+ * HISTORY:
+ *	20 Oct 93  AL	Now finds uid/gid for nobody/nogroup by name
+ *			(doesn't use default 65534 right away).
+ *			Also understands negative uids/gids.
+ *	14 Nov 93  MD	Added VMS compatibility
+ *
+ * BUGS:
+ *
+ *
+ */
+
+#include <HTUtils.h>
+
+#ifndef VMS
+#ifndef NOUSERS
+#include <pwd.h>		/* Unix password file routine: getpwnam()       */
+#include <grp.h>		/* Unix group file routine: getgrnam()          */
+#endif /* NOUSERS */
+#endif /* not VMS */
+
+#include <HTAAUtil.h>
+#include <HTLex.h>		/* Lexical analysor     */
+#include <HTAAProt.h>		/* Implemented here     */
+
+#include <LYUtils.h>
+#include <LYLeaks.h>
+
+#define NOBODY    65534		/* -2 in 16-bit environment */
+#define NONESUCH  65533		/* -3 in 16-bit environment */
+
+/*
+ * Protection setup caching
+ */
+typedef struct {
+    char *prot_filename;
+    HTAAProt *prot;
+} HTAAProtCache;
+
+static HTList *prot_cache = NULL;	/* Protection setup cache.      */
+static HTAAProt *default_prot = NULL;	/* Default protection.          */
+static HTAAProt *current_prot = NULL;	/* Current protection mode      */
+
+					/* which is set up by callbacks */
+					/* from the rule system when    */
+					/* a "protect" rule is matched. */
+
+#ifndef NOUSERS
+/* static							isNumber()
+ *		DOES A CHARACTER STRING REPRESENT A NUMBER
+ */
+static BOOL isNumber(const char *s)
+{
+    const char *cur = s;
+
+    if (isEmpty(s))
+	return NO;
+
+    if (*cur == '-')
+	cur++;			/* Allow initial minus sign in a number */
+
+    while (*cur) {
+	if (*cur < '0' || *cur > '9')
+	    return NO;
+	cur++;
+    }
+    return YES;
+}
+
+/* PUBLIC							HTAA_getUid()
+ *		GET THE USER ID TO CHANGE THE PROCESS UID TO
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *	returns	the uid number to give to setuid() system call.
+ *		Default is 65534 (nobody).
+ */
+int HTAA_getUid(void)
+{
+    int uid;
+
+    if (current_prot && current_prot->uid_name) {
+	if (isNumber(current_prot->uid_name)) {
+	    uid = atoi(current_prot->uid_name);
+	    if ((*HTAA_UidToName(uid)) != '\0') {
+		return uid;
+	    }
+	} else {		/* User name (not a number) */
+	    if ((uid = HTAA_NameToUid(current_prot->uid_name)) != NONESUCH) {
+		return uid;
+	    }
+	}
+    }
+    /*
+     * Ok, then let's get uid for nobody.
+     */
+    if ((uid = HTAA_NameToUid("nobody")) != NONESUCH) {
+	return uid;
+    }
+    /*
+     * Ok, then use default.
+     */
+    return NOBODY;		/* nobody */
+}
+
+/* PUBLIC							HTAA_getGid()
+ *		GET THE GROUP ID TO CHANGE THE PROCESS GID TO
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *	returns	the uid number to give to setgid() system call.
+ *		Default is 65534 (nogroup).
+ */
+int HTAA_getGid(void)
+{
+    int gid;
+
+    if (current_prot && current_prot->gid_name) {
+	if (isNumber(current_prot->gid_name)) {
+	    gid = atoi(current_prot->gid_name);
+	    if (*HTAA_GidToName(gid) != '\0') {
+		return gid;
+	    }
+	} else {		/* Group name (not number) */
+	    if ((gid = HTAA_NameToGid(current_prot->gid_name)) != NONESUCH) {
+		return gid;
+	    }
+	}
+    }
+    /*
+     * Ok, then let's get gid for nogroup.
+     */
+    if ((gid = HTAA_NameToGid("nogroup")) != NONESUCH) {
+	return gid;
+    }
+    /*
+     * Ok, then use default.
+     */
+    return NOBODY;		/* nogroup */
+}
+#endif /* !NOUSERS */
+
+/* static							HTAA_setIds()
+ *		SET UID AND GID (AS NAMES OR NUMBERS)
+ *		TO HTAAProt STRUCTURE
+ * ON ENTRY:
+ *	prot		destination.
+ *	ids		is a string like "james.www" or "1422.69" etc.
+ *			giving uid and gid.
+ *
+ * ON EXIT:
+ *	returns		nothing.
+ */
+static void HTAA_setIds(HTAAProt *prot, const char *ids)
+{
+    if (ids) {
+	char *local_copy = NULL;
+	char *point;
+
+	StrAllocCopy(local_copy, ids);
+	point = StrChr(local_copy, '.');
+	if (point) {
+	    *(point++) = (char) 0;
+	    StrAllocCopy(prot->gid_name, point);
+	} else {
+	    StrAllocCopy(prot->gid_name, "nogroup");
+	}
+	StrAllocCopy(prot->uid_name, local_copy);
+	FREE(local_copy);
+    } else {
+	StrAllocCopy(prot->uid_name, "nobody");
+	StrAllocCopy(prot->gid_name, "nogroup");
+    }
+}
+
+/* static						HTAA_parseProtFile()
+ *		PARSE A PROTECTION SETUP FILE AND
+ *		PUT THE RESULT IN A HTAAProt STRUCTURE
+ * ON ENTRY:
+ *	prot		destination structure.
+ *	fp		open protection file.
+ *
+ * ON EXIT:
+ *	returns		nothing.
+ */
+static void HTAA_parseProtFile(HTAAProt *prot, FILE *fp)
+{
+    if (prot && fp) {
+	LexItem lex_item;
+	char *fieldname = NULL;
+
+	while (LEX_EOF != (lex_item = lex(fp))) {
+
+	    while (lex_item == LEX_REC_SEP)	/* Ignore empty lines */
+		lex_item = lex(fp);
+
+	    if (lex_item == LEX_EOF)	/* End of file */
+		break;
+
+	    if (lex_item == LEX_ALPH_STR) {	/* Valid setup record */
+
+		StrAllocCopy(fieldname, HTlex_buffer);
+
+		if (LEX_FIELD_SEP != (lex_item = lex(fp)))
+		    unlex(lex_item);	/* If someone wants to use colon */
+		/* after field name it's ok, but */
+		/* not required. Here we read it. */
+
+		if (0 == strncasecomp(fieldname, "Auth", 4)) {
+		    lex_item = lex(fp);
+		    while (lex_item == LEX_ALPH_STR) {
+			HTAAScheme scheme = HTAAScheme_enum(HTlex_buffer);
+
+			if (scheme != HTAA_UNKNOWN) {
+			    if (!prot->valid_schemes)
+				prot->valid_schemes = HTList_new();
+			    HTList_addObject(prot->valid_schemes, (void *) scheme);
+			    CTRACE((tfp, "%s %s `%s'\n",
+				    "HTAA_parseProtFile: valid",
+				    "authentication scheme:",
+				    HTAAScheme_name(scheme)));
+			} else {
+			    CTRACE((tfp, "%s %s `%s'\n",
+				    "HTAA_parseProtFile: unknown",
+				    "authentication scheme:",
+				    HTlex_buffer));
+			}
+
+			if (LEX_ITEM_SEP != (lex_item = lex(fp)))
+			    break;
+			/*
+			 * Here lex_item == LEX_ITEM_SEP; after item separator
+			 * it is ok to have one or more newlines (LEX_REC_SEP)
+			 * and they are ignored (continuation line).
+			 */
+			do {
+			    lex_item = lex(fp);
+			} while (lex_item == LEX_REC_SEP);
+		    }		/* while items in list */
+		}
+		/* if "Authenticate" */
+		else if (0 == strncasecomp(fieldname, "mask", 4)) {
+		    prot->mask_group = HTAA_parseGroupDef(fp);
+		    lex_item = LEX_REC_SEP;	/*groupdef parser read this already */
+		    if (TRACE) {
+			if (prot->mask_group) {
+			    fprintf(tfp,
+				    "HTAA_parseProtFile: Mask group:\n");
+			    HTAA_printGroupDef(prot->mask_group);
+			} else
+			    fprintf(tfp,
+				    "HTAA_parseProtFile: Mask group syntax error\n");
+		    }
+		}
+		/* if "Mask" */
+		else {		/* Just a name-value pair, put it to assoclist */
+
+		    if (LEX_ALPH_STR == (lex_item = lex(fp))) {
+			if (!prot->values)
+			    prot->values = HTAssocList_new();
+			HTAssocList_add(prot->values, fieldname, HTlex_buffer);
+			lex_item = lex(fp);	/* Read record separator */
+			CTRACE((tfp, "%s `%s' bound to value `%s'\n",
+				"HTAA_parseProtFile: Name",
+				fieldname, HTlex_buffer));
+		    }
+		}		/* else name-value pair */
+
+	    }
+	    /* if valid field */
+	    if (lex_item != LEX_EOF && lex_item != LEX_REC_SEP) {
+		CTRACE((tfp, "%s %s %d (that line ignored)\n",
+			"HTAA_parseProtFile: Syntax error",
+			"in protection setup file at line",
+			HTlex_line));
+		do {
+		    lex_item = lex(fp);
+		} while (lex_item != LEX_EOF && lex_item != LEX_REC_SEP);
+	    }			/* if syntax error */
+	}			/* while not end-of-file */
+	FREE(fieldname);
+    }				/* if valid parameters */
+}
+
+/* static						HTAAProt_new()
+ *		ALLOCATE A NEW HTAAProt STRUCTURE AND
+ *		INITIALIZE IT FROM PROTECTION SETUP FILE
+ * ON ENTRY:
+ *	cur_docname	current filename after rule translations.
+ *	prot_filename	protection setup file name.
+ *			If NULL, not an error.
+ *	ids		Uid and gid names or numbers,
+ *			examples:
+ *				james	( <=> james.nogroup)
+ *				.www	( <=> nobody.www)
+ *				james.www
+ *				james.69
+ *				1422.69
+ *				1422.www
+ *
+ *			May be NULL, defaults to nobody.nogroup.
+ *			Should be NULL, if prot_file is NULL.
+ *
+ * ON EXIT:
+ *	returns		returns a new and initialized protection
+ *			setup structure.
+ *			If setup file is already read in (found
+ *			in cache), only sets uid_name and gid
+ *			fields, and returns that.
+ */
+static HTAAProt *HTAAProt_new(const char *cur_docname,
+			      const char *prot_filename,
+			      const char *ids)
+{
+    HTList *cur = prot_cache;
+    HTAAProtCache *cache_item = NULL;
+    HTAAProt *prot;
+    FILE *fp;
+
+    if (!prot_cache)
+	prot_cache = HTList_new();
+
+    while (NULL != (cache_item = (HTAAProtCache *) HTList_nextObject(cur))) {
+	if (!strcmp(cache_item->prot_filename, prot_filename))
+	    break;
+    }
+    if (cache_item) {
+	prot = cache_item->prot;
+	CTRACE((tfp, "%s `%s' already in cache\n",
+		"HTAAProt_new: Protection file", prot_filename));
+    } else {
+	CTRACE((tfp, "HTAAProt_new: Loading protection file `%s'\n",
+		prot_filename));
+
+	if ((prot = typecalloc(HTAAProt)) == 0)
+	      outofmem(__FILE__, "HTAAProt_new");
+
+	prot->ctemplate = NULL;
+	prot->filename = NULL;
+	prot->uid_name = NULL;
+	prot->gid_name = NULL;
+	prot->valid_schemes = HTList_new();
+	prot->mask_group = NULL;	/* Masking disabled by defaults */
+	prot->values = HTAssocList_new();
+
+	if (prot_filename && NULL != (fp = fopen(prot_filename, TXT_R))) {
+	    HTAA_parseProtFile(prot, fp);
+	    fclose(fp);
+	    if ((cache_item = typecalloc(HTAAProtCache)) == 0)
+		outofmem(__FILE__, "HTAAProt_new");
+
+	    cache_item->prot = prot;
+	    cache_item->prot_filename = NULL;
+	    StrAllocCopy(cache_item->prot_filename, prot_filename);
+	    HTList_addObject(prot_cache, (void *) cache_item);
+	} else {
+	    CTRACE((tfp, "HTAAProt_new: %s `%s'\n",
+		    "Unable to open protection setup file",
+		    NONNULL(prot_filename)));
+	}
+    }
+
+    if (cur_docname)
+	StrAllocCopy(prot->filename, cur_docname);
+    HTAA_setIds(prot, ids);
+
+    return prot;
+}
+
+/* PUBLIC					HTAA_setDefaultProtection()
+ *		SET THE DEFAULT PROTECTION MODE
+ *		(called by rule system when a
+ *		"defprot" rule is matched)
+ * ON ENTRY:
+ *	cur_docname	is the current result of rule translations.
+ *	prot_filename	is the protection setup file (second argument
+ *			for "defprot" rule, optional)
+ *	ids		contains user and group names separated by
+ *			a dot, corresponding to the uid
+ *			gid under which the server should run,
+ *			default is "nobody.nogroup" (third argument
+ *			for "defprot" rule, optional; can be given
+ *			only if protection setup file is also given).
+ *
+ * ON EXIT:
+ *	returns		nothing.
+ *			Sets the module-wide variable default_prot.
+ */
+void HTAA_setDefaultProtection(const char *cur_docname,
+			       const char *prot_filename,
+			       const char *ids)
+{
+    default_prot = NULL;	/* Not free()'d because this is in cache */
+
+    if (prot_filename) {
+	default_prot = HTAAProt_new(cur_docname, prot_filename, ids);
+    } else {
+	CTRACE((tfp, "%s %s\n",
+		"HTAA_setDefaultProtection: ERROR: Protection file",
+		"not specified (obligatory for DefProt rule)!!\n"));
+    }
+}
+
+/* PUBLIC					HTAA_setCurrentProtection()
+ *		SET THE CURRENT PROTECTION MODE
+ *		(called by rule system when a
+ *		"protect" rule is matched)
+ * ON ENTRY:
+ *	cur_docname	is the current result of rule translations.
+ *	prot_filename	is the protection setup file (second argument
+ *			for "protect" rule, optional)
+ *	ids		contains user and group names separated by
+ *			a dot, corresponding to the uid
+ *			gid under which the server should run,
+ *			default is "nobody.nogroup" (third argument
+ *			for "protect" rule, optional; can be given
+ *			only if protection setup file is also given).
+ *
+ * ON EXIT:
+ *	returns		nothing.
+ *			Sets the module-wide variable current_prot.
+ */
+void HTAA_setCurrentProtection(const char *cur_docname,
+			       const char *prot_filename,
+			       const char *ids)
+{
+    current_prot = NULL;	/* Not free()'d because this is in cache */
+
+    if (prot_filename) {
+	current_prot = HTAAProt_new(cur_docname, prot_filename, ids);
+    } else {
+	if (default_prot) {
+	    current_prot = default_prot;
+	    HTAA_setIds(current_prot, ids);
+	    CTRACE((tfp, "%s %s %s\n",
+		    "HTAA_setCurrentProtection: Protection file",
+		    "not specified for Protect rule",
+		    "-- using default protection"));
+	} else {
+	    CTRACE((tfp, "%s %s %s\n",
+		    "HTAA_setCurrentProtection: ERROR: Protection",
+		    "file not specified for Protect rule, and",
+		    "default protection is not set!!"));
+	}
+    }
+}
+
+/* PUBLIC					HTAA_getCurrentProtection()
+ *		GET CURRENT PROTECTION SETUP STRUCTURE
+ *		(this is set up by callbacks made from
+ *		 the rule system when matching "protect"
+ *		 (and "defprot") rules)
+ * ON ENTRY:
+ *	HTTranslate() must have been called before calling
+ *	this function.
+ *
+ * ON EXIT:
+ *	returns	a HTAAProt structure representing the
+ *		protection setup of the HTTranslate()'d file.
+ *		This must not be free()'d.
+ */
+HTAAProt *HTAA_getCurrentProtection(void)
+{
+    return current_prot;
+}
+
+/* PUBLIC					HTAA_getDefaultProtection()
+ *		GET DEFAULT PROTECTION SETUP STRUCTURE
+ *		AND SET IT TO CURRENT PROTECTION
+ *		(this is set up by callbacks made from
+ *		 the rule system when matching "defprot"
+ *		 rules)
+ * ON ENTRY:
+ *	HTTranslate() must have been called before calling
+ *	this function.
+ *
+ * ON EXIT:
+ *	returns	a HTAAProt structure representing the
+ *		default protection setup of the HTTranslate()'d
+ *		file (if HTAA_getCurrentProtection() returned
+ *		NULL, i.e., if there is no "protect" rule
+ *		but ACL exists, and we need to know default
+ *		protection settings).
+ *		This must not be free()'d.
+ * IMPORTANT:
+ *	As a side-effect this tells the protection system that
+ *	the file is in fact protected and sets the current
+ *	protection mode to default.
+ */
+HTAAProt *HTAA_getDefaultProtection(void)
+{
+    if (!current_prot) {
+	current_prot = default_prot;
+	default_prot = NULL;
+    }
+    return current_prot;
+}
+
+/* SERVER INTERNAL					HTAA_clearProtections()
+ *		CLEAR DOCUMENT PROTECTION MODE
+ *		(ALSO DEFAULT PROTECTION)
+ *		(called by the rule system)
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *	returns	nothing.
+ *		Frees the memory used by protection information.
+ */
+void HTAA_clearProtections(void)
+{
+    current_prot = NULL;	/* These are not freed because  */
+    default_prot = NULL;	/* they are actually in cache.  */
+}
+
+typedef struct {
+    char *name;
+    int user;
+} USER_DATA;
+
+#ifndef NOUSERS
+static HTList *known_grp = NULL;
+static HTList *known_pwd = NULL;
+static BOOL uidgid_cache_inited = NO;
+#endif
+
+#ifdef LY_FIND_LEAKS
+static void clear_uidgid_cache(void)
+{
+#ifndef NOUSERS
+    USER_DATA *data;
+
+    if (known_grp) {
+	while ((data = HTList_removeLastObject(known_grp)) != NULL) {
+	    FREE(data->name);
+	    FREE(data);
+	}
+	FREE(known_grp);
+    }
+    if (known_pwd) {
+	while ((data = HTList_removeLastObject(known_pwd)) != NULL) {
+	    FREE(data->name);
+	    FREE(data);
+	}
+	FREE(known_pwd);
+    }
+#endif
+}
+#endif /* LY_FIND_LEAKS */
+
+#ifndef NOUSERS
+static void save_gid_info(const char *name, int user)
+{
+    USER_DATA *data = typecalloc(USER_DATA);
+
+    if (!data)
+	return;
+    if (!known_grp) {
+	known_grp = HTList_new();
+	if (!uidgid_cache_inited) {
+#ifdef LY_FIND_LEAKS
+	    atexit(clear_uidgid_cache);
+#endif
+	    uidgid_cache_inited = YES;
+	}
+    }
+    StrAllocCopy(data->name, name);
+    data->user = user;
+    HTList_addObject(known_grp, data);
+}
+#endif /* NOUSERS */
+
+#ifndef NOUSERS
+static void save_uid_info(const char *name, int user)
+{
+    USER_DATA *data = typecalloc(USER_DATA);
+
+    if (!data)
+	return;
+    if (!known_pwd) {
+	known_pwd = HTList_new();
+	if (!uidgid_cache_inited) {
+#ifdef LY_FIND_LEAKS
+	    atexit(clear_uidgid_cache);
+#endif
+	    uidgid_cache_inited = YES;
+	}
+    }
+    StrAllocCopy(data->name, name);
+    data->user = user;
+    HTList_addObject(known_pwd, data);
+}
+#endif /* !NOUSERS */
+
+/* PUBLIC							HTAA_UidToName
+ *		GET THE USER NAME
+ * ON ENTRY:
+ *      The user-id
+ *
+ * ON EXIT:
+ *      returns the user name, or an empty string if not found.
+ */
+const char *HTAA_UidToName(int uid GCC_UNUSED)
+{
+#ifndef NOUSERS
+    struct passwd *pw;
+    HTList *me = known_pwd;
+
+    while (HTList_nextObject(me)) {
+	USER_DATA *data = (USER_DATA *) (me->object);
+
+	if (uid == data->user)
+	    return data->name;
+    }
+
+    if ((pw = getpwuid((uid_t) uid)) != 0
+	&& pw->pw_name != 0) {
+	CTRACE((tfp, "%s(%d) returned (%s:%d:...)\n",
+		"HTAA_UidToName: getpwuid",
+		uid,
+		pw->pw_name, (int) pw->pw_uid));
+	save_uid_info(pw->pw_name, (int) pw->pw_uid);
+	return pw->pw_name;
+    }
+#endif
+    return "";
+}
+
+/* PUBLIC							HTAA_NameToUid
+ *		GET THE USER ID
+ * ON ENTRY:
+ *      The user-name
+ *
+ * ON EXIT:
+ *      returns the user id, or NONESUCH if not found.
+ */
+int HTAA_NameToUid(const char *name GCC_UNUSED)
+{
+#ifndef NOUSERS
+    struct passwd *pw;
+    HTList *me = known_pwd;
+
+    while (HTList_nextObject(me)) {
+	USER_DATA *data = (USER_DATA *) (me->object);
+
+	if (!strcmp(name, data->name))
+	    return data->user;
+    }
+
+    if ((pw = getpwnam(name)) != 0) {
+	CTRACE((tfp, "%s(%s) returned (%s:%d:...)\n",
+		"HTAA_NameToUid: getpwnam",
+		name,
+		pw->pw_name, (int) pw->pw_uid));
+	save_uid_info(pw->pw_name, (int) pw->pw_uid);
+	return (int) pw->pw_uid;
+    }
+#endif
+    return NONESUCH;
+}
+
+/* PUBLIC							HTAA_GidToName
+ *		GET THE GROUP NAME
+ * ON ENTRY:
+ *      The group-id
+ *
+ * ON EXIT:
+ *      returns the group name, or an empty string if not found.
+ */
+const char *HTAA_GidToName(int gid GCC_UNUSED)
+{
+#ifndef NOUSERS
+    struct group *gr;
+    HTList *me = known_grp;
+
+    while (HTList_nextObject(me)) {
+	USER_DATA *data = (USER_DATA *) (me->object);
+
+	if (gid == data->user)
+	    return data->name;
+    }
+
+    if ((gr = getgrgid((gid_t) gid)) != 0
+	&& gr->gr_name != 0) {
+	CTRACE((tfp, "%s(%d) returned (%s:%d:...)\n",
+		"HTAA_GidToName: getgrgid",
+		gid,
+		gr->gr_name, (int) gr->gr_gid));
+	save_gid_info(gr->gr_name, (int) gr->gr_gid);
+	return gr->gr_name;
+    }
+#endif
+    return "";
+}
+
+/* PUBLIC							HTAA_NameToGid
+ *		GET THE GROUP ID
+ * ON ENTRY:
+ *      The group-name
+ *
+ * ON EXIT:
+ *      returns the group id, or NONESUCH if not found.
+ */
+int HTAA_NameToGid(const char *name GCC_UNUSED)
+{
+#ifndef NOUSERS
+    struct group *gr;
+    HTList *me = known_grp;
+
+    while (HTList_nextObject(me)) {
+	USER_DATA *data = (USER_DATA *) (me->object);
+
+	if (!strcmp(name, data->name))
+	    return data->user;
+    }
+
+    if ((gr = getgrnam(name)) != 0) {
+	CTRACE((tfp, "%s(%s) returned (%s:%d:...)\n",
+		"HTAA_NameToGid: getgrnam",
+		name,
+		gr->gr_name, (int) gr->gr_gid));
+	save_gid_info(gr->gr_name, (int) gr->gr_gid);
+	return (int) gr->gr_gid;
+    }
+#endif
+    return NONESUCH;
+}
diff --git a/WWW/Library/Implementation/HTAAProt.h b/WWW/Library/Implementation/HTAAProt.h
new file mode 100644
index 0000000..22e3d92
--- /dev/null
+++ b/WWW/Library/Implementation/HTAAProt.h
@@ -0,0 +1,226 @@
+/*                                   PROTECTION SETUP FILE
+
+ */
+
+#ifndef HTAAPROT_H
+#define HTAAPROT_H
+
+#include <HTGroup.h>
+#include <HTAssoc.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+
+Server's Representation of Document (Tree) Protections
+
+ */ typedef struct {
+	char *ctemplate;	/* Template for this protection         */
+	char *filename;		/* Current document file                */
+	char *uid_name;		/* Effective uid (name of it)           */
+	char *gid_name;		/* Effective gid (name of it)           */
+	GroupDef *mask_group;	/* Allowed users and IP addresses       */
+	HTList *valid_schemes;	/* Valid authentication schemes         */
+	HTAssocList *values;	/* Association list for scheme specific */
+	/* parameters.                          */
+    } HTAAProt;
+
+/*
+
+Callbacks for rule system
+
+   The following three functioncs are called by the rule system:
+
+      HTAA_clearProtections() when starting to translate a filename
+
+      HTAA_setDefaultProtection() when "defprot" rule is matched
+
+      HTAA_setCurrentProtection() when "protect" rule is matched
+
+   Protection setup files are cached by these functions.
+
+ */
+
+/* PUBLIC                                       HTAA_setDefaultProtection()
+ *              SET THE DEFAULT PROTECTION MODE
+ *              (called by rule system when a
+ *              "defprot" rule is matched)
+ * ON ENTRY:
+ *      cur_docname     is the current result of rule translations.
+ *      prot_filename   is the protection setup file (second argument
+ *                      for "defprot" rule, optional)
+ *      eff_ids         contains user and group names separated by
+ *                      a dot, corresponding to the effective uid
+ *                      gid under which the server should run,
+ *                      default is "nobody.nogroup" (third argument
+ *                      for "defprot" rule, optional; can be given
+ *                      only if protection setup file is also given).
+ *
+ * ON EXIT:
+ *      returns         nothing.
+ *                      Sets the module-wide variable default_prot.
+ */
+    extern void HTAA_setDefaultProtection(const char *cur_docname,
+					  const char *prot_filename,
+					  const char *eff_ids);
+
+/* PUBLIC                                       HTAA_setCurrentProtection()
+ *              SET THE CURRENT PROTECTION MODE
+ *              (called by rule system when a
+ *              "protect" rule is matched)
+ * ON ENTRY:
+ *      cur_docname     is the current result of rule translations.
+ *      prot_filename   is the protection setup file (second argument
+ *                      for "protect" rule, optional)
+ *      eff_ids         contains user and group names separated by
+ *                      a dot, corresponding to the effective uid
+ *                      gid under which the server should run,
+ *                      default is "nobody.nogroup" (third argument
+ *                      for "protect" rule, optional; can be given
+ *                      only if protection setup file is also given).
+ *
+ * ON EXIT:
+ *      returns         nothing.
+ *                      Sets the module-wide variable current_prot.
+ */
+    extern void HTAA_setCurrentProtection(const char *cur_docname,
+					  const char *prot_filename,
+					  const char *eff_ids);
+
+/* SERVER INTERNAL                                      HTAA_clearProtections()
+ *              CLEAR DOCUMENT PROTECTION MODE
+ *              (ALSO DEFAULT PROTECTION)
+ *              (called by the rule system)
+ * ON ENTRY:
+ *      No arguments.
+ *
+ * ON EXIT:
+ *      returns nothing.
+ *              Frees the memory used by protection information.
+ */
+    extern void HTAA_clearProtections(void);
+
+/*
+
+Getting Protection Settings
+
+      HTAA_getCurrentProtection() returns the current protection mode (if there was a
+      "protect" rule). NULL, if no "protect" rule has been matched.
+
+      HTAA_getDefaultProtection() sets the current protection mode to what it was set to
+      by "defprot" rule and also returns it (therefore after this call also
+      HTAA_getCurrentProtection() returns the same structure.
+
+ */
+
+/* PUBLIC                                       HTAA_getCurrentProtection()
+ *              GET CURRENT PROTECTION SETUP STRUCTURE
+ *              (this is set up by callbacks made from
+ *               the rule system when matching "protect"
+ *               (and "defprot") rules)
+ * ON ENTRY:
+ *      HTTranslate() must have been called before calling
+ *      this function.
+ *
+ * ON EXIT:
+ *      returns a HTAAProt structure representing the
+ *              protection setup of the HTTranslate()'d file.
+ *              This must not be free()'d.
+ */
+    extern HTAAProt *HTAA_getCurrentProtection(void);
+
+/* PUBLIC                                       HTAA_getDefaultProtection()
+ *              GET DEFAULT PROTECTION SETUP STRUCTURE
+ *              (this is set up by callbacks made from
+ *               the rule system when matching "defprot"
+ *               rules)
+ * ON ENTRY:
+ *      HTTranslate() must have been called before calling
+ *      this function.
+ *
+ * ON EXIT:
+ *      returns a HTAAProt structure representing the
+ *              default protection setup of the HTTranslate()'d
+ *              file (if HTAA_getCurrentProtection() returned
+ *              NULL, i.e., if there is no "protect" rule
+ *              but ACL exists, and we need to know default
+ *              protection settings).
+ *              This must not be free()'d.
+ */
+    extern HTAAProt *HTAA_getDefaultProtection(void);
+
+/*
+
+Get User and Group IDs to Which Set to
+
+ */
+
+#ifndef NOUSERS
+/* PUBLIC                                                       HTAA_getUid()
+ *              GET THE USER ID TO CHANGE THE PROCESS UID TO
+ * ON ENTRY:
+ *      No arguments.
+ *
+ * ON EXIT:
+ *      returns the uid number to give to setuid() system call.
+ *              Default is 65534 (nobody).
+ */
+    extern int HTAA_getUid(void);
+
+/* PUBLIC                                                       HTAA_getGid()
+ *              GET THE GROUP ID TO CHANGE THE PROCESS GID TO
+ * ON ENTRY:
+ *      No arguments.
+ *
+ * ON EXIT:
+ *      returns the uid number to give to setgid() system call.
+ *              Default is 65534 (nogroup).
+ */
+    extern int HTAA_getGid(void);
+#endif				/* !NOUSERS */
+
+/* PUBLIC                                                       HTAA_UidToName
+ *              GET THE USER NAME
+ * ON ENTRY:
+ *      The user-id
+ *
+ * ON EXIT:
+ *      returns the user name
+ */
+    extern const char *HTAA_UidToName(int uid);
+
+/* PUBLIC                                                       HTAA_NameToUid
+ *              GET THE USER ID
+ * ON ENTRY:
+ *      The user-name
+ *
+ * ON EXIT:
+ *      returns the user id
+ */
+    extern int HTAA_NameToUid(const char *name);
+
+/* PUBLIC                                                       HTAA_GidToName
+ *              GET THE GROUP NAME
+ * ON ENTRY:
+ *      The group-id
+ *
+ * ON EXIT:
+ *      returns the group name
+ */
+    extern const char *HTAA_GidToName(int gid);
+
+/* PUBLIC                                                       HTAA_NameToGid
+ *              GET THE GROUP ID
+ * ON ENTRY:
+ *      The group-name
+ *
+ * ON EXIT:
+ *      returns the group id
+ */
+    extern int HTAA_NameToGid(const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* not HTAAPROT_H */
diff --git a/WWW/Library/Implementation/HTAAUtil.c b/WWW/Library/Implementation/HTAAUtil.c
new file mode 100644
index 0000000..1be26f9
--- /dev/null
+++ b/WWW/Library/Implementation/HTAAUtil.c
@@ -0,0 +1,605 @@
+/*
+ * $LynxId: HTAAUtil.c,v 1.36 2016/11/24 15:29:50 tom Exp $
+ *
+ * MODULE							HTAAUtil.c
+ *		COMMON PARTS OF ACCESS AUTHORIZATION MODULE
+ *			FOR BOTH SERVER AND BROWSER
+ *
+ * IMPORTANT:
+ *	Routines in this module use dynamic allocation, but free
+ *	automatically all the memory reserved by them.
+ *
+ *	Therefore the caller never has to (and never should)
+ *	free() any object returned by these functions.
+ *
+ *	Therefore also all the strings returned by this package
+ *	are only valid until the next call to the same function
+ *	is made.  This approach is selected, because of the nature
+ *	of access authorization: no string returned by the package
+ *	needs to be valid longer than until the next call.
+ *
+ *	This also makes it easy to plug the AA package in:
+ *	you don't have to ponder whether to free() something
+ *	here or is it done somewhere else (because it is always
+ *	done somewhere else).
+ *
+ *	The strings that the package needs to store are copied
+ *	so the original strings given as parameters to AA
+ *	functions may be freed or modified with no side effects.
+ *
+ *	The AA package does not free() anything else than what
+ *	it has itself allocated.
+ *
+ *	AA (Access Authorization) package means modules which
+ *	names start with HTAA.
+ *
+ * AUTHORS:
+ *	AL	Ari Luotonen	luotonen@dxcern.cern.ch
+ *	MD	Mark Donszelmann    duns@vxdeop.cern.ch
+ *
+ * HISTORY:
+ *	 8 Nov 93  MD	(VMS only) Added case insensitive comparison in HTAA_templateCaseMatch
+ *
+ *
+ * BUGS:
+ *
+ *
+ */
+
+#include <HTUtils.h>
+
+#include <HTAAUtil.h>		/* Implemented here     */
+#include <HTAssoc.h>		/* Assoc list           */
+#include <HTTCP.h>
+#include <HTTP.h>
+
+#include <LYStrings.h>
+#include <LYUtils.h>
+#include <LYLeaks.h>
+
+/* PUBLIC						HTAAScheme_enum()
+ *		TRANSLATE SCHEME NAME INTO
+ *		A SCHEME ENUMERATION
+ *
+ * ON ENTRY:
+ *	name		is a string representing the scheme name.
+ *
+ * ON EXIT:
+ *	returns		the enumerated constant for that scheme.
+ */
+HTAAScheme HTAAScheme_enum(const char *name)
+{
+    char *upcased = NULL;
+
+    if (!name)
+	return HTAA_UNKNOWN;
+
+    StrAllocCopy(upcased, name);
+    LYUpperCase(upcased);
+
+    if (!StrNCmp(upcased, "NONE", 4)) {
+	FREE(upcased);
+	return HTAA_NONE;
+    } else if (!StrNCmp(upcased, "BASIC", 5)) {
+	FREE(upcased);
+	return HTAA_BASIC;
+    } else if (!StrNCmp(upcased, "PUBKEY", 6)) {
+	FREE(upcased);
+	return HTAA_PUBKEY;
+    } else if (!StrNCmp(upcased, "KERBEROSV4", 10)) {
+	FREE(upcased);
+	return HTAA_KERBEROS_V4;
+    } else if (!StrNCmp(upcased, "KERBEROSV5", 10)) {
+	FREE(upcased);
+	return HTAA_KERBEROS_V5;
+    } else {
+	FREE(upcased);
+	return HTAA_UNKNOWN;
+    }
+}
+
+/* PUBLIC						HTAAScheme_name()
+ *			GET THE NAME OF A GIVEN SCHEME
+ * ON ENTRY:
+ *	scheme		is one of the scheme enum values:
+ *			HTAA_NONE, HTAA_BASIC, HTAA_PUBKEY, ...
+ *
+ * ON EXIT:
+ *	returns		the name of the scheme, i.e.
+ *			"None", "Basic", "Pubkey", ...
+ */
+const char *HTAAScheme_name(HTAAScheme scheme)
+{
+    switch (scheme) {
+    case HTAA_NONE:
+	return "None";
+    case HTAA_BASIC:
+	return "Basic";
+    case HTAA_PUBKEY:
+	return "Pubkey";
+    case HTAA_KERBEROS_V4:
+	return "KerberosV4";
+    case HTAA_KERBEROS_V5:
+	return "KerberosV5";
+    case HTAA_UNKNOWN:
+	return "UNKNOWN";
+    default:
+	return "THIS-IS-A-BUG";
+    }
+}
+
+/* PUBLIC						    HTAAMethod_enum()
+ *		TRANSLATE METHOD NAME INTO AN ENUMERATED VALUE
+ * ON ENTRY:
+ *	name		is the method name to translate.
+ *
+ * ON EXIT:
+ *	returns		HTAAMethod enumerated value corresponding
+ *			to the given name.
+ */
+HTAAMethod HTAAMethod_enum(const char *name)
+{
+    if (!name)
+	return METHOD_UNKNOWN;
+
+    if (0 == strcasecomp(name, "GET"))
+	return METHOD_GET;
+    else if (0 == strcasecomp(name, "PUT"))
+	return METHOD_PUT;
+    else
+	return METHOD_UNKNOWN;
+}
+
+/* PUBLIC						HTAAMethod_name()
+ *			GET THE NAME OF A GIVEN METHOD
+ * ON ENTRY:
+ *	method		is one of the method enum values:
+ *			METHOD_GET, METHOD_PUT, ...
+ *
+ * ON EXIT:
+ *	returns		the name of the scheme, i.e.
+ *			"GET", "PUT", ...
+ */
+const char *HTAAMethod_name(HTAAMethod method)
+{
+    switch (method) {
+    case METHOD_GET:
+	return "GET";
+    case METHOD_PUT:
+	return "PUT";
+    case METHOD_UNKNOWN:
+	return "UNKNOWN";
+    default:
+	return "THIS-IS-A-BUG";
+    }
+}
+
+/* PUBLIC						HTAAMethod_inList()
+ *		IS A METHOD IN A LIST OF METHOD NAMES
+ * ON ENTRY:
+ *	method		is the method to look for.
+ *	list		is a list of method names.
+ *
+ * ON EXIT:
+ *	returns		YES, if method was found.
+ *			NO, if not found.
+ */
+BOOL HTAAMethod_inList(HTAAMethod method, HTList *list)
+{
+    HTList *cur = list;
+    char *item;
+
+    while (NULL != (item = (char *) HTList_nextObject(cur))) {
+	CTRACE((tfp, " %s", item));
+	if (method == HTAAMethod_enum(item))
+	    return YES;
+    }
+
+    return NO;			/* Not found */
+}
+
+/* PUBLIC						HTAA_templateMatch()
+ *		STRING COMPARISON FUNCTION FOR FILE NAMES
+ *		   WITH ONE WILDCARD * IN THE TEMPLATE
+ * NOTE:
+ *	This is essentially the same code as in HTRules.c, but it
+ *	cannot be used because it is embedded in between other code.
+ *	(In fact, HTRules.c should use this routine, but then this
+ *	 routine would have to be more sophisticated... why is life
+ *	 sometimes so hard...)
+ *
+ * ON ENTRY:
+ *	ctemplate	is a template string to match the file name
+ *			against, may contain a single wildcard
+ *			character * which matches zero or more
+ *			arbitrary characters.
+ *	filename	is the filename (or pathname) to be matched
+ *			against the template.
+ *
+ * ON EXIT:
+ *	returns		YES, if filename matches the template.
+ *			NO, otherwise.
+ */
+BOOL HTAA_templateMatch(const char *ctemplate,
+			const char *filename)
+{
+    const char *p = ctemplate;
+    const char *q = filename;
+    int m;
+
+    for (; *p && *q && *p == *q; p++, q++)	/* Find first mismatch */
+	;			/* do nothing else */
+
+    if (!*p && !*q)
+	return YES;		/* Equally long equal strings */
+    else if ('*' == *p) {	/* Wildcard */
+	p++;			/* Skip wildcard character */
+	m = (int) (strlen(q) - strlen(p));	/* Amount to match to wildcard */
+	if (m < 0)
+	    return NO;		/* No match, filename too short */
+	else {			/* Skip the matched characters and compare */
+	    if (strcmp(p, q + m))
+		return NO;	/* Tail mismatch */
+	    else
+		return YES;	/* Tail match */
+	}
+	/* if wildcard */
+    } else
+	return NO;		/* Length or character mismatch */
+}
+
+/* PUBLIC						HTAA_templateCaseMatch()
+ *		STRING COMPARISON FUNCTION FOR FILE NAMES
+ *		   WITH ONE WILDCARD * IN THE TEMPLATE (Case Insensitive)
+ * NOTE:
+ *	This is essentially the same code as in HTAA_templateMatch, but
+ *	it compares case insensitive (for VMS). Reason for this routine
+ *	is that HTAA_templateMatch gets called from several places, also
+ *	there where a case sensitive match is needed, so one cannot just
+ *	change the HTAA_templateMatch routine for VMS.
+ *
+ * ON ENTRY:
+ *	template	is a template string to match the file name
+ *			against, may contain a single wildcard
+ *			character * which matches zero or more
+ *			arbitrary characters.
+ *	filename	is the filename (or pathname) to be matched
+ *			against the template.
+ *
+ * ON EXIT:
+ *	returns		YES, if filename matches the template.
+ *			NO, otherwise.
+ */
+BOOL HTAA_templateCaseMatch(const char *ctemplate,
+			    const char *filename)
+{
+    const char *p = ctemplate;
+    const char *q = filename;
+    int m;
+
+    /* Find first mismatch */
+    for (; *p && *q && TOUPPER(*p) == TOUPPER(*q); p++, q++) ;	/* do nothing else */
+
+    if (!*p && !*q)
+	return YES;		/* Equally long equal strings */
+    else if ('*' == *p) {	/* Wildcard */
+	p++;			/* Skip wildcard character */
+	m = (int) (strlen(q) - strlen(p));	/* Amount to match to wildcard */
+	if (m < 0)
+	    return NO;		/* No match, filename too short */
+	else {			/* Skip the matched characters and compare */
+	    if (strcasecomp(p, q + m))
+		return NO;	/* Tail mismatch */
+	    else
+		return YES;	/* Tail match */
+	}
+	/* if wildcard */
+    } else
+	return NO;		/* Length or character mismatch */
+}
+
+/* PUBLIC					HTAA_makeProtectionTemplate()
+ *		CREATE A PROTECTION TEMPLATE FOR THE FILES
+ *		IN THE SAME DIRECTORY AS THE GIVEN FILE
+ *		(Used by server if there is no fancier way for
+ *		it to tell the client, and by browser if server
+ *		didn't send WWW-ProtectionTemplate: field)
+ * ON ENTRY:
+ *	docname is the document pathname (from URL).
+ *
+ * ON EXIT:
+ *	returns a template matching docname, and other files
+ *		files in that directory.
+ *
+ *		E.g.  /foo/bar/x.html  =>  /foo/bar/ *
+ *						    ^
+ *				Space only to prevent it from
+ *				being a comment marker here,
+ *				there really isn't any space.
+ */
+char *HTAA_makeProtectionTemplate(const char *docname)
+{
+    char *ctemplate = NULL;
+    char *slash = NULL;
+
+    if (docname) {
+	StrAllocCopy(ctemplate, docname);
+	slash = strrchr(ctemplate, '/');
+	if (slash)
+	    slash++;
+	else
+	    slash = ctemplate;
+	*slash = '\0';
+	StrAllocCat(ctemplate, "*");
+    } else
+	StrAllocCopy(ctemplate, "*");
+
+    CTRACE((tfp, "make_template: made template `%s' for file `%s'\n",
+	    ctemplate, docname));
+
+    return ctemplate;
+}
+
+/*
+ * Skip leading whitespace from *s forward
+ */
+#define SKIPWS(s) while (*s==' ' || *s=='\t') s++;
+
+/*
+ * Kill trailing whitespace starting from *(s-1) backwards
+ */
+#define KILLWS(s) {char *c=s-1; while (*c==' ' || *c=='\t') *(c--)='\0';}
+
+/* PUBLIC						HTAA_parseArgList()
+ *		PARSE AN ARGUMENT LIST GIVEN IN A HEADER FIELD
+ * ON ENTRY:
+ *	str	is a comma-separated list:
+ *
+ *			item, item, item
+ *		where
+ *			item ::= value
+ *			       | name=value
+ *			       | name="value"
+ *
+ *		Leading and trailing whitespace is ignored
+ *		everywhere except inside quotes, so the following
+ *		examples are equal:
+ *
+ *			name=value,foo=bar
+ *			 name="value",foo="bar"
+ *			  name = value ,  foo = bar
+ *			   name = "value" ,  foo = "bar"
+ *
+ * ON EXIT:
+ *	returns a list of name-value pairs (actually HTAssocList*).
+ *		For items with no name, just value, the name is
+ *		the number of order number of that item. E.g.
+ *		"1" for the first, etc.
+ */
+HTAssocList *HTAA_parseArgList(char *str)
+{
+    HTAssocList *assoc_list = HTAssocList_new();
+    char *cur = NULL;
+    char *name = NULL;
+    int n = 0;
+
+    if (!str)
+	return assoc_list;
+
+    while (*str) {
+	SKIPWS(str);		/* Skip leading whitespace */
+	cur = str;
+	n++;
+
+	while (*cur && *cur != '=' && *cur != ',')
+	    cur++;		/* Find end of name (or lonely value without a name) */
+	KILLWS(cur);		/* Kill trailing whitespace */
+
+	if (*cur == '=') {	/* Name followed by a value */
+	    *(cur++) = '\0';	/* Terminate name */
+	    StrAllocCopy(name, str);
+	    SKIPWS(cur);	/* Skip WS leading the value */
+	    str = cur;
+	    if (*str == '"') {	/* Quoted value */
+		str++;
+		cur = str;
+		while (*cur && *cur != '"')
+		    cur++;
+		if (*cur == '"')
+		    *(cur++) = '\0';	/* Terminate value */
+		/* else it is lacking terminating quote */
+		SKIPWS(cur);	/* Skip WS leading comma */
+		if (*cur == ',')
+		    cur++;	/* Skip separating colon */
+	    } else {		/* Unquoted value */
+		while (*cur && *cur != ',')
+		    cur++;
+		KILLWS(cur);	/* Kill trailing whitespace */
+		if (*cur == ',')
+		    *(cur++) = '\0';
+		/* else *cur already NULL */
+	    }
+	} else {		/* No name, just a value */
+	    if (*cur == ',')
+		*(cur++) = '\0';	/* Terminate value */
+	    /* else last value on line (already terminated by NULL) */
+	    HTSprintf0(&name, "%d", n);		/* Item order number for name */
+	}
+	HTAssocList_add(assoc_list, name, str);
+	str = cur;
+    }				/* while *str */
+
+    FREE(name);
+    return assoc_list;
+}
+
+/************** HEADER LINE READER -- DOES UNFOLDING *************************/
+
+#define BUFFER_SIZE	1024
+
+static size_t buffer_length;
+static char *buffer = 0;
+static char *start_pointer;
+static char *end_pointer;
+static int in_soc = -1;
+
+#ifdef LY_FIND_LEAKS
+static void FreeHTAAUtil(void)
+{
+    FREE(buffer);
+}
+#endif /* LY_FIND_LEAKS */
+
+/* PUBLIC						HTAA_setupReader()
+ *		SET UP HEADER LINE READER, i.e., give
+ *		the already-read-but-not-yet-processed
+ *		buffer of text to be read before more
+ *		is read from the socket.
+ * ON ENTRY:
+ *	start_of_headers is a pointer to a buffer containing
+ *			the beginning of the header lines
+ *			(rest will be read from a socket).
+ *	length		is the number of valid characters in
+ *			'start_of_headers' buffer.
+ *	soc		is the socket to use when start_of_headers
+ *			buffer is used up.
+ * ON EXIT:
+ *	returns		nothing.
+ *			Subsequent calls to HTAA_getUnfoldedLine()
+ *			will use this buffer first and then
+ *			proceed to read from socket.
+ */
+void HTAA_setupReader(char *start_of_headers,
+		      size_t length,
+		      int soc)
+{
+    if (!start_of_headers)
+	length = 0;		/* initialize length (is this reached at all?) */
+    if (buffer == NULL) {	/* first call? */
+	buffer_length = length;
+	if (buffer_length < BUFFER_SIZE)	/* would fall below BUFFER_SIZE? */
+	    buffer_length = BUFFER_SIZE;
+	buffer = (char *) malloc((size_t) (sizeof(char) * (buffer_length + 1)));
+    } else if (length > buffer_length) {	/* need more space? */
+	buffer_length = length;
+	buffer = (char *) realloc((char *) buffer,
+				  (size_t) (sizeof(char) * (buffer_length + 1)));
+    }
+    if (buffer == NULL)
+	outofmem(__FILE__, "HTAA_setupReader");
+
+#ifdef LY_FIND_LEAKS
+    atexit(FreeHTAAUtil);
+#endif
+    start_pointer = buffer;
+    if (start_of_headers) {
+	LYStrNCpy(buffer, start_of_headers, length);
+	end_pointer = buffer + length;
+    } else {
+	*start_pointer = '\0';
+	end_pointer = start_pointer;
+    }
+    in_soc = soc;
+}
+
+/* PUBLIC						HTAA_getUnfoldedLine()
+ *		READ AN UNFOLDED HEADER LINE FROM SOCKET
+ * ON ENTRY:
+ *	HTAA_setupReader must absolutely be called before
+ *	this function to set up internal buffer.
+ *
+ * ON EXIT:
+ *	returns a newly-allocated character string representing
+ *		the read line.	The line is unfolded, i.e.
+ *		lines that begin with whitespace are appended
+ *		to current line.  E.g.
+ *
+ *			Field-Name: Blaa-Blaa
+ *			 This-Is-A-Continuation-Line
+ *			 Here-Is_Another
+ *
+ *		is seen by the caller as:
+ *
+ *	Field-Name: Blaa-Blaa This-Is-A-Continuation-Line Here-Is_Another
+ *
+ */
+char *HTAA_getUnfoldedLine(void)
+{
+    char *line = NULL;
+    char *cur;
+    int count;
+    BOOL peek_for_folding = NO;
+
+    if (in_soc < 0) {
+	CTRACE((tfp, "%s %s\n",
+		"HTAA_getUnfoldedLine: buffer not initialized",
+		"with function HTAA_setupReader()"));
+	return NULL;
+    }
+
+    for (;;) {
+
+	/* Reading from socket */
+
+	if (start_pointer >= end_pointer) {	/*Read the next block and continue */
+#ifdef USE_SSL
+	    if (SSL_handle)
+		count = SSL_read(SSL_handle, buffer, BUFFER_SIZE);
+	    else
+		count = NETREAD(in_soc, buffer, BUFFER_SIZE);
+#else
+	    count = NETREAD(in_soc, buffer, BUFFER_SIZE);
+#endif /* USE_SSL */
+	    if (count <= 0) {
+		in_soc = -1;
+		return line;
+	    }
+	    if (count > (int) buffer_length)
+		count = (int) buffer_length;
+	    start_pointer = buffer;
+	    end_pointer = buffer + count;
+	    *end_pointer = '\0';
+#ifdef NOT_ASCII
+	    cur = start_pointer;
+	    while (cur < end_pointer) {
+		*cur = TOASCII(*cur);
+		cur++;
+	    }
+#endif /*NOT_ASCII */
+	}
+	cur = start_pointer;
+
+	/* Unfolding */
+
+	if (peek_for_folding) {
+	    if (*cur != ' ' && *cur != '\t')
+		return line;	/* Ok, no continuation line */
+	    else		/* So this is a continuation line, continue */
+		peek_for_folding = NO;
+	}
+
+	/* Finding end-of-line */
+
+	while (cur < end_pointer && *cur != '\n')	/* Find the end-of-line */
+	    cur++;		/* (or end-of-buffer).  */
+
+	/* Terminating line */
+
+	if (cur < end_pointer) {	/* So *cur==LF, terminate line */
+	    *cur = '\0';	/* Overwrite LF */
+	    if (*(cur - 1) == '\r')
+		*(cur - 1) = '\0';	/* Overwrite CR */
+	    peek_for_folding = YES;	/* Check for a continuation line */
+	}
+
+	/* Copying the result */
+
+	if (line)
+	    StrAllocCat(line, start_pointer);	/* Append */
+	else
+	    StrAllocCopy(line, start_pointer);	/* A new line */
+
+	start_pointer = cur + 1;	/* Skip the read line */
+
+    }				/* forever */
+}
diff --git a/WWW/Library/Implementation/HTAAUtil.h b/WWW/Library/Implementation/HTAAUtil.h
new file mode 100644
index 0000000..33a8ee3
--- /dev/null
+++ b/WWW/Library/Implementation/HTAAUtil.h
@@ -0,0 +1,318 @@
+/*
+ * $LynxId: HTAAUtil.h,v 1.13 2010/10/27 00:09:52 tom Exp $
+ *
+ *                                            Utilities for the Authorization parts of libwww
+ *           COMMON PARTS OF AUTHORIZATION MODULE TO BOTH SERVER AND BROWSER
+ *
+ * This module is the interface to the common parts of Access Authorization (AA) package
+ * for both server and browser.  Important to know about memory allocation:
+ *
+ * Routines in this module use dynamic allocation, but free automatically all the memory
+ * reserved by them.
+ *
+ * Therefore the caller never has to (and never should) free() any object returned by
+ * these functions.
+ *
+ * Therefore also all the strings returned by this package are only valid until the next
+ * call to the same function is made. This approach is selected, because of the nature of
+ * access authorization: no string returned by the package needs to be valid longer than
+ * until the next call.
+ *
+ * This also makes it easy to plug the AA package in: you don't have to ponder whether to
+ * free() something here or is it done somewhere else (because it is always done somewhere
+ * else).
+ *
+ * The strings that the package needs to store are copied so the original strings given as
+ * parameters to AA functions may be freed or modified with no side effects.
+ *
+ * Also note: The AA package does not free() anything else than what it has itself
+ * allocated.
+ *
+ */
+
+#ifndef HTAAUTIL_H
+#define HTAAUTIL_H
+
+#include <HTList.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Numeric constants
+ */
+#define MAX_USERNAME_LEN        16	/* @@ Longest allowed username    */
+#define MAX_PASSWORD_LEN        3*13	/* @@ Longest allowed password    */
+    /* (encrypted, so really only 3*8) */
+#define MAX_METHODNAME_LEN      12	/* @@ Longest allowed method name */
+#define MAX_FIELDNAME_LEN       16	/* @@ Longest field name in       */
+    /* protection setup file          */
+#define MAX_PATHNAME_LEN        80	/* @@ Longest passwd/group file   */
+/* pathname to allow               */
+/*
+
+   Datatype definitions
+
+   HTAASCHEME
+
+   The enumeration HTAAScheme represents the possible authentication schemes used by the
+   WWW Access Authorization.
+
+ */ typedef enum {
+	HTAA_UNKNOWN,
+	HTAA_NONE,
+	HTAA_BASIC,
+	HTAA_PUBKEY,
+	HTAA_KERBEROS_V4,
+	HTAA_KERBEROS_V5,
+	HTAA_MAX_SCHEMES	/* THIS MUST ALWAYS BE LAST! Number of schemes */
+    } HTAAScheme;
+
+/*
+
+  ENUMERATION TO REPRESENT HTTP METHODS
+
+ */
+
+    typedef enum {
+	METHOD_UNKNOWN,
+	METHOD_GET,
+	METHOD_PUT
+    } HTAAMethod;
+
+/*
+
+Authentication Schemes
+
+ */
+
+/* PUBLIC                                               HTAAScheme_enum()
+ *              TRANSLATE SCHEME NAME TO A SCHEME ENUMERATION
+ * ON ENTRY:
+ *      name            is a string representing the scheme name.
+ *
+ * ON EXIT:
+ *      returns         the enumerated constant for that scheme.
+ */
+    extern HTAAScheme HTAAScheme_enum(const char *name);
+
+/* PUBLIC                                               HTAAScheme_name()
+ *                      GET THE NAME OF A GIVEN SCHEME
+ * ON ENTRY:
+ *      scheme          is one of the scheme enum values:
+ *                      HTAA_NONE, HTAA_BASIC, HTAA_PUBKEY, ...
+ *
+ * ON EXIT:
+ *      returns         the name of the scheme, i.e.
+ *                      "none", "basic", "pubkey", ...
+ */
+    extern const char *HTAAScheme_name(HTAAScheme scheme);
+
+/*
+
+Methods
+
+ */
+
+/* PUBLIC                                                   HTAAMethod_enum()
+ *              TRANSLATE METHOD NAME INTO AN ENUMERATED VALUE
+ * ON ENTRY:
+ *      name            is the method name to translate.
+ *
+ * ON EXIT:
+ *      returns         HTAAMethod enumerated value corresponding
+ *                      to the given name.
+ */
+    extern HTAAMethod HTAAMethod_enum(const char *name);
+
+/* PUBLIC                                               HTAAMethod_name()
+ *                      GET THE NAME OF A GIVEN METHOD
+ * ON ENTRY:
+ *      method          is one of the method enum values:
+ *                      METHOD_GET, METHOD_PUT, ...
+ *
+ * ON EXIT:
+ *      returns         the name of the scheme, i.e.
+ *                      "GET", "PUT", ...
+ */
+    extern const char *HTAAMethod_name(HTAAMethod method);
+
+/* PUBLIC                                               HTAAMethod_inList()
+ *              IS A METHOD IN A LIST OF METHOD NAMES
+ * ON ENTRY:
+ *      method          is the method to look for.
+ *      list            is a list of method names.
+ *
+ * ON EXIT:
+ *      returns         YES, if method was found.
+ *                      NO, if not found.
+ */
+    extern BOOL HTAAMethod_inList(HTAAMethod method, HTList *list);
+
+/*
+
+Match Template Against Filename
+
+ */
+
+/* PUBLIC                                               HTAA_templateMatch()
+ *              STRING COMPARISON FUNCTION FOR FILE NAMES
+ *                 WITH ONE WILDCARD * IN THE TEMPLATE
+ * NOTE:
+ *      This is essentially the same code as in HTRules.c, but it
+ *      cannot be used because it is embedded in between other code.
+ *      (In fact, HTRules.c should use this routine, but then this
+ *       routine would have to be more sophisticated... why is life
+ *       sometimes so hard...)
+ *
+ * ON ENTRY:
+ *      ctemplate       is a template string to match the file name
+ *                      against, may contain a single wildcard
+ *                      character * which matches zero or more
+ *                      arbitrary characters.
+ *      filename        is the filename (or pathname) to be matched
+ *                      against the template.
+ *
+ * ON EXIT:
+ *      returns         YES, if filename matches the template.
+ *                      NO, otherwise.
+ */
+    extern BOOL HTAA_templateMatch(const char *ctemplate,
+				   const char *filename);
+
+/* PUBLIC                                               HTAA_templateCaseMatch()
+ *              STRING COMPARISON FUNCTION FOR FILE NAMES
+ *                 WITH ONE WILDCARD * IN THE TEMPLATE (Case Insensitive)
+ * NOTE:
+ *      This is essentially the same code as in HTAA_templateMatch, but
+ *      it compares case insensitive (for VMS). Reason for this routine
+ *      is that HTAA_templateMatch gets called from several places, also
+ *      there where a case sensitive match is needed, so one cannot just
+ *      change the HTAA_templateMatch routine for VMS.
+ *
+ * ON ENTRY:
+ *      ctemplate       is a template string to match the file name
+ *                      against, may contain a single wildcard
+ *                      character * which matches zero or more
+ *                      arbitrary characters.
+ *      filename        is the filename (or pathname) to be matched
+ *                      against the template.
+ *
+ * ON EXIT:
+ *      returns         YES, if filename matches the template.
+ *                      NO, otherwise.
+ */
+    extern BOOL HTAA_templateCaseMatch(const char *ctemplate,
+				       const char *filename);
+
+/* PUBLIC                                       HTAA_makeProtectionTemplate()
+ *              CREATE A PROTECTION TEMPLATE FOR THE FILES
+ *              IN THE SAME DIRECTORY AS THE GIVEN FILE
+ *              (Used by server if there is no fancier way for
+ *              it to tell the client, and by browser if server
+ *              didn't send WWW-ProtectionTemplate: field)
+ * ON ENTRY:
+ *      docname is the document pathname (from URL).
+ *
+ * ON EXIT:
+ *      returns a template matching docname, and other files
+ *              files in that directory.
+ *
+ *              E.g.  /foo/bar/x.html  =>  /foo/bar/ *
+ *                                                  ^
+ *                              Space only to prevent it from
+ *                              being a comment marker here,
+ *                              there really isn't any space.
+ */
+    extern char *HTAA_makeProtectionTemplate(const char *docname);
+
+/*
+
+MIME Argument List Parser
+
+ */
+
+/* PUBLIC                                               HTAA_parseArgList()
+ *              PARSE AN ARGUMENT LIST GIVEN IN A HEADER FIELD
+ * ON ENTRY:
+ *      str     is a comma-separated list:
+ *
+ *                      item, item, item
+ *              where
+ *                      item ::= value
+ *                             | name=value
+ *                             | name="value"
+ *
+ *              Leading and trailing whitespace is ignored
+ *              everywhere except inside quotes, so the following
+ *              examples are equal:
+ *
+ *                      name=value,foo=bar
+ *                       name="value",foo="bar"
+ *                        name = value ,  foo = bar
+ *                         name = "value" ,  foo = "bar"
+ *
+ * ON EXIT:
+ *      returns a list of name-value pairs (actually HTAssocList*).
+ *              For items with no name, just value, the name is
+ *              the number of order number of that item. E.g.
+ *              "1" for the first, etc.
+ */
+    extern HTList *HTAA_parseArgList(char *str);
+
+/*
+
+Header Line Reader
+
+ */
+
+/* PUBLIC                                               HTAA_setupReader()
+ *              SET UP HEADER LINE READER, i.e., give
+ *              the already-read-but-not-yet-processed
+ *              buffer of text to be read before more
+ *              is read from the socket.
+ * ON ENTRY:
+ *      start_of_headers is a pointer to a buffer containing
+ *                      the beginning of the header lines
+ *                      (rest will be read from a socket).
+ *      length          is the number of valid characters in
+ *                      'start_of_headers' buffer.
+ *      soc             is the socket to use when start_of_headers
+ *                      buffer is used up.
+ * ON EXIT:
+ *      returns         nothing.
+ *                      Subsequent calls to HTAA_getUnfoldedLine()
+ *                      will use this buffer first and then
+ *                      proceed to read from socket.
+ */
+    extern void HTAA_setupReader(char *start_of_headers,
+				 size_t length,
+				 int soc);
+
+/* PUBLIC                                               HTAA_getUnfoldedLine()
+ *              READ AN UNFOLDED HEADER LINE FROM SOCKET
+ * ON ENTRY:
+ *      HTAA_setupReader must absolutely be called before
+ *      this function to set up internal buffer.
+ *
+ * ON EXIT:
+ *      returns a newly-allocated character string representing
+ *              the read line.  The line is unfolded, i.e.
+ *              lines that begin with whitespace are appended
+ *              to current line.  E.g.
+ *
+ *                      Field-Name: Blaa-Blaa
+ *                       This-Is-A-Continuation-Line
+ *                       Here-Is_Another
+ *
+ *              is seen by the caller as:
+ *
+ *      Field-Name: Blaa-Blaa This-Is-A-Continuation-Line Here-Is_Another
+ *
+ */
+    extern char *HTAA_getUnfoldedLine(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* NOT HTAAUTIL_H */
diff --git a/WWW/Library/Implementation/HTAccess.c b/WWW/Library/Implementation/HTAccess.c
new file mode 100644
index 0000000..a79a8a2
--- /dev/null
+++ b/WWW/Library/Implementation/HTAccess.c
@@ -0,0 +1,1460 @@
+/*
+ * $LynxId: HTAccess.c,v 1.85 2019/08/24 00:27:06 tom Exp $
+ *
+ *		Access Manager					HTAccess.c
+ *		==============
+ *
+ *  Authors
+ *	TBL	Tim Berners-Lee timbl@info.cern.ch
+ *	JFG	Jean-Francois Groff jfg@dxcern.cern.ch
+ *	DD	Denis DeLaRoca (310) 825-4580  <CSP1DWD@mvs.oac.ucla.edu>
+ *	FM	Foteos Macrides macrides@sci.wfeb.edu
+ *	PDM	Danny Mayer mayer@ljo.dec.com
+ *
+ *  History
+ *	 8 Jun 92 Telnet hopping prohibited as telnet is not secure TBL
+ *	26 Jun 92 When over DECnet, suppressed FTP, Gopher and News. JFG
+ *	 6 Oct 92 Moved HTClientHost and logfile into here. TBL
+ *	17 Dec 92 Tn3270 added, bug fix. DD
+ *	 4 Feb 93 Access registration, Search escapes bad chars TBL
+ *		  PARAMETERS TO HTSEARCH AND HTLOADRELATIVE CHANGED
+ *	28 May 93 WAIS gateway explicit if no WAIS library linked in.
+ *	31 May 94 Added DIRECT_WAIS support for VMS. FM
+ *	27 Jan 95 Fixed proxy support to use NNTPSERVER for checking
+ *		  whether or not to use the proxy server. PDM
+ *	27 Jan 95 Ensured that proxy service will be overridden for files
+ *		  on the local host (because HTLoadFile() doesn't try ftp
+ *		  for those) and will substitute ftp for remote files. FM
+ *	28 Jan 95 Tweaked PDM's proxy override mods to handle port info
+ *		  for news and wais URL's. FM
+ *
+ *  Bugs
+ *	This module assumes that that the graphic object is hypertext, as it
+ *	needs to select it when it has been loaded.  A superclass needs to be
+ *	defined which accepts select and select_anchor.
+ */
+
+#ifdef VMS
+#define DIRECT_WAIS
+#endif /* VMS */
+
+#include <HTUtils.h>
+#include <HTTP.h>
+#include <HTAlert.h>
+/*
+ *  Implements:
+ */
+#include <HTAccess.h>
+
+/*
+ *  Uses:
+ */
+#include <HTParse.h>
+#include <HTML.h>		/* SCW */
+
+#ifndef NO_RULES
+#include <HTRules.h>
+#endif
+
+#include <HTList.h>
+#include <HText.h>		/* See bugs above */
+#include <HTCJK.h>
+#include <UCMap.h>
+#include <GridText.h>
+
+#include <LYGlobalDefs.h>
+#include <LYexit.h>
+#include <LYStrings.h>
+#include <LYUtils.h>
+#include <LYLeaks.h>
+
+/*
+ *  These flags may be set to modify the operation of this module
+ */
+char *HTClientHost = NULL;	/* Name of remote login host if any */
+FILE *HTlogfile = NULL;		/* File to which to output one-liners */
+BOOL HTSecure = NO;		/* Disable access for telnet users? */
+BOOL HTPermitRedir = NO;	/* Always allow redirection in getfile()? */
+
+BOOL using_proxy = NO;		/* are we using a proxy gateway? */
+
+/*
+ *  To generate other things, play with these:
+ */
+HTFormat HTOutputFormat = NULL;
+HTStream *HTOutputStream = NULL;	/* For non-interactive, set this */
+
+static HTList *protocols = NULL;	/* List of registered protocol descriptors */
+
+char *use_this_url_instead = NULL;
+
+static int pushed_assume_LYhndl = -1;	/* see LYUC* functions below - kw */
+static char *pushed_assume_MIMEname = NULL;
+
+#ifdef LY_FIND_LEAKS
+static void free_protocols(void)
+{
+    HTList_delete(protocols);
+    protocols = NULL;
+    FREE(pushed_assume_MIMEname);	/* shouldn't happen, just in case - kw */
+}
+#endif /* LY_FIND_LEAKS */
+
+/*	Register a Protocol.				HTRegisterProtocol()
+ *	--------------------
+ */
+BOOL HTRegisterProtocol(HTProtocol * protocol)
+{
+    if (!protocols) {
+	protocols = HTList_new();
+#ifdef LY_FIND_LEAKS
+	atexit(free_protocols);
+#endif
+    }
+    HTList_addObject(protocols, protocol);
+    return YES;
+}
+
+/*	Register all known protocols.			HTAccessInit()
+ *	-----------------------------
+ *
+ *	Add to or subtract from this list if you add or remove protocol
+ *	modules.  This routine is called the first time the protocol list
+ *	is needed, unless any protocols are already registered, in which
+ *	case it is not called.	Therefore the application can override
+ *	this list.
+ *
+ *	Compiling with NO_INIT prevents all known protocols from being
+ *	forced in at link time.
+ */
+#ifndef NO_INIT
+#ifdef GLOBALREF_IS_MACRO
+extern GLOBALREF (HTProtocol, HTTP);
+extern GLOBALREF (HTProtocol, HTTPS);
+extern GLOBALREF (HTProtocol, HTFile);
+extern GLOBALREF (HTProtocol, HTTelnet);
+extern GLOBALREF (HTProtocol, HTTn3270);
+extern GLOBALREF (HTProtocol, HTRlogin);
+
+#ifndef DECNET
+#ifndef DISABLE_FTP
+extern GLOBALREF (HTProtocol, HTFTP);
+#endif /* DISABLE_FTP */
+#ifndef DISABLE_NEWS
+extern GLOBALREF (HTProtocol, HTNews);
+extern GLOBALREF (HTProtocol, HTNNTP);
+extern GLOBALREF (HTProtocol, HTNewsPost);
+extern GLOBALREF (HTProtocol, HTNewsReply);
+extern GLOBALREF (HTProtocol, HTSNews);
+extern GLOBALREF (HTProtocol, HTSNewsPost);
+extern GLOBALREF (HTProtocol, HTSNewsReply);
+#endif /* not DISABLE_NEWS */
+#ifndef DISABLE_GOPHER
+extern GLOBALREF (HTProtocol, HTGopher);
+extern GLOBALREF (HTProtocol, HTCSO);
+#endif /* not DISABLE_GOPHER */
+#ifndef DISABLE_FINGER
+extern GLOBALREF (HTProtocol, HTFinger);
+#endif /* not DISABLE_FINGER */
+#ifdef DIRECT_WAIS
+extern GLOBALREF (HTProtocol, HTWAIS);
+#endif /* DIRECT_WAIS */
+#endif /* !DECNET */
+#else
+GLOBALREF HTProtocol HTTP, HTTPS, HTFile, HTTelnet, HTTn3270, HTRlogin;
+
+#ifndef DECNET
+#ifndef DISABLE_FTP
+GLOBALREF HTProtocol HTFTP;
+#endif /* DISABLE_FTP */
+#ifndef DISABLE_NEWS
+GLOBALREF HTProtocol HTNews, HTNNTP, HTNewsPost, HTNewsReply;
+GLOBALREF HTProtocol HTSNews, HTSNewsPost, HTSNewsReply;
+#endif /* not DISABLE_NEWS */
+#ifndef DISABLE_GOPHER
+GLOBALREF HTProtocol HTGopher, HTCSO;
+#endif /* not DISABLE_GOPHER */
+#ifndef DISABLE_FINGER
+GLOBALREF HTProtocol HTFinger;
+#endif /* not DISABLE_FINGER */
+#ifdef DIRECT_WAIS
+GLOBALREF HTProtocol HTWAIS;
+#endif /* DIRECT_WAIS */
+#endif /* !DECNET */
+#endif /* GLOBALREF_IS_MACRO */
+
+static void HTAccessInit(void)	/* Call me once */
+{
+    HTRegisterProtocol(&HTTP);
+    HTRegisterProtocol(&HTTPS);
+    HTRegisterProtocol(&HTFile);
+    HTRegisterProtocol(&HTTelnet);
+    HTRegisterProtocol(&HTTn3270);
+    HTRegisterProtocol(&HTRlogin);
+#ifndef DECNET
+#ifndef DISABLE_FTP
+    HTRegisterProtocol(&HTFTP);
+#endif /* DISABLE_FTP */
+#ifndef DISABLE_NEWS
+    HTRegisterProtocol(&HTNews);
+    HTRegisterProtocol(&HTNNTP);
+    HTRegisterProtocol(&HTNewsPost);
+    HTRegisterProtocol(&HTNewsReply);
+    HTRegisterProtocol(&HTSNews);
+    HTRegisterProtocol(&HTSNewsPost);
+    HTRegisterProtocol(&HTSNewsReply);
+#endif /* not DISABLE_NEWS */
+#ifndef DISABLE_GOPHER
+    HTRegisterProtocol(&HTGopher);
+    HTRegisterProtocol(&HTCSO);
+#endif /* not DISABLE_GOPHER */
+#ifndef DISABLE_FINGER
+    HTRegisterProtocol(&HTFinger);
+#endif /* not DISABLE_FINGER */
+#ifdef DIRECT_WAIS
+    HTRegisterProtocol(&HTWAIS);
+#endif /* DIRECT_WAIS */
+#endif /* !DECNET */
+    LYRegisterLynxProtocols();
+}
+#endif /* !NO_INIT */
+
+/*	Check for proxy override.			override_proxy()
+ *	-------------------------
+ *
+ *	Check the no_proxy environment variable to get the list
+ *	of hosts for which proxy server is not consulted.
+ *
+ *	no_proxy is a comma- or space-separated list of machine
+ *	or domain names, with optional :port part.  If no :port
+ *	part is present, it applies to all ports on that domain.
+ *
+ *  Example:
+ *	    no_proxy="cern.ch,some.domain:8001"
+ *
+ *  Use "*" to override all proxy service:
+ *	     no_proxy="*"
+ */
+BOOL override_proxy(const char *addr)
+{
+    const char *no_proxy = getenv("no_proxy");
+    char *p = NULL;
+    char *at = NULL;
+    char *host = NULL;
+    char *Host = NULL;
+    char *acc_method = NULL;
+    int port = 0;
+    int h_len = 0;
+
+    /*
+     * Check for global override.
+     */
+    if (no_proxy) {
+	if (!strcmp(no_proxy, "*"))
+	    return YES;
+    }
+
+    /*
+     * Never proxy file:// URLs if they are on the local host.  HTLoadFile()
+     * will not attempt ftp for those if direct access fails.  We'll check that
+     * first, in case no_proxy hasn't been defined.  - FM
+     */
+    if (!addr)
+	return NO;
+    if (!(host = HTParse(addr, "", PARSE_HOST)))
+	return NO;
+    if (!*host) {
+	FREE(host);
+	return NO;
+    }
+    Host = (((at = StrChr(host, '@')) != NULL) ? (at + 1) : host);
+
+    if ((acc_method = HTParse(addr, "", PARSE_ACCESS))) {
+	if (!strcmp("file", acc_method) &&
+	    (LYSameHostname(Host, "localhost") ||
+	     LYSameHostname(Host, HTHostName()))) {
+	    FREE(host);
+	    FREE(acc_method);
+	    return YES;
+	}
+	FREE(acc_method);
+    }
+
+    if (!no_proxy) {
+	FREE(host);
+	return NO;
+    }
+
+    if (NULL != (p = HTParsePort(Host, &port))) {	/* Port specified */
+	*p = 0;			/* Chop off port */
+    } else {			/* Use default port */
+	acc_method = HTParse(addr, "", PARSE_ACCESS);
+	if (acc_method != NULL) {
+	    /* *INDENT-OFF* */
+	    if	    (!strcmp(acc_method, "http"))	port = 80;
+	    else if (!strcmp(acc_method, "https"))	port = 443;
+	    else if (!strcmp(acc_method, "ftp"))	port = 21;
+#ifndef DISABLE_GOPHER
+	    else if (!strcmp(acc_method, "gopher"))	port = 70;
+#endif
+	    else if (!strcmp(acc_method, "cso"))	port = 105;
+#ifndef DISABLE_NEWS
+	    else if (!strcmp(acc_method, "news"))	port = 119;
+	    else if (!strcmp(acc_method, "nntp"))	port = 119;
+	    else if (!strcmp(acc_method, "newspost"))	port = 119;
+	    else if (!strcmp(acc_method, "newsreply"))	port = 119;
+	    else if (!strcmp(acc_method, "snews"))	port = 563;
+	    else if (!strcmp(acc_method, "snewspost"))	port = 563;
+	    else if (!strcmp(acc_method, "snewsreply")) port = 563;
+#endif
+	    else if (!strcmp(acc_method, "wais"))	port = 210;
+#ifndef DISABLE_FINGER
+	    else if (!strcmp(acc_method, "finger"))	port = 79;
+#endif
+	    else if (!strcmp(acc_method, "telnet"))	port = 23;
+	    else if (!strcmp(acc_method, "tn3270"))	port = 23;
+	    else if (!strcmp(acc_method, "rlogin"))	port = 513;
+	    /* *INDENT-ON* */
+
+	    FREE(acc_method);
+	}
+    }
+    if (!port)
+	port = 80;		/* Default */
+    h_len = (int) strlen(Host);
+
+    while (*no_proxy) {
+	const char *end;
+	const char *colon = NULL;
+	int templ_port = 0;
+	int t_len;
+	int brackets = 0;
+
+	while (*no_proxy && (WHITE(*no_proxy) || *no_proxy == ','))
+	    no_proxy++;		/* Skip whitespace and separators */
+
+	end = no_proxy;
+	while (*end && !WHITE(*end) && *end != ',') {	/* Find separator */
+	    if (!brackets && (*end == ':'))
+		colon = end;	/* Port number given */
+	    else if (*end == '[')
+		++brackets;
+	    else if (*end == ']')
+		--brackets;
+	    end++;
+	}
+
+	if (colon) {
+	    /* unlike HTParsePort(), this may be followed by non-digits */
+	    templ_port = atoi(colon + 1);
+	    t_len = (int) (colon - no_proxy);
+	} else {
+	    t_len = (int) (end - no_proxy);
+	}
+
+	if ((!templ_port || templ_port == port) &&
+	    (t_len > 0 && t_len <= h_len &&
+	     !strncasecomp(Host + h_len - t_len, no_proxy, t_len))) {
+	    FREE(host);
+	    return YES;
+	}
+#ifdef CJK_EX			/* ASATAKU PROXY HACK */
+	if ((!templ_port || templ_port == port) &&
+	    (t_len > 0 && t_len <= h_len &&
+	     isdigit(UCH(*no_proxy)) &&
+	     !StrNCmp(host, no_proxy, t_len))) {
+	    FREE(host);
+	    return YES;
+	}
+#endif /* ASATAKU PROXY HACK */
+
+	if (*end)
+	    no_proxy = (end + 1);
+	else
+	    break;
+    }
+
+    FREE(host);
+    return NO;
+}
+
+/*	Find physical name and access protocol		get_physical()
+ *	--------------------------------------
+ *
+ *  On entry,
+ *	addr		must point to the fully qualified hypertext reference.
+ *	anchor		a parent anchor with whose address is addr
+ *
+ *  On exit,
+ *	returns		HT_NO_ACCESS		Error has occurred.
+ *			HT_OK			Success
+ */
+static int get_physical(const char *addr,
+			HTParentAnchor *anchor)
+{
+    int result;
+    char *acc_method = NULL;	/* Name of access method */
+    char *physical = NULL;
+    char *Server_addr = NULL;
+    BOOL override_flag = NO;
+
+    CTRACE((tfp, "get_physical %s\n", addr));
+
+    /*
+     * Make sure the using_proxy variable is FALSE.
+     */
+    using_proxy = NO;
+
+#ifndef NO_RULES
+    if ((physical = HTTranslate(addr)) == 0) {
+	if (redirecting_url) {
+	    return HT_REDIRECTING;
+	}
+	return HT_FORBIDDEN;
+    }
+    if (anchor->isISMAPScript == TRUE) {
+	StrAllocCat(physical, "?0,0");
+	CTRACE((tfp, "HTAccess: Appending '?0,0' coordinate pair.\n"));
+    }
+    if (!StrNCmp(physical, "Proxied=", 8)) {
+	HTAnchor_setPhysical(anchor, physical + 8);
+	using_proxy = YES;
+    } else if (!StrNCmp(physical, "NoProxy=", 8)) {
+	HTAnchor_setPhysical(anchor, physical + 8);
+	override_flag = YES;
+    } else {
+	HTAnchor_setPhysical(anchor, physical);
+    }
+    FREE(physical);		/* free our copy */
+#else
+    if (anchor->isISMAPScript == TRUE) {
+	StrAllocCopy(physical, addr);
+	StrAllocCat(physical, "?0,0");
+	CTRACE((tfp, "HTAccess: Appending '?0,0' coordinate pair.\n"));
+	HTAnchor_setPhysical(anchor, physical);
+	FREE(physical);		/* free our copy */
+    } else {
+	HTAnchor_setPhysical(anchor, addr);
+    }
+#endif /* NO_RULES */
+
+    acc_method = HTParse(HTAnchor_physical(anchor), STR_FILE_URL, PARSE_ACCESS);
+
+    /*
+     * Check whether gateway access has been set up for this.
+     *
+     * This function can be replaced by the rule system above.
+     *
+     * If the rule system has already determined that we should use a proxy, or
+     * that we shouldn't, ignore proxy-related settings, don't use no_proxy
+     * either.
+     */
+#define USE_GATEWAYS
+#ifdef USE_GATEWAYS
+
+    if (!override_flag && !using_proxy) {	/* else ignore no_proxy env var */
+	char *host = NULL;
+	int port;
+
+	if (!strcasecomp(acc_method, "news")) {
+	    /*
+	     * News is different, so we need to check the name of the server,
+	     * as well as the default port for selective exclusions.
+	     */
+	    if ((host = HTParse(addr, "", PARSE_HOST))) {
+		if (HTParsePort(host, &port) == NULL) {
+		    StrAllocCopy(Server_addr, "news://");
+		    StrAllocCat(Server_addr, host);
+		    StrAllocCat(Server_addr, ":119/");
+		}
+		FREE(host);
+	    } else if (LYGetEnv("NNTPSERVER") != NULL) {
+		StrAllocCopy(Server_addr, "news://");
+		StrAllocCat(Server_addr, LYGetEnv("NNTPSERVER"));
+		StrAllocCat(Server_addr, ":119/");
+	    }
+	} else if (!strcasecomp(acc_method, "wais")) {
+	    /*
+	     * Wais also needs checking of the default port for selective
+	     * exclusions.
+	     */
+	    if ((host = HTParse(addr, "", PARSE_HOST))) {
+		if (!(HTParsePort(host, &port))) {
+		    StrAllocCopy(Server_addr, "wais://");
+		    StrAllocCat(Server_addr, host);
+		    StrAllocCat(Server_addr, ":210/");
+		}
+		FREE(host);
+	    } else
+		StrAllocCopy(Server_addr, addr);
+	} else {
+	    StrAllocCopy(Server_addr, addr);
+	}
+	override_flag = override_proxy(Server_addr);
+    }
+
+    if (!override_flag && !using_proxy) {
+	char *gateway_parameter = NULL, *gateway, *proxy;
+
+	/*
+	 * Search for gateways.
+	 */
+	HTSprintf0(&gateway_parameter, "WWW_%s_GATEWAY", acc_method);
+	gateway = LYGetEnv(gateway_parameter);	/* coerce for decstation */
+
+	/*
+	 * Search for proxy servers.
+	 */
+	if (!strcmp(acc_method, "file"))
+	    /*
+	     * If we got to here, a file URL is for ftp on a remote host. - FM
+	     */
+	    strcpy(gateway_parameter, "ftp_proxy");
+	else
+	    sprintf(gateway_parameter, "%s_proxy", acc_method);
+	proxy = LYGetEnv(gateway_parameter);
+	FREE(gateway_parameter);
+
+	if (gateway)
+	    CTRACE((tfp, "Gateway found: %s\n", gateway));
+	if (proxy)
+	    CTRACE((tfp, "proxy server found: %s\n", proxy));
+
+	/*
+	 * Proxy servers have precedence over gateway servers.
+	 */
+	if (proxy) {
+	    char *gatewayed = NULL;
+
+	    StrAllocCopy(gatewayed, proxy);
+	    if (!StrNCmp(gatewayed, "http", 4)) {
+		char *cp = strrchr(gatewayed, '/');
+
+		/* Append a slash to the proxy specification if it doesn't
+		 * end in one but otherwise looks normal (starts with "http",
+		 * has no '/' other than ones before the hostname). - kw */
+		if (cp && (cp - gatewayed) <= 7)
+		    LYAddHtmlSep(&gatewayed);
+	    }
+	    /*
+	     * Ensure that the proxy server uses ftp for file URLs. - FM
+	     */
+	    if (!StrNCmp(addr, "file", 4)) {
+		StrAllocCat(gatewayed, "ftp");
+		StrAllocCat(gatewayed, (addr + 4));
+	    } else
+		StrAllocCat(gatewayed, addr);
+	    using_proxy = YES;
+	    if (anchor->isISMAPScript == TRUE)
+		StrAllocCat(gatewayed, "?0,0");
+	    HTAnchor_setPhysical(anchor, gatewayed);
+	    FREE(gatewayed);
+	    FREE(acc_method);
+
+	    acc_method = HTParse(HTAnchor_physical(anchor),
+				 STR_HTTP_URL, PARSE_ACCESS);
+
+	} else if (gateway) {
+	    char *path = HTParse(addr, "",
+				 PARSE_HOST + PARSE_PATH + PARSE_PUNCTUATION);
+
+	    /* Chop leading / off to make host into part of path */
+	    char *gatewayed = HTParse(path + 1, gateway, PARSE_ALL);
+
+	    FREE(path);
+	    HTAnchor_setPhysical(anchor, gatewayed);
+	    FREE(gatewayed);
+	    FREE(acc_method);
+
+	    acc_method = HTParse(HTAnchor_physical(anchor),
+				 STR_HTTP_URL, PARSE_ACCESS);
+	}
+    }
+    FREE(Server_addr);
+#endif /* use gateways */
+
+    /*
+     * Search registered protocols to find suitable one.
+     */
+    result = HT_NO_ACCESS;
+    {
+	int i, n;
+
+#ifndef NO_INIT
+	if (!protocols)
+	    HTAccessInit();
+#endif
+	n = HTList_count(protocols);
+	for (i = 0; i < n; i++) {
+	    HTProtocol *p = (HTProtocol *) HTList_objectAt(protocols, i);
+
+	    if (!strcmp(p->name, acc_method)) {
+		HTAnchor_setProtocol(anchor, p);
+		FREE(acc_method);
+		result = HT_OK;
+		break;
+	    }
+	}
+    }
+
+    FREE(acc_method);
+    return result;
+}
+
+/*
+ * Temporarily set the int UCLYhndl_for_unspec and string UCLYhndl_for_unspec
+ * used for charset "assuming" to the values implied by a HTParentAnchor's
+ * UCStages, after saving the current values for later restoration.  - kw @@@
+ * These functions may not really belong here, but where else?  I want the
+ * "pop" to occur as soon as possible after loading has finished.  - kw @@@
+ */
+void LYUCPushAssumed(HTParentAnchor *anchor)
+{
+    int anchor_LYhndl = -1;
+    LYUCcharset *anchor_UCI = NULL;
+
+    if (anchor) {
+	anchor_LYhndl = HTAnchor_getUCLYhndl(anchor, UCT_STAGE_PARSER);
+	if (anchor_LYhndl >= 0)
+	    anchor_UCI = HTAnchor_getUCInfoStage(anchor,
+						 UCT_STAGE_PARSER);
+	if (anchor_UCI && anchor_UCI->MIMEname) {
+	    pushed_assume_MIMEname = UCAssume_MIMEcharset;
+	    UCAssume_MIMEcharset = NULL;
+	    if (HTCJK == JAPANESE)
+		StrAllocCopy(UCAssume_MIMEcharset, pushed_assume_MIMEname);
+	    else
+		StrAllocCopy(UCAssume_MIMEcharset, anchor_UCI->MIMEname);
+	    pushed_assume_LYhndl = anchor_LYhndl;
+	    /* some diagnostics */
+	    if (UCLYhndl_for_unspec != anchor_LYhndl)
+		CTRACE((tfp,
+			"LYUCPushAssumed: UCLYhndl_for_unspec changed %d -> %d\n",
+			UCLYhndl_for_unspec,
+			anchor_LYhndl));
+	    UCLYhndl_for_unspec = anchor_LYhndl;
+	    return;
+	}
+    }
+    pushed_assume_LYhndl = -1;
+    FREE(pushed_assume_MIMEname);
+}
+
+/*
+ * Restore the int UCLYhndl_for_unspec and string UCLYhndl_for_unspec used for
+ * charset "assuming" from the values saved by LYUCPushAssumed, if any.  - kw
+ */
+int LYUCPopAssumed(void)
+{
+    if (pushed_assume_LYhndl >= 0) {
+	/* some diagnostics */
+	if (UCLYhndl_for_unspec != pushed_assume_LYhndl)
+	    CTRACE((tfp,
+		    "LYUCPopAssumed: UCLYhndl_for_unspec changed %d -> %d\n",
+		    UCLYhndl_for_unspec,
+		    pushed_assume_LYhndl));
+	UCLYhndl_for_unspec = pushed_assume_LYhndl;
+	pushed_assume_LYhndl = -1;
+	FREE(UCAssume_MIMEcharset);
+	UCAssume_MIMEcharset = pushed_assume_MIMEname;
+	pushed_assume_MIMEname = NULL;
+	return UCLYhndl_for_unspec;
+    }
+    return -1;
+}
+
+/*	Load a document					HTLoad()
+ *	---------------
+ *
+ *	This is an internal routine, which has an address AND a matching
+ *	anchor.  (The public routines are called with one OR the other.)
+ *
+ *  On entry,
+ *	addr		must point to the fully qualified hypertext reference.
+ *	anchor		a parent anchor with whose address is addr
+ *
+ *  On exit,
+ *	returns		<0		Error has occurred.
+ *			HT_LOADED	Success
+ *			HT_NO_DATA	Success, but no document loaded.
+ *					(telnet session started etc)
+ */
+static int HTLoad(const char *addr,
+		  HTParentAnchor *anchor,
+		  HTFormat format_out,
+		  HTStream *sink)
+{
+    HTProtocol *p;
+    int status = get_physical(addr, anchor);
+
+    if (reloading) {
+	FREE(anchor->charset);
+	FREE(anchor->UCStages);
+    }
+
+    if (status == HT_FORBIDDEN) {
+	/* prevent crash if telnet or similar was forbidden by rule. - kw */
+	LYFixCursesOn("show alert:");
+	status = HTLoadError(sink, 500, gettext("Access forbidden by rule"));
+    } else if (status == HT_REDIRECTING) {
+	;			/* fake redirection by rule, to redirecting_url */
+    } else if (status >= 0) {
+	/* prevent crash if telnet or similar mapped or proxied by rule. - kw */
+	LYFixCursesOnForAccess(addr, HTAnchor_physical(anchor));
+	p = (HTProtocol *) HTAnchor_protocol(anchor);
+	anchor->parent->underway = TRUE;	/* Hack to deal with caching */
+	status = p->load(HTAnchor_physical(anchor),
+			 anchor, format_out, sink);
+	anchor->parent->underway = FALSE;
+	LYUCPopAssumed();
+    }
+    return status;
+}
+
+/*	Get a save stream for a document		HTSaveStream()
+ *	--------------------------------
+ */
+HTStream *HTSaveStream(HTParentAnchor *anchor)
+{
+    HTProtocol *p = (HTProtocol *) HTAnchor_protocol(anchor);
+
+    if (!p)
+	return NULL;
+
+    return p->saveStream(anchor);
+}
+
+int redirection_limit = 10;
+int redirection_attempts = 0;	/* counter in HTLoadDocument */
+
+static BOOL too_many_redirections(void)
+{
+    if (redirection_attempts > redirection_limit) {
+	char *msg = NULL;
+
+	HTSprintf0(&msg, TOO_MANY_REDIRECTIONS, redirection_limit);
+	free(msg);
+	redirection_attempts = 0;
+	return TRUE;
+    }
+    return FALSE;
+}
+
+/*	Load a document - with logging etc		HTLoadDocument()
+ *	----------------------------------
+ *
+ *	- Checks or documents already loaded
+ *	- Logs the access
+ *	- Allows stdin filter option
+ *	- Trace output and error messages
+ *
+ *  On Entry,
+ *	  anchor	    is the node_anchor for the document
+ *	  full_address	    The address of the document to be accessed.
+ *	  filter	    if YES, treat stdin as HTML
+ *
+ *  On Exit,
+ *	  returns    YES     Success in opening document
+ *		     NO      Failure
+ */
+static BOOL HTLoadDocument(const char *full_address,	/* may include #fragment */
+			   HTParentAnchor *anchor,
+			   HTFormat format_out,
+			   HTStream *sink)
+{
+    int status;
+    HText *text;
+    const char *address_to_load = full_address;
+    char *cp;
+    BOOL ForcingNoCache = LYforce_no_cache;
+
+    CTRACE((tfp, "HTAccess: loading document %s\n", NonNull(address_to_load)));
+    if (isEmpty(address_to_load))
+	return NO;
+
+    /*
+     * Free use_this_url_instead and reset permanent_redirection if not done
+     * elsewhere.  - FM
+     */
+    FREE(use_this_url_instead);
+    permanent_redirection = FALSE;
+
+    if (too_many_redirections()) {
+	return NO;
+    }
+
+    /*
+     * If this is marked as an internal link but we don't have the document
+     * loaded any more, and we haven't explicitly flagged that we want to
+     * reload with LYforce_no_cache, then something has disappeared from the
+     * cache when we expected it to be still there.  The user probably doesn't
+     * expect a new network access.  So if we have POST data and safe is not
+     * set in the anchor, ask for confirmation, and fail if not granted.  The
+     * exception are LYNXIMGMAP documents, for which we defer to LYLoadIMGmap
+     * for prompting if necessary.  - kw
+     */
+    text = (HText *) HTAnchor_document(anchor);
+    if (LYinternal_flag && !text && !LYforce_no_cache &&
+	anchor->post_data && !anchor->safe &&
+	!isLYNXIMGMAP(full_address) &&
+	HTConfirm(gettext("Document with POST content not found in cache.  Resubmit?"))
+	!= TRUE) {
+	return NO;
+    }
+
+    /*
+     * If we don't have POST content, check whether this is a previous
+     * redirecting URL, and keep re-checking until we get to the final
+     * destination or redirection limit.  If we do have POST content, we didn't
+     * allow permanent redirection, and an interactive user will be deciding
+     * whether to keep redirecting.  - FM
+     */
+    if (!anchor->post_data) {
+	while ((cp = HTAnchor_physical(anchor)) != NULL &&
+	       !StrNCmp(cp, "Location=", 9)) {
+	    DocAddress NewDoc;
+
+	    CTRACE((tfp, "HTAccess: '%s' is a redirection URL.\n",
+		    anchor->address));
+	    CTRACE((tfp, "HTAccess: Redirecting to '%s'\n", cp + 9));
+
+	    /*
+	     * Don't exceed the redirection_attempts limit.  - FM
+	     */
+	    ++redirection_attempts;
+	    if (too_many_redirections()) {
+		FREE(use_this_url_instead);
+		return NO;
+	    }
+
+	    /*
+	     * Set up the redirection. - FM
+	     */
+	    StrAllocCopy(use_this_url_instead, cp + 9);
+	    NewDoc.address = use_this_url_instead;
+	    NewDoc.post_data = NULL;
+	    NewDoc.post_content_type = NULL;
+	    NewDoc.bookmark = anchor->bookmark;
+	    NewDoc.isHEAD = anchor->isHEAD;
+	    NewDoc.safe = anchor->safe;
+	    anchor = HTAnchor_findAddress(&NewDoc);
+	}
+    }
+    /*
+     * If we had previous redirection, go back and check out that the URL under
+     * the current restrictions.  - FM
+     */
+    if (use_this_url_instead) {
+	FREE(redirecting_url);
+	return (NO);
+    }
+
+    /*
+     * See if we can use an already loaded document.
+     */
+    text = (HText *) HTAnchor_document(anchor);
+    if (text && !LYforce_no_cache) {
+	/*
+	 * We have a cached rendition of the target document.  Check if it's OK
+	 * to re-use it.  We consider it OK if:
+	 * (1) the anchor does not have the no_cache element set, or
+	 * (2) we've overridden it, e.g., because we are acting on a PREV_DOC
+	 * command or a link in the History Page and it's not a reply from a
+	 * POST with the LYresubmit_posts flag set, or
+	 * (3) we are repositioning within the currently loaded document based
+	 * on the target anchor's address (URL_Reference).
+	 *
+	 * If track_internal_links is false, HText_AreDifferent() is
+	 * used to determine whether (3) applies.  If the target address
+	 * differs from that of the current document only by a fragment and the
+	 * target address has an appended fragment, repositioning without
+	 * reloading is always assumed.  Note that HText_AreDifferent()
+	 * currently always returns TRUE if the target has a LYNXIMGMAP URL, so
+	 * that an internally generated pseudo-document will normally not be
+	 * re-used unless condition (2) applies.  (Condition (1) cannot apply
+	 * since in LYMap.c, no_cache is always set in the anchor object). 
+	 * This doesn't guarantee that the resource from which the MAP element
+	 * is taken will be read again (reloaded) when the list of links for a
+	 * client-side image map is regenerated, when in some cases it should
+	 * (e.g., user requested RELOAD, or HTTP response with no-cache header
+	 * and we are not overriding).
+	 *
+	 * If track_internal_links is true, a target address that
+	 * points to the same URL as the current document may still result in
+	 * reloading, depending on whether the original URL-Reference was given
+	 * as an internal link in the context of the previously loaded
+	 * document.  HText_AreDifferent() is not used here for testing whether
+	 * we are just repositioning.  For an internal link, the potential
+	 * callers of this function from mainloop() down will either avoid
+	 * making the call (and do the repositioning differently) or set
+	 * LYinternal_flag (or LYoverride_no_cache).  Note that (a) LYNXIMGMAP
+	 * pseudo-documents and (b) The "List Page" document are treated
+	 * logically as being part of the document on which they are based, for
+	 * the purpose of whether to treat a link as internal, but the logic
+	 * for this (by setting LYinternal_flag as necessary) is implemented
+	 * elsewhere.  There is a specific test for LYNXIMGMAP here so that the
+	 * generated pseudo-document will not be re-used unless
+	 * LYoverride_no_cache is set.  The same caveat as above applies w.r.t. 
+	 * reloading of the underlying resource.
+	 *
+	 * We also should be checking other aspects of cache regulation (e.g.,
+	 * based on an If-Modified-Since check, etc.) but the code for doing
+	 * those other things isn't available yet.
+	 */
+	if ((reloading != REAL_RELOAD) &&
+	    (LYoverride_no_cache ||
+	     ((!track_internal_links &&
+	       (!HText_hasNoCacheSet(text) ||
+		!HText_AreDifferent(anchor, full_address))) ||
+	      (track_internal_links &&
+	       (((LYinternal_flag || !HText_hasNoCacheSet(text)) &&
+		 !isLYNXIMGMAP(full_address))))))) {
+	    CTRACE((tfp, "HTAccess: Document already in memory.\n"));
+	    HText_select(text);
+
+#ifdef DIRED_SUPPORT
+	    if (HTAnchor_format(anchor) == WWW_DIRED)
+		lynx_edit_mode = TRUE;
+#endif
+	    redirection_attempts = 0;
+	    return YES;
+	} else {
+	    ForcingNoCache = YES;
+	    BStrFree(anchor->post_data);
+	    CTRACE((tfp, "HTAccess: Auto-reloading document.\n"));
+	}
+    }
+
+    if (HText_HaveUserChangedForms(text)) {
+	/*
+	 * Issue a warning.  User forms content will be lost.
+	 * Will not restore changed forms, currently.
+	 */
+	HTAlert(RELOADING_FORM);
+    }
+
+    /*
+     * Get the document from the net.  If we are auto-reloading, the mutable
+     * anchor elements from the previous rendition should be freed in
+     * conjunction with loading of the new rendition.  - FM
+     */
+    LYforce_no_cache = NO;	/* reset after each time through */
+    if (ForcingNoCache) {
+	FREE(anchor->title);	/* ??? */
+    }
+    status = HTLoad(address_to_load, anchor, format_out, sink);
+    CTRACE((tfp, "HTAccess:  status=%d\n", status));
+
+    /*
+     * RECOVERY:  if the loading failed, and we had a cached HText copy, and no
+     * new HText created - use a previous copy, issue a warning.
+     */
+    if (text && status < 0 && (HText *) HTAnchor_document(anchor) == text) {
+	HTAlert(gettext("Loading failed, use a previous copy."));
+	CTRACE((tfp, "HTAccess: Loading failed, use a previous copy.\n"));
+	HText_select(text);
+
+#ifdef DIRED_SUPPORT
+	if (HTAnchor_format(anchor) == WWW_DIRED)
+	    lynx_edit_mode = TRUE;
+#endif
+	redirection_attempts = 0;
+	return YES;
+    }
+
+    /*
+     * Log the access if necessary.
+     */
+    if (HTlogfile) {
+	time_t theTime;
+
+	time(&theTime);
+	fprintf(HTlogfile, "%24.24s %s %s %s\n",
+		ctime(&theTime),
+		HTClientHost ? HTClientHost : "local",
+		status < 0 ? "FAIL" : "GET",
+		full_address);
+	fflush(HTlogfile);	/* Actually update it on disk */
+	CTRACE((tfp, "Log: %24.24s %s %s %s\n",
+		ctime(&theTime),
+		HTClientHost ? HTClientHost : "local",
+		status < 0 ? "FAIL" : "GET",
+		full_address));
+    }
+
+    /*
+     * Check out what we received from the net.
+     */
+    if (status == HT_REDIRECTING) {
+	/* Exported from HTMIME.c, of all places.  */
+	/* NO!! - FM */
+	/*
+	 * Doing this via HTMIME.c meant that the redirection cover page was
+	 * already loaded before we learned that we want a different URL. 
+	 * Also, changing anchor->address, as Lynx was doing, meant we could
+	 * never again access its hash table entry, creating an insolvable
+	 * memory leak.  Instead, if we had a 301 status and set
+	 * permanent_redirection, we'll load the new URL in anchor->physical,
+	 * preceded by a token, which we can check to make replacements on
+	 * subsequent access attempts.  We'll check recursively, and retrieve
+	 * the final URL if we had multiple redirections to it.  If we just
+	 * went to HTLoad now, as Lou originally had this, we couldn't do
+	 * Lynx's security checks and alternate handling of some URL types. 
+	 * So, instead, we'll go all the way back to the top of getfile in
+	 * LYGetFile.c when the status is HT_REDIRECTING.  This may seem
+	 * bizarre, but it works like a charm!  - FM
+	 *
+	 * Actually, the location header for redirections is now again picked
+	 * up in HTMIME.c.  But that's an internal matter between HTTP.c and
+	 * HTMIME.c, is still under control of HTLoadHTTP for http URLs, is
+	 * done in a way that doesn't load the redirection response's body
+	 * (except when wanted as an error fallback), and thus need not concern
+	 * us here.  - kw 1999-12-02
+	 */
+	CTRACE((tfp, "HTAccess: '%s' is a redirection URL.\n",
+		address_to_load));
+	CTRACE((tfp, "HTAccess: Redirecting to '%s'\n",
+		redirecting_url));
+	/*
+	 * Prevent circular references.
+	 */
+	if (strcmp(address_to_load, redirecting_url)) {		/* if different */
+	    /*
+	     * Load token and redirecting url into anchor->physical if we had
+	     * 301 Permanent redirection.  HTTP.c does not allow this if we
+	     * have POST content.  - FM
+	     */
+	    if (permanent_redirection) {
+		StrAllocCopy(anchor->physical, "Location=");
+		StrAllocCat(anchor->physical, redirecting_url);
+	    }
+
+	    /*
+	     * Set up flags before return to getfile.  - FM
+	     */
+	    StrAllocCopy(use_this_url_instead, redirecting_url);
+	    if (ForcingNoCache)
+		LYforce_no_cache = YES;
+	    ++redirection_attempts;
+	    FREE(redirecting_url);
+	    permanent_redirection = FALSE;
+	    return (NO);
+	}
+	++redirection_attempts;
+	FREE(redirecting_url);
+	permanent_redirection = FALSE;
+	return (YES);
+    }
+
+    /*
+     * We did not receive a redirecting URL.  - FM
+     */
+    redirection_attempts = 0;
+    FREE(redirecting_url);
+    permanent_redirection = FALSE;
+
+    if (status == HT_LOADED) {
+	CTRACE((tfp, "HTAccess: `%s' has been accessed.\n",
+		full_address));
+	return YES;
+    }
+    if (status == HT_PARTIAL_CONTENT) {
+	HTAlert(gettext("Loading incomplete."));
+	CTRACE((tfp, "HTAccess: `%s' has been accessed, partial content.\n",
+		full_address));
+	return YES;
+    }
+
+    if (status == HT_NO_DATA) {
+	CTRACE((tfp, "HTAccess: `%s' has been accessed, No data left.\n",
+		full_address));
+	return NO;
+    }
+
+    if (status == HT_NOT_LOADED) {
+	CTRACE((tfp, "HTAccess: `%s' has been accessed, No data loaded.\n",
+		full_address));
+	return NO;
+    }
+
+    if (status == HT_INTERRUPTED) {
+	CTRACE((tfp,
+		"HTAccess: `%s' has been accessed, transfer interrupted.\n",
+		full_address));
+	return NO;
+    }
+
+    if (status > 0) {
+	/*
+	 * If you get this, then please find which routine is returning a
+	 * positive unrecognized error code!
+	 */
+	fprintf(stderr,
+		gettext("**** HTAccess: socket or file number returned by obsolete load routine!\n"));
+	fprintf(stderr,
+		gettext("**** HTAccess: Internal software error.  Please mail lynx-dev@nongnu.org!\n"));
+	fprintf(stderr, gettext("**** HTAccess: Status returned was: %d\n"), status);
+	exit_immediately(EXIT_FAILURE);
+    }
+
+    /* Failure in accessing a document */
+    cp = NULL;
+    StrAllocCopy(cp, gettext("Can't Access"));
+    StrAllocCat(cp, " `");
+    StrAllocCat(cp, full_address);
+    StrAllocCat(cp, "'");
+    _HTProgress(cp);
+    FREE(cp);
+
+    CTRACE((tfp, "HTAccess: Can't access `%s'\n", full_address));
+    HTLoadError(sink, 500, gettext("Unable to access document."));
+    return NO;
+}				/* HTLoadDocument */
+
+/*	Load a document from absolute name.		HTLoadAbsolute()
+ *	-----------------------------------
+ *
+ *  On Entry,
+ *	  addr	   The absolute address of the document to be accessed.
+ *	  filter   if YES, treat document as HTML
+ *
+ *  On Exit,
+ *	  returns    YES     Success in opening document
+ *		     NO      Failure
+ */
+BOOL HTLoadAbsolute(const DocAddress *docaddr)
+{
+    BOOL result;
+    HTParentAnchor *anchor = HTAnchor_findAddress(docaddr);
+
+    result = HTLoadDocument(docaddr->address,
+			    anchor,
+			    (HTOutputFormat ? HTOutputFormat : WWW_PRESENT),
+			    HTOutputStream);
+    if (!result) {
+	HTAnchor_delete(anchor->parent);
+    }
+    return result;
+}
+
+#ifdef NOT_USED_CODE
+/*	Load a document from absolute name to stream.	HTLoadToStream()
+ *	---------------------------------------------
+ *
+ *  On Entry,
+ *	  addr	   The absolute address of the document to be accessed.
+ *	  sink	   if non-NULL, send data down this stream
+ *
+ *  On Exit,
+ *	  returns    YES     Success in opening document
+ *		     NO      Failure
+ */
+BOOL HTLoadToStream(const char *addr,
+		    BOOL filter,
+		    HTStream *sink)
+{
+    return HTLoadDocument(addr,
+			  HTAnchor_findSimpleAddress(addr),
+			  (HTOutputFormat ? HTOutputFormat : WWW_PRESENT),
+			  sink);
+}
+#endif /* NOT_USED_CODE */
+
+/*	Load a document from relative name.		HTLoadRelative()
+ *	-----------------------------------
+ *
+ *  On Entry,
+ *	  relative_name     The relative address of the document
+ *			    to be accessed.
+ *
+ *  On Exit,
+ *	  returns    YES     Success in opening document
+ *		     NO      Failure
+ */
+BOOL HTLoadRelative(const char *relative_name,
+		    HTParentAnchor *here)
+{
+    DocAddress full_address;
+    BOOL result;
+    char *mycopy = NULL;
+    char *stripped = NULL;
+
+    full_address.address = NULL;
+    full_address.post_data = NULL;
+    full_address.post_content_type = NULL;
+    full_address.bookmark = NULL;
+    full_address.isHEAD = FALSE;
+    full_address.safe = FALSE;
+
+    StrAllocCopy(mycopy, relative_name);
+
+    stripped = HTStrip(mycopy);
+    full_address.address =
+	HTParse(stripped,
+		here->address,
+		PARSE_ALL_WITHOUT_ANCHOR);
+    result = HTLoadAbsolute(&full_address);
+    /*
+     * If we got redirection, result will be NO, but use_this_url_instead will
+     * be set.  The calling routine should check both and do whatever is
+     * appropriate.  - FM
+     */
+    FREE(full_address.address);
+    FREE(mycopy);		/* Memory leak fixed 10/7/92 -- JFG */
+    return result;
+}
+
+/*	Load if necessary, and select an anchor.	HTLoadAnchor()
+ *	----------------------------------------
+ *
+ *  On Entry,
+ *	  destination		    The child or parent anchor to be loaded.
+ *
+ *  On Exit,
+ *	  returns    YES     Success
+ *		     NO      Failure
+ */
+BOOL HTLoadAnchor(HTAnchor * destination)
+{
+    HTParentAnchor *parent;
+    BOOL loaded = NO;
+
+    if (!destination)
+	return NO;		/* No link */
+
+    parent = HTAnchor_parent(destination);
+
+    if (HTAnchor_document(parent) == NULL) {	/* If not already loaded */
+	/* TBL 921202 */
+	BOOL result;
+
+	result = HTLoadDocument(parent->address,
+				parent,
+				HTOutputFormat ?
+				HTOutputFormat : WWW_PRESENT,
+				HTOutputStream);
+	if (!result)
+	    return NO;
+	loaded = YES;
+    } {
+	HText *text = (HText *) HTAnchor_document(parent);
+
+	if ((destination != (HTAnchor *) parent) &&
+	    (destination != (HTAnchor *) (parent->parent))) {
+	    /* If child anchor */
+	    HText_selectAnchor(text,	/* Double display? @@ */
+			       (HTChildAnchor *) destination);
+	} else {
+	    if (!loaded)
+		HText_select(text);
+	}
+    }
+    return YES;
+
+}				/* HTLoadAnchor */
+
+/*	Search.						HTSearch()
+ *	-------
+ *
+ *	Performs a keyword search on word given by the user.  Adds the
+ *	keyword to the end of the current address and attempts to open
+ *	the new address.
+ *
+ *  On Entry,
+ *	 *keywords	space-separated keyword list or similar search list
+ *	here		is anchor search is to be done on.
+ */
+static char hex(int i)
+{
+    const char *hexchars = "0123456789ABCDEF";
+
+    return hexchars[i];
+}
+
+BOOL HTSearch(const char *keywords,
+	      HTParentAnchor *here)
+{
+#define acceptable \
+"1234567890abcdefghijlkmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-_"
+
+    char *q, *u;
+    const char *p, *s, *e;	/* Pointers into keywords */
+    char *address = NULL;
+    BOOL result;
+    char *escaped = typecallocn(char, (strlen(keywords) * 3) + 1);
+    static const BOOL isAcceptable[96] =
+    /* *INDENT-OFF* */
+    /*	 0 1 2 3 4 5 6 7 8 9 A B C D E F */
+    {	 0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,0,	/* 2x	!"#$%&'()*+,-./  */
+	 1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,	/* 3x  0123456789:;<=>?  */
+	 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,	/* 4x  @ABCDEFGHIJKLMNO  */
+	 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,	/* 5X  PQRSTUVWXYZ[\]^_  */
+	 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,	/* 6x  `abcdefghijklmno  */
+	 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0 };	/* 7X  pqrstuvwxyz{\}~	DEL */
+    /* *INDENT-ON* */
+
+    if (escaped == NULL)
+	outofmem(__FILE__, "HTSearch");
+
+    if (here->isIndexAction == NULL) {
+	free(escaped);
+	return FALSE;
+    }
+    StrAllocCopy(address, here->isIndexAction);
+
+    /*
+     * Convert spaces to + and hex escape unacceptable characters.
+     */
+    for (s = keywords; *s && WHITE(*s); s++)	/* Scan */
+	;			/* Skip white space */
+    for (e = s + strlen(s); e > s && WHITE(*(e - 1)); e--)	/* Scan */
+	;			/* Skip trailers */
+    for (q = escaped, p = s; p < e; p++) {	/* Scan stripped field */
+	unsigned char c = UCH(TOASCII(*p));
+
+	if (WHITE(*p)) {
+	    *q++ = '+';
+	} else if (IS_CJK_TTY) {
+	    *q++ = *p;
+	} else if (c >= 32 && c <= UCH(127) && isAcceptable[c - 32]) {
+	    *q++ = *p;		/* 930706 TBL for MVS bug */
+	} else {
+	    *q++ = '%';
+	    *q++ = hex((int) (c >> 4));
+	    *q++ = hex((int) (c & 15));
+	}
+    }				/* Loop over string */
+    *q = '\0';			/* Terminate escaped string */
+    u = StrChr(address, '?');	/* Find old search string */
+    if (u != NULL)
+	*u = '\0';		/* Chop old search off */
+
+    StrAllocCat(address, "?");
+    StrAllocCat(address, escaped);
+    FREE(escaped);
+    result = HTLoadRelative(address, here);
+    FREE(address);
+
+    /*
+     * If we got redirection, result will be NO, but use_this_url_instead will
+     * be set.  The calling routine should check both and do whatever is
+     * appropriate.  Only an http server (not a gopher or wais server) could
+     * return redirection.  Lynx will go all the way back to its mainloop() and
+     * subject a redirecting URL to all of its security and restrictions
+     * checks.  - FM
+     */
+    return result;
+}
+
+/*	Search Given Indexname.			HTSearchAbsolute()
+ *	-----------------------
+ *
+ *	Performs a keyword search on word given by the user.  Adds the
+ *	keyword to the end of the current address and attempts to open
+ *	the new address.
+ *
+ *  On Entry,
+ *	*keywords	space-separated keyword list or similar search list
+ *	*indexname	is name of object search is to be done on.
+ */
+BOOL HTSearchAbsolute(const char *keywords,
+		      char *indexname)
+{
+    DocAddress abs_doc;
+    HTParentAnchor *anchor;
+
+    abs_doc.address = indexname;
+    abs_doc.post_data = NULL;
+    abs_doc.post_content_type = NULL;
+    abs_doc.bookmark = NULL;
+    abs_doc.isHEAD = FALSE;
+    abs_doc.safe = FALSE;
+
+    anchor = HTAnchor_findAddress(&abs_doc);
+    return HTSearch(keywords, anchor);
+}
+
+#ifdef NOT_USED_CODE
+/*	Generate the anchor for the home page.		HTHomeAnchor()
+ *	--------------------------------------
+ *
+ *	As it involves file access, this should only be done once
+ *	when the program first runs.
+ *	This is a default algorithm -- browser don't HAVE to use this.
+ *	But consistency between browsers is STRONGLY recommended!
+ *
+ *  Priority order is:
+ *		1	WWW_HOME environment variable (logical name, etc)
+ *		2	~/WWW/default.html
+ *		3	/usr/local/bin/default.html
+ *		4	http://www.w3.org/default.html
+ */
+HTParentAnchor *HTHomeAnchor(void)
+{
+    char *my_home_document = NULL;
+    char *home = LYGetEnv(LOGICAL_DEFAULT);
+    char *ref;
+    HTParentAnchor *anchor;
+
+    if (home) {
+	StrAllocCopy(my_home_document, home);
+#define MAX_FILE_NAME 1024	/* @@@ */
+    } else if (HTClientHost) {	/* Telnet server */
+	/*
+	 * Someone telnets in, they get a special home.
+	 */
+	FILE *fp = fopen(REMOTE_POINTER, "r");
+	char *status;
+
+	if (fp) {
+	    my_home_document = typecallocn(char, MAX_FILE_NAME);
+
+	    if (my_home_document == NULL)
+		outofmem(__FILE__, "HTHomeAnchor");
+	    status = fgets(my_home_document, MAX_FILE_NAME, fp);
+	    if (!status) {
+		FREE(my_home_document);
+	    }
+	    fclose(fp);
+	}
+	if (my_home_document == NULL)
+	    StrAllocCopy(my_home_document, REMOTE_ADDRESS);
+    }
+#ifdef UNIX
+    if (my_home_document == NULL) {
+	FILE *fp = NULL;
+	char *home = LYGetEnv("HOME");
+
+	if (home != 0) {
+	    HTSprintf0(&my_home_document, "%s/%s", home, PERSONAL_DEFAULT);
+	    fp = fopen(my_home_document, "r");
+	}
+
+	if (!fp) {
+	    StrAllocCopy(my_home_document, LOCAL_DEFAULT_FILE);
+	    fp = fopen(my_home_document, "r");
+	}
+	if (fp) {
+	    fclose(fp);
+	} else {
+	    CTRACE((tfp, "HTBrowse: No local home document ~/%s or %s\n",
+		    PERSONAL_DEFAULT, LOCAL_DEFAULT_FILE));
+	    FREE(my_home_document);
+	}
+    }
+#endif /* UNIX */
+    ref = HTParse((my_home_document ?
+		   my_home_document : (HTClientHost ?
+				       REMOTE_ADDRESS : LAST_RESORT)),
+		  STR_FILE_URL,
+		  PARSE_ALL_WITHOUT_ANCHOR);
+    if (my_home_document) {
+	CTRACE((tfp, "HTAccess: Using custom home page %s i.e., address %s\n",
+		my_home_document, ref));
+	FREE(my_home_document);
+    }
+    anchor = HTAnchor_findSimpleAddress(ref);
+    FREE(ref);
+    return anchor;
+}
+#endif /* NOT_USED_CODE */
diff --git a/WWW/Library/Implementation/HTAccess.h b/WWW/Library/Implementation/HTAccess.h
new file mode 100644
index 0000000..b898535
--- /dev/null
+++ b/WWW/Library/Implementation/HTAccess.h
@@ -0,0 +1,268 @@
+/*
+ * $LynxId: HTAccess.h,v 1.21 2019/08/23 23:51:45 tom Exp $
+ *					HTAccess:  Access manager for libwww
+ *			ACCESS MANAGER
+ *
+ * This module keeps a list of valid protocol (naming scheme) specifiers with
+ * associated access code.  It allows documents to be loaded given various
+ * combinations of parameters.  New access protocols may be registered at any
+ * time.
+ *
+ * Part of the libwww library .
+ *
+ */
+#ifndef HTACCESS_H
+#define HTACCESS_H
+
+/*      Definition uses:
+*/
+#include <HTAnchor.h>
+#include <HTFormat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern char *use_this_url_instead;
+
+    extern int redirection_limit;
+    extern int redirection_attempts;
+
+/*      Return codes from load routines:
+ *
+ *      These codes may be returned by the protocol modules,
+ *      and by the HTLoad routines.
+ *      In general, positive codes are OK and negative ones are bad.
+ */
+
+/*
+
+Default Addresses
+
+   These control the home page selection.  To mess with these for normal browses is asking
+   for user confusion.
+
+ */
+#define LOGICAL_DEFAULT "WWW_HOME"	/* Defined to be the home page */
+
+#ifndef PERSONAL_DEFAULT
+#define PERSONAL_DEFAULT "WWW/default.html"	/* in home directory */
+#endif
+#ifndef LOCAL_DEFAULT_FILE
+#define LOCAL_DEFAULT_FILE "/usr/local/lib/WWW/default.html"
+#endif
+/*  If one telnets to a www access point,
+    it will look in this file for home page */
+#ifndef REMOTE_POINTER
+#define REMOTE_POINTER  "/etc/www-remote.url"	/* can't be file */
+#endif
+/* and if that fails it will use this. */
+#ifndef REMOTE_ADDRESS
+#define REMOTE_ADDRESS  "http://www.w3.org/remote.html"		/* can't be file */
+#endif
+
+/* If run from telnet daemon and no -l specified, use this file:
+*/
+#ifndef DEFAULT_LOGFILE
+#define DEFAULT_LOGFILE "/usr/adm/www-log/www-log"
+#endif
+
+/*      If the home page isn't found, use this file:
+*/
+#ifndef LAST_RESORT
+#define LAST_RESORT     "http://www.w3.org/default.html"
+#endif
+
+/*
+
+Flags which may be set to control this module
+
+ */
+#ifdef NOT
+    extern int HTDiag;		/* Flag: load source as plain text */
+#endif				/* NOT */
+    extern char *HTClientHost;	/* Name or number of telnetting host */
+    extern FILE *HTlogfile;	/* File to output one-liners to */
+    extern BOOL HTSecure;	/* Disable security holes? */
+    extern BOOL HTPermitRedir;	/* Special flag for getfile() */
+    extern HTStream *HTOutputStream;	/* For non-interactive, set this */
+    extern HTFormat HTOutputFormat;	/* To convert on load, set this */
+
+/*	Check for proxy override.			override_proxy()
+ *
+ *	Check the no_proxy environment variable to get the list
+ *	of hosts for which proxy server is not consulted.
+ *
+ *	no_proxy is a comma- or space-separated list of machine
+ *	or domain names, with optional :port part.  If no :port
+ *	part is present, it applies to all ports on that domain.
+ *
+ *  Example:
+ *          no_proxy="cern.ch,some.domain:8001"
+ *
+ *  Use "*" to override all proxy service:
+ *	     no_proxy="*"
+ */
+    extern BOOL override_proxy(const char *addr);
+
+/*
+
+Load a document from relative name
+
+  ON ENTRY,
+  relative_name           The relative address of the file to be accessed.
+  here                    The anchor of the object being searched
+
+  ON EXIT,
+  returns    YES          Success in opening file
+  NO                      Failure
+
+ */
+    extern BOOL HTLoadRelative(const char *relative_name,
+			       HTParentAnchor *here);
+
+/*
+
+Load a document from absolute name
+
+  ON ENTRY,
+  addr                    The absolute address of the document to be accessed.
+  filter_it               if YES, treat document as HTML
+
+  ON EXIT,
+  returns YES             Success in opening document
+  NO                      Failure
+
+ */
+    extern BOOL HTLoadAbsolute(const DocAddress *addr);
+
+/*
+
+Load a document from absolute name to a stream
+
+  ON ENTRY,
+  addr                    The absolute address of the document to be accessed.
+  filter_it               if YES, treat document as HTML
+
+  ON EXIT,
+  returns YES             Success in opening document
+  NO                      Failure
+
+   Note: This is equivalent to HTLoadDocument
+
+ */
+    extern BOOL HTLoadToStream(const char *addr, BOOL filter_it,
+			       HTStream *sink);
+
+/*
+
+Load if necessary, and select an anchor
+
+  ON ENTRY,
+  destination                The child or parent anchor to be loaded.
+
+  ON EXIT,
+  returns YES             Success
+  returns NO              Failure
+
+ */
+    extern BOOL HTLoadAnchor(HTAnchor * destination);
+
+/*
+
+Make a stream for Saving object back
+
+  ON ENTRY,
+  anchor                  is valid anchor which has previously been loaded
+
+  ON EXIT,
+  returns                 0 if error else a stream to save the object to.
+
+ */
+    extern HTStream *HTSaveStream(HTParentAnchor *anchor);
+
+/*
+
+Search
+
+   Performs a search on word given by the user.  Adds the search words to the end of the
+   current address and attempts to open the new address.
+
+  ON ENTRY,
+  *keywords               space-separated keyword list or similar search list
+  here                    The anchor of the object being searched
+
+ */
+    extern BOOL HTSearch(const char *keywords, HTParentAnchor *here);
+
+/*
+
+Search Given Indexname
+
+   Performs a keyword search on word given by the user.  Adds the keyword to  the end of
+   the current address and attempts to open the new address.
+
+  ON ENTRY,
+  *keywords               space-separated keyword list or similar search list
+  *indexname              is name of object search is to be done on.
+
+ */
+    extern BOOL HTSearchAbsolute(const char *keywords,
+				 char *indexname);
+
+/*
+
+Register an access method
+
+ */
+
+    typedef struct _HTProtocol {
+	const char *name;
+
+	int (*load) (const char *full_address,
+		     HTParentAnchor *anchor,
+		     HTFormat format_out,
+		     HTStream *sink);
+
+	HTStream *(*saveStream) (HTParentAnchor *anchor);
+
+    } HTProtocol;
+
+    extern BOOL HTRegisterProtocol(HTProtocol * protocol);
+
+/*
+
+Generate the anchor for the home page
+
+ */
+
+/*
+
+   As it involves file access, this should only be done once when the program first runs.
+   This is a default algorithm -- browser don't HAVE to use this.
+
+ */
+    extern HTParentAnchor *HTHomeAnchor(void);
+
+/*
+
+Return Host Name
+
+ */
+    extern const char *HTHostName(void);
+
+/*
+
+For registering protocols supported by Lynx
+
+*/
+    extern void LYRegisterLynxProtocols(void);
+
+    extern void LYUCPushAssumed(HTParentAnchor *anchor);
+    extern int LYUCPopAssumed(void);
+
+    extern BOOL using_proxy;	/* Are we using an NNTP proxy? */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTACCESS_H */
diff --git a/WWW/Library/Implementation/HTAnchor.c b/WWW/Library/Implementation/HTAnchor.c
new file mode 100644
index 0000000..b5ca251
--- /dev/null
+++ b/WWW/Library/Implementation/HTAnchor.c
@@ -0,0 +1,1460 @@
+/*
+ * $LynxId: HTAnchor.c,v 1.82 2020/01/21 21:58:52 tom Exp $
+ *
+ *	Hypertext "Anchor" Object				HTAnchor.c
+ *	==========================
+ *
+ * An anchor represents a region of a hypertext document which is linked to
+ * another anchor in the same or a different document.
+ *
+ * History
+ *
+ *	   Nov 1990  Written in Objective-C for the NeXT browser (TBL)
+ *	24-Oct-1991 (JFG), written in C, browser-independent
+ *	21-Nov-1991 (JFG), first complete version
+ *
+ *	(c) Copyright CERN 1991 - See Copyright.html
+ */
+
+#define HASH_SIZE 997		/* Arbitrary prime.  Memory/speed tradeoff */
+
+#include <HTUtils.h>
+#include <HTAnchor.h>
+#include <HTParse.h>
+#include <HTString.h>
+#include <UCAux.h>
+#include <UCMap.h>
+
+#include <GridText.h>
+#include <LYUtils.h>
+#include <LYCharSets.h>
+#include <LYUtils.h>
+#include <LYLeaks.h>
+
+#define HASH_OF(h, v) ((HASH_TYPE)((h) * 3 + UCH(v)) % HASH_SIZE)
+
+static HASH_TYPE anchor_hash(const char *cp_address)
+{
+    HASH_TYPE hash;
+    const char *p;
+
+    for (p = cp_address, hash = 0; *p; p++)
+	hash = HASH_OF(hash, *p);
+
+    return (hash);
+}
+
+typedef struct _HyperDoc Hyperdoc;
+
+#ifdef VMS
+struct _HyperDoc {
+    int junk;			/* VMS cannot handle pointers to undefined structs */
+};
+#endif /* VMS */
+
+/* Table of lists of all parents */
+static HTList adult_table[HASH_SIZE] =
+{
+    {NULL, NULL}};
+
+/*				Creation Methods
+ *				================
+ *
+ *	Do not use "new" by itself outside this module.  In order to enforce
+ *	consistency, we insist that you furnish more information about the
+ *	anchor you are creating : use newWithParent or newWithAddress.
+ */
+static HTParentAnchor0 *HTParentAnchor0_new(const char *address,
+					    unsigned hash)
+{
+    HTParentAnchor0 *newAnchor = typecalloc(HTParentAnchor0);
+
+    if (newAnchor == NULL)
+	outofmem(__FILE__, "HTParentAnchor0_new");
+
+    newAnchor->parent = newAnchor;	/* self */
+    StrAllocCopy(newAnchor->address, address);
+    newAnchor->adult_hash = (HASH_TYPE) hash;
+
+    return (newAnchor);
+}
+
+static HTParentAnchor *HTParentAnchor_new(HTParentAnchor0 *parent)
+{
+    HTParentAnchor *newAnchor = typecalloc(HTParentAnchor);
+
+    if (newAnchor == NULL)
+	outofmem(__FILE__, "HTParentAnchor_new");
+
+    newAnchor->parent = parent;	/* cross reference */
+    parent->info = newAnchor;	/* cross reference */
+    newAnchor->address = parent->address;	/* copy pointer */
+
+    newAnchor->isISMAPScript = FALSE;	/* Lynx appends ?0,0 if TRUE. - FM */
+    newAnchor->isHEAD = FALSE;	/* HEAD request if TRUE. - FM */
+    newAnchor->safe = FALSE;	/* Safe. - FM */
+    newAnchor->no_cache = FALSE;	/* no-cache? - FM */
+    newAnchor->inBASE = FALSE;	/* duplicated from HTML.c/h */
+    newAnchor->content_length = 0;	/* Content-Length. - FM */
+    return (newAnchor);
+}
+
+static HTChildAnchor *HTChildAnchor_new(HTParentAnchor0 *parent)
+{
+    HTChildAnchor *p = typecalloc(HTChildAnchor);
+
+    if (p == NULL)
+	outofmem(__FILE__, "HTChildAnchor_new");
+
+    p->parent = parent;		/* parent reference */
+    return p;
+}
+
+static HTChildAnchor *HText_pool_ChildAnchor_new(HTParentAnchor *parent)
+{
+    HTChildAnchor *p = (HTChildAnchor *) HText_pool_calloc((HText *) (parent->document),
+							   (unsigned) sizeof(HTChildAnchor));
+
+    if (p == NULL)
+	outofmem(__FILE__, "HText_pool_ChildAnchor_new");
+
+    p->parent = parent->parent;	/* parent reference */
+    return p;
+}
+
+#ifdef CASE_INSENSITIVE_ANCHORS
+/* Case insensitive string comparison */
+#define HT_EQUIV(a,b) (TOUPPER(a) == TOUPPER(b))
+#else
+/* Case sensitive string comparison */
+#define HT_EQUIV(a,b) ((a) == (b))
+#endif
+
+/*	Null-terminated string comparison
+ *	---------------------------------
+ * On entry,
+ *	s	Points to one string, null terminated
+ *	t	points to the other.
+ * On exit,
+ *	returns YES if the strings are equivalent
+ *		NO if they differ.
+ */
+static BOOL HTSEquivalent(const char *s,
+			  const char *t)
+{
+    if (s && t) {		/* Make sure they point to something */
+	for (; *s && *t; s++, t++) {
+	    if (!HT_EQUIV(*s, *t)) {
+		return (NO);
+	    }
+	}
+	return (BOOL) (HT_EQUIV(*s, *t));
+    } else {
+	return (BOOL) (s == t);	/* Two NULLs are equivalent, aren't they ? */
+    }
+}
+
+/*	Binary string comparison
+ *	------------------------
+ * On entry,
+ *	s	Points to one bstring
+ *	t	points to the other.
+ * On exit,
+ *	returns YES if the strings are equivalent
+ *		NO if they differ.
+ */
+static BOOL HTBEquivalent(const bstring *s,
+			  const bstring *t)
+{
+    if (s && t && BStrLen(s) == BStrLen(t)) {
+	int j;
+	int len = BStrLen(s);
+
+	for (j = 0; j < len; ++j) {
+	    if (!HT_EQUIV(BStrData(s)[j], BStrData(t)[j])) {
+		return (NO);
+	    }
+	}
+	return (YES);
+    } else {
+	return (BOOL) (s == t);	/* Two NULLs are equivalent, aren't they ? */
+    }
+}
+
+/*
+ * Three-way compare function
+ */
+static int compare_anchors(void *l,
+			   void *r)
+{
+    const char *a = ((HTChildAnchor *) l)->tag;
+    const char *b = ((HTChildAnchor *) r)->tag;
+
+    /* both tags are not NULL */
+
+#ifdef CASE_INSENSITIVE_ANCHORS
+    return strcasecomp(a, b);	/* Case insensitive */
+#else
+    return strcmp(a, b);	/* Case sensitive - FM */
+#endif /* CASE_INSENSITIVE_ANCHORS */
+}
+
+/*	Create new or find old sub-anchor
+ *	---------------------------------
+ *
+ *	This one is for a named child.
+ *	The parent anchor must already exist.
+ */
+static HTChildAnchor *HTAnchor_findNamedChild(HTParentAnchor0 *parent,
+					      const char *tag)
+{
+    HTChildAnchor *child;
+
+    if (parent && tag && *tag) {	/* TBL */
+	if (parent->children) {
+	    /*
+	     * Parent has children.  Search them.
+	     */
+	    HTChildAnchor sample;
+
+	    sample.tag = DeConst(tag);	/* for compare_anchors() only */
+
+	    child = (HTChildAnchor *) HTBTree_search(parent->children, &sample);
+	    if (child != NULL) {
+		CTRACE((tfp,
+			"Child anchor %p of parent %p with name `%s' already exists.\n",
+			(void *) child, (void *) parent, tag));
+		return (child);
+	    }
+	} else {		/* parent doesn't have any children yet : create family */
+	    parent->children = HTBTree_new(compare_anchors);
+	}
+
+	child = HTChildAnchor_new(parent);
+	CTRACE((tfp, "HTAnchor: New Anchor %p named `%s' is child of %p\n",
+		(void *) child,
+		NonNull(tag),
+		(void *) child->parent));
+
+	StrAllocCopy(child->tag, tag);	/* should be set before HTBTree_add */
+	HTBTree_add(parent->children, child);
+	return (child);
+
+    } else {
+	CTRACE((tfp, "HTAnchor_findNamedChild called with NULL parent.\n"));
+	return (NULL);
+    }
+
+}
+
+/*
+ *	This one is for a new unnamed child being edited into an existing
+ *	document.  The parent anchor and the document must already exist.
+ *	(Just add new unnamed child).
+ */
+static HTChildAnchor *HTAnchor_addChild(HTParentAnchor *parent)
+{
+    HTChildAnchor *child;
+
+    if (!parent) {
+	CTRACE((tfp, "HTAnchor_addChild called with NULL parent.\n"));
+	return (NULL);
+    }
+
+    child = HText_pool_ChildAnchor_new(parent);
+    CTRACE((tfp, "HTAnchor: New unnamed Anchor %p is child of %p\n",
+	    (void *) child,
+	    (void *) child->parent));
+
+    child->tag = 0;
+    HTList_linkObject(&parent->children_notag, child, &child->_add_children_notag);
+
+    return (child);
+}
+
+static HTParentAnchor0 *HTAnchor_findAddress_in_adult_table(const DocAddress *newdoc);
+
+static BOOL HTAnchor_link(HTChildAnchor *child,
+			  HTAnchor * destination,
+			  HTLinkType *type);
+
+/*	Create or find a child anchor with a possible link
+ *	--------------------------------------------------
+ *
+ *	Create new anchor with a given parent and possibly
+ *	a name, and possibly a link to a _relatively_ named anchor.
+ *	(Code originally in ParseHTML.h)
+ */
+HTChildAnchor *HTAnchor_findChildAndLink(HTParentAnchor *parent,	/* May not be 0   */
+					 const char *tag,	/* May be "" or 0 */
+					 const char *href,	/* May be "" or 0 */
+					 HTLinkType *ltype)	/* May be 0       */
+{
+    HTChildAnchor *child;
+
+    CTRACE((tfp, "Entered HTAnchor_findChildAndLink:  tag=`%s',%s href=`%s'\n",
+	    NonNull(tag),
+	    (ltype == HTInternalLink) ? " (internal link)" : "",
+	    NonNull(href)));
+
+    if (parent == 0) {
+	child = 0;
+    } else {
+	if (non_empty(tag)) {
+	    child = HTAnchor_findNamedChild(parent->parent, tag);
+	} else {
+	    child = HTAnchor_addChild(parent);
+	}
+
+	if (non_empty(href)) {
+	    const char *fragment = NULL;
+	    HTParentAnchor0 *dest;
+
+	    if (ltype == HTInternalLink && *href == '#') {
+		dest = parent->parent;
+	    } else {
+		const char *relative_to = ((parent->inBASE && *href != '#')
+					   ? parent->content_base
+					   : parent->address);
+		DocAddress parsed_doc;
+
+		parsed_doc.address = HTParse(href, relative_to,
+					     PARSE_ALL_WITHOUT_ANCHOR);
+
+		parsed_doc.post_data = NULL;
+		parsed_doc.post_content_type = NULL;
+		if (ltype && parent->post_data && ltype == HTInternalLink) {
+		    /* for internal links, find a destination with the same
+		       post data if the source of the link has post data. - kw
+		       Example: LYNXIMGMAP: */
+		    parsed_doc.post_data = parent->post_data;
+		    parsed_doc.post_content_type = parent->post_content_type;
+		}
+		parsed_doc.bookmark = NULL;
+		parsed_doc.isHEAD = FALSE;
+		parsed_doc.safe = FALSE;
+
+		dest = HTAnchor_findAddress_in_adult_table(&parsed_doc);
+		FREE(parsed_doc.address);
+	    }
+
+	    /*
+	     * [from HTAnchor_findAddress()]
+	     * If the address represents a sub-anchor, we load its parent (above),
+	     * then we create a named child anchor within that parent.
+	     */
+	    fragment = (*href == '#') ? href + 1 : HTParseAnchor(href);
+
+	    if (*fragment)
+		dest = (HTParentAnchor0 *) HTAnchor_findNamedChild(dest, fragment);
+
+	    if (tag && *tag) {
+		if (child->dest) {	/* DUPLICATE_ANCHOR_NAME_WORKAROUND  - kw */
+		    CTRACE((tfp,
+			    "*** Duplicate ChildAnchor %p named `%s'",
+			    (void *) child, tag));
+		    if ((HTAnchor *) dest != child->dest || ltype != child->type) {
+			CTRACE((tfp,
+				", different dest %p or type, creating unnamed child\n",
+				(void *) child->dest));
+			child = HTAnchor_addChild(parent);
+		    }
+		}
+	    }
+	    HTAnchor_link(child, (HTAnchor *) dest, ltype);
+	}
+    }
+    return child;
+}
+
+/*	Create new or find old parent anchor
+ *	------------------------------------
+ *
+ *	Me one is for a reference which is found in a document, and might
+ *	not be already loaded.
+ *	Note: You are not guaranteed a new anchor -- you might get an old one,
+ *	like with fonts.
+ */
+HTParentAnchor *HTAnchor_findAddress(const DocAddress *newdoc)
+{
+    /* Anchor tag specified ? */
+    const char *tag = HTParseAnchor(newdoc->address);
+
+    CTRACE((tfp, "Entered HTAnchor_findAddress\n"));
+
+    /*
+     * If the address represents a sub-anchor, we load its parent, then we
+     * create a named child anchor within that parent.
+     */
+    if (*tag) {
+	DocAddress parsed_doc;
+	HTParentAnchor0 *foundParent;
+
+	parsed_doc.address = HTParse(newdoc->address, "",
+				     PARSE_ALL_WITHOUT_ANCHOR);
+	parsed_doc.post_data = newdoc->post_data;
+	parsed_doc.post_content_type = newdoc->post_content_type;
+	parsed_doc.bookmark = newdoc->bookmark;
+	parsed_doc.isHEAD = newdoc->isHEAD;
+	parsed_doc.safe = newdoc->safe;
+
+	foundParent = HTAnchor_findAddress_in_adult_table(&parsed_doc);
+	(void) HTAnchor_findNamedChild(foundParent, tag);
+	FREE(parsed_doc.address);
+	return HTAnchor_parent((HTAnchor *) foundParent);
+    }
+    return HTAnchor_parent((HTAnchor *) HTAnchor_findAddress_in_adult_table(newdoc));
+}
+
+/*  The address has no anchor tag, for sure.
+ */
+static HTParentAnchor0 *HTAnchor_findAddress_in_adult_table(const DocAddress *newdoc)
+{
+    /*
+     * Check whether we have this node.
+     */
+    HASH_TYPE hash;
+    HTList *adults;
+    HTList *grownups;
+    HTParentAnchor0 *foundAnchor;
+    BOOL need_extra_info = (BOOL) (newdoc->post_data ||
+				   newdoc->post_content_type ||
+				   newdoc->bookmark ||
+				   newdoc->isHEAD ||
+				   newdoc->safe);
+
+    /*
+     * We need not free adult_table[] atexit - it should be perfectly empty
+     * after free'ing all HText's.  (There is an error if it is not empty at
+     * exit).  -LP
+     */
+
+    /*
+     * Select list from hash table,
+     */
+    hash = anchor_hash(newdoc->address);
+    adults = &(adult_table[hash]);
+
+    /*
+     * Search list for anchor.
+     */
+    grownups = adults;
+    while (NULL != (foundAnchor =
+		    (HTParentAnchor0 *) HTList_nextObject(grownups))) {
+	if (HTSEquivalent(foundAnchor->address, newdoc->address) &&
+
+	    ((!foundAnchor->info && !need_extra_info) ||
+	     (foundAnchor->info &&
+	      HTBEquivalent(foundAnchor->info->post_data, newdoc->post_data) &&
+	      foundAnchor->info->isHEAD == newdoc->isHEAD))) {
+	    CTRACE((tfp, "Anchor %p with address `%s' already exists.\n",
+		    (void *) foundAnchor, newdoc->address));
+	    return foundAnchor;
+	}
+    }
+
+    /*
+     * Node not found:  create new anchor.
+     */
+    foundAnchor = HTParentAnchor0_new(newdoc->address, hash);
+    CTRACE((tfp, "New anchor %p has hash %d and address `%s'\n",
+	    (void *) foundAnchor, hash, newdoc->address));
+
+    if (need_extra_info) {
+	/* rare case, create a big structure */
+	HTParentAnchor *p = HTParentAnchor_new(foundAnchor);
+
+	if (newdoc->post_data)
+	    BStrCopy(p->post_data, newdoc->post_data);
+	if (newdoc->post_content_type)
+	    StrAllocCopy(p->post_content_type,
+			 newdoc->post_content_type);
+	if (newdoc->bookmark)
+	    StrAllocCopy(p->bookmark, newdoc->bookmark);
+	p->isHEAD = newdoc->isHEAD;
+	p->safe = newdoc->safe;
+    }
+    HTList_linkObject(adults, foundAnchor, &foundAnchor->_add_adult);
+
+    return foundAnchor;
+}
+
+/*	Create new or find old named anchor - simple form
+ *	-------------------------------------------------
+ *
+ *     Like HTAnchor_findAddress, but simpler to use for simple cases.
+ *	No post data etc. can be supplied. - kw
+ */
+HTParentAnchor *HTAnchor_findSimpleAddress(const char *url)
+{
+    DocAddress urldoc;
+
+    urldoc.address = DeConst(url);	/* ignore warning, it IS treated like const - kw */
+    urldoc.post_data = NULL;
+    urldoc.post_content_type = NULL;
+    urldoc.bookmark = NULL;
+    urldoc.isHEAD = FALSE;
+    urldoc.safe = FALSE;
+    return HTAnchor_findAddress(&urldoc);
+}
+
+/*	Link me Anchor to another given one
+ *	-------------------------------------
+ */
+static BOOL HTAnchor_link(HTChildAnchor *child,
+			  HTAnchor * destination,
+			  HTLinkType *type)
+{
+    if (!(child && destination))
+	return (NO);		/* Can't link to/from non-existing anchor */
+
+    CTRACE((tfp, "Linking child %p to anchor %p\n", (void *) child, (void *) destination));
+    if (child->dest) {
+	CTRACE((tfp, "*** child anchor already has destination, exiting!\n"));
+	return (NO);
+    }
+
+    child->dest = destination;
+    child->type = type;
+
+    if (child->parent != destination->parent)
+	/* link only foreign children */
+	HTList_linkObject(&destination->parent->sources, child, &child->_add_sources);
+
+    return (YES);		/* Success */
+}
+
+/*	Delete an anchor and possibly related things (auto garbage collection)
+ *	--------------------------------------------
+ *
+ *	The anchor is only deleted if the corresponding document is not loaded.
+ *	All outgoing links from children are deleted, and children are
+ *	removed from the sources lists of theirs targets.
+ *	We also try to delete the targets whose documents are not loaded.
+ *	If this anchor's sources list is empty, we delete it and its children.
+ */
+
+/*
+ *	Recursively try to delete destination anchor of this child.
+ *	In any event, this will tell destination anchor that we
+ *	no longer consider it a destination.
+ */
+static void deleteLinks(HTChildAnchor *me)
+{
+    /*
+     * Unregister me with our destination anchor's parent.
+     */
+    if (me->dest) {
+	HTParentAnchor0 *parent = me->dest->parent;
+
+	/*
+	 * Start.  Set the dest pointer to zero.
+	 */
+	me->dest = NULL;
+
+	/*
+	 * Remove me from the parent's sources so that the parent knows one
+	 * less anchor is its dest.
+	 */
+	if ((me->parent != parent) && !HTList_isEmpty(&parent->sources)) {
+	    /*
+	     * Really should only need to deregister once.
+	     */
+	    HTList_unlinkObject(&parent->sources, (void *) me);
+	}
+
+	/*
+	 * Recursive call.  Test here to avoid calling overhead.  Don't delete
+	 * if document is loaded or being loaded.
+	 */
+	if ((me->parent != parent) &&
+	    parent != NULL &&
+	    !parent->underway &&
+	    (!parent->info || !parent->info->document)) {
+	    HTAnchor_delete(parent);
+	}
+
+	/*
+	 * At this point, we haven't a destination.  Set it to be so.  Leave
+	 * the HTAtom pointed to by type up to other code to handle (reusable,
+	 * near static).
+	 */
+	me->type = NULL;
+    }
+}
+
+static void HTParentAnchor_free(HTParentAnchor *me);
+
+BOOL HTAnchor_delete(HTParentAnchor0 *me)
+{
+    /*
+     * Memory leaks fixed.
+     * 05-27-94 Lynx 2-3-1 Garrett Arch Blythe
+     */
+    HTBTElement *ele;
+    HTChildAnchor *child;
+
+    /*
+     * Do nothing if nothing to do.
+     */
+    if (!me) {
+	return (NO);
+    }
+
+    /*
+     * Don't delete if document is loaded or being loaded.
+     */
+    if (me->underway || (me->info && me->info->document)) {
+	return (NO);
+    }
+
+    /*
+     * Mark ourselves busy, so that recursive calls of this function on this
+     * HTParentAnchor0 will not free it from under our feet.  - kw
+     */
+    me->underway = TRUE;
+
+    {
+	/*
+	 * Delete all outgoing links from named children.  Do not delete named
+	 * children itself (may have incoming links).
+	 */
+	if (me->children) {
+	    ele = HTBTree_next(me->children, NULL);
+	    while (ele != NULL) {
+		child = (HTChildAnchor *) HTBTree_object(ele);
+		if (child->dest)
+		    deleteLinks(child);
+		ele = HTBTree_next(me->children, ele);
+	    }
+	}
+    }
+    me->underway = FALSE;
+
+    /*
+     * There are still incoming links to this one (we are the
+     * destination of another anchor).
+     */
+    if (!HTList_isEmpty(&me->sources)) {
+	/*
+	 * Can't delete parent, still have sources.
+	 */
+	return (NO);
+    }
+
+    /*
+     * No more incoming and outgoing links :  kill everything First, delete
+     * named children.
+     */
+    if (me->children) {
+	ele = HTBTree_next(me->children, NULL);
+	while (ele != NULL) {
+	    child = (HTChildAnchor *) HTBTree_object(ele);
+	    FREE(child->tag);
+	    FREE(child);
+	    ele = HTBTree_next(me->children, ele);
+	}
+	HTBTree_free(me->children);
+    }
+
+    /*
+     * Delete the ParentAnchor, if any.  (Document was already deleted).
+     */
+    if (me->info) {
+	HTParentAnchor_free(me->info);
+	FREE(me->info);
+    }
+
+    /*
+     * Remove ourselves from the hash table's list.
+     */
+    HTList_unlinkObject(&(adult_table[me->adult_hash]), (void *) me);
+
+    /*
+     * Free the address.
+     */
+    FREE(me->address);
+
+    /*
+     * Finally, kill the parent anchor passed in.
+     */
+    FREE(me);
+
+    return (YES);
+}
+
+/*
+ * Unnamed children (children_notag) have no sense without HText - delete them
+ * and their links if we are about to free HText.  Document currently exists. 
+ * Called within HText_free().
+ */
+void HTAnchor_delete_links(HTParentAnchor *me)
+{
+    HTList *cur;
+    HTChildAnchor *child;
+
+    /*
+     * Do nothing if nothing to do.
+     */
+    if (!me || !me->document) {
+	return;
+    }
+
+    /*
+     * Mark ourselves busy, so that recursive calls on this HTParentAnchor0
+     * will not free it from under our feet.  - kw
+     */
+    me->parent->underway = TRUE;
+
+    /*
+     * Delete all outgoing links from unnamed children.
+     */
+    if (!HTList_isEmpty(&me->children_notag)) {
+	cur = &me->children_notag;
+	while ((child =
+		(HTChildAnchor *) HTList_unlinkLastObject(cur)) != 0) {
+	    deleteLinks(child);
+	    /* child allocated in HText pool, HText_free() will free it later */
+	}
+    }
+    me->parent->underway = FALSE;
+}
+
+static void HTParentAnchor_free(HTParentAnchor *me)
+{
+    /*
+     * Delete the methods list.
+     */
+    if (me->methods) {
+	/*
+	 * Leave what the methods point to up in memory for other code (near
+	 * static stuff).
+	 */
+	HTList_delete(me->methods);
+	me->methods = NULL;
+    }
+
+    /*
+     * Free up all allocated members.
+     */
+    FREE(me->charset);
+    FREE(me->isIndexAction);
+    FREE(me->isIndexPrompt);
+    FREE(me->title);
+    FREE(me->physical);
+    BStrFree(me->post_data);
+    FREE(me->post_content_type);
+    FREE(me->bookmark);
+    FREE(me->owner);
+    FREE(me->RevTitle);
+    FREE(me->citehost);
+#ifdef USE_SOURCE_CACHE
+    HTAnchor_clearSourceCache(me);
+#endif
+    if (me->FileCache) {
+	FILE *fd;
+
+	if ((fd = fopen(me->FileCache, "r")) != NULL) {
+	    fclose(fd);
+	    (void) remove(me->FileCache);
+	}
+	FREE(me->FileCache);
+    }
+    FREE(me->SugFname);
+    FREE(me->cache_control);
+    HTChunkClear(&(me->http_headers));
+    FREE(me->content_type_params);
+    FREE(me->content_type);
+    FREE(me->content_language);
+    FREE(me->content_encoding);
+    FREE(me->content_base);
+    FREE(me->content_disposition);
+    FREE(me->content_location);
+    FREE(me->content_md5);
+    FREE(me->message_id);
+    FREE(me->subject);
+    FREE(me->date);
+    FREE(me->expires);
+
+    FREE(me->last_modified);
+    FREE(me->ETag);
+    FREE(me->server);
+#ifdef USE_COLOR_STYLE
+    FREE(me->style);
+#endif
+
+    /*
+     * Original code wanted a way to clean out the HTFormat if no longer needed
+     * (ref count?).  I'll leave it alone since those HTAtom objects are a
+     * little harder to know where they are being referenced all at one time. 
+     * (near static)
+     */
+
+    FREE(me->UCStages);
+    ImageMapList_free(me->imaps);
+}
+
+#ifdef USE_SOURCE_CACHE
+void HTAnchor_clearSourceCache(HTParentAnchor *me)
+{
+    /*
+     * Clean up the source cache, if any.
+     */
+    if (me->source_cache_file) {
+	CTRACE((tfp, "SourceCache: Removing file %s\n",
+		me->source_cache_file));
+	(void) LYRemoveTemp(me->source_cache_file);
+	FREE(me->source_cache_file);
+    }
+    if (me->source_cache_chunk) {
+	CTRACE((tfp, "SourceCache: Removing memory chunk %p\n",
+		(void *) me->source_cache_chunk));
+	HTChunkFree(me->source_cache_chunk);
+	me->source_cache_chunk = NULL;
+    }
+}
+#endif /* USE_SOURCE_CACHE */
+
+/*	Data access functions
+ *	---------------------
+ */
+HTParentAnchor *HTAnchor_parent(HTAnchor * me)
+{
+    if (!me)
+	return NULL;
+
+    if (me->parent->info)
+	return me->parent->info;
+
+    /* else: create a new structure */
+    return HTParentAnchor_new(me->parent);
+}
+
+void HTAnchor_setDocument(HTParentAnchor *me,
+			  HyperDoc *doc)
+{
+    if (me)
+	me->document = doc;
+}
+
+HyperDoc *HTAnchor_document(HTParentAnchor *me)
+{
+    return (me ? me->document : NULL);
+}
+
+char *HTAnchor_address(HTAnchor * me)
+{
+    char *addr = NULL;
+
+    if (me) {
+	if (((HTParentAnchor0 *) me == me->parent) ||
+	    ((HTParentAnchor *) me == me->parent->info) ||
+	    !((HTChildAnchor *) me)->tag) {	/* it's an adult or no tag */
+	    StrAllocCopy(addr, me->parent->address);
+	} else {		/* it's a named child */
+	    HTSprintf0(&addr, "%s#%s",
+		       me->parent->address, ((HTChildAnchor *) me)->tag);
+	}
+    }
+    return (addr);
+}
+
+char *HTAnchor_short_address(HTAnchor * me)
+{
+    const char chop[] = "file://localhost/";
+    char *addr = HTAnchor_address(me);
+
+    if (!strncmp(addr, chop, sizeof(chop) - 1)) {
+	char *a = addr + 7;
+	char *b = addr + sizeof(chop) - 2;
+
+	while ((*a++ = *b++) != '\0') {
+	    ;
+	}
+    }
+    return addr;
+}
+
+void HTAnchor_setFormat(HTParentAnchor *me,
+			HTFormat form)
+{
+    if (me)
+	me->format = form;
+}
+
+HTFormat HTAnchor_format(HTParentAnchor *me)
+{
+    return (me ? me->format : NULL);
+}
+
+void HTAnchor_setIndex(HTParentAnchor *me,
+		       const char *address)
+{
+    if (me) {
+	me->isIndex = YES;
+	StrAllocCopy(me->isIndexAction, address);
+    }
+}
+
+void HTAnchor_setPrompt(HTParentAnchor *me,
+			const char *prompt)
+{
+    if (me) {
+	StrAllocCopy(me->isIndexPrompt, prompt);
+    }
+}
+
+BOOL HTAnchor_isIndex(HTParentAnchor *me)
+{
+    return (BOOL) (me
+		   ? me->isIndex
+		   : NO);
+}
+
+/*	Whether Anchor has been designated as an ISMAP link
+ *	(normally by presence of an ISMAP attribute on A or IMG) - KW
+ */
+BOOL HTAnchor_isISMAPScript(HTAnchor * me)
+{
+    return (BOOL) ((me && me->parent->info)
+		   ? me->parent->info->isISMAPScript
+		   : NO);
+}
+
+#if defined(USE_COLOR_STYLE)
+/*	Style handling.
+*/
+const char *HTAnchor_style(HTParentAnchor *me)
+{
+    return (me ? me->style : NULL);
+}
+
+void HTAnchor_setStyle(HTParentAnchor *me,
+		       const char *style)
+{
+    if (me) {
+	StrAllocCopy(me->style, style);
+    }
+}
+#endif
+
+/*	Title handling.
+*/
+const char *HTAnchor_title(HTParentAnchor *me)
+{
+    return (me ? me->title : NULL);
+}
+
+void HTAnchor_setTitle(HTParentAnchor *me,
+		       const char *title)
+{
+    int i;
+
+    if (me) {
+	if (title) {
+	    StrAllocCopy(me->title, title);
+	    for (i = 0; me->title[i]; i++) {
+		if (UCH(me->title[i]) == 1 ||
+		    UCH(me->title[i]) == 2) {
+		    me->title[i] = ' ';
+		}
+	    }
+	} else {
+	    CTRACE((tfp, "HTAnchor_setTitle: New title is NULL! "));
+	    if (me->title) {
+		CTRACE((tfp, "Old title was \"%s\".\n", me->title));
+		FREE(me->title);
+	    } else {
+		CTRACE((tfp, "Old title was NULL.\n"));
+	    }
+	}
+    }
+}
+
+void HTAnchor_appendTitle(HTParentAnchor *me,
+			  const char *title)
+{
+    int i;
+
+    if (me) {
+	StrAllocCat(me->title, title);
+	for (i = 0; me->title[i]; i++) {
+	    if (UCH(me->title[i]) == 1 ||
+		UCH(me->title[i]) == 2) {
+		me->title[i] = ' ';
+	    }
+	}
+    }
+}
+
+/*	Bookmark handling.
+*/
+const char *HTAnchor_bookmark(HTParentAnchor *me)
+{
+    return (me ? me->bookmark : NULL);
+}
+
+void HTAnchor_setBookmark(HTParentAnchor *me,
+			  const char *bookmark)
+{
+    if (me)
+	StrAllocCopy(me->bookmark, bookmark);
+}
+
+/*	Owner handling.
+*/
+const char *HTAnchor_owner(HTParentAnchor *me)
+{
+    return (me ? me->owner : NULL);
+}
+
+void HTAnchor_setOwner(HTParentAnchor *me,
+		       const char *owner)
+{
+    if (me) {
+	StrAllocCopy(me->owner, owner);
+    }
+}
+
+/*	TITLE handling in LINKs with REV="made" or REV="owner". - FM
+*/
+const char *HTAnchor_RevTitle(HTParentAnchor *me)
+{
+    return (me ? me->RevTitle : NULL);
+}
+
+void HTAnchor_setRevTitle(HTParentAnchor *me,
+			  const char *title)
+{
+    int i;
+
+    if (me) {
+	StrAllocCopy(me->RevTitle, title);
+	for (i = 0; me->RevTitle[i]; i++) {
+	    if (UCH(me->RevTitle[i]) == 1 ||
+		UCH(me->RevTitle[i]) == 2) {
+		me->RevTitle[i] = ' ';
+	    }
+	}
+    }
+}
+
+#ifndef DISABLE_BIBP
+/*	Citehost for bibp links from LINKs with REL="citehost". - RDC
+*/
+const char *HTAnchor_citehost(HTParentAnchor *me)
+{
+    return (me ? me->citehost : NULL);
+}
+
+void HTAnchor_setCitehost(HTParentAnchor *me,
+			  const char *citehost)
+{
+    if (me) {
+	StrAllocCopy(me->citehost, citehost);
+    }
+}
+#endif /* !DISABLE_BIBP */
+
+/*	Suggested filename handling. - FM
+ *	(will be loaded if we had a Content-Disposition
+ *	 header or META element with filename=name.suffix)
+ */
+const char *HTAnchor_SugFname(HTParentAnchor *me)
+{
+    return (me ? me->SugFname : NULL);
+}
+
+/*	HTTP Headers.
+*/
+const char *HTAnchor_http_headers(HTParentAnchor *me)
+{
+    return (me ? me->http_headers.data : NULL);
+}
+
+/*	Content-Type handling (parameter list).
+*/
+const char *HTAnchor_content_type_params(HTParentAnchor *me)
+{
+    return (me ? me->content_type_params : NULL);
+}
+
+/*	Content-Encoding handling. - FM
+ *	(will be loaded if we had a Content-Encoding
+ *	 header.)
+ */
+const char *HTAnchor_content_encoding(HTParentAnchor *me)
+{
+    return (me ? me->content_encoding : NULL);
+}
+
+/*	Content-Type handling. - FM
+*/
+const char *HTAnchor_content_type(HTParentAnchor *me)
+{
+    return (me ? me->content_type : NULL);
+}
+
+/*	Last-Modified header handling. - FM
+*/
+const char *HTAnchor_last_modified(HTParentAnchor *me)
+{
+    return (me ? me->last_modified : NULL);
+}
+
+/*	Date header handling. - FM
+*/
+const char *HTAnchor_date(HTParentAnchor *me)
+{
+    return (me ? me->date : NULL);
+}
+
+/*	Server header handling. - FM
+*/
+const char *HTAnchor_server(HTParentAnchor *me)
+{
+    return (me ? me->server : NULL);
+}
+
+/*	Safe header handling. - FM
+*/
+BOOL HTAnchor_safe(HTParentAnchor *me)
+{
+    return (BOOL) (me ? me->safe : FALSE);
+}
+
+/*	Content-Base header handling. - FM
+*/
+const char *HTAnchor_content_base(HTParentAnchor *me)
+{
+    return (me ? me->content_base : NULL);
+}
+
+/*	Content-Location header handling. - FM
+*/
+const char *HTAnchor_content_location(HTParentAnchor *me)
+{
+    return (me ? me->content_location : NULL);
+}
+
+/*	Message-ID, used for mail replies - kw
+*/
+const char *HTAnchor_messageID(HTParentAnchor *me)
+{
+    return (me ? me->message_id : NULL);
+}
+
+BOOL HTAnchor_setMessageID(HTParentAnchor *me,
+			   const char *messageid)
+{
+    if (!(me && messageid && *messageid)) {
+	return FALSE;
+    }
+    StrAllocCopy(me->message_id, messageid);
+    return TRUE;
+}
+
+/*	Subject, used for mail replies - kw
+*/
+const char *HTAnchor_subject(HTParentAnchor *me)
+{
+    return (me ? me->subject : NULL);
+}
+
+BOOL HTAnchor_setSubject(HTParentAnchor *me,
+			 const char *subject)
+{
+    if (!(me && subject && *subject)) {
+	return FALSE;
+    }
+    StrAllocCopy(me->subject, subject);
+    return TRUE;
+}
+
+/*	Manipulation of links
+ *	---------------------
+ */
+HTAnchor *HTAnchor_followLink(HTChildAnchor *me)
+{
+    return (me->dest);
+}
+
+HTAnchor *HTAnchor_followTypedLink(HTChildAnchor *me,
+				   HTLinkType *type)
+{
+    if (me->type == type)
+	return (me->dest);
+    return (NULL);		/* No link of me type */
+}
+
+/*	Methods List
+ *	------------
+ */
+HTList *HTAnchor_methods(HTParentAnchor *me)
+{
+    if (!me->methods) {
+	me->methods = HTList_new();
+    }
+    return (me->methods);
+}
+
+/*	Protocol
+ *	--------
+ */
+void *HTAnchor_protocol(HTParentAnchor *me)
+{
+    return (me->protocol);
+}
+
+void HTAnchor_setProtocol(HTParentAnchor *me,
+			  void *protocol)
+{
+    me->protocol = protocol;
+}
+
+/*	Physical Address
+ *	----------------
+ */
+char *HTAnchor_physical(HTParentAnchor *me)
+{
+    return (me->physical);
+}
+
+void HTAnchor_setPhysical(HTParentAnchor *me,
+			  char *physical)
+{
+    if (me) {
+	StrAllocCopy(me->physical, physical);
+    }
+}
+
+#ifdef DEBUG
+static void show_stages(HTParentAnchor *me, const char *tag, int which_stage)
+{
+    int j;
+
+    CTRACE((tfp, "Stages %s*%s", NonNull(me->charset), tag));
+    for (j = 0; j < UCT_STAGEMAX; j++) {
+	CTRACE((tfp, " "));
+	if (j == which_stage)
+	    CTRACE((tfp, "("));
+	CTRACE((tfp, "%d:%d:%s",
+		j,
+		me->UCStages->s[j].LYhndl,
+		NonNull(me->UCStages->s[j].C.MIMEname)));
+	if (j == which_stage)
+	    CTRACE((tfp, ")"));
+    }
+    CTRACE((tfp, "\n"));
+}
+#else
+#define show_stages(me,tag,which_stage)		/* nothing */
+#endif
+
+/*
+ *  We store charset info in the HTParentAnchor object, for several
+ *  "stages".  (See UCDefs.h)
+ *  A stream method is supposed to know what stage in the model it is.
+ *
+ *  General model	MIME	 ->  parser  ->  structured  ->  HText
+ *  e.g., text/html
+ *	from HTTP:	HTMIME.c ->  SGML.c  ->  HTML.c      ->  GridText.c
+ *     text/plain
+ *	from file:	HTFile.c ->  HTPlain.c		     ->  GridText.c
+ *
+ *  The lock/set_by is used to lock e.g. a charset set by an explicit
+ *  HTTP MIME header against overriding by a HTML META tag - the MIME
+ *  header has higher priority.  Defaults (from -assume_.. options etc.)
+ *  will not override charset explicitly given by server.
+ *
+ *  Some advantages of keeping this in the HTAnchor:
+ *  - Global variables are bad.
+ *  - Can remember a charset given by META tag when toggling to SOURCE view.
+ *  - Can remember a charset given by <A CHARSET=...> href in another doc.
+ *
+ *  We don't modify the HTParentAnchor's charset element
+ *  here, that one will only be set when explicitly given.
+ */
+LYUCcharset *HTAnchor_getUCInfoStage(HTParentAnchor *me,
+				     int which_stage)
+{
+    LYUCcharset *result = NULL;
+
+    if (me) {
+	if (!me->UCStages) {
+	    int i;
+	    int chndl = UCLYhndl_for_unspec;	/* always >= 0 */
+	    UCAnchorInfo *stages = typecalloc(UCAnchorInfo);
+
+	    if (stages == NULL)
+		outofmem(__FILE__, "HTAnchor_getUCInfoStage");
+
+	    for (i = 0; i < UCT_STAGEMAX; i++) {
+		stages->s[i].C.MIMEname = "";
+		stages->s[i].LYhndl = -1;
+	    }
+	    if (me->charset) {
+		chndl = UCGetLYhndl_byMIME(me->charset);
+		if (chndl < 0)
+		    chndl = UCLYhndl_for_unrec;
+		if (chndl < 0)
+		    /*
+		     * UCLYhndl_for_unrec not defined :-(
+		     * fallback to UCLYhndl_for_unspec which always valid.
+		     */
+		    chndl = UCLYhndl_for_unspec;	/* always >= 0 */
+	    }
+	    MemCpy(&stages->s[UCT_STAGE_MIME].C, &LYCharSet_UC[chndl],
+		   sizeof(LYUCcharset));
+
+	    stages->s[UCT_STAGE_MIME].lock = UCT_SETBY_DEFAULT;
+	    stages->s[UCT_STAGE_MIME].LYhndl = chndl;
+	    me->UCStages = stages;
+	}
+	result = (&me->UCStages->s[which_stage].C);
+	show_stages(me, "_getUCInfoStage", which_stage);
+    }
+    return (result);
+}
+
+int HTAnchor_getUCLYhndl(HTParentAnchor *me,
+			 int which_stage)
+{
+    if (me) {
+	if (!me->UCStages) {
+	    /*
+	     * This will allocate and initialize, if not yet done.
+	     */
+	    (void) HTAnchor_getUCInfoStage(me, which_stage);
+	}
+	if (me->UCStages->s[which_stage].lock > UCT_SETBY_NONE) {
+	    return (me->UCStages->s[which_stage].LYhndl);
+	}
+    }
+    return (-1);
+}
+
+#ifdef CAN_SWITCH_DISPLAY_CHARSET
+static void setup_switch_display_charset(HTParentAnchor *me, int h)
+{
+    if (!Switch_Display_Charset(h, SWITCH_DISPLAY_CHARSET_MAYBE))
+	return;
+    HTAnchor_setUCInfoStage(me, current_char_set,
+			    UCT_STAGE_HTEXT, UCT_SETBY_MIME);	/* highest priority! */
+    HTAnchor_setUCInfoStage(me, current_char_set,
+			    UCT_STAGE_STRUCTURED, UCT_SETBY_MIME);	/* highest priority! */
+    CTRACE((tfp,
+	    "changing UCInfoStage: HTEXT/STRUCTURED stages charset='%s'.\n",
+	    LYCharSet_UC[current_char_set].MIMEname));
+}
+#endif
+
+LYUCcharset *HTAnchor_setUCInfoStage(HTParentAnchor *me,
+				     int LYhndl,
+				     int which_stage,
+				     int set_by)
+{
+    if (me) {
+	/*
+	 * This will allocate and initialize, if not yet done.
+	 */
+	LYUCcharset *p = HTAnchor_getUCInfoStage(me, which_stage);
+
+	/*
+	 * Can we override?
+	 */
+	if (set_by >= me->UCStages->s[which_stage].lock) {
+#ifdef CAN_SWITCH_DISPLAY_CHARSET
+	    int ohandle = me->UCStages->s[which_stage].LYhndl;
+#endif
+	    me->UCStages->s[which_stage].lock = set_by;
+	    me->UCStages->s[which_stage].LYhndl = LYhndl;
+	    if (LYhndl >= 0) {
+		MemCpy(p, &LYCharSet_UC[LYhndl], sizeof(LYUCcharset));
+
+#ifdef CAN_SWITCH_DISPLAY_CHARSET
+		/* Allow a switch to a more suitable display charset */
+		if (LYhndl != ohandle && which_stage == UCT_STAGE_PARSER)
+		    setup_switch_display_charset(me, LYhndl);
+#endif
+	    } else {
+		p->UChndl = -1;
+	    }
+	    show_stages(me, "_setUCInfoStage", which_stage);
+	    return (p);
+	}
+    }
+    return (NULL);
+}
+
+LYUCcharset *HTAnchor_resetUCInfoStage(HTParentAnchor *me,
+				       int LYhndl,
+				       int which_stage,
+				       int set_by)
+{
+    LYUCcharset *result = NULL;
+    int ohandle;
+
+    if (me && me->UCStages) {
+	me->UCStages->s[which_stage].lock = set_by;
+	ohandle = me->UCStages->s[which_stage].LYhndl;
+	me->UCStages->s[which_stage].LYhndl = LYhndl;
+#ifdef CAN_SWITCH_DISPLAY_CHARSET
+	/* Allow a switch to a more suitable display charset */
+	if (LYhndl >= 0 && LYhndl != ohandle
+	    && which_stage == UCT_STAGE_PARSER)
+	    setup_switch_display_charset(me, LYhndl);
+#else
+	(void) ohandle;
+#endif
+	show_stages(me, "_resetUCInfoStage", which_stage);
+	result = (&me->UCStages->s[which_stage].C);
+    }
+    return result;
+}
+
+/*
+ *  A set_by of (-1) means use the lock value from the from_stage.
+ */
+LYUCcharset *HTAnchor_copyUCInfoStage(HTParentAnchor *me,
+				      int to_stage,
+				      int from_stage,
+				      int set_by)
+{
+    if (me) {
+	/*
+	 * This will allocate and initialize, if not yet done.
+	 */
+	LYUCcharset *p_from = HTAnchor_getUCInfoStage(me, from_stage);
+	LYUCcharset *p_to = HTAnchor_getUCInfoStage(me, to_stage);
+
+	/*
+	 * Can we override?
+	 */
+	if (set_by == -1)
+	    set_by = me->UCStages->s[from_stage].lock;
+	if (set_by == UCT_SETBY_NONE)
+	    set_by = UCT_SETBY_DEFAULT;
+	if (set_by >= me->UCStages->s[to_stage].lock) {
+#ifdef CAN_SWITCH_DISPLAY_CHARSET
+	    int ohandle = me->UCStages->s[to_stage].LYhndl;
+#endif
+	    me->UCStages->s[to_stage].lock = set_by;
+	    me->UCStages->s[to_stage].LYhndl =
+		me->UCStages->s[from_stage].LYhndl;
+#ifdef CAN_SWITCH_DISPLAY_CHARSET
+	    /* Allow a switch to a more suitable display charset */
+	    if (me->UCStages->s[to_stage].LYhndl >= 0
+		&& me->UCStages->s[to_stage].LYhndl != ohandle
+		&& to_stage == UCT_STAGE_PARSER)
+		setup_switch_display_charset(me,
+					     me->UCStages->s[to_stage].LYhndl);
+#endif
+	    if (p_to != p_from)
+		MemCpy(p_to, p_from, sizeof(LYUCcharset));
+
+	    return (p_to);
+	}
+    }
+    return (NULL);
+}
diff --git a/WWW/Library/Implementation/HTAnchor.h b/WWW/Library/Implementation/HTAnchor.h
new file mode 100644
index 0000000..3b1e6e6
--- /dev/null
+++ b/WWW/Library/Implementation/HTAnchor.h
@@ -0,0 +1,412 @@
+/*
+ * $LynxId: HTAnchor.h,v 1.40 2018/03/11 18:43:50 tom Exp $
+ *
+ *	Hypertext "Anchor" Object				     HTAnchor.h
+ *	==========================
+ *
+ *	An anchor represents a region of a hypertext document which is linked
+ *	to another anchor in the same or a different document.
+ */
+
+#ifndef HTANCHOR_H
+#define HTANCHOR_H
+
+/* Version 0 (TBL) written in Objective-C for the NeXT browser */
+/* Version 1 of 24-Oct-1991 (JFG), written in C, browser-independent */
+
+#include <HTList.h>
+#include <HTBTree.h>
+#include <HTChunk.h>
+#include <HTAtom.h>
+#include <UCDefs.h>
+
+typedef struct _HyperDoc HyperDoc;	/* Ready for forward references */
+typedef struct _HTAnchor HTAnchor;
+typedef struct _HTParentAnchor HTParentAnchor;
+typedef struct _HTParentAnchor0 HTParentAnchor0;
+
+#include <HTFormat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    struct _HTAnchor {
+	/* Generic anchor */
+	HTParentAnchor0 *parent;	/* Parent of this anchor (self for adults) */
+    };
+
+#define HASH_TYPE unsigned short
+
+    struct _HTParentAnchor0 {	/* One for adult_table,
+				 * generally not used outside HTAnchor.c */
+	/* Common part from the generic anchor structure */
+	HTParentAnchor0 *parent;	/* (self) */
+
+	/* ParentAnchor0-specific information */
+	char *address;		/* Absolute address of this node */
+	HTParentAnchor *info;	/* additional info, allocated on demand */
+
+	HTBTree *children;	/* Subanchors <a name="tag">, sorted by tag */
+	HTList sources;		/* List of anchors pointing to this, if any */
+
+	HTList _add_adult;	/* - just a memory for list entry:) */
+	HASH_TYPE adult_hash;	/* adult list number */
+	BOOL underway;		/* Document about to be attached to it */
+    };
+
+    /*
+     *  Separated from the above to save memory:  allocated on demand,
+     *  it is nearly 1:1 to HText (well, sometimes without HText...),
+     *  available for SGML, HTML, and HText stages.
+     *  [being precise, we currently allocate it before HTLoadDocument(),
+     *  in HTAnchor_findAddress() and HTAnchor_parent()].
+     */
+    struct _HTParentAnchor {
+	/* Common part from the generic anchor structure */
+	HTParentAnchor0 *parent;	/* Parent of this anchor */
+
+	/* ParentAnchor-specific information */
+	HTList children_notag;	/* Subanchors <a href=...>, tag is NULL */
+	HyperDoc *document;	/* The document within which this is an anchor */
+
+	char *address;		/* parent->address, a pointer */
+	bstring *post_data;	/* Posting data */
+	char *post_content_type;	/* Type of post data */
+	char *bookmark;		/* Bookmark filename */
+	HTFormat format;	/* Pointer to node format descriptor */
+	char *charset;		/* Pointer to character set (kludge, for now */
+	BOOL isIndex;		/* Acceptance of a keyword search */
+	char *isIndexAction;	/* URL of isIndex server */
+	char *isIndexPrompt;	/* Prompt for isIndex query */
+	char *title;		/* Title of document */
+	char *owner;		/* Owner of document */
+	char *RevTitle;		/* TITLE in REV="made" or REV="owner" LINK */
+	char *citehost;		/* Citehost from REL="citehost" LINK */
+#ifdef USE_COLOR_STYLE
+	char *style;
+#endif
+
+	HTList *methods;	/* Methods available as HTAtoms */
+	void *protocol;		/* Protocol object */
+	char *physical;		/* Physical address */
+	BOOL isISMAPScript;	/* Script for clickable image map */
+	BOOL isHEAD;		/* Document is headers from a HEAD request */
+	BOOL safe;		/* Safe */
+#ifdef USE_SOURCE_CACHE
+	char *source_cache_file;
+	HTChunk *source_cache_chunk;
+#endif
+	char *FileCache;	/* Path to a disk-cached copy (see src/HTFWriter.c) */
+	char *SugFname;		/* Suggested filename */
+	char *cache_control;	/* Cache-Control */
+	BOOL no_cache;		/* Cache-Control, Pragma or META "no-cache"? */
+	BOOL inHEAD;		/* HTMIMEConvert is decoding server-headers */
+	BOOL inBASE;		/* duplicated from HTStructured (HTML.c/h) */
+	HTChunk http_headers;
+	BOOL no_content_encoding;	/* server did not use C-T? */
+	char *content_type_params;	/* Content-Type (with parameters if any) */
+	char *content_type;	/* Content-Type */
+	char *content_language;	/* Content-Language */
+	char *content_encoding;	/* Compression algorithm */
+	char *content_base;	/* Content-Base */
+	char *content_disposition;	/* Content-Disposition */
+	char *content_location;	/* Content-Location */
+	char *content_md5;	/* Content-MD5 */
+	char *message_id;	/* Message-ID */
+	char *subject;		/* Subject */
+	off_t header_length;	/* length of headers */
+	off_t content_length;	/* Content-Length */
+	off_t actual_length;	/* actual length may differ */
+	char *date;		/* Date */
+	char *expires;		/* Expires */
+	char *last_modified;	/* Last-Modified */
+	char *ETag;		/* ETag (HTTP1.1 cache validator) */
+	char *server;		/* Server */
+	UCAnchorInfo *UCStages;	/* chartrans stages */
+	HTList *imaps;		/* client side image maps */
+    };
+
+    typedef HTAtom HTLinkType;
+
+    typedef struct {
+	/* Common part from the generic anchor structure */
+	HTParentAnchor0 *parent;	/* Parent of this anchor */
+
+	/* ChildAnchor-specific information */
+	char *tag;		/* #fragment,  relative to the parent */
+
+	HTAnchor *dest;		/* The anchor to which this leads */
+	HTLinkType *type;	/* Semantics of this link */
+
+	HTList _add_children_notag;	/* - just a memory for list entry:) */
+	HTList _add_sources;	/* - just a memory for list entry:) */
+    } HTChildAnchor;
+
+    /*
+     *  DocAddress structure is used for loading an absolute anchor with all
+     *  needed information including posting data and post content type.
+     */
+    typedef struct _DocAddress {
+	char *address;
+	bstring *post_data;
+	char *post_content_type;
+	char *bookmark;
+	BOOL isHEAD;
+	BOOL safe;
+    } DocAddress;
+
+    /* "internal" means "within the same document, with certainty". */
+    extern HTLinkType *HTInternalLink;
+
+    /* Create or find a child anchor with a possible link
+     * --------------------------------------------------
+     *
+     * Create new anchor with a given parent and possibly
+     * a name, and possibly a link to a _relatively_ named anchor.
+     * (Code originally in ParseHTML.h)
+     */
+    extern HTChildAnchor *HTAnchor_findChildAndLink(HTParentAnchor *parent,	/* May not be 0 */
+						    const char *tag,	/* May be "" or 0 */
+						    const char *href,	/* May be "" or 0 */
+						    HTLinkType *ltype);		/* May be 0 */
+
+    /* Create new or find old parent anchor
+     * ------------------------------------
+     *
+     * This one is for a reference which is found in a document, and might
+     * not be already loaded.
+     * Note: You are not guaranteed a new anchor -- you might get an old one,
+     * like with fonts.
+     */
+    extern HTParentAnchor *HTAnchor_findAddress(const DocAddress *address);
+
+    /* Create new or find old named anchor - simple form
+     * -------------------------------------------------
+     *
+     * Like the previous one, but simpler to use for simple cases.
+     * No post data etc.  can be supplied.  - kw
+     */
+    extern HTParentAnchor *HTAnchor_findSimpleAddress(const char *url);
+
+    /* Delete an anchor and possibly related things (auto garbage collection)
+     * --------------------------------------------
+     *
+     * The anchor is only deleted if the corresponding document is not loaded.
+     * All outgoing links from children are deleted, and children are
+     * removed from the sources lists of their targets.
+     * We also try to delete the targets whose documents are not loaded.
+     * If this anchor's sources list is empty, we delete it and its children.
+     */
+    extern BOOL HTAnchor_delete(HTParentAnchor0 *me);
+
+    /*
+     * Unnamed children (children_notag) have no sense without HText -
+     * delete them and their links if we are about to free HText.
+     * Document currently exists.  Called within HText_free().
+     */
+    extern void HTAnchor_delete_links(HTParentAnchor *me);
+
+#ifdef USE_SOURCE_CACHE
+    extern void HTAnchor_clearSourceCache(HTParentAnchor *me);
+#endif
+
+    /* Data access functions
+     * ---------------------
+     */
+    extern HTParentAnchor *HTAnchor_parent(HTAnchor * me);
+
+    extern void HTAnchor_setDocument(HTParentAnchor *me,
+				     HyperDoc *doc);
+
+    extern HyperDoc *HTAnchor_document(HTParentAnchor *me);
+
+    /* Returns the full URI of the anchor, child or parent
+     * as a malloc'd string to be freed by the caller.
+     */
+    extern char *HTAnchor_address(HTAnchor * me);
+
+    extern char *HTAnchor_short_address(HTAnchor * me);
+
+    extern void HTAnchor_setFormat(HTParentAnchor *me,
+				   HTFormat form);
+
+    extern HTFormat HTAnchor_format(HTParentAnchor *me);
+
+    extern void HTAnchor_setIndex(HTParentAnchor *me,
+				  const char *address);
+
+    extern void HTAnchor_setPrompt(HTParentAnchor *me,
+				   const char *prompt);
+
+    extern BOOL HTAnchor_isIndex(HTParentAnchor *me);
+
+    extern BOOL HTAnchor_isISMAPScript(HTAnchor * me);
+
+#if defined(USE_COLOR_STYLE)
+    extern const char *HTAnchor_style(HTParentAnchor *me);
+
+    extern void HTAnchor_setStyle(HTParentAnchor *me,
+				  const char *style);
+#endif
+
+    /* Title handling.
+     */
+    extern const char *HTAnchor_title(HTParentAnchor *me);
+
+    extern void HTAnchor_setTitle(HTParentAnchor *me,
+				  const char *title);
+
+    extern void HTAnchor_appendTitle(HTParentAnchor *me,
+				     const char *title);
+
+    /* Bookmark handling.
+     */
+    extern const char *HTAnchor_bookmark(HTParentAnchor *me);
+
+    extern void HTAnchor_setBookmark(HTParentAnchor *me,
+				     const char *bookmark);
+
+    /* Owner handling.
+     */
+    extern const char *HTAnchor_owner(HTParentAnchor *me);
+
+    extern void HTAnchor_setOwner(HTParentAnchor *me,
+				  const char *owner);
+
+    /* TITLE handling in LINKs with REV="made" or REV="owner".  - FM
+     */
+    extern const char *HTAnchor_RevTitle(HTParentAnchor *me);
+
+    extern void HTAnchor_setRevTitle(HTParentAnchor *me,
+				     const char *title);
+
+    /* Citehost for bibp links from LINKs with REL="citehost".  - RDC
+     */
+    extern const char *HTAnchor_citehost(HTParentAnchor *me);
+
+    extern void HTAnchor_setCitehost(HTParentAnchor *me,
+				     const char *citehost);
+
+    /* Suggested filename handling.  - FM
+     * (will be loaded if we had a Content-Disposition
+     * header or META element with filename=name.suffix)
+     */
+    extern const char *HTAnchor_SugFname(HTParentAnchor *me);
+
+    /* HTTP Headers.
+     */
+    extern const char *HTAnchor_http_headers(HTParentAnchor *me);
+
+    /* Content-Type handling (parameter list).
+     */
+    extern const char *HTAnchor_content_type_params(HTParentAnchor *me);
+
+    /* Content-Type handling.  - FM
+     */
+    extern const char *HTAnchor_content_type(HTParentAnchor *me);
+
+    /* Content-Encoding handling.  - FM
+     * (will be loaded if we had a Content-Encoding
+     * header.)
+     */
+    extern const char *HTAnchor_content_encoding(HTParentAnchor *me);
+
+    /* Last-Modified header handling.  - FM
+     */
+    extern const char *HTAnchor_last_modified(HTParentAnchor *me);
+
+    /* Date header handling.  - FM
+     */
+    extern const char *HTAnchor_date(HTParentAnchor *me);
+
+    /* Server header handling.  - FM
+     */
+    extern const char *HTAnchor_server(HTParentAnchor *me);
+
+    /* Safe header handling.  - FM
+     */
+    extern BOOL HTAnchor_safe(HTParentAnchor *me);
+
+    /* Content-Base header handling.  - FM
+     */
+    extern const char *HTAnchor_content_base(HTParentAnchor *me);
+
+    /* Content-Location header handling.  - FM
+     */
+    extern const char *HTAnchor_content_location(HTParentAnchor *me);
+
+    /* Message-ID, used for mail replies - kw
+     */
+    extern const char *HTAnchor_messageID(HTParentAnchor *me);
+
+    extern BOOL HTAnchor_setMessageID(HTParentAnchor *me,
+				      const char *messageid);
+
+    /* Subject, used for mail replies - kw
+     */
+    extern const char *HTAnchor_subject(HTParentAnchor *me);
+
+    extern BOOL HTAnchor_setSubject(HTParentAnchor *me,
+				    const char *subject);
+
+    /* Manipulation of links
+     * ---------------------
+     */
+    extern HTAnchor *HTAnchor_followLink(HTChildAnchor *me);
+
+    extern HTAnchor *HTAnchor_followTypedLink(HTChildAnchor *me,
+					      HTLinkType *type);
+
+    /* Read and write methods
+     * ----------------------
+     */
+    extern HTList *HTAnchor_methods(HTParentAnchor *me);
+
+    /* Protocol
+     * --------
+     */
+    extern void *HTAnchor_protocol(HTParentAnchor *me);
+
+    extern void HTAnchor_setProtocol(HTParentAnchor *me,
+				     void *protocol);
+
+    /* Physical address
+     * ----------------
+     */
+    extern char *HTAnchor_physical(HTParentAnchor *me);
+
+    extern void HTAnchor_setPhysical(HTParentAnchor *me,
+				     char *protocol);
+
+    extern LYUCcharset *HTAnchor_getUCInfoStage(HTParentAnchor *me,
+						int which_stage);
+
+    extern int HTAnchor_getUCLYhndl(HTParentAnchor *me,
+				    int which_stage);
+
+    extern LYUCcharset *HTAnchor_setUCInfoStage(HTParentAnchor *me,
+						int LYhndl,
+						int which_stage,
+						int set_by);
+
+    extern LYUCcharset *HTAnchor_setUCInfoStage(HTParentAnchor *me,
+						int LYhndl,
+						int which_stage,
+						int set_by);
+
+    extern LYUCcharset *HTAnchor_resetUCInfoStage(HTParentAnchor *me,
+						  int LYhndl,
+						  int which_stage,
+						  int set_by);
+
+    extern LYUCcharset *HTAnchor_copyUCInfoStage(HTParentAnchor *me,
+						 int to_stage,
+						 int from_stage,
+						 int set_by);
+
+    extern void ImageMapList_free(HTList *list);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTANCHOR_H */
diff --git a/WWW/Library/Implementation/HTAssoc.c b/WWW/Library/Implementation/HTAssoc.c
new file mode 100644
index 0000000..831b196
--- /dev/null
+++ b/WWW/Library/Implementation/HTAssoc.c
@@ -0,0 +1,82 @@
+/*
+ * $LynxId: HTAssoc.c,v 1.11 2016/11/24 15:29:50 tom Exp $
+ *
+ * MODULE							HTAssoc.c
+ *	    ASSOCIATION LIST FOR STORING NAME-VALUE PAIRS.
+ *	    NAMES NOT CASE SENSITIVE, AND ONLY COMMON LENGTH
+ *	    IS CHECKED (allows abbreviations; well, length is
+ *	    taken from lookup-up name, so if table contains
+ *	    a shorter abbrev it is not found).
+ * AUTHORS:
+ *	AL	Ari Luotonen	luotonen@dxcern.cern.ch
+ *
+ * HISTORY:
+ *
+ *
+ * BUGS:
+ *
+ *
+ */
+
+#include <HTUtils.h>
+
+#include <HTAssoc.h>
+
+#include <LYLeaks.h>
+
+HTAssocList *HTAssocList_new(void)
+{
+    return HTList_new();
+}
+
+void HTAssocList_delete(HTAssocList *alist)
+{
+    if (alist) {
+	HTAssocList *cur = alist;
+	HTAssoc *assoc;
+
+	while (NULL != (assoc = (HTAssoc *) HTList_nextObject(cur))) {
+	    FREE(assoc->name);
+	    FREE(assoc->value);
+	    FREE(assoc);
+	}
+	HTList_delete(alist);
+	alist = NULL;
+    }
+}
+
+void HTAssocList_add(HTAssocList *alist,
+		     const char *name,
+		     const char *value)
+{
+    HTAssoc *assoc;
+
+    if (alist) {
+	if (!(assoc = (HTAssoc *) malloc(sizeof(HTAssoc))))
+	      outofmem(__FILE__, "HTAssoc_add");
+
+	assoc->name = NULL;
+	assoc->value = NULL;
+
+	if (name)
+	    StrAllocCopy(assoc->name, name);
+	if (value)
+	    StrAllocCopy(assoc->value, value);
+	HTList_addObject(alist, (void *) assoc);
+    } else {
+	CTRACE((tfp, "HTAssoc_add: ERROR: assoc list NULL!!\n"));
+    }
+}
+
+char *HTAssocList_lookup(HTAssocList *alist,
+			 const char *name)
+{
+    HTAssocList *cur = alist;
+    HTAssoc *assoc;
+
+    while (NULL != (assoc = (HTAssoc *) HTList_nextObject(cur))) {
+	if (!strncasecomp(assoc->name, name, (int) strlen(name)))
+	    return assoc->value;
+    }
+    return NULL;
+}
diff --git a/WWW/Library/Implementation/HTAssoc.h b/WWW/Library/Implementation/HTAssoc.h
new file mode 100644
index 0000000..327809c
--- /dev/null
+++ b/WWW/Library/Implementation/HTAssoc.h
@@ -0,0 +1,35 @@
+/*                       ASSOCIATION LIST FOR STORING NAME-VALUE PAIRS
+
+   Lookups from association list are not case-sensitive.
+
+ */
+
+#ifndef HTASSOC_H
+#define HTASSOC_H
+
+#include <HTList.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef HTList HTAssocList;
+
+    typedef struct {
+	char *name;
+	char *value;
+    } HTAssoc;
+
+    extern HTAssocList *HTAssocList_new(void);
+    extern void HTAssocList_delete(HTAssocList *alist);
+
+    extern void HTAssocList_add(HTAssocList *alist,
+				const char *name,
+				const char *value);
+
+    extern char *HTAssocList_lookup(HTAssocList *alist,
+				    const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* not HTASSOC_H */
diff --git a/WWW/Library/Implementation/HTAtom.c b/WWW/Library/Implementation/HTAtom.c
new file mode 100644
index 0000000..07eca77
--- /dev/null
+++ b/WWW/Library/Implementation/HTAtom.c
@@ -0,0 +1,107 @@
+/*
+ * $LynxId: HTAtom.c,v 1.22 2018/03/06 09:46:58 tom Exp $
+ *
+ *			Atoms: Names to numbers			HTAtom.c
+ *			=======================
+ *
+ *	Atoms are names which are given representative pointer values
+ *	so that they can be stored more efficiently, and comparisons
+ *	for equality done more efficiently.
+ *
+ *	Atoms are kept in a hash table consisting of an array of linked lists.
+ *
+ * Authors:
+ *	TBL	Tim Berners-Lee, WorldWideWeb project, CERN
+ *	(c) Copyright CERN 1991 - See Copyright.html
+ *
+ */
+
+#include <HTUtils.h>
+#include <HTAtom.h>
+#include <HTList.h>
+#include <LYexit.h>
+#include <LYLeaks.h>
+
+#define HASH_SIZE 101		/* Arbitrary prime.  Memory/speed tradeoff */
+
+static HTAtom *hash_table[HASH_SIZE];
+static BOOL initialised = NO;
+
+/*
+ *	To free off all atoms.
+ */
+#ifdef LY_FIND_LEAKS
+static void free_atoms(void);
+#endif
+
+#define HASH_FUNCTION(cp_hash) ((strlen(cp_hash) * UCH(*cp_hash)) % HASH_SIZE)
+
+HTAtom *HTAtom_for(const char *string)
+{
+    size_t hash;
+    HTAtom *a;
+
+    if (!initialised) {
+	memset(hash_table, 0, sizeof(hash_table));
+	initialised = YES;
+#ifdef LY_FIND_LEAKS
+	atexit(free_atoms);
+#endif
+    }
+
+    hash = HASH_FUNCTION(string);
+
+    for (a = hash_table[hash]; a; a = a->next) {
+	if (0 == strcasecomp(a->name, string)) {
+	    return a;
+	}
+    }
+
+    a = (HTAtom *) malloc(sizeof(*a));
+    if (a == NULL)
+	outofmem(__FILE__, "HTAtom_for");
+
+    a->name = (char *) malloc(strlen(string) + 1);
+    if (a->name == NULL)
+	outofmem(__FILE__, "HTAtom_for");
+
+    strcpy(a->name, string);
+    a->next = hash_table[hash];
+    hash_table[hash] = a;
+    return a;
+}
+
+#ifdef LY_FIND_LEAKS
+/*
+ *	Purpose:	Free off all atoms.
+ *	Arguments:	void
+ *	Return Value:	void
+ *	Remarks/Portability/Dependencies/Restrictions:
+ *		To be used at program exit.
+ *	Revision History:
+ *		05-29-94	created Lynx 2-3-1 Garrett Arch Blythe
+ */
+static void free_atoms(void)
+{
+    auto int i_counter;
+    HTAtom *HTAp_freeme;
+
+    /*
+     * Loop through all lists of atoms.
+     */
+    for (i_counter = 0; i_counter < HASH_SIZE; i_counter++) {
+	/*
+	 * Loop through the list.
+	 */
+	while (hash_table[i_counter] != NULL) {
+	    /*
+	     * Free off atoms and any members.
+	     */
+	    HTAp_freeme = hash_table[i_counter];
+	    hash_table[i_counter] = HTAp_freeme->next;
+	    FREE(HTAp_freeme->name);
+	    FREE(HTAp_freeme);
+	}
+    }
+}
+#endif /* LY_FIND_LEAKS */
diff --git a/WWW/Library/Implementation/HTAtom.h b/WWW/Library/Implementation/HTAtom.h
new file mode 100644
index 0000000..0d787bc
--- /dev/null
+++ b/WWW/Library/Implementation/HTAtom.h
@@ -0,0 +1,53 @@
+/*  */
+
+/*                      Atoms: Names to numbers                 HTAtom.h
+ *                      =======================
+ *
+ *      Atoms are names which are given representative pointer values
+ *      so that they can be stored more efficiently, and compaisons
+ *      for equality done more efficiently.
+ *
+ *      HTAtom_for(string) returns a representative value such that it
+ *      will always (within one run of the program) return the same
+ *      value for the same given string.
+ *
+ * Authors:
+ *      TBL     Tim Berners-Lee, WorldWideWeb project, CERN
+ *
+ *      (c) Copyright CERN 1991 - See Copyright.html
+ *
+ */
+
+#ifndef HTATOM_H
+#define HTATOM_H
+
+#include <HTList.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef struct _HTAtom HTAtom;
+
+    struct _HTAtom {
+	HTAtom *next;
+	char *name;
+    };				/* struct _HTAtom */
+
+    extern HTAtom *HTAtom_for(const char *string);
+
+#define HTAtom_name(a) ((a)->name)
+
+/*
+
+The HTFormat type
+
+   We use the HTAtom object for holding representations.  This allows faster manipulation
+   (comparison and copying) that if we stayed with strings.
+
+ */
+    typedef HTAtom *HTFormat;
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTATOM_H */
diff --git a/WWW/Library/Implementation/HTBTree.c b/WWW/Library/Implementation/HTBTree.c
new file mode 100644
index 0000000..f595bae
--- /dev/null
+++ b/WWW/Library/Implementation/HTBTree.c
@@ -0,0 +1,680 @@
+/*                  Binary Tree for sorting things
+ *                  ==============================
+ *                      Author: Arthur Secret
+ *
+ *       4 March 94: Bug fixed in the balancing procedure
+ *
+ */
+
+#include <HTUtils.h>
+#include <HTBTree.h>
+
+#define MAXIMUM(a,b) ((a)>(b)?(a):(b))
+
+#include <LYLeaks.h>
+
+/*********************************************************
+ * This function returns an HTBTree with memory allocated
+ * for it when given a mean to compare things
+ */
+HTBTree *HTBTree_new(HTComparer comp)
+{
+    HTBTree *tree = typeMalloc(HTBTree);
+
+    if (tree == NULL)
+	outofmem(__FILE__, "HTBTree_new");
+
+    tree->compare = comp;
+    tree->top = NULL;
+
+    return tree;
+}
+
+/*********************************************************
+ * This void will free the memory allocated for one element
+ */
+static void HTBTElement_free(HTBTElement *element)
+{
+    if (element) {
+	if (element->left != NULL)
+	    HTBTElement_free(element->left);
+	if (element->right != NULL)
+	    HTBTElement_free(element->right);
+	FREE(element);
+    }
+}
+
+/*************************************************************
+ * This void will free the memory allocated for the whole tree
+ */
+void HTBTree_free(HTBTree *tree)
+{
+    HTBTElement_free(tree->top);
+    FREE(tree);
+}
+
+/*********************************************************
+ * This void will free the memory allocated for one element
+ */
+static void HTBTElementAndObject_free(HTBTElement *element)
+{
+    if (element) {		/* Just in case nothing was in the tree anyway */
+	if (element->left != NULL)
+	    HTBTElementAndObject_free(element->left);
+	if (element->right != NULL)
+	    HTBTElementAndObject_free(element->right);
+	FREE(element->object);
+	FREE(element);
+    }
+}
+
+/*************************************************************
+ * This void will free the memory allocated for the whole tree
+ */
+void HTBTreeAndObject_free(HTBTree *tree)
+{
+    HTBTElementAndObject_free(tree->top);
+    FREE(tree);
+}
+
+/*********************************************************************
+ * Returns a pointer to equivalent object in a tree or NULL if none.
+ */
+void *HTBTree_search(HTBTree *tree,
+		     void *object)
+{
+    HTBTElement *cur = tree->top;
+    int res;
+
+    while (cur != NULL) {
+	res = tree->compare(object, cur->object);
+
+	if (res == 0)
+	    return cur->object;
+	else if (res < 0)
+	    cur = cur->left;
+	else if (res > 0)
+	    cur = cur->right;
+    }
+    return NULL;
+}
+
+/*********************************************************************
+ * This void is the core of HTBTree.c . It will
+ *       1/ add a new element to the tree at the right place
+ *		so that the tree remains sorted
+ *       2/ balance the tree to be as fast as possible when reading it
+ */
+void HTBTree_add(HTBTree *tree,
+		 void *object)
+{
+    HTBTElement *father_of_element;
+    HTBTElement *added_element;
+    HTBTElement *forefather_of_element;
+    HTBTElement *father_of_forefather;
+    BOOL father_found, top_found;
+    int depth, depth2, corrections;
+
+    /* father_of_element is a pointer to the structure that is the father of
+     * the new object "object".  added_element is a pointer to the structure
+     * that contains or will contain the new object "object". 
+     * father_of_forefather and forefather_of_element are pointers that are
+     * used to modify the depths of upper elements, when needed.
+     *
+     * father_found indicates by a value NO when the future father of "object"
+     * is found.  top_found indicates by a value NO when, in case of a
+     * difference of depths < 2, the top of the tree is encountered and forbids
+     * any further try to balance the tree.  corrections is an integer used to
+     * avoid infinite loops in cases such as:
+     *
+     *             3                        3
+     *          4                              4
+     *           5                            5
+     *
+     * 3 is used here to show that it need not be the top of the tree.
+     */
+
+    /*
+     * 1/ Adding of the element to the binary tree
+     */
+
+    if (tree->top == NULL) {
+	tree->top = typeMalloc(HTBTElement);
+
+	if (tree->top == NULL)
+	    outofmem(__FILE__, "HTBTree_add");
+
+	tree->top->up = NULL;
+	tree->top->object = object;
+	tree->top->left = NULL;
+	tree->top->left_depth = 0;
+	tree->top->right = NULL;
+	tree->top->right_depth = 0;
+    } else {
+	father_found = YES;
+	father_of_element = tree->top;
+	added_element = NULL;
+	father_of_forefather = NULL;
+	forefather_of_element = NULL;
+	while (father_found) {
+	    int res = tree->compare(object, father_of_element->object);
+
+	    if (res < 0) {
+		if (father_of_element->left != NULL)
+		    father_of_element = father_of_element->left;
+		else {
+		    father_found = NO;
+		    father_of_element->left = typeMalloc(HTBTElement);
+
+		    if (father_of_element->left == NULL)
+			outofmem(__FILE__, "HTBTree_add");
+
+		    added_element = father_of_element->left;
+		    added_element->up = father_of_element;
+		    added_element->object = object;
+		    added_element->left = NULL;
+		    added_element->left_depth = 0;
+		    added_element->right = NULL;
+		    added_element->right_depth = 0;
+		}
+	    } else {		/* res >= 0 */
+		if (father_of_element->right != NULL) {
+		    father_of_element = father_of_element->right;
+		} else {
+		    father_found = NO;
+		    father_of_element->right = typeMalloc(HTBTElement);
+
+		    if (father_of_element->right == NULL)
+			outofmem(__FILE__, "HTBTree_add");
+
+		    added_element = father_of_element->right;
+		    added_element->up = father_of_element;
+		    added_element->object = object;
+		    added_element->left = NULL;
+		    added_element->left_depth = 0;
+		    added_element->right = NULL;
+		    added_element->right_depth = 0;
+		}
+	    }
+	}
+
+	/*
+	 * Changing of all depths that need to be changed
+	 */
+	father_of_forefather = father_of_element;
+	forefather_of_element = added_element;
+	do {
+	    if (father_of_forefather->left == forefather_of_element) {
+		depth = father_of_forefather->left_depth;
+		father_of_forefather->left_depth = 1
+		    + MAXIMUM(forefather_of_element->right_depth,
+			      forefather_of_element->left_depth);
+		depth2 = father_of_forefather->left_depth;
+	    } else {
+		depth = father_of_forefather->right_depth;
+		father_of_forefather->right_depth = 1
+		    + MAXIMUM(forefather_of_element->right_depth,
+			      forefather_of_element->left_depth);
+		depth2 = father_of_forefather->right_depth;
+	    }
+	    forefather_of_element = father_of_forefather;
+	    father_of_forefather = father_of_forefather->up;
+	} while ((depth != depth2) && (father_of_forefather != NULL));
+
+	/*
+	 * 2/ Balancing the binary tree, if necessary
+	 */
+	top_found = YES;
+	corrections = 0;
+	while ((top_found) && (corrections < 7)) {
+	    if ((abs(father_of_element->left_depth
+		     - father_of_element->right_depth)) < 2) {
+		if (father_of_element->up != NULL)
+		    father_of_element = father_of_element->up;
+		else
+		    top_found = NO;
+	    } else {		/* We start the process of balancing */
+
+		corrections = corrections + 1;
+		/*
+		 * corrections is an integer used to avoid infinite
+		 * loops in cases such as:
+		 *
+		 *             3                        3
+		 *          4                              4
+		 *           5                            5
+		 *
+		 * 3 is used to show that it need not be the top of the tree
+		 * But let's avoid these two exceptions anyhow
+		 * with the two following conditions (4 March 94 - AS)
+		 */
+
+		if (father_of_element->left == NULL) {
+		    if ((father_of_element->right != NULL)
+			&& (father_of_element->right->right == NULL)
+			&& (father_of_element->right->left != NULL)
+			&& (father_of_element->right->left->left == NULL)
+			&& (father_of_element->right->left->right == NULL)) {
+			corrections = 7;
+		    }
+		} else {
+		    if ((father_of_element->right == NULL)
+			&& (father_of_element->left->left == NULL)
+			&& (father_of_element->left->right != NULL)
+			&& (father_of_element->left->right->right == NULL)
+			&& (father_of_element->left->right->left == NULL)) {
+			corrections = 7;
+		    }
+		}
+
+		if ((father_of_element->left != NULL)
+		    && (father_of_element->left_depth > father_of_element->right_depth)) {
+		    added_element = father_of_element->left;
+		    father_of_element->left_depth = added_element->right_depth;
+		    added_element->right_depth = 1
+			+ MAXIMUM(father_of_element->right_depth,
+				  father_of_element->left_depth);
+		    if (father_of_element->up != NULL) {
+			/* Bug fixed in March 94  -  AS */
+			BOOL first_time;
+
+			father_of_forefather = father_of_element->up;
+			forefather_of_element = added_element;
+			first_time = YES;
+			do {
+			    if (father_of_forefather->left
+				== forefather_of_element->up) {
+				depth = father_of_forefather->left_depth;
+				if (first_time) {
+				    father_of_forefather->left_depth = 1
+					+ MAXIMUM(forefather_of_element->left_depth,
+						  forefather_of_element->right_depth);
+				    first_time = NO;
+				} else
+				    father_of_forefather->left_depth = 1
+					+ MAXIMUM(forefather_of_element->up->left_depth,
+						  forefather_of_element->up->right_depth);
+
+				depth2 = father_of_forefather->left_depth;
+			    } else {
+				depth = father_of_forefather->right_depth;
+				if (first_time) {
+				    father_of_forefather->right_depth = 1
+					+ MAXIMUM(forefather_of_element->left_depth,
+						  forefather_of_element->right_depth);
+				    first_time = NO;
+				} else
+				    father_of_forefather->right_depth = 1
+					+ MAXIMUM(forefather_of_element->up->left_depth,
+						  forefather_of_element->up->right_depth);
+				depth2 = father_of_forefather->right_depth;
+			    }
+			    forefather_of_element = forefather_of_element->up;
+			    father_of_forefather = father_of_forefather->up;
+			} while ((depth != depth2) &&
+				 (father_of_forefather != NULL));
+			father_of_forefather = father_of_element->up;
+			if (father_of_forefather->left == father_of_element) {
+			    /*
+			     *                   3                       3
+			     *               4                       5
+			     * When tree   5   6        becomes    7    4
+			     *            7 8                          8 6
+			     *
+			     * 3 is used to show that it may not be the top of the
+			     * tree.
+			     */
+			    father_of_forefather->left = added_element;
+			    father_of_element->left = added_element->right;
+			    added_element->right = father_of_element;
+			}
+			if (father_of_forefather->right == father_of_element) {
+			    /*
+			     *          3                       3
+			     *               4                       5
+			     * When tree   5   6        becomes    7    4
+			     *            7 8                          8 6
+			     *
+			     * 3 is used to show that it may not be the top of the
+			     * tree
+			     */
+			    father_of_forefather->right = added_element;
+			    father_of_element->left = added_element->right;
+			    added_element->right = father_of_element;
+			}
+			added_element->up = father_of_forefather;
+		    } else {
+			/*
+
+			 *               1                       2
+			 * When tree   2   3        becomes    4    1
+			 *            4 5                          5 3
+			 *
+			 * 1 is used to show that it is the top of the tree
+			 */
+			added_element->up = NULL;
+			father_of_element->left = added_element->right;
+			added_element->right = father_of_element;
+		    }
+		    father_of_element->up = added_element;
+		    if (father_of_element->left != NULL)
+			father_of_element->left->up = father_of_element;
+		} else if (father_of_element->right != NULL) {
+		    added_element = father_of_element->right;
+		    father_of_element->right_depth = added_element->left_depth;
+		    added_element->left_depth = 1 +
+			MAXIMUM(father_of_element->right_depth,
+				father_of_element->left_depth);
+		    if (father_of_element->up != NULL)
+			/* Bug fixed in March 94  -  AS */
+		    {
+			BOOL first_time;
+
+			father_of_forefather = father_of_element->up;
+			forefather_of_element = added_element;
+			first_time = YES;
+			do {
+			    if (father_of_forefather->left
+				== forefather_of_element->up) {
+				depth = father_of_forefather->left_depth;
+				if (first_time) {
+				    father_of_forefather->left_depth = 1
+					+ MAXIMUM(forefather_of_element->left_depth,
+						  forefather_of_element->right_depth);
+				    first_time = NO;
+				} else
+				    father_of_forefather->left_depth = 1
+					+ MAXIMUM(forefather_of_element->up->left_depth,
+						  forefather_of_element->up->right_depth);
+				depth2 = father_of_forefather->left_depth;
+			    } else {
+				depth = father_of_forefather->right_depth;
+				if (first_time) {
+				    father_of_forefather->right_depth = 1
+					+ MAXIMUM(forefather_of_element->left_depth,
+						  forefather_of_element->right_depth);
+				    first_time = NO;
+				} else
+				    father_of_forefather->right_depth = 1
+					+ MAXIMUM(forefather_of_element->up->left_depth,
+						  forefather_of_element->up->right_depth);
+				depth2 = father_of_forefather->right_depth;
+			    }
+			    father_of_forefather = father_of_forefather->up;
+			    forefather_of_element = forefather_of_element->up;
+			} while ((depth != depth2) &&
+				 (father_of_forefather != NULL));
+			father_of_forefather = father_of_element->up;
+			if (father_of_forefather->left == father_of_element) {
+			    /*
+			     *                    3                       3
+			     *               4                       6
+			     * When tree   5   6        becomes    4    8
+			     *                7 8                 5 7
+			     *
+			     * 3 is used to show that it may not be the top of the
+			     * tree.
+			     */
+			    father_of_forefather->left = added_element;
+			    father_of_element->right = added_element->left;
+			    added_element->left = father_of_element;
+			}
+			if (father_of_forefather->right == father_of_element) {
+			    /*
+			     *           3                      3
+			     *               4                       6
+			     * When tree   5   6        becomes    4    8
+			     *                7 8                 5 7
+			     *
+			     * 3 is used to show that it may not be the top of the
+			     * tree
+			     */
+			    father_of_forefather->right = added_element;
+			    father_of_element->right = added_element->left;
+			    added_element->left = father_of_element;
+			}
+			added_element->up = father_of_forefather;
+		    } else {
+			/*
+
+			 *               1                       3
+			 * When tree   2   3        becomes    1    5
+			 *                4 5                 2 4
+			 *
+			 * 1 is used to show that it is the top of the tree.
+			 */
+			added_element->up = NULL;
+			father_of_element->right = added_element->left;
+			added_element->left = father_of_element;
+		    }
+		    father_of_element->up = added_element;
+		    if (father_of_element->right != NULL)
+			father_of_element->right->up = father_of_element;
+		}
+	    }
+	}
+	while (father_of_element->up != NULL) {
+	    father_of_element = father_of_element->up;
+	}
+	tree->top = father_of_element;
+    }
+}
+
+/*************************************************************************
+ * this function returns a pointer to the leftmost element if ele is NULL,
+ * and to the next object to the right otherwise.
+ * If no elements left, returns a pointer to NULL.
+ */
+HTBTElement *HTBTree_next(HTBTree *tree,
+			  HTBTElement *ele)
+{
+    HTBTElement *father_of_element;
+    HTBTElement *father_of_forefather;
+
+    if (ele == NULL) {
+	father_of_element = tree->top;
+	if (father_of_element != NULL)
+	    while (father_of_element->left != NULL)
+		father_of_element = father_of_element->left;
+    } else {
+	father_of_element = ele;
+	if (father_of_element->right != NULL) {
+	    father_of_element = father_of_element->right;
+	    while (father_of_element->left != NULL)
+		father_of_element = father_of_element->left;
+	} else {
+	    father_of_forefather = father_of_element->up;
+	    while (father_of_forefather &&
+		   (father_of_forefather->right == father_of_element)) {
+		father_of_element = father_of_forefather;
+		father_of_forefather = father_of_element->up;
+	    }
+	    father_of_element = father_of_forefather;
+	}
+    }
+#ifdef BTREE_TRACE
+    /* The option -DBTREE_TRACE will give much more information
+     * about the way the process is running, for debugging matters
+     */
+    if (father_of_element != NULL) {
+	printf("\nObject = %s\t", (char *) father_of_element->object);
+	if (father_of_element->up != NULL)
+	    printf("Objet du pere = %s\n",
+		   (char *) father_of_element->up->object);
+	else
+	    printf("Pas de Pere\n");
+	if (father_of_element->left != NULL)
+	    printf("Objet du fils gauche = %s\t",
+		   (char *) father_of_element->left->object);
+	else
+	    printf("Pas de fils gauche\t");
+	if (father_of_element->right != NULL)
+	    printf("Objet du fils droit = %s\n",
+		   (char *) father_of_element->right->object);
+	else
+	    printf("Pas de fils droit\n");
+	printf("Profondeur gauche = %d\t", father_of_element->left_depth);
+	printf("Profondeur droite = %d\n", father_of_element->right_depth);
+	printf("      **************\n");
+    }
+#endif
+    return father_of_element;
+}
+
+#ifdef TEST
+/*****************************************************
+ * This is just a test to show how to handle HTBTree.c
+ */
+main()
+{
+    HTBTree *tree;
+    HTBTElement *next_element;
+
+    tree = HTBTree_new((HTComparer) strcasecomp);
+    HTBTree_add(tree, "hypertext");
+    HTBTree_add(tree, "Addressing");
+    HTBTree_add(tree, "X11");
+    HTBTree_add(tree, "Tools");
+    HTBTree_add(tree, "Proposal.wn");
+    HTBTree_add(tree, "Protocols");
+    HTBTree_add(tree, "NeXT");
+    HTBTree_add(tree, "Daemon");
+    HTBTree_add(tree, "Test");
+    HTBTree_add(tree, "Administration");
+    HTBTree_add(tree, "LineMode");
+    HTBTree_add(tree, "DesignIssues");
+    HTBTree_add(tree, "MarkUp");
+    HTBTree_add(tree, "Macintosh");
+    HTBTree_add(tree, "Proposal.rtf.wn");
+    HTBTree_add(tree, "FIND");
+    HTBTree_add(tree, "Paper");
+    HTBTree_add(tree, "Tcl");
+    HTBTree_add(tree, "Talks");
+    HTBTree_add(tree, "Architecture");
+    HTBTree_add(tree, "VMSHelp");
+    HTBTree_add(tree, "Provider");
+    HTBTree_add(tree, "Archive");
+    HTBTree_add(tree, "SLAC");
+    HTBTree_add(tree, "Project");
+    HTBTree_add(tree, "News");
+    HTBTree_add(tree, "Viola");
+    HTBTree_add(tree, "Users");
+    HTBTree_add(tree, "FAQ");
+    HTBTree_add(tree, "WorkingNotes");
+    HTBTree_add(tree, "Windows");
+    HTBTree_add(tree, "FineWWW");
+    HTBTree_add(tree, "Frame");
+    HTBTree_add(tree, "XMosaic");
+    HTBTree_add(tree, "People");
+    HTBTree_add(tree, "All");
+    HTBTree_add(tree, "Curses");
+    HTBTree_add(tree, "Erwise");
+    HTBTree_add(tree, "Carl");
+    HTBTree_add(tree, "MidasWWW");
+    HTBTree_add(tree, "XPM");
+    HTBTree_add(tree, "MailRobot");
+    HTBTree_add(tree, "Illustrations");
+    HTBTree_add(tree, "VMClient");
+    HTBTree_add(tree, "XPA");
+    HTBTree_add(tree, "Clients.html");
+    HTBTree_add(tree, "Library");
+    HTBTree_add(tree, "CERNLIB_Distribution");
+    HTBTree_add(tree, "libHTML");
+    HTBTree_add(tree, "WindowsPC");
+    HTBTree_add(tree, "tkWWW");
+    HTBTree_add(tree, "tk2.3");
+    HTBTree_add(tree, "CVS-RCS");
+    HTBTree_add(tree, "DecnetSockets");
+    HTBTree_add(tree, "SGMLStream");
+    HTBTree_add(tree, "NextStep");
+    HTBTree_add(tree, "CVSRepository_old");
+    HTBTree_add(tree, "ArthurSecret");
+    HTBTree_add(tree, "CVSROOT");
+    HTBTree_add(tree, "HytelnetGate");
+    HTBTree_add(tree, "cern.www.new.src");
+    HTBTree_add(tree, "Conditions");
+    HTBTree_add(tree, "HTMLGate");
+    HTBTree_add(tree, "Makefile");
+    HTBTree_add(tree, "Newsgroups.html");
+    HTBTree_add(tree, "People.html");
+    HTBTree_add(tree, "Bugs.html");
+    HTBTree_add(tree, "Summary.html");
+    HTBTree_add(tree, "zDesignIssues.wn");
+    HTBTree_add(tree, "HT.draw");
+    HTBTree_add(tree, "HTandCERN.wn");
+    HTBTree_add(tree, "Ideas.wn");
+    HTBTree_add(tree, "MarkUp.wn");
+    HTBTree_add(tree, "Proposal.html");
+    HTBTree_add(tree, "SearchPanel.draw");
+    HTBTree_add(tree, "Comments.wn");
+    HTBTree_add(tree, "Xanadu.html");
+    HTBTree_add(tree, "Storinglinks.html");
+    HTBTree_add(tree, "TheW3Book.html");
+    HTBTree_add(tree, "Talk_Feb-91.html");
+    HTBTree_add(tree, "JFosterEntry.txt");
+    HTBTree_add(tree, "Summary.txt");
+    HTBTree_add(tree, "Bibliography.html");
+    HTBTree_add(tree, "HTandCern.txt");
+    HTBTree_add(tree, "Talk.draw");
+    HTBTree_add(tree, "zDesignNotes.html");
+    HTBTree_add(tree, "Link.html");
+    HTBTree_add(tree, "Status.html");
+    HTBTree_add(tree, "http.txt");
+    HTBTree_add(tree, "People.html~");
+    HTBTree_add(tree, "TAGS");
+    HTBTree_add(tree, "summary.txt");
+    HTBTree_add(tree, "Technical.html");
+    HTBTree_add(tree, "Terms.html");
+    HTBTree_add(tree, "JANETAccess.html");
+    HTBTree_add(tree, "People.txt");
+    HTBTree_add(tree, "README.txt");
+    HTBTree_add(tree, "CodingStandards.html");
+    HTBTree_add(tree, "Copyright.txt");
+    HTBTree_add(tree, "Status_old.html");
+    HTBTree_add(tree, "patches~");
+    HTBTree_add(tree, "RelatedProducts.html");
+    HTBTree_add(tree, "Implementation");
+    HTBTree_add(tree, "History.html");
+    HTBTree_add(tree, "Makefile.bak");
+    HTBTree_add(tree, "Makefile.old");
+    HTBTree_add(tree, "Policy.html");
+    HTBTree_add(tree, "WhatIs.html");
+    HTBTree_add(tree, "TheProject.html");
+    HTBTree_add(tree, "Notation.html");
+    HTBTree_add(tree, "Helping.html");
+    HTBTree_add(tree, "Cyber-WWW.sit.Hqx");
+    HTBTree_add(tree, "Glossary.html");
+    HTBTree_add(tree, "maketags.html");
+    HTBTree_add(tree, "IntroCS.html");
+    HTBTree_add(tree, "Contrib");
+    HTBTree_add(tree, "Help.html");
+    HTBTree_add(tree, "CodeManagExec");
+    HTBTree_add(tree, "HT-0.1draz");
+    HTBTree_add(tree, "Cello");
+    HTBTree_add(tree, "TOPUB");
+    HTBTree_add(tree, "BUILD");
+    HTBTree_add(tree, "BUILDALL");
+    HTBTree_add(tree, "Lynx");
+    HTBTree_add(tree, "ArthurLibrary");
+    HTBTree_add(tree, "RashtyClient");
+    HTBTree_add(tree, "#History.html#");
+    HTBTree_add(tree, "PerlServers");
+    HTBTree_add(tree, "modules");
+    HTBTree_add(tree, "NCSA_httpd");
+    HTBTree_add(tree, "MAIL2HTML");
+    HTBTree_add(tree, "core");
+    HTBTree_add(tree, "EmacsWWW");
+#ifdef BTREE_TRACE
+    printf("\nTreeTopObject=%s\n\n", tree->top->object);
+#endif
+    next_element = HTBTree_next(tree, NULL);
+    while (next_element != NULL) {
+#ifndef BTREE_TRACE
+	printf("The next element is %s\n", next_element->object);
+#endif
+	next_element = HTBTree_next(tree, next_element);
+    }
+    HTBTree_free(tree);
+}
+
+#endif
diff --git a/WWW/Library/Implementation/HTBTree.h b/WWW/Library/Implementation/HTBTree.h
new file mode 100644
index 0000000..a4f78f9
--- /dev/null
+++ b/WWW/Library/Implementation/HTBTree.h
@@ -0,0 +1,104 @@
+/*                  /Net/dxcern/userd/timbl/hypertext/WWW/Library/Implementation/HTBTree.html
+                         BALANCED BINARY TREE FOR SORTING THINGS
+
+   Tree creation, traversal and freeing.  User-supplied comparison routine.
+
+   Author: Arthur Secret, CERN. Public domain.  Please mail bugs and changes to
+   www-request@info.cern.ch
+
+   part of libWWW
+
+ */
+#ifndef HTBTREE_H
+#define HTBTREE_H 1
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+
+Data structures
+
+ */ typedef struct _HTBTree_element {
+	void *object;		/* User object */
+	struct _HTBTree_element *up;
+	struct _HTBTree_element *left;
+	int left_depth;
+	struct _HTBTree_element *right;
+	int right_depth;
+    } HTBTElement;
+
+    typedef int (*HTComparer) (void *a, void *b);
+
+    typedef struct _HTBTree_top {
+	HTComparer compare;
+	struct _HTBTree_element *top;
+    } HTBTree;
+
+/*
+
+Create a binary tree given its discrimination routine
+
+ */
+    extern HTBTree *HTBTree_new(HTComparer comp);
+
+/*
+
+Free storage of the tree but not of the objects
+
+ */
+    extern void HTBTree_free(HTBTree *tree);
+
+/*
+
+Free storage of the tree and of the objects
+
+ */
+    extern void HTBTreeAndObject_free(HTBTree *tree);
+
+/*
+
+Add an object to a binary tree
+
+ */
+
+    extern void HTBTree_add(HTBTree *tree, void *object);
+
+/*
+
+Search an object in a binary tree
+
+  returns          Pointer to equivalent object in a tree or NULL if none.
+ */
+
+    extern void *HTBTree_search(HTBTree *tree, void *object);
+
+/*
+
+Find user object for element
+
+ */
+#define HTBTree_object(element)  ((element)->object)
+
+/*
+
+Find next element in depth-first order
+
+  ON ENTRY,
+
+  ele                    if NULL, start with leftmost element. if != 0 give next object to
+                         the right.
+
+  returns                Pointer to element or NULL if none left.
+
+ */
+    extern HTBTElement *HTBTree_next(HTBTree *tree, HTBTElement *ele);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTBTREE_H */
diff --git a/WWW/Library/Implementation/HTCJK.h b/WWW/Library/Implementation/HTCJK.h
new file mode 100644
index 0000000..7edf50b
--- /dev/null
+++ b/WWW/Library/Implementation/HTCJK.h
@@ -0,0 +1,121 @@
+/*
+ * $LynxId: HTCJK.h,v 1.22 2021/07/01 23:51:38 tom Exp $
+ *
+ *			CJK character converter		HTCJK.h
+ *			=======================
+ *
+ *	Added 11-Jun-96 by FM, based on jiscode.h for
+ *	  Yutaka Sato's (ysato@etl.go.jp) SJIS.c, and
+ *	  Takuya ASADA's (asada@three-a.co.jp) CJK patches.
+ *	  (see SGML.c).
+ *
+ */
+
+#ifndef HTCJK_H
+#define HTCJK_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ *	STATUS CHANGE CODES
+ */
+#define TO_2BCODE	'$'
+#define TO_1BCODE	'('
+#define TO_KANA		'\016'
+#define TO_KANAOUT	'\017'
+#define TO_KANJI	"\033$B"
+#define TO_HANJI	"\033$A"
+#define TO_HANGUL	"\033$(C"
+#define TO_ASCII	"\033(B"
+
+#define IS_GBK_LO(lo)	((0xA1 <= (lo)) && ((lo) <= 0xFE))
+#define IS_GBK_HI(hi)	((0xA1 <= (hi)) && ((hi) <= 0xF7))
+
+#define IS_SJIS_LO(lo)	((0x40 <= (lo)) && ((lo) != 0x7F) && ((lo) <= 0xFC))
+#define IS_SJIS_HI1(hi) ((0x81 <= (hi)) && ((hi) <= 0x9F))	/* 1st lev. */
+#define IS_SJIS_HI2(hi) ((0xE0 <= (hi)) && ((hi) <= 0xEF))	/* 2nd lev. */
+#define IS_SJIS(hi,lo,in_sjis) (!IS_SJIS_LO(lo) ? 0 : IS_SJIS_HI1(hi) ? (in_sjis=1) : in_sjis && IS_SJIS_HI2(hi))
+#define IS_SJIS_2BYTE(hi,lo)   (IS_SJIS_LO(lo) && (IS_SJIS_HI1(hi) || IS_SJIS_HI2(hi)))
+#define IS_SJIS_X0201KANA(lo)  ((0xA1 <= (lo)) && ((lo) <= 0xDF))
+
+#define IS_EUC_LOS(lo)	((0x21 <= (lo)) && ((lo) <= 0x7E))	/* standard */
+#define IS_EUC_LOX(lo)	((0xA1 <= (lo)) && ((lo) <= 0xFE))	/* extended */
+#define IS_EUC_HI(hi)	((0xA1 <= (hi)) && ((hi) <= 0xFE))
+#define IS_EUC_X0201KANA(hi,lo) (((hi) == 0x8E) && (0xA1 <= (lo)) && ((lo) <= 0xDF))
+#define IS_EUC(hi,lo) ((IS_EUC_HI(hi) && IS_EUC_LOX(lo)) || IS_EUC_X0201KANA(hi,lo))
+
+#define IS_JAPANESE_2BYTE(hi,lo) (IS_SJIS_2BYTE(hi,lo) || IS_EUC(hi,lo))
+
+#define IS_BIG5_LOS(lo)	((0x40 <= (lo)) && ((lo) <= 0x7E))	/* standard */
+#define IS_BIG5_LOX(lo)	((0xA1 <= (lo)) && ((lo) <= 0xFE))	/* extended */
+#define IS_BIG5_HI(hi)	((0xA1 <= (hi)) && ((hi) <= 0xFE))
+#define IS_BIG5(hi,lo)	(IS_BIG5_HI(hi) && (IS_BIG5_LOS(lo) || IS_BIG5_LOX(lo)))
+
+    typedef enum {
+	NOKANJI = 0, EUC, SJIS, JIS
+    } HTkcode;
+    typedef enum {
+	NOCJK = 0, JAPANESE, CHINESE, KOREAN, TAIPEI
+    } HTCJKlang;
+
+    extern HTCJKlang HTCJK;
+
+/*
+ *  Function prototypes.
+ */
+    extern void JISx0201TO0208_EUC(unsigned IHI,
+				   unsigned ILO,
+				   unsigned char *OHI,
+				   unsigned char *OLO);
+
+    extern unsigned char *SJIS_TO_JIS1(unsigned HI,
+				       unsigned LO,
+				       unsigned char *JCODE);
+
+    extern unsigned char *JIS_TO_SJIS1(unsigned HI,
+				       unsigned LO,
+				       unsigned char *SJCODE);
+
+    extern unsigned char *EUC_TO_SJIS1(unsigned HI,
+				       unsigned LO,
+				       register unsigned char *SJCODE);
+
+    extern void JISx0201TO0208_SJIS(unsigned I,
+				    unsigned char *OHI,
+				    unsigned char *OLO);
+
+    extern unsigned char *SJIS_TO_EUC1(unsigned HI,
+				       unsigned LO,
+				       unsigned char *EUCp);
+
+    extern unsigned char *SJIS_TO_EUC(unsigned char *src,
+				      unsigned char *dst);
+
+    extern unsigned char *EUC_TO_SJIS(unsigned char *src,
+				      unsigned char *dst);
+
+    extern unsigned char *EUC_TO_JIS(unsigned char *src,
+				     unsigned char *dst,
+				     const char *toK,
+				     const char *toA);
+
+    extern unsigned char *TO_EUC(const unsigned char *jis,
+				 unsigned char *euc);
+
+    extern void TO_SJIS(const unsigned char *any,
+			unsigned char *sjis);
+
+    extern void TO_JIS(const unsigned char *any,
+		       unsigned char *jis);
+
+    extern char *str_kcode(HTkcode code);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTCJK_H */
diff --git a/WWW/Library/Implementation/HTChunk.c b/WWW/Library/Implementation/HTChunk.c
new file mode 100644
index 0000000..6b67011
--- /dev/null
+++ b/WWW/Library/Implementation/HTChunk.c
@@ -0,0 +1,332 @@
+/*
+ * $LynxId: HTChunk.c,v 1.28 2016/11/24 15:29:50 tom Exp $
+ *
+ *		Chunk handling:	Flexible arrays
+ *		===============================
+ *
+ */
+
+#include <HTUtils.h>
+#include <HTChunk.h>
+
+#include <LYLeaks.h>
+
+/*
+ *	Initialize a chunk with a certain allocation unit
+ */
+void HTChunkInit(HTChunk *ch, int grow)
+{
+    ch->data = 0;
+    ch->growby = grow;
+    ch->size = 0;
+    ch->allocated = 0;
+}
+
+/*	Create a chunk with a certain allocation unit
+ *	--------------
+ */
+HTChunk *HTChunkCreate(int grow)
+{
+    HTChunk *ch = typecalloc(HTChunk);
+
+    if (ch == NULL)
+	outofmem(__FILE__, "creation of chunk");
+
+    HTChunkInit(ch, grow);
+    return ch;
+}
+
+HTChunk *HTChunkCreateMayFail(int grow, int failok)
+{
+    HTChunk *ch = typecalloc(HTChunk);
+
+    if (ch == NULL) {
+	if (!failok) {
+	    outofmem(__FILE__, "creation of chunk");
+	} else {
+	    return ch;
+	}
+    }
+
+    HTChunkInit(ch, grow);
+    ch->failok = failok;
+    return ch;
+}
+
+/*	Create a chunk with a certain allocation unit and ensured size
+ *	--------------
+ */
+HTChunk *HTChunkCreate2(int grow, size_t needed)
+{
+    HTChunk *ch = typecalloc(HTChunk);
+
+    if (ch == NULL)
+	outofmem(__FILE__, "HTChunkCreate2");
+
+    HTChunkInit(ch, grow);
+    if (needed-- > 0) {
+	/* Round up */
+	ch->allocated = (int) (needed - (needed % (size_t) ch->growby)
+			       + (unsigned) ch->growby);
+	CTRACE((tfp, "HTChunkCreate2: requested %d, allocate %u\n",
+		(int) needed, (unsigned) ch->allocated));
+	ch->data = typecallocn(char, (unsigned) ch->allocated);
+
+	if (!ch->data)
+	    outofmem(__FILE__, "HTChunkCreate2 data");
+    }
+    return ch;
+}
+
+/*	Clear a chunk of all data
+ *	--------------------------
+ */
+void HTChunkClear(HTChunk *ch)
+{
+    FREE(ch->data);
+    ch->size = 0;
+    ch->allocated = 0;
+}
+
+/*     Free a chunk (and it's chain, if any)
+ *     -------------------------------------
+ */
+void HTChunkFree(HTChunk *ch)
+{
+    HTChunk *next;
+
+    do {
+	next = ch->next;
+	FREE(ch->data);
+	FREE(ch);
+	ch = next;
+    } while (ch != NULL);
+}
+
+/*	Realloc the chunk
+ *	-----------------
+ */
+BOOL HTChunkRealloc(HTChunk *ch, int growby)
+{
+    char *data;
+
+    ch->allocated = ch->allocated + growby;
+
+    data = (ch->data
+	    ? typeRealloc(char, ch->data, ch->allocated)
+	    : typecallocn(char, ch->allocated));
+
+    if (data) {
+	ch->data = data;
+    } else if (ch->failok) {
+	HTChunkClear(ch);	/* allocation failed, clear all data - kw */
+	return FALSE;		/* caller should check ch->allocated - kw */
+    } else {
+	outofmem(__FILE__, "HTChunkRealloc");
+    }
+    return TRUE;
+}
+
+/*	Append a character
+ *	------------------
+ */
+void HTChunkPutc(HTChunk *ch, unsigned c)
+{
+    if (ch->size >= ch->allocated) {
+	if (!HTChunkRealloc(ch, ch->growby))
+	    return;
+    }
+    ch->data[ch->size++] = (char) c;
+}
+
+/* like above but no realloc: extend to another chunk if necessary */
+HTChunk *HTChunkPutc2(HTChunk *ch, int c)
+{
+    if (ch->size >= ch->allocated) {
+	HTChunk *chunk = HTChunkCreateMayFail(ch->growby, ch->failok);
+
+	ch->next = chunk;
+	ch = chunk;
+	HTChunkPutc(ch, UCH(c));
+    } else {
+	ch->data[ch->size++] = (char) c;
+    }
+    return ch;
+}
+
+/*	Ensure a certain size
+ *	---------------------
+ */
+void HTChunkEnsure(HTChunk *ch, int needed)
+{
+    if (needed <= ch->allocated)
+	return;
+    ch->allocated = needed - 1 - ((needed - 1) % ch->growby)
+	+ ch->growby;		/* Round up */
+    ch->data = (ch->data
+		? typeRealloc(char, ch->data, ch->allocated)
+		: typecallocn(char, ch->allocated));
+
+    if (ch->data == NULL)
+	outofmem(__FILE__, "HTChunkEnsure");
+}
+
+/*
+ * Append a block of characters.
+ */
+void HTChunkPutb(HTChunk *ch, const char *b, int l)
+{
+    if (l <= 0)
+	return;
+    if (ch->size + l > ch->allocated) {
+	int growby = l - (l % ch->growby) + ch->growby;		/* Round up */
+
+	if (!HTChunkRealloc(ch, growby))
+	    return;
+    }
+    MemCpy(ch->data + ch->size, b, l);
+    ch->size += l;
+}
+
+/* like above but no realloc: extend to another chunk if necessary */
+HTChunk *HTChunkPutb2(HTChunk *ch, const char *b, int l)
+{
+    if (l <= 0)
+	return ch;
+    if (ch->size + l > ch->allocated) {
+	HTChunk *chunk;
+	int m = ch->allocated - ch->size;
+
+	MemCpy(ch->data + ch->size, b, (unsigned) m);
+	ch->size += m;
+
+	chunk = HTChunkCreateMayFail(ch->growby, ch->failok);
+	ch->next = chunk;
+	ch = chunk;
+	HTChunkPutb(ch, b + m, l - m);
+    } else {
+	MemCpy(ch->data + ch->size, b, (unsigned) l);
+	ch->size += l;
+    }
+    return ch;
+}
+
+#define PUTC(code)  ch->data[ch->size++] = (char)(code)
+#define PUTC2(code) ch->data[ch->size++] = (char)(0x80|(0x3f &(code)))
+
+/*
+ * Append a character encoded as UTF-8.
+ */
+void HTChunkPutUtf8Char(HTChunk *ch, UCode_t code)
+{
+    int utflen;
+
+    if (TOASCII(code) < 128)
+	utflen = 1;
+    else if (code < 0x800L) {
+	utflen = 2;
+    } else if (code < 0x10000L) {
+	utflen = 3;
+    } else if (code < 0x200000L) {
+	utflen = 4;
+    } else if (code < 0x4000000L) {
+	utflen = 5;
+    } else if (code <= 0x7fffffffL) {
+	utflen = 6;
+    } else
+	utflen = 0;
+
+    if (ch->size + utflen > ch->allocated) {
+	int growby = (ch->growby >= utflen) ? ch->growby : utflen;
+
+	if (!HTChunkRealloc(ch, growby))
+	    return;
+    }
+
+    switch (utflen) {
+    case 0:
+	return;
+    case 1:
+	ch->data[ch->size++] = (char) code;
+	return;
+    case 2:
+	PUTC(0xc0 | (code >> 6));
+	break;
+    case 3:
+	PUTC(0xe0 | (code >> 12));
+	break;
+    case 4:
+	PUTC(0xf0 | (code >> 18));
+	break;
+    case 5:
+	PUTC(0xf8 | (code >> 24));
+	break;
+    case 6:
+	PUTC(0xfc | (code >> 30));
+	break;
+    }
+    switch (utflen) {
+    case 6:
+	PUTC2(code >> 24);
+	/* FALLTHRU */
+    case 5:
+	PUTC2(code >> 18);
+	/* FALLTHRU */
+    case 4:
+	PUTC2(code >> 12);
+	/* FALLTHRU */
+    case 3:
+	PUTC2(code >> 6);
+	/* FALLTHRU */
+    case 2:
+	PUTC2(code);
+	break;
+    }
+}
+
+/*	Terminate a chunk
+ *	-----------------
+ */
+void HTChunkTerminate(HTChunk *ch)
+{
+    HTChunkPutc(ch, (char) 0);
+}
+
+/*	Append a string
+ *	---------------
+ */
+void HTChunkPuts(HTChunk *ch, const char *s)
+{
+    const char *p;
+
+    if (s != NULL) {
+	for (p = s; *p; p++) {
+	    if (ch->size >= ch->allocated) {
+		if (!HTChunkRealloc(ch, ch->growby))
+		    break;
+	    }
+	    ch->data[ch->size++] = *p;
+	}
+    }
+}
+
+/* like above but no realloc: extend to another chunk if necessary */
+HTChunk *HTChunkPuts2(HTChunk *ch, const char *s)
+{
+    const char *p;
+
+    if (s != NULL) {
+	for (p = s; *p; p++) {
+	    if (ch->size >= ch->allocated) {
+		HTChunk *chunk = HTChunkCreateMayFail(ch->growby, ch->failok);
+
+		ch->next = chunk;
+		ch = chunk;
+		HTChunkPuts(ch, p);
+		break;
+	    }
+	    ch->data[ch->size++] = *p;
+	}
+    }
+    return ch;
+}
diff --git a/WWW/Library/Implementation/HTChunk.h b/WWW/Library/Implementation/HTChunk.h
new file mode 100644
index 0000000..fa51c99
--- /dev/null
+++ b/WWW/Library/Implementation/HTChunk.h
@@ -0,0 +1,228 @@
+/*
+ * $LynxId: HTChunk.h,v 1.21 2020/01/21 22:02:43 tom Exp $
+ *
+ *				     HTChunk: Flexible array handling for libwww
+ *					CHUNK HANDLING:
+ *					FLEXIBLE ARRAYS
+ *
+ * This module implements a flexible array.  It is a general utility module.  A
+ * chunk is a structure which may be extended.	These routines create and
+ * append data to chunks, automatically reallocating them as necessary.
+ *
+ */
+#ifndef HTCHUNK_H
+#define HTCHUNK_H 1
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#include <UCMap.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef struct _HTChunk HTChunk;
+
+    struct _HTChunk {
+	int size;		/* In bytes                     */
+	int growby;		/* Allocation unit in bytes     */
+	int allocated;		/* Current size of *data        */
+	char *data;		/* Pointer to malloc'd area or 0 */
+	int failok;		/* allowed to fail without exiting program? */
+	HTChunk *next;		/* pointer to the next chunk */
+    };
+
+/*
+ * Initialize a chunk's allocation data and allocation-increment.
+ */
+    extern void HTChunkInit(HTChunk *ch, int grow);
+
+/*
+ *
+ * Create new chunk
+ *
+ *   ON ENTRY,
+ *
+ *   growby		The number of bytes to allocate at a time when the chunk
+ *			is later extended.  Arbitrary but normally a trade-off
+ *			of time vs memory.
+ *
+ *   ON EXIT,
+ *
+ *   returns		A chunk pointer to the new chunk,
+ *
+ */
+
+    extern HTChunk *HTChunkCreate(int growby);
+
+/*
+ *  Create a chunk for which an allocation error is not a fatal application
+ *  error if failok != 0, but merely resets the chunk.  When using a chunk
+ *  created this way, the caller should always check whether the contents
+ *  are ok each time after data have been appended.
+ *  The create call may also fail and will return NULL in that case. - kw
+ */
+    extern HTChunk *HTChunkCreateMayFail(int growby, int failok);
+
+/*
+ *  Like HTChunkCreate but with initial allocation - kw
+ *
+ */
+    extern HTChunk *HTChunkCreate2(int growby, size_t needed);
+
+/*
+ *
+ * Free a chunk
+ *
+ *   ON ENTRY,
+ *
+ *   ch			A valid chunk pointer made by HTChunkCreate()
+ *
+ *   ON EXIT,
+ *
+ *   ch			is invalid and may not be used.
+ *
+ */
+
+    extern void HTChunkFree(HTChunk *ch);
+
+/*
+ *
+ * Clear a chunk
+ *
+ *   ON ENTRY,
+ *
+ *   ch			A valid chunk pointer made by HTChunkCreate()
+ *
+ *   ON EXIT,
+ *
+ *   *ch		The size of the chunk is zero.
+ *
+ */
+
+    extern void HTChunkClear(HTChunk *ch);
+
+/*
+ *
+ * Realloc a chunk
+ *
+ *   ON ENTRY,
+ *
+ *   ch			A valid chunk pointer made by HTChunkCreate()
+ *
+ *   growby		growby
+ *
+ *   ON EXIT,
+ *
+ *   *ch		Expanded by growby
+ *
+ */
+
+    extern BOOL HTChunkRealloc(HTChunk *ch, int growby);
+
+/*
+ *
+ * Ensure a chunk has a certain space in
+ *
+ *   ON ENTRY,
+ *
+ *   ch			A valid chunk pointer made by HTChunkCreate()
+ *
+ *   s			The size required
+ *
+ *   ON EXIT,
+ *
+ *   *ch		Has size at least s
+ *
+ */
+
+    extern void HTChunkEnsure(HTChunk *ch, int s);
+
+/*
+ *
+ * Append a character to a  chunk
+ *
+ *   ON ENTRY,
+ *
+ *   ch			A valid chunk pointer made by HTChunkCreate()
+ *
+ *   c			The character to be appended
+ *
+ *   ON EXIT,
+ *
+ *   *ch		Is one character bigger
+ *
+ */
+    extern void HTChunkPutc(HTChunk *ch, unsigned c);
+
+    extern void HTChunkPutb(HTChunk *ch, const char *b, int l);
+
+    extern void HTChunkPutUtf8Char(HTChunk *ch, UCode_t code);
+
+/*
+ * Append a string to a  chunk
+ *
+ *   ON ENTRY,
+ *
+ *   ch			A valid chunk pointer made by HTChunkCreate()
+ *
+ *   str		Points to a zero-terminated string to be appended
+ *
+ *   ON EXIT,
+ *
+ *   *ch		Is bigger by strlen(str)
+ *
+ */
+
+    extern void HTChunkPuts(HTChunk *ch, const char *str);
+
+/*
+ *
+ * Append a zero character to a  chunk
+ *
+ */
+
+/*
+ *
+ *   ON ENTRY,
+ *
+ *   ch			A valid chunk pointer made by HTChunkCreate()
+ *
+ *   ON EXIT,
+ *
+ *   *ch		Is one character bigger
+ *
+ */
+
+    extern void HTChunkTerminate(HTChunk *ch);
+
+/* like the above but no realloc: extend to another chunk if necessary */
+/*
+ *
+ * Append a character (string, data) to a chunk
+ *
+ *   ON ENTRY,
+ *
+ *   ch                        A valid chunk pointer made by HTChunkCreate()
+ *
+ *   c                 The character to be appended
+ *
+ *   ON EXIT,
+ *
+ *   returns           original chunk or a pointer to the new chunk
+ *                     (original chunk is referenced to the new one
+ *                     by the field 'next')
+ *
+ */
+    extern HTChunk *HTChunkPutc2(HTChunk *ch, int c);
+    extern HTChunk *HTChunkPuts2(HTChunk *ch, const char *str);
+    extern HTChunk *HTChunkPutb2(HTChunk *ch, const char *b, int l);
+
+/* New pool infrastructure: UNlike the above, store data using alignment */
+    extern HTChunk *HTChunkPutb0(HTChunk *ch, const char *b, int l);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTCHUNK_H */
diff --git a/WWW/Library/Implementation/HTDOS.c b/WWW/Library/Implementation/HTDOS.c
new file mode 100644
index 0000000..84bff79
--- /dev/null
+++ b/WWW/Library/Implementation/HTDOS.c
@@ -0,0 +1,241 @@
+/*
+ * $LynxId: HTDOS.c,v 1.40 2013/11/28 11:11:05 tom Exp $
+ *							DOS specific routines
+ */
+
+#include <HTUtils.h>
+#include <LYUtils.h>
+#include <HTDOS.h>
+#include <LYStrings.h>
+
+#include <LYLeaks.h>
+
+#ifdef _WINDOWS
+#include <LYGlobalDefs.h>
+#include <HTAlert.h>
+#endif
+
+/*
+ * Make a copy of the source argument in the result, allowing some extra
+ * space so we can append directly onto the result without reallocating.
+ */
+static char *copy_plus(char **result, const char *source)
+{
+    int length = (int) strlen(source);
+    int extra = 10;
+    int n;
+
+    for (n = 0; n < length; ++n) {
+	if (source[n] == ' ')
+	    ++extra;
+    }
+
+    HTSprintf0(result, "%-*s", length + extra, source);
+    (*result)[length] = 0;
+    return (*result);
+}
+
+/* PUBLIC							HTDOS_wwwName()
+ *		CONVERTS DOS Name into WWW Name
+ * ON ENTRY:
+ *	dosname		DOS file specification (NO NODE)
+ *
+ * ON EXIT:
+ *	returns		WWW file specification
+ *
+ */
+const char *HTDOS_wwwName(const char *dosname)
+{
+    static char *wwwname = NULL;
+    char *cp_url = copy_plus(&wwwname, dosname);
+    int wwwname_len;
+    char ch;
+
+    while ((ch = *dosname) != '\0') {
+	switch (ch) {
+	case '\\':
+	    /* convert dos backslash to unix-style */
+	    *cp_url++ = '/';
+	    break;
+	case ' ':
+	    *cp_url++ = '%';
+	    *cp_url++ = '2';
+	    *cp_url++ = '0';
+	    break;
+	default:
+	    *cp_url++ = ch;
+	    break;
+	}
+	dosname++;
+    }
+    *cp_url = '\0';
+
+    wwwname_len = (int) strlen(wwwname);
+    if (wwwname_len > 1)
+	cp_url--;		/* point last char */
+
+    if (wwwname_len > 3 && *cp_url == '/') {
+	cp_url++;
+	*cp_url = '\0';
+    }
+    return (wwwname);
+}
+
+/*
+ * Convert slashes from Unix to DOS
+ */
+char *HTDOS_slashes(char *path)
+{
+    char *s;
+
+    for (s = path; *s != '\0'; ++s) {
+	if (*s == '/') {
+	    *s = '\\';
+	}
+    }
+    return path;
+}
+
+/* PUBLIC							HTDOS_name()
+ *		CONVERTS WWW name into a DOS name
+ * ON ENTRY:
+ *	wwwname		WWW file name
+ *
+ * ON EXIT:
+ *	returns		DOS file specification
+ */
+char *HTDOS_name(const char *wwwname)
+{
+    static char *result = NULL;
+    int joe;
+
+#if defined(SH_EX)		/* 2000/03/07 (Tue) 18:32:42 */
+    if (unsafe_filename(wwwname)) {
+	HTUserMsg2("unsafe filename : %s", wwwname);
+	copy_plus(&result, "BAD_LOCAL_FILE_NAME");
+    } else {
+	copy_plus(&result, wwwname);
+    }
+#else
+    copy_plus(&result, wwwname);
+#endif
+#ifdef __DJGPP__
+    if (result[0] == '/'
+	&& result[1] == 'd'
+	&& result[2] == 'e'
+	&& result[3] == 'v'
+	&& result[4] == '/'
+	&& isalpha(result[5])) {
+	return (result);
+    }
+#endif /* __DJGPP__ */
+
+    (void) HTDOS_slashes(result);
+
+    /* pesky leading slash, rudiment from file://localhost/  */
+    /* the rest of path may be with or without drive letter  */
+    if ((result[1] != '\\') && (result[0] == '\\')) {
+	for (joe = 0; (result[joe] = result[joe + 1]) != 0; joe++) ;
+    }
+    /* convert '|' after the drive letter to ':' */
+    if (isalpha(UCH(result[0])) && result[1] == '|') {
+	result[1] = ':';
+    }
+#ifdef _WINDOWS			/* 1998/04/02 (Thu) 08:59:48 */
+    if (LYLastPathSep(result) != NULL
+	&& !LYIsDosDrive(result)) {
+	char temp_buff[LY_MAXPATH];
+
+	sprintf(temp_buff, "%.3s\\%.*s", windows_drive,
+		(int) (sizeof(temp_buff) - 5), result);
+	StrAllocCopy(result, temp_buff);
+    }
+#endif
+    /*
+     * If we have only a device, add a trailing slash.  Otherwise it just
+     * refers to the current directory on the given device.
+     */
+    if (LYLastPathSep(result) == NULL
+	&& LYIsDosDrive(result))
+	LYAddPathSep0(result);
+
+    CTRACE((tfp, "HTDOS_name changed `%s' to `%s'\n", wwwname, result));
+    return (result);
+}
+
+#ifdef WIN_EX
+char *HTDOS_short_name(const char *path)
+{
+    static char sbuf[LY_MAXPATH];
+    char *ret;
+    DWORD r;
+
+    if (StrChr(path, '/'))
+	path = HTDOS_name(path);
+    r = GetShortPathName(path, sbuf, sizeof sbuf);
+    if (r >= sizeof(sbuf) || r == 0) {
+	ret = LYStrNCpy(sbuf, path, sizeof(sbuf));
+    } else {
+	ret = sbuf;
+    }
+    return ret;
+}
+#endif
+
+#if defined(DJGPP)
+/*
+ * Poll tcp/ip lib and yield to DPMI-host while nothing in
+ * keyboard buffer (head = tail) (simpler than kbhit).
+ * This is required to be able to finish off dead sockets,
+ * answer pings etc.
+ */
+#include <pc.h>
+#include <dpmi.h>
+#include <libc/farptrgs.h>
+#include <go32.h>
+
+void djgpp_idle_loop(void)
+{
+    while (_farpeekw(_dos_ds, 0x41a) == _farpeekw(_dos_ds, 0x41c)) {
+	tcp_tick(NULL);
+	__dpmi_yield();
+#if defined(USE_SLANG)
+	if (SLang_input_pending(1))
+	    break;
+#endif
+    }
+}
+
+/* PUBLIC       getxkey()
+ *              Replaces libc's getxkey() with polling of tcp/ip
+ *              library (WatTcp or Watt-32). *
+ * ON EXIT:
+ *      returns extended keypress.
+ */
+
+/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
+
+int getxkey(void)
+{
+#if defined(DJGPP_KEYHANDLER)
+    __dpmi_regs r;
+
+    djgpp_idle_loop();
+
+    r.h.ah = 0x10;
+    __dpmi_int(0x16, &r);
+
+    if (r.h.al == 0x00)
+	return 0x0100 | r.h.ah;
+    if (r.h.al == 0xe0)
+	return 0x0200 | r.h.ah;
+    return r.h.al;
+
+#elif defined(USE_SLANG)
+    djgpp_idle_loop();
+    return SLkp_getkey();
+#else
+    /* PDcurses uses myGetChar() in LYString.c */
+#endif
+}
+#endif /* DJGPP */
diff --git a/WWW/Library/Implementation/HTDOS.h b/WWW/Library/Implementation/HTDOS.h
new file mode 100644
index 0000000..e1613cb
--- /dev/null
+++ b/WWW/Library/Implementation/HTDOS.h
@@ -0,0 +1,56 @@
+/*
+ * $LynxId: HTDOS.h,v 1.14 2009/09/09 00:16:06 tom Exp $
+ *
+ * DOS specific routines
+ */
+
+#ifndef HTDOS_H
+#define HTDOS_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif /* HTUTILS_H */
+
+/* PUBLIC                                                       HTDOS_wwwName()
+ *              CONVERTS DOS Name into WWW Name
+ * ON ENTRY:
+ *	dosname		DOS file specification (NO NODE)
+ *
+ * ON EXIT:
+ *	returns		WWW file specification
+ *
+ */
+const char *HTDOS_wwwName(const char *dosname);
+
+/*
+ * Converts Unix slashes to DOS
+ */
+char *HTDOS_slashes(char *path);
+
+/* PUBLIC                                                       HTDOS_name()
+ *              CONVERTS WWW name into a DOS name
+ * ON ENTRY:
+ *	wwwname		WWW file name
+ *
+ * ON EXIT:
+ *	returns		DOS file specification
+ *
+ * Bug:	Returns pointer to static -- non-reentrant
+ */
+char *HTDOS_name(const char *wwwname);
+
+#ifdef WIN_EX
+char *HTDOS_short_name(const char *fn);
+
+#else
+#define HTDOS_short_name(fn)  fn
+#endif
+
+#ifdef DJGPP
+/*
+ * Poll tcp/ip lib and yield to DPMI-host while nothing in
+ * keyboard buffer (head = tail) (simpler than kbhit).
+ */
+void djgpp_idle_loop(void);
+#endif
+#endif /*  HTDOS_H */
diff --git a/WWW/Library/Implementation/HTFTP.c b/WWW/Library/Implementation/HTFTP.c
new file mode 100644
index 0000000..decf559
--- /dev/null
+++ b/WWW/Library/Implementation/HTFTP.c
@@ -0,0 +1,4177 @@
+/*
+ * $LynxId: HTFTP.c,v 1.148 2023/01/05 09:17:15 tom Exp $
+ *
+ *			File Transfer Protocol (FTP) Client
+ *			for a WorldWideWeb browser
+ *			===================================
+ *
+ *	A cache of control connections is kept.
+ *
+ * Note: Port allocation
+ *
+ *	It is essential that the port is allocated by the system, rather
+ *	than chosen in rotation by us (POLL_PORTS), or the following
+ *	problem occurs.
+ *
+ *	It seems that an attempt by the server to connect to a port which has
+ *	been used recently by a listen on the same socket, or by another
+ *	socket this or another process causes a hangup of (almost exactly)
+ *	one minute.  Therefore, we have to use a rotating port number.
+ *	The problem remains that if the application is run twice in quick
+ *	succession, it will hang for what remains of a minute.
+ *
+ * Authors
+ *	TBL	Tim Berners-lee <timbl@info.cern.ch>
+ *	DD	Denis DeLaRoca 310 825-4580 <CSP1DWD@mvs.oac.ucla.edu>
+ *	LM	Lou Montulli <montulli@ukanaix.cc.ukans.edu>
+ *	FM	Foteos Macrides <macrides@sci.wfeb.edu>
+ * History:
+ *	 2 May 91	Written TBL, as a part of the WorldWideWeb project.
+ *	15 Jan 92	Bug fix: close() was used for NETCLOSE for control soc
+ *	10 Feb 92	Retry if cached connection times out or breaks
+ *	 8 Dec 92	Bug fix 921208 TBL after DD
+ *	17 Dec 92	Anon FTP password now just WWWuser@ suggested by DD
+ *			fails on princeton.edu!
+ *	27 Dec 93 (FM)	Fixed up so FTP now works with VMS hosts.  Path
+ *			must be Unix-style and cannot include the device
+ *			or top directory.
+ *	?? ??? ?? (LM)	Added code to prompt and send passwords for non
+ *			anonymous FTP
+ *	25 Mar 94 (LM)	Added code to recognize different ftp server types
+ *			and code to parse dates and sizes on most hosts.
+ *	27 Mar 93 (FM)	Added code for getting dates and sizes on VMS hosts.
+ *
+ * Notes:
+ *			Portions Copyright 1994 Trustees of Dartmouth College
+ *			Code for recognizing different FTP servers and
+ *			parsing "ls -l" output taken from Macintosh Fetch
+ *			program with permission from Jim Matthews,
+ *			Dartmouth Software Development Team.
+ */
+
+/*
+ * BUGS:	@@@	Limit connection cache size!
+ * 		Error reporting to user.
+ * 		400 & 500 errors are ack'ed by user with windows.
+ * 		Use configuration file for user names
+ * 
+ *		Note for portability this version does not use select() and
+ *		so does not watch the control and data channels at the
+ *		same time.
+ */
+
+#include <HTUtils.h>
+
+#include <HTAlert.h>
+
+#include <HTFTP.h>		/* Implemented here */
+#include <HTTCP.h>
+#include <HTTP.h>
+#include <HTFont.h>
+
+#define REPEAT_PORT		/* Give the port number for each file */
+#define REPEAT_LISTEN		/* Close each listen socket and open a new one */
+
+/* define POLL_PORTS		 If allocation does not work, poll ourselves.*/
+#define LISTEN_BACKLOG 2	/* Number of pending connect requests (TCP) */
+
+#define FIRST_TCP_PORT	1024	/* Region to try for a listening port */
+#define LAST_TCP_PORT	5999
+
+#define LINE_LENGTH 256
+
+#include <HTParse.h>
+#include <HTAnchor.h>
+#include <HTFile.h>		/* For HTFileFormat() */
+#include <HTBTree.h>
+#include <HTChunk.h>
+#ifndef IPPORT_FTP
+#define IPPORT_FTP	21
+#endif /* !IPORT_FTP */
+
+#include <LYUtils.h>
+#include <LYGlobalDefs.h>
+#include <LYStrings.h>
+#include <LYLeaks.h>
+
+typedef struct _connection {
+    struct _connection *next;	/* Link on list         */
+    int socket;			/* Socket number for communication */
+    BOOL is_binary;		/* Binary mode? */
+} connection;
+
+/*		Hypertext object building machinery
+*/
+#include <HTML.h>
+
+/*
+ * socklen_t is the standard, but there are many pre-standard variants.
+ * This ifdef works around a few of those cases.
+ *
+ * Information was obtained from header files on these platforms:
+ *	AIX 4.3.2, 5.1
+ *	HPUX 10.20, 11.00, 11.11
+ *	IRIX64 6.5
+ *	Tru64 4.0G, 4.0D, 5.1
+ */
+#if defined(SYS_IRIX64)
+	/* IRIX64 6.5 socket.h may use socklen_t if SGI_SOURCE is not defined */
+#  if _NO_XOPEN4 && _NO_XOPEN5
+#    define LY_SOCKLEN socklen_t
+#  elif _ABIAPI
+#    define LY_SOCKLEN int
+#  elif _XOPEN5
+#    if (_MIPS_SIM != _ABIO32)
+#      define LY_SOCKLEN socklen_t
+#    else
+#      define LY_SOCKLEN int
+#    endif
+#  else
+#    define LY_SOCKLEN size_t
+#  endif
+#elif defined(SYS_HPUX)
+#  if defined(_XOPEN_SOURCE_EXTENDED) && defined(SO_PROTOTYPE)
+#    define LY_SOCKLEN socklen_t
+#  else	/* HPUX 10.20, etc. */
+#    define LY_SOCKLEN int
+#  endif
+#elif defined(SYS_TRU64)
+#  if defined(_POSIX_PII_SOCKET)
+#    define LY_SOCKLEN socklen_t
+#  elif defined(_XOPEN_SOURCE_EXTENDED)
+#    define LY_SOCKLEN size_t
+#  else
+#    define LY_SOCKLEN int
+#  endif
+#else
+#  define LY_SOCKLEN socklen_t
+#endif
+
+#define PUTC(c)      (*target->isa->put_character) (target, c)
+#define PUTS(s)      (*target->isa->put_string)    (target, s)
+#define START(e)     (*target->isa->start_element) (target, e, 0, 0, -1, 0)
+#define END(e)       (*target->isa->end_element)   (target, e, 0)
+#define FREE_TARGET  (*target->isa->_free)         (target)
+#define ABORT_TARGET (*target->isa->_free)         (target)
+
+#define TRACE_ENTRY(tag, entry_info) \
+    CTRACE((tfp, "HTFTP: %s filename: %s  date: %s  size: %" PRI_off_t "\n", \
+	    tag, \
+	    entry_info->filename, \
+	    NonNull(entry_info->date), \
+	    CAST_off_t(entry_info->size)))
+
+struct _HTStructured {
+    const HTStructuredClass *isa;
+    /* ... */
+};
+
+/*	Global Variables
+ *	---------------------
+ */
+int HTfileSortMethod = FILE_BY_NAME;
+
+#ifndef DISABLE_FTP		/*This disables everything to end-of-file */
+static char ThisYear[8];
+static char LastYear[8];
+static int TheDate;
+static BOOLEAN HaveYears = FALSE;
+
+/*	Module-Wide Variables
+ *	---------------------
+ */
+static connection *connections = NULL;	/* Linked list of connections */
+static char response_text[LINE_LENGTH + 1];	/* Last response from ftp host */
+static connection *control = NULL;	/* Current connection */
+static int data_soc = -1;	/* Socket for data transfer =invalid */
+static char *user_entered_password = NULL;
+static char *last_username_and_host = NULL;
+
+/*
+ * Some ftp servers are known to have a broken implementation of RETR.  If
+ * asked to retrieve a directory, they get confused and fail subsequent
+ * commands such as CWD and LIST.
+ */
+static int Broken_RETR = FALSE;
+
+/*
+ * Some ftp servers are known to have a broken implementation of EPSV.  The
+ * server will hang for a long time when we attempt to connect after issuing
+ * this command.
+ */
+#ifdef INET6
+static int Broken_EPSV = FALSE;
+#endif
+
+typedef enum {
+    GENERIC_SERVER
+    ,MACHTEN_SERVER
+    ,UNIX_SERVER
+    ,VMS_SERVER
+    ,CMS_SERVER
+    ,DCTS_SERVER
+    ,TCPC_SERVER
+    ,PETER_LEWIS_SERVER
+    ,NCSA_SERVER
+    ,WINDOWS_NT_SERVER
+    ,WINDOWS_2K_SERVER
+    ,MS_WINDOWS_SERVER
+    ,MSDOS_SERVER
+    ,APPLESHARE_SERVER
+    ,NETPRESENZ_SERVER
+    ,DLS_SERVER
+} eServerType;
+
+static eServerType server_type = GENERIC_SERVER;	/* the type of ftp host */
+static int unsure_type = FALSE;	/* sure about the type? */
+static BOOLEAN use_list = FALSE;	/* use the LIST command? */
+
+static int interrupted_in_next_data_char = FALSE;
+
+#ifdef POLL_PORTS
+static PortNumber port_number = FIRST_TCP_PORT;
+#endif /* POLL_PORTS */
+
+static BOOL have_socket = FALSE;	/* true if master_socket is valid */
+static LYNX_FD master_socket;	/* Listening socket = invalid */
+
+static char *port_command;	/* Command for setting the port */
+static fd_set open_sockets;	/* Mask of active channels */
+static LYNX_FD num_sockets;	/* Number of sockets to scan */
+static PortNumber passive_port;	/* Port server specified for data */
+
+#define NEXT_CHAR HTGetCharacter()	/* Use function in HTFormat.c */
+
+#define DATA_BUFFER_SIZE 2048
+static char data_buffer[DATA_BUFFER_SIZE];	/* Input data buffer */
+static char *data_read_pointer;
+static char *data_write_pointer;
+
+#define NEXT_DATA_CHAR next_data_char()
+static int close_connection(connection * con);
+
+#ifndef HAVE_ATOLL
+off_t LYatoll(const char *value)
+{
+    off_t result = 0;
+
+    while (*value != '\0') {
+	result = (result * 10) + (off_t) (*value++ - '0');
+    }
+    return result;
+}
+#endif
+
+#ifdef LY_FIND_LEAKS
+/*
+ *  This function frees module globals. - FM
+ */
+static void free_FTPGlobals(void)
+{
+    FREE(user_entered_password);
+    FREE(last_username_and_host);
+    if (control) {
+	if (control->socket != -1)
+	    close_connection(control);
+	FREE(control);
+    }
+}
+#endif /* LY_FIND_LEAKS */
+
+/* PUBLIC						HTVMS_name()
+ *		CONVERTS WWW name into a VMS name
+ * ON ENTRY:
+ *	nn		Node Name (optional)
+ *	fn		WWW file name
+ *
+ * ON EXIT:
+ *	returns		vms file specification
+ *
+ * Bug: Returns pointer to static -- non-reentrant
+ */
+char *HTVMS_name(const char *nn,
+		 const char *fn)
+{
+    /* We try converting the filename into Files-11 syntax.  That is, we assume
+     * first that the file is, like us, on a VMS node.  We try remote (or
+     * local) DECnet access.  Files-11, VMS, VAX and DECnet are trademarks of
+     * Digital Equipment Corporation.  The node is assumed to be local if the
+     * hostname WITHOUT DOMAIN matches the local one.  @@@
+     */
+    static char *vmsname;
+    char *filename = (char *) malloc(strlen(fn) + 1);
+    char *nodename = (char *) malloc(strlen(nn) + 2 + 1);	/* Copies to hack */
+    char *second;		/* 2nd slash */
+    char *last;			/* last slash */
+
+    const char *hostname = HTHostName();
+
+    if (!filename || !nodename)
+	outofmem(__FILE__, "HTVMSname");
+
+    strcpy(filename, fn);
+    strcpy(nodename, "");	/* On same node?  Yes if node names match */
+    if (StrNCmp(nn, "localhost", 9)) {
+	const char *p;
+	const char *q;
+
+	for (p = hostname, q = nn;
+	     *p && *p != '.' && *q && *q != '.'; p++, q++) {
+	    if (TOUPPER(*p) != TOUPPER(*q)) {
+		char *r;
+
+		strcpy(nodename, nn);
+		r = StrChr(nodename, '.');	/* Mismatch */
+		if (r)
+		    *r = '\0';	/* Chop domain */
+		strcat(nodename, "::");		/* Try decnet anyway */
+		break;
+	    }
+	}
+    }
+
+    second = StrChr(filename + 1, '/');		/* 2nd slash */
+    last = strrchr(filename, '/');	/* last slash */
+
+    if (!second) {		/* Only one slash */
+	HTSprintf0(&vmsname, "%s%s", nodename, filename + 1);
+    } else if (second == last) {	/* Exactly two slashes */
+	*second = '\0';		/* Split filename from disk */
+	HTSprintf0(&vmsname, "%s%s:%s", nodename, filename + 1, second + 1);
+	*second = '/';		/* restore */
+    } else {			/* More than two slashes */
+	char *p;
+
+	*second = '\0';		/* Split disk from directories */
+	*last = '\0';		/* Split dir from filename */
+	HTSprintf0(&vmsname, "%s%s:[%s]%s",
+		   nodename, filename + 1, second + 1, last + 1);
+	*second = *last = '/';	/* restore filename */
+	if ((p = StrChr(vmsname, '[')) != 0) {
+	    while (*p != '\0' && *p != ']') {
+		if (*p == '/')
+		    *p = '.';	/* Convert dir sep.  to dots */
+		++p;
+	    }
+	}
+    }
+    FREE(nodename);
+    FREE(filename);
+    return vmsname;
+}
+
+/*	Procedure: Read a character from the data connection
+ *	----------------------------------------------------
+ */
+static int next_data_char(void)
+{
+    int status;
+
+    if (data_read_pointer >= data_write_pointer) {
+	status = NETREAD(data_soc, data_buffer, DATA_BUFFER_SIZE);
+	if (status == HT_INTERRUPTED)
+	    interrupted_in_next_data_char = 1;
+	if (status <= 0)
+	    return EOF;
+	data_write_pointer = data_buffer + status;
+	data_read_pointer = data_buffer;
+    }
+#ifdef NOT_ASCII
+    {
+	char c = *data_read_pointer++;
+
+	return FROMASCII(c);
+    }
+#else
+    return UCH(*data_read_pointer++);
+#endif /* NOT_ASCII */
+}
+
+/*	Close an individual connection
+ *
+ */
+static int close_connection(connection * con)
+{
+    connection *scan;
+    int status;
+
+    CTRACE((tfp, "HTFTP: Closing control socket %d\n", con->socket));
+    status = NETCLOSE(con->socket);
+    if (TRACE && status != 0) {
+#ifdef UNIX
+	CTRACE((tfp, "HTFTP:close_connection: %s", LYStrerror(errno)));
+#else
+	if (con->socket != INVSOC)
+	    HTInetStatus("HTFTP:close_connection");
+#endif
+    }
+    con->socket = -1;
+    if (connections == con) {
+	connections = con->next;
+	return status;
+    }
+    for (scan = connections; scan; scan = scan->next) {
+	if (scan->next == con) {
+	    scan->next = con->next;	/* Unlink */
+	    if (control == con)
+		control = (connection *) 0;
+	    return status;
+	}			/*if */
+    }				/* for */
+    return -1;			/* very strange -- was not on list. */
+}
+
+static char *help_message_buffer = NULL;	/* global :( */
+
+static void init_help_message_cache(void)
+{
+    FREE(help_message_buffer);
+}
+
+static void help_message_cache_add(char *string)
+{
+    if (help_message_buffer)
+	StrAllocCat(help_message_buffer, string);
+    else
+	StrAllocCopy(help_message_buffer, string);
+
+    CTRACE((tfp, "Adding message to help cache: %s\n", string));
+}
+
+static char *help_message_cache_non_empty(void)
+{
+    return (help_message_buffer);
+}
+
+static char *help_message_cache_contents(void)
+{
+    return (help_message_buffer);
+}
+
+/*	Send One Command
+ *	----------------
+ *
+ *	This function checks whether we have a control connection, and sends
+ *	one command if given.
+ *
+ * On entry,
+ *	control	points to the connection which is established.
+ *	cmd	points to a command, or is zero to just get the response.
+ *
+ *	The command should already be terminated with the CRLF pair.
+ *
+ * On exit,
+ *	returns:  1 for success,
+ *		  or negative for communication failure (in which case
+ *		  the control connection will be closed).
+ */
+static int write_cmd(const char *cmd)
+{
+    int status;
+
+    if (!control) {
+	CTRACE((tfp, "HTFTP: No control connection set up!!\n"));
+	return HT_NO_CONNECTION;
+    }
+
+    if (cmd) {
+	CTRACE((tfp, "  Tx: %s", cmd));
+#ifdef NOT_ASCII
+	{
+	    char *p;
+
+	    for (p = cmd; *p; p++) {
+		*p = TOASCII(*p);
+	    }
+	}
+#endif /* NOT_ASCII */
+	status = (int) NETWRITE(control->socket, cmd, (unsigned) strlen(cmd));
+	if (status < 0) {
+	    CTRACE((tfp,
+		    "HTFTP: Error %d sending command: closing socket %d\n",
+		    status, control->socket));
+	    close_connection(control);
+	    return status;
+	}
+    }
+    return 1;
+}
+
+/*
+ * For each string in the list, check if it is found in the response text.
+ * If so, return TRUE.
+ */
+static BOOL find_response(HTList *list)
+{
+    BOOL result = FALSE;
+    HTList *p = list;
+    char *value;
+
+    while ((value = (char *) HTList_nextObject(p)) != NULL) {
+	if (LYstrstr(response_text, value)) {
+	    result = TRUE;
+	    break;
+	}
+    }
+    return result;
+}
+
+/*	Execute Command and get Response
+ *	--------------------------------
+ *
+ *	See the state machine illustrated in RFC959, p57. This implements
+ *	one command/reply sequence.  It also interprets lines which are to
+ *	be continued, which are marked with a "-" immediately after the
+ *	status code.
+ *
+ *	Continuation then goes on until a line with a matching reply code
+ *	an a space after it.
+ *
+ * On entry,
+ *	control	points to the connection which is established.
+ *	cmd	points to a command, or is zero to just get the response.
+ *
+ *	The command must already be terminated with the CRLF pair.
+ *
+ * On exit,
+ *	returns:  The first digit of the reply type,
+ *		  or negative for communication failure.
+ */
+static int response(const char *cmd)
+{
+    int result;			/* Three-digit decimal code */
+    int continuation_response = -1;
+    int status;
+
+    if ((status = write_cmd(cmd)) < 0)
+	return status;
+
+    do {
+	char *p = response_text;
+
+	for (;;) {
+	    int ich = NEXT_CHAR;
+
+	    if (((*p++ = (char) ich) == LF)
+		|| (p == &response_text[LINE_LENGTH])) {
+
+		char continuation;
+
+		if (interrupted_in_htgetcharacter) {
+		    CTRACE((tfp,
+			    "HTFTP: Interrupted in HTGetCharacter, apparently.\n"));
+		    NETCLOSE(control->socket);
+		    control->socket = -1;
+		    return HT_INTERRUPTED;
+		}
+
+		*p = '\0';	/* Terminate the string */
+		CTRACE((tfp, "    Rx: %s", response_text));
+
+		/* Check for login or help messages */
+		if (!StrNCmp(response_text, "230-", 4) ||
+		    !StrNCmp(response_text, "250-", 4) ||
+		    !StrNCmp(response_text, "220-", 4))
+		    help_message_cache_add(response_text + 4);
+
+		sscanf(response_text, "%d%c", &result, &continuation);
+		if (continuation_response == -1) {
+		    if (continuation == '-')	/* start continuation */
+			continuation_response = result;
+		} else {	/* continuing */
+		    if (continuation_response == result &&
+			continuation == ' ')
+			continuation_response = -1;	/* ended */
+		}
+		if (result == 220 && find_response(broken_ftp_retr)) {
+		    Broken_RETR = TRUE;
+		    CTRACE((tfp, "This server is broken (RETR)\n"));
+		}
+#ifdef INET6
+		if (result == 220 && find_response(broken_ftp_epsv)) {
+		    Broken_EPSV = TRUE;
+		    CTRACE((tfp, "This server is broken (EPSV)\n"));
+		}
+#endif
+		break;
+	    }
+	    /* if end of line */
+	    if (interrupted_in_htgetcharacter) {
+		CTRACE((tfp,
+			"HTFTP: Interrupted in HTGetCharacter, apparently.\n"));
+		NETCLOSE(control->socket);
+		control->socket = -1;
+		return HT_INTERRUPTED;
+	    }
+
+	    if (ich == EOF) {
+		CTRACE((tfp, "Error on rx: closing socket %d\n",
+			control->socket));
+		strcpy(response_text, "000 *** TCP read error on response\n");
+		close_connection(control);
+		return -1;	/* End of file on response */
+	    }
+	}			/* Loop over characters */
+
+    } while (continuation_response != -1);
+
+    if (result == 421) {
+	CTRACE((tfp, "HTFTP: They close so we close socket %d\n",
+		control->socket));
+	close_connection(control);
+	return -1;
+    }
+    if ((result == 255 && server_type == CMS_SERVER) &&
+	(0 == strncasecomp(cmd, "CWD", 3) ||
+	 0 == strcasecomp(cmd, "CDUP"))) {
+	/*
+	 * Alas, CMS returns 255 on failure to CWD to parent of root.  - PG
+	 */
+	result = 555;
+    }
+    return result / 100;
+}
+
+static int send_cmd_1(const char *verb)
+{
+    char command[80];
+
+    sprintf(command, "%.*s%c%c", (int) sizeof(command) - 4, verb, CR, LF);
+    return response(command);
+}
+
+static int send_cmd_2(const char *verb, const char *param)
+{
+    char *command = 0;
+    int status;
+
+    HTSprintf0(&command, "%s %s%c%c", verb, param, CR, LF);
+    status = response(command);
+    FREE(command);
+
+    return status;
+}
+
+#define send_cwd(path) send_cmd_2("CWD", path)
+
+/*
+ * This function should try to set the macintosh server into binary mode.  Some
+ * servers need an additional letter after the MACB command.
+ */
+static int set_mac_binary(eServerType ServerType)
+{
+    /* try to set mac binary mode */
+    if (ServerType == APPLESHARE_SERVER ||
+	ServerType == NETPRESENZ_SERVER) {
+	/*
+	 * Presumably E means "Enable".  - KW
+	 */
+	return (2 == response("MACB E\r\n"));
+    } else {
+	return (2 == response("MACB\r\n"));
+    }
+}
+
+/* This function gets the current working directory to help
+ * determine what kind of host it is
+ */
+
+static void get_ftp_pwd(eServerType *ServerType, BOOLEAN *UseList)
+{
+    char *cp;
+
+    /* get the working directory (to see what it looks like) */
+    int status = response("PWD\r\n");
+
+    if (status < 0) {
+	return;
+    } else {
+	cp = StrChr(response_text + 5, '"');
+	if (cp)
+	    *cp = '\0';
+	if (*ServerType == TCPC_SERVER) {
+	    *ServerType = ((response_text[5] == '/') ?
+			   NCSA_SERVER : TCPC_SERVER);
+	    CTRACE((tfp, "HTFTP: Treating as %s server.\n",
+		    ((*ServerType == NCSA_SERVER) ?
+		     "NCSA" : "TCPC")));
+	} else if (response_text[5] == '/') {
+	    /* path names beginning with / imply Unix,
+	     * right?
+	     */
+	    if (set_mac_binary(*ServerType)) {
+		*ServerType = NCSA_SERVER;
+		CTRACE((tfp, "HTFTP: Treating as NCSA server.\n"));
+	    } else {
+		*ServerType = UNIX_SERVER;
+		*UseList = TRUE;
+		CTRACE((tfp, "HTFTP: Treating as Unix server.\n"));
+	    }
+	    return;
+	} else if (response_text[strlen(response_text) - 1] == ']') {
+	    /* path names ending with ] imply VMS, right? */
+	    *ServerType = VMS_SERVER;
+	    *UseList = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as VMS server.\n"));
+	} else {
+	    *ServerType = GENERIC_SERVER;
+	    CTRACE((tfp, "HTFTP: Treating as Generic server.\n"));
+	}
+
+	if ((*ServerType == NCSA_SERVER) ||
+	    (*ServerType == TCPC_SERVER) ||
+	    (*ServerType == PETER_LEWIS_SERVER) ||
+	    (*ServerType == NETPRESENZ_SERVER))
+	    set_mac_binary(*ServerType);
+    }
+}
+
+/* This function turns MSDOS-like directory output off for
+ * Windows NT servers.
+ */
+
+static void set_unix_dirstyle(eServerType *ServerType, BOOLEAN *UseList)
+{
+    char *cp;
+
+    /* This is a toggle.  It seems we have to toggle in order to see
+     * the current state (after toggling), so we may end up toggling
+     * twice.  - kw
+     */
+    int status = response("SITE DIRSTYLE\r\n");
+
+    if (status != 2) {
+	*ServerType = GENERIC_SERVER;
+	CTRACE((tfp, "HTFTP: DIRSTYLE failed, treating as Generic server.\n"));
+	return;
+    } else {
+	*UseList = TRUE;
+	/* Expecting one of:
+	 * 200 MSDOS-like directory output is off
+	 * 200 MSDOS-like directory output is on
+	 * The following code doesn't look for the full exact string -
+	 * who knows how the wording may change in some future version.
+	 * If the first response isn't recognized, we toggle again
+	 * anyway, under the assumption that it's more likely that
+	 * the MSDOS setting was "off" originally. - kw
+	 */
+	cp = strstr(response_text + 4, "MSDOS");
+	if (cp && strstr(cp, " off")) {
+	    return;		/* already off now. */
+	} else {
+	    response("SITE DIRSTYLE\r\n");
+	}
+    }
+}
+
+#define CheckForInterrupt(msg) \
+	if (status == HT_INTERRUPTED) { \
+	    CTRACE((tfp, "HTFTP: Interrupted %s.\n", msg)); \
+	    _HTProgress(CONNECTION_INTERRUPTED); \
+	    NETCLOSE(control->socket); \
+	    control->socket = -1; \
+	    return HT_INTERRUPTED; \
+	}
+
+/*	Get a valid connection to the host
+ *	----------------------------------
+ *
+ * On entry,
+ *	arg	points to the name of the host in a hypertext address
+ * On exit,
+ *	returns <0 if error
+ *		socket number if success
+ *
+ *	This routine takes care of managing timed-out connections, and
+ *	limiting the number of connections in use at any one time.
+ *
+ *	It ensures that all connections are logged in if they exist.
+ *	It ensures they have the port number transferred.
+ */
+static int get_connection(const char *arg,
+			  HTParentAnchor *anchor)
+{
+    int status;
+    char *command = 0;
+    connection *con;
+    char *username = NULL;
+    char *password = NULL;
+    static BOOLEAN firstuse = TRUE;
+
+    if (firstuse) {
+	/*
+	 * Set up freeing at exit.  - FM
+	 */
+#ifdef LY_FIND_LEAKS
+	atexit(free_FTPGlobals);
+#endif
+	firstuse = FALSE;
+    }
+
+    if (control != 0) {
+	connection *next = control->next;
+
+	if (control->socket != -1) {
+	    NETCLOSE(control->socket);
+	}
+	memset(con = control, 0, sizeof(*con));
+	con->next = next;
+    } else {
+	con = typecalloc(connection);
+	if (con == NULL)
+	    outofmem(__FILE__, "get_connection");
+    }
+    con->socket = -1;
+
+    if (isEmpty(arg)) {
+	free(con);
+	return -1;		/* Bad if no name specified     */
+    }
+
+    /* Get node name:
+     */
+    CTRACE((tfp, "get_connection(%s)\n", arg));
+    {
+	char *p1 = HTParse(arg, "", PARSE_HOST);
+	char *p2 = strrchr(p1, '@');	/* user? */
+	char *pw = NULL;
+
+	if (p2 != NULL) {
+	    username = p1;
+	    *p2 = '\0';		/* terminate */
+	    p1 = p2 + 1;	/* point to host */
+	    pw = StrChr(username, ':');
+	    if (pw != NULL) {
+		*pw++ = '\0';
+		password = HTUnEscape(pw);
+	    }
+	    if (*username)
+		HTUnEscape(username);
+
+	    /*
+	     * If the password doesn't exist then we are going to have to ask
+	     * the user for it.  The only problem is that we don't want to ask
+	     * for it every time, so we will store away in a primitive fashion.
+	     */
+	    if (!password) {
+		char *tmp = NULL;
+
+		HTSprintf0(&tmp, "%s@%s", username, p1);
+		/*
+		 * If the user@host is not equal to the last time through or
+		 * user_entered_password has no data then we need to ask the
+		 * user for the password.
+		 */
+		if (!last_username_and_host ||
+		    strcmp(tmp, last_username_and_host) ||
+		    !user_entered_password) {
+
+		    StrAllocCopy(last_username_and_host, tmp);
+		    HTSprintf0(&tmp, gettext("Enter password for user %s@%s:"),
+			       username, p1);
+		    FREE(user_entered_password);
+		    user_entered_password = HTPromptPassword(tmp, NULL);
+
+		}		/* else we already know the password */
+		password = user_entered_password;
+		FREE(tmp);
+	    }
+	}
+
+	if (!username)
+	    FREE(p1);
+    }				/* scope of p1 */
+
+    status = HTDoConnect(arg, "FTP", IPPORT_FTP, (int *) &con->socket);
+
+    if (status < 0) {
+	if (status == HT_INTERRUPTED) {
+	    CTRACE((tfp, "HTFTP: Interrupted on connect\n"));
+	} else {
+	    CTRACE((tfp, "HTFTP: Unable to connect to remote host for `%s'.\n",
+		    arg));
+	}
+	if (status == HT_INTERRUPTED) {
+	    _HTProgress(CONNECTION_INTERRUPTED);
+	    status = HT_NOT_LOADED;
+	} else {
+	    HTAlert(gettext("Unable to connect to FTP host."));
+	}
+	if (con->socket != -1) {
+	    NETCLOSE(con->socket);
+	}
+
+	FREE(username);
+	if (control == con)
+	    control = NULL;
+	FREE(con);
+	return status;		/* Bad return */
+    }
+
+    CTRACE((tfp, "FTP connected, socket %d  control %p\n",
+	    con->socket, (void *) con));
+    control = con;		/* Current control connection */
+
+    /* Initialise buffering for control connection */
+    HTInitInput(control->socket);
+    init_help_message_cache();	/* Clear the login message buffer. */
+
+    /*  Now we log in           Look up username, prompt for pw.
+     */
+    status = response(NULL);	/* Get greeting */
+    CheckForInterrupt("at beginning of login");
+
+    server_type = GENERIC_SERVER;	/* reset */
+    if (status == 2) {		/* Send username */
+	char *cp;		/* look at greeting text */
+
+	/* don't gettext() this -- incoming text: */
+	if (strlen(response_text) > 4) {
+	    if ((cp = strstr(response_text, " awaits your command")) ||
+		(cp = strstr(response_text, " ready."))) {
+		*cp = '\0';
+	    }
+	    cp = response_text + 4;
+	    if (!strncasecomp(cp, "NetPresenz", 10))
+		server_type = NETPRESENZ_SERVER;
+	} else {
+	    cp = response_text;
+	}
+	StrAllocCopy(anchor->server, cp);
+
+	status = send_cmd_2("USER", (username && *username)
+			    ? username
+			    : "anonymous");
+
+	CheckForInterrupt("while sending username");
+    }
+    if (status == 3) {		/* Send password */
+	if (non_empty(password)) {
+	    HTSprintf0(&command, "PASS %s%c%c", password, CR, LF);
+	} else {
+	    /*
+	     * No password was given; use mail-address.
+	     */
+	    const char *the_address;
+	    char *user = NULL;
+	    const char *host = NULL;
+	    char *cp;
+
+	    the_address = anonftp_password;
+	    if (isEmpty(the_address))
+		the_address = personal_mail_address;
+	    if (isEmpty(the_address))
+		the_address = LYGetEnv("USER");
+	    if (isEmpty(the_address))
+		the_address = "WWWuser";
+
+	    StrAllocCopy(user, the_address);
+	    if ((cp = StrChr(user, '@')) != NULL) {
+		*cp++ = '\0';
+		if (*cp == '\0')
+		    host = HTHostName();
+		else
+		    host = cp;
+	    } else {
+		host = HTHostName();
+	    }
+
+	    /*
+	     * If host is not fully qualified, suppress it
+	     * as ftp.uu.net prefers a blank to a bad name
+	     */
+	    if (!(host) || StrChr(host, '.') == NULL)
+		host = "";
+
+	    HTSprintf0(&command, "PASS %s@%s%c%c", user, host, CR, LF);
+	    FREE(user);
+	}
+	status = response(command);
+	FREE(command);
+	CheckForInterrupt("while sending password");
+    }
+    FREE(username);
+
+    if (status == 3) {
+	status = send_cmd_1("ACCT noaccount");
+	CheckForInterrupt("while sending password");
+    }
+    if (status != 2) {
+	CTRACE((tfp, "HTFTP: Login fail: %s", response_text));
+	/* if (control->socket > 0) close_connection(control->socket); */
+	return -1;		/* Bad return */
+    }
+    CTRACE((tfp, "HTFTP: Logged in.\n"));
+
+    /* Check for host type */
+    if (server_type != NETPRESENZ_SERVER)
+	server_type = GENERIC_SERVER;	/* reset */
+    use_list = FALSE;		/* reset */
+    if (response("SYST\r\n") == 2) {
+	/* we got a line -- what kind of server are we talking to? */
+	if (StrNCmp(response_text + 4,
+		    "UNIX Type: L8 MAC-OS MachTen", 28) == 0) {
+	    server_type = MACHTEN_SERVER;
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as MachTen server.\n"));
+
+	} else if (strstr(response_text + 4, "UNIX") != NULL ||
+		   strstr(response_text + 4, "Unix") != NULL) {
+	    server_type = UNIX_SERVER;
+	    unsure_type = FALSE;	/* to the best of out knowledge... */
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as Unix server.\n"));
+
+	} else if (strstr(response_text + 4, "MSDOS") != NULL) {
+	    server_type = MSDOS_SERVER;
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as MSDOS (Unix emulation) server.\n"));
+
+	} else if (StrNCmp(response_text + 4, "VMS", 3) == 0) {
+	    char *tilde = strstr(arg, "/~");
+
+	    use_list = TRUE;
+	    if (tilde != 0
+		&& tilde[2] != 0
+		&& strstr(response_text + 4, "MadGoat") != 0) {
+		server_type = UNIX_SERVER;
+		CTRACE((tfp, "HTFTP: Treating VMS as UNIX server.\n"));
+	    } else {
+		server_type = VMS_SERVER;
+		CTRACE((tfp, "HTFTP: Treating as VMS server.\n"));
+	    }
+
+	} else if ((StrNCmp(response_text + 4, "VM/CMS", 6) == 0) ||
+		   (StrNCmp(response_text + 4, "VM ", 3) == 0)) {
+	    server_type = CMS_SERVER;
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as CMS server.\n"));
+
+	} else if (StrNCmp(response_text + 4, "DCTS", 4) == 0) {
+	    server_type = DCTS_SERVER;
+	    CTRACE((tfp, "HTFTP: Treating as DCTS server.\n"));
+
+	} else if (strstr(response_text + 4, "MAC-OS TCP/Connect II") != NULL) {
+	    server_type = TCPC_SERVER;
+	    CTRACE((tfp, "HTFTP: Looks like a TCPC server.\n"));
+	    get_ftp_pwd(&server_type, &use_list);
+	    unsure_type = TRUE;
+
+	} else if (server_type == NETPRESENZ_SERVER) {	/* already set above */
+	    use_list = TRUE;
+	    set_mac_binary(server_type);
+	    CTRACE((tfp, "HTFTP: Treating as NetPresenz (MACOS) server.\n"));
+
+	} else if (StrNCmp(response_text + 4, "MACOS Peter's Server", 20) == 0) {
+	    server_type = PETER_LEWIS_SERVER;
+	    use_list = TRUE;
+	    set_mac_binary(server_type);
+	    CTRACE((tfp, "HTFTP: Treating as Peter Lewis (MACOS) server.\n"));
+
+	} else if (StrNCmp(response_text + 4, "Windows_NT", 10) == 0) {
+	    server_type = WINDOWS_NT_SERVER;
+	    CTRACE((tfp, "HTFTP: Treating as Window_NT server.\n"));
+	    set_unix_dirstyle(&server_type, &use_list);
+
+	} else if (StrNCmp(response_text + 4, "Windows2000", 11) == 0) {
+	    server_type = WINDOWS_2K_SERVER;
+	    CTRACE((tfp, "HTFTP: Treating as Window_2K server.\n"));
+	    set_unix_dirstyle(&server_type, &use_list);
+
+	} else if (StrNCmp(response_text + 4, "MS Windows", 10) == 0) {
+	    server_type = MS_WINDOWS_SERVER;
+	    use_list = TRUE;
+	    CTRACE((tfp, "HTFTP: Treating as MS Windows server.\n"));
+
+	} else if (StrNCmp(response_text + 4,
+			   "MACOS AppleShare IP FTP Server", 30) == 0) {
+	    server_type = APPLESHARE_SERVER;
+	    use_list = TRUE;
+	    set_mac_binary(server_type);
+	    CTRACE((tfp, "HTFTP: Treating as AppleShare server.\n"));
+
+	} else {
+	    server_type = GENERIC_SERVER;
+	    CTRACE((tfp, "HTFTP: Ugh!  A Generic server.\n"));
+	    get_ftp_pwd(&server_type, &use_list);
+	    unsure_type = TRUE;
+	}
+    } else {
+	/* SYST fails :(  try to get the type from the PWD command */
+	get_ftp_pwd(&server_type, &use_list);
+    }
+
+    return con->socket;		/* Good return */
+}
+
+static void reset_master_socket(void)
+{
+    have_socket = FALSE;
+}
+
+static void set_master_socket(int value)
+{
+    have_socket = (BOOLEAN) (value >= 0);
+    if (have_socket)
+	master_socket = (LYNX_FD) value;
+}
+
+/*	Close Master (listening) socket
+ *	-------------------------------
+ *
+ *
+ */
+static int close_master_socket(void)
+{
+    int status;
+
+    if (have_socket)
+	FD_CLR(master_socket, &open_sockets);
+
+    status = NETCLOSE((int) master_socket);
+    CTRACE((tfp, "HTFTP: Closed master socket %u\n", (unsigned) master_socket));
+
+    reset_master_socket();
+
+    if (status < 0)
+	return HTInetStatus(gettext("close master socket"));
+    else
+	return status;
+}
+
+/*	Open a master socket for listening on
+ *	-------------------------------------
+ *
+ *	When data is transferred, we open a port, and wait for the server to
+ *	connect with the data.
+ *
+ * On entry,
+ *	have_socket	Must be false, if master_socket is not setup already
+ *	master_socket	Must be negative if not set up already.
+ * On exit,
+ *	Returns		socket number if good
+ *			less than zero if error.
+ *	master_socket	is socket number if good, else negative.
+ *	port_number	is valid if good.
+ */
+static int get_listen_socket(void)
+{
+    LY_SOCKADDR soc_A;
+
+#ifdef INET6
+    unsigned short af;
+    LY_SOCKLEN slen;
+#endif /* INET6 */
+    int new_socket;		/* Will be master_socket */
+
+    FD_ZERO(&open_sockets);	/* Clear our record of open sockets */
+    num_sockets = 0;
+
+    FREE(port_command);
+#ifndef REPEAT_LISTEN
+    if (have_socket)
+	return master_socket;	/* Done already */
+#endif /* !REPEAT_LISTEN */
+
+#ifdef INET6
+    /* query address family of control connection */
+    memset(&soc_A, 0, sizeof(soc_A));
+    slen = (LY_SOCKLEN) sizeof(soc_A);
+    if (getsockname(control->socket, SOCKADDR_OF(soc_A), &slen) < 0) {
+	return HTInetStatus("getsockname failed");
+    }
+    af = SOCKADDR_OF(soc_A)->sa_family;
+#endif /* INET6 */
+
+/*  Create internet socket
+*/
+#ifdef INET6
+    new_socket = socket(af, SOCK_STREAM, IPPROTO_TCP);
+#else
+    new_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+#endif /* INET6 */
+
+    if (new_socket < 0)
+	return HTInetStatus(gettext("socket for master socket"));
+
+    CTRACE((tfp, "HTFTP: Opened master socket number %d\n", new_socket));
+
+/*  Search for a free port.
+*/
+#ifdef INET6
+    memset(&soc_A, 0, sizeof(soc_A));
+    SOCKADDR_OF(soc_A)->sa_family = (unsigned short) af;
+    switch (af) {
+    case AF_INET:
+#ifdef SIN6_LEN
+	SOCKADDR_OF(soc_A)->sa_len = sizeof(struct sockaddr_in);
+#endif /* SIN6_LEN */
+	break;
+    case AF_INET6:
+#ifdef SIN6_LEN
+	SOCKADDR_OF(soc_A)->sa_len = sizeof(struct sockaddr_in6);
+#endif /* SIN6_LEN */
+	break;
+    default:
+	HTInetStatus("AF");
+    }
+#else
+    soc_A.soc_in.sin_family = AF_INET;	/* Family = internet, host order  */
+    soc_A.soc_in.sin_addr.s_addr = INADDR_ANY;	/* Any peer address */
+#endif /* INET6 */
+#ifdef POLL_PORTS
+    {
+	PortNumber old_port_number = port_number;
+
+	for (port_number = (old_port_number + 1);; port_number++) {
+	    int status;
+
+	    if (port_number > LAST_TCP_PORT)
+		port_number = FIRST_TCP_PORT;
+	    if (port_number == old_port_number) {
+		return HTInetStatus("bind");
+	    }
+#ifdef INET6
+	    soc_A.soc_in.sin_port = htons(port_number);
+#else
+	    soc_A.sin_port = htons(port_number);
+#endif /* INET6 */
+#ifdef SOCKS
+	    if (socks_flag)
+		if ((status = Rbind(new_socket,
+				    SOCKADDR_OF(soc_A),
+				    SOCKADDR_LEN(soc_A))) == 0) {
+		    break;
+		} else
+#endif /* SOCKS */
+		    if ((status = bind(new_socket,
+				       SOCKADDR_OF(soc_A),
+				       SOCKADDR_LEN(soc_A)
+			 )) == 0) {
+		    break;
+		}
+	    CTRACE((tfp, "TCP bind attempt to port %d yields %d, errno=%d\n",
+		    port_number, status, SOCKET_ERRNO));
+	}			/* for */
+    }
+#else
+    {
+	int status;
+	LY_SOCKLEN address_length = (LY_SOCKLEN) sizeof(soc_A);
+
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Rgetsockname(control->socket,
+				  SOCKADDR_OF(soc_A),
+				  &address_length);
+	else
+#endif /* SOCKS */
+	    status = getsockname(control->socket,
+				 SOCKADDR_OF(soc_A),
+				 &address_length);
+	if (status < 0) {
+	    close(new_socket);
+	    return HTInetStatus("getsockname");
+	}
+	CTRACE((tfp, "HTFTP: This host is %s\n",
+		HTInetString((void *) &soc_A.soc_in)));
+
+	soc_A.soc_in.sin_port = 0;	/* Unspecified: please allocate */
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Rbind(new_socket,
+			   SOCKADDR_OF(soc_A),
+			   sizeof(soc_A));
+	else
+#endif /* SOCKS */
+	    status = bind(new_socket,
+			  SOCKADDR_OF(soc_A),
+			  SOCKADDR_LEN(soc_A));
+	if (status < 0) {
+	    close(new_socket);
+	    return HTInetStatus("bind");
+	}
+
+	address_length = sizeof(soc_A);
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Rgetsockname(new_socket,
+				  SOCKADDR_OF(soc_A),
+				  &address_length);
+	else
+#endif /* SOCKS */
+	    status = getsockname(new_socket,
+				 SOCKADDR_OF(soc_A),
+				 &address_length);
+	if (status < 0) {
+	    close(new_socket);
+	    return HTInetStatus("getsockname");
+	}
+    }
+#endif /* POLL_PORTS */
+
+    CTRACE((tfp, "HTFTP: bound to port %d on %s\n",
+	    (int) ntohs(soc_A.soc_in.sin_port),
+	    HTInetString((void *) &soc_A.soc_in)));
+
+#ifdef REPEAT_LISTEN
+    if (have_socket)
+	(void) close_master_socket();
+#endif /* REPEAT_LISTEN */
+
+    set_master_socket(new_socket);
+
+/*	Now we must find out who we are to tell the other guy
+*/
+    (void) HTHostName();	/* Make address valid - doesn't work */
+#ifdef INET6
+    switch (SOCKADDR_OF(soc_A)->sa_family) {
+    case AF_INET:
+#endif /* INET6 */
+	HTSprintf0(&port_command, "PORT %d,%d,%d,%d,%d,%d%c%c",
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_addr) + 0),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_addr) + 1),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_addr) + 2),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_addr) + 3),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_port) + 0),
+		   (int) *((unsigned char *) (&soc_A.soc_in.sin_port) + 1),
+		   CR, LF);
+
+#ifdef INET6
+	break;
+
+    case AF_INET6:
+	{
+	    char hostbuf[MAXHOSTNAMELEN];
+	    char portbuf[MAXHOSTNAMELEN];
+
+	    getnameinfo(SOCKADDR_OF(soc_A),
+			SOCKADDR_LEN(soc_A),
+			hostbuf,
+			(socklen_t) sizeof(hostbuf),
+			portbuf,
+			(socklen_t) sizeof(portbuf),
+			NI_NUMERICHOST | NI_NUMERICSERV);
+	    HTSprintf0(&port_command, "EPRT |%d|%s|%s|%c%c", 2, hostbuf, portbuf,
+		       CR, LF);
+	    break;
+	}
+    default:
+	HTSprintf0(&port_command, "JUNK%c%c", CR, LF);
+	break;
+    }
+#endif /* INET6 */
+    if (port_command == NULL)
+	return -1;
+
+    /*  Inform TCP that we will accept connections
+     */
+    {
+	int status;
+
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Rlisten((int) master_socket, 1);
+	else
+#endif /* SOCKS */
+	    status = listen((int) master_socket, 1);
+	if (status < 0) {
+	    reset_master_socket();
+	    return HTInetStatus("listen");
+	}
+    }
+    CTRACE((tfp, "TCP: Master socket(), bind() and listen() all OK\n"));
+    FD_SET(master_socket, &open_sockets);
+    if ((master_socket + 1) > num_sockets)
+	num_sockets = master_socket + 1;
+
+    return (int) master_socket;	/* Good */
+
+}				/* get_listen_socket */
+
+static const char *months[12] =
+{
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+
+/*	Procedure: Set the current and last year strings and date integer
+ *	-----------------------------------------------------------------
+ *
+ *	Bug:
+ *		This code is for sorting listings by date, if that option
+ *		is selected in Lynx, and doesn't take into account time
+ *		zones or ensure resetting at midnight, so the sort may not
+ *		be perfect, but the actual date isn't changed in the display,
+ *		i.e., the date is still correct. - FM
+ */
+static void set_years_and_date(void)
+{
+    char day[8], month[8], date[12];
+    time_t NowTime;
+    int i;
+    char *printable;
+
+    NowTime = time(NULL);
+    printable = ctime(&NowTime);
+    LYStrNCpy(day, printable + 8, 2);
+    if (day[0] == ' ') {
+	day[0] = '0';
+    }
+    LYStrNCpy(month, printable + 4, 3);
+    for (i = 0; i < 12; i++) {
+	if (!strcasecomp(month, months[i])) {
+	    break;
+	}
+    }
+    i++;
+    sprintf(date, "9999%02d%.2s", i % 100, day);
+    TheDate = atoi(date);
+    LYStrNCpy(ThisYear, printable + 20, 4);
+    sprintf(LastYear, "%d", (atoi(ThisYear) - 1) % 10000);
+    HaveYears = TRUE;
+}
+
+typedef struct _EntryInfo {
+    char *filename;
+    char *linkname;		/* symbolic link, if any */
+    char *type;
+    char *date;
+    off_t size;
+    BOOLEAN display;		/* show this entry? */
+#ifdef LONG_LIST
+    unsigned long file_links;
+    char *file_mode;
+    char *file_user;
+    char *file_group;
+#endif
+} EntryInfo;
+
+static void free_entryinfo_struct_contents(EntryInfo *entry_info)
+{
+    if (entry_info) {
+#ifdef LONG_LIST
+	FREE(entry_info->file_mode);
+	FREE(entry_info->file_user);
+	FREE(entry_info->file_group);
+#endif
+	FREE(entry_info->filename);
+	FREE(entry_info->linkname);
+	FREE(entry_info->type);
+	FREE(entry_info->date);
+    }
+    /* don't free the struct */
+}
+
+/*
+ * is_ls_date() --
+ *	Return TRUE if s points to a string of the form:
+ *		"Sep  1  1990 " or
+ *		"Sep 11 11:59 " or
+ *		"Dec 12 1989  " or
+ *		"FCv 23 1990  " ...
+ */
+static BOOLEAN is_ls_date(char *s)
+{
+    /* must start with three alpha characters */
+    if (!isalpha(UCH(*s++)) || !isalpha(UCH(*s++)) || !isalpha(UCH(*s++)))
+	return FALSE;
+
+    /* space or HT_NON_BREAK_SPACE */
+    if (!(*s == ' ' || *s == HT_NON_BREAK_SPACE)) {
+	return FALSE;
+    }
+    s++;
+
+    /* space or digit */
+    if (!(*s == ' ' || isdigit(UCH(*s)))) {
+	return FALSE;
+    }
+    s++;
+
+    /* digit */
+    if (!isdigit(UCH(*s++)))
+	return FALSE;
+
+    /* space */
+    if (*s++ != ' ')
+	return FALSE;
+
+    /* space or digit */
+    if (!(*s == ' ' || isdigit(UCH(*s)))) {
+	return FALSE;
+    }
+    s++;
+
+    /* digit */
+    if (!isdigit(UCH(*s++)))
+	return FALSE;
+
+    /* colon or digit */
+    if (!(*s == ':' || isdigit(UCH(*s)))) {
+	return FALSE;
+    }
+    s++;
+
+    /* digit */
+    if (!isdigit(UCH(*s++)))
+	return FALSE;
+
+    /* space or digit */
+    if (!(*s == ' ' || isdigit(UCH(*s)))) {
+	return FALSE;
+    }
+    s++;
+
+    /* space */
+    if (*s != ' ')
+	return FALSE;
+
+    return TRUE;
+}				/* is_ls_date() */
+
+/*
+ * Extract the name, size, and date from an EPLF line.  - 08-06-96 DJB
+ */
+static void parse_eplf_line(char *line,
+			    EntryInfo *info)
+{
+    char *cp = line;
+    char ct[26];
+    off_t size;
+    time_t secs;
+    static time_t base;		/* time() value on this OS in 1970 */
+    static int flagbase = 0;
+
+    if (!flagbase) {
+	struct tm t;
+
+	t.tm_year = 70;
+	t.tm_mon = 0;
+	t.tm_mday = 0;
+	t.tm_hour = 0;
+	t.tm_min = 0;
+	t.tm_sec = 0;
+	t.tm_isdst = -1;
+	base = mktime(&t);	/* could return -1 */
+	flagbase = 1;
+    }
+
+    while (*cp) {
+	switch (*cp) {
+	case '\t':
+	    StrAllocCopy(info->filename, cp + 1);
+	    return;
+	case 's':
+	    size = 0;
+	    while (*(++cp) && (*cp != ','))
+		size = (size * 10) + (off_t) (*cp - '0');
+	    info->size = size;
+	    break;
+	case 'm':
+	    secs = 0;
+	    while (*(++cp) && (*cp != ','))
+		secs = (secs * 10) + (*cp - '0');
+	    secs += base;	/* assumes that time_t is #seconds */
+	    LYStrNCpy(ct, ctime(&secs), 24);
+	    StrAllocCopy(info->date, ct);
+	    break;
+	case '/':
+	    StrAllocCopy(info->type, ENTRY_IS_DIRECTORY);
+	    /* FALLTHRU */
+	default:
+	    while (*cp) {
+		if (*cp++ == ',')
+		    break;
+	    }
+	    break;
+	}
+    }
+}				/* parse_eplf_line */
+
+/*
+ * Extract the name, size, and date from an ls -l line.
+ */
+static void parse_ls_line(char *line,
+			  EntryInfo *entry)
+{
+#ifdef LONG_LIST
+    char *next;
+    char *cp;
+#endif
+    int i, j;
+    off_t base = 1;
+    off_t size_num = 0;
+
+    for (i = (int) strlen(line) - 1;
+	 (i > 13) && (!isspace(UCH(line[i])) || !is_ls_date(&line[i - 12]));
+	 i--) {
+	;			/* null body */
+    }
+    line[i] = '\0';
+    if (i > 13) {
+	StrAllocCopy(entry->date, &line[i - 12]);
+	/* replace the 4th location with nbsp if it is a space or zero */
+	if (entry->date[4] == ' ' || entry->date[4] == '0')
+	    entry->date[4] = HT_NON_BREAK_SPACE;
+	/* make sure year or time is flush right */
+	if (entry->date[11] == ' ') {
+	    for (j = 11; j > 6; j--) {
+		entry->date[j] = entry->date[j - 1];
+	    }
+	}
+    }
+    j = i - 14;
+    while (isdigit(UCH(line[j]))) {
+	size_num += ((off_t) (line[j] - '0') * base);
+	base *= 10;
+	j--;
+    }
+    entry->size = size_num;
+    StrAllocCopy(entry->filename, &line[i + 1]);
+
+#ifdef LONG_LIST
+    line[j] = '\0';
+
+    /*
+     * Extract the file-permissions, as a string.
+     */
+    if ((cp = StrChr(line, ' ')) != 0) {
+	if ((cp - line) == 10) {
+	    *cp = '\0';
+	    StrAllocCopy(entry->file_mode, line);
+	    *cp = ' ';
+	}
+
+	/*
+	 * Next is the link-count.
+	 */
+	next = 0;
+	entry->file_links = (unsigned long) strtol(cp, &next, 10);
+	if (next == 0 || *next != ' ') {
+	    entry->file_links = 0;
+	    next = cp;
+	} else {
+	    cp = next;
+	}
+	/*
+	 * Next is the user-name.
+	 */
+	while (isspace(UCH(*cp)))
+	    ++cp;
+	if ((next = StrChr(cp, ' ')) != 0)
+	    *next = '\0';
+	if (*cp != '\0')
+	    StrAllocCopy(entry->file_user, cp);
+	/*
+	 * Next is the group-name (perhaps).
+	 */
+	if (next != NULL) {
+	    cp = (next + 1);
+	    while (isspace(UCH(*cp)))
+		++cp;
+	    if ((next = StrChr(cp, ' ')) != 0)
+		*next = '\0';
+	    if (*cp != '\0')
+		StrAllocCopy(entry->file_group, cp);
+	}
+    }
+#endif
+}
+
+/*
+ * Extract the name and size info and whether it refers to a directory from a
+ * LIST line in "dls" format.
+ */
+static void parse_dls_line(char *line,
+			   EntryInfo *entry_info,
+			   char **pspilledname)
+{
+    short j;
+    int base = 1;
+    off_t size_num = 0;
+    int len;
+    char *cps = NULL;
+
+    /* README              763  Information about this server\0
+       bin/                  -  \0
+       etc/                  =  \0
+       ls-lR                 0  \0
+       ls-lR.Z               3  \0
+       pub/                  =  Public area\0
+       usr/                  -  \0
+       morgan               14  -> ../real/morgan\0
+       TIMIT.mostlikely.Z\0
+       79215    \0
+     */
+
+    len = (int) strlen(line);
+    if (len == 0) {
+	FREE(*pspilledname);
+	entry_info->display = FALSE;
+	return;
+    }
+    cps = LYSkipNonBlanks(line);
+    if (*cps == '\0') {		/* only a filename, save it and return. */
+	StrAllocCopy(*pspilledname, line);
+	entry_info->display = FALSE;
+	return;
+    }
+    if (len < 24 || line[23] != ' ' ||
+	(isspace(UCH(line[0])) && !*pspilledname)) {
+	/* this isn't the expected "dls" format! */
+	if (!isspace(UCH(line[0])))
+	    *cps = '\0';
+	if (*pspilledname && !*line) {
+	    entry_info->filename = *pspilledname;
+	    *pspilledname = NULL;
+	    if (entry_info->filename[strlen(entry_info->filename) - 1] == '/')
+		StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    else
+		StrAllocCopy(entry_info->type, "");
+	} else {
+	    StrAllocCopy(entry_info->filename, line);
+	    if (cps != line && *(cps - 1) == '/')
+		StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    else
+		StrAllocCopy(entry_info->type, "");
+	    FREE(*pspilledname);
+	}
+	return;
+    }
+
+    j = 22;
+    if (line[j] == '=' || line[j] == '-') {
+	StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+    } else {
+	while (isdigit(UCH(line[j]))) {
+	    size_num += (line[j] - '0') * base;
+	    base *= 10;
+	    j--;
+	}
+    }
+    entry_info->size = size_num;
+
+    cps = LYSkipBlanks(&line[23]);
+    if (!StrNCmp(cps, "-> ", 3) && cps[3] != '\0' && cps[3] != ' ') {
+	StrAllocCopy(entry_info->type, ENTRY_IS_SYMBOLIC_LINK);
+	StrAllocCopy(entry_info->linkname, LYSkipBlanks(cps + 3));
+	entry_info->size = 0;	/* don't display size */
+    }
+
+    if (j > 0)
+	line[j] = '\0';
+
+    LYTrimTrailing(line);
+
+    len = (int) strlen(line);
+    if (len == 0 && *pspilledname && **pspilledname) {
+	line = *pspilledname;
+	len = (int) strlen(*pspilledname);
+    }
+    if (len > 0 && line[len - 1] == '/') {
+	/*
+	 * It's a dir, remove / and mark it as such.
+	 */
+	if (len > 1)
+	    line[len - 1] = '\0';
+	if (!entry_info->type)
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+    }
+
+    StrAllocCopy(entry_info->filename, line);
+    FREE(*pspilledname);
+}				/* parse_dls_line() */
+
+/*
+ * parse_vms_dir_entry()
+ *	Format the name, date, and size from a VMS LIST line
+ *	into the EntryInfo structure - FM
+ */
+static void parse_vms_dir_entry(char *line,
+				EntryInfo *entry_info)
+{
+    int i, j;
+    off_t ialloc;
+    char *cp, *cpd, *cps, date[16];
+    const char *sp = " ";
+
+    /* Get rid of blank lines, and information lines.  Valid lines have the ';'
+     * version number token.
+     */
+    if (!strlen(line) || (cp = StrChr(line, ';')) == NULL) {
+	entry_info->display = FALSE;
+	return;
+    }
+
+    /* Cut out file or directory name at VMS version number. */
+    *cp++ = '\0';
+    StrAllocCopy(entry_info->filename, line);
+
+    /* Cast VMS non-README file and directory names to lowercase. */
+    if (strstr(entry_info->filename, "READ") == NULL) {
+	LYLowerCase(entry_info->filename);
+	i = (int) strlen(entry_info->filename);
+    } else {
+	i = (int) ((strstr(entry_info->filename, "READ")
+		    - entry_info->filename)
+		   + 4);
+	if (!StrNCmp(&entry_info->filename[i], "ME", 2)) {
+	    i += 2;
+	    while (entry_info->filename[i] && entry_info->filename[i] != '.') {
+		i++;
+	    }
+	} else if (!StrNCmp(&entry_info->filename[i], ".ME", 3)) {
+	    i = (int) strlen(entry_info->filename);
+	} else {
+	    i = 0;
+	}
+	LYLowerCase(entry_info->filename + i);
+    }
+
+    /* Uppercase terminal .z's or _z's. */
+    if ((--i > 2) &&
+	entry_info->filename[i] == 'z' &&
+	(entry_info->filename[i - 1] == '.' ||
+	 entry_info->filename[i - 1] == '_'))
+	entry_info->filename[i] = 'Z';
+
+    /* Convert any tabs in rest of line to spaces. */
+    cps = cp - 1;
+    while ((cps = StrChr(cps + 1, '\t')) != NULL)
+	*cps = ' ';
+
+    /* Collapse serial spaces. */
+    i = 0;
+    j = 1;
+    cps = cp;
+    while (cps[j] != '\0') {
+	if (cps[i] == ' ' && cps[j] == ' ')
+	    j++;
+	else
+	    cps[++i] = cps[j++];
+    }
+    cps[++i] = '\0';
+
+    /* Set the years and date, if we don't have them yet. * */
+    if (!HaveYears) {
+	set_years_and_date();
+    }
+
+    /* Track down the date. */
+    if ((cpd = StrChr(cp, '-')) != NULL &&
+	strlen(cpd) > 9 && isdigit(UCH(*(cpd - 1))) &&
+	isalpha(UCH(*(cpd + 1))) && *(cpd + 4) == '-') {
+
+	/* Month */
+	*(cpd + 2) = (char) TOLOWER(*(cpd + 2));
+	*(cpd + 3) = (char) TOLOWER(*(cpd + 3));
+	sprintf(date, "%.3s ", cpd + 1);
+
+	/* Day */
+	if (isdigit(UCH(*(cpd - 2))))
+	    sprintf(date + 4, "%.2s ", cpd - 2);
+	else
+	    sprintf(date + 4, "%c%.1s ", HT_NON_BREAK_SPACE, cpd - 1);
+
+	/* Time or Year */
+	if (!StrNCmp(ThisYear, cpd + 5, 4) &&
+	    strlen(cpd) > 15 && *(cpd + 12) == ':') {
+	    sprintf(date + 7, "%.5s", cpd + 10);
+	} else {
+	    sprintf(date + 7, " %.4s", cpd + 5);
+	}
+
+	StrAllocCopy(entry_info->date, date);
+    }
+
+    /* Track down the size */
+    if ((cpd = StrChr(cp, '/')) != NULL) {
+	/* Appears be in used/allocated format */
+	cps = cpd;
+	while (isdigit(UCH(*(cps - 1))))
+	    cps--;
+	if (cps < cpd)
+	    *cpd = '\0';
+	entry_info->size = LYatoll(cps);
+	cps = cpd + 1;
+	while (isdigit(UCH(*cps)))
+	    cps++;
+	*cps = '\0';
+	ialloc = LYatoll(cpd + 1);
+	/* Check if used is in blocks or bytes */
+	if (entry_info->size <= ialloc)
+	    entry_info->size *= 512;
+
+    } else if (strtok(cp, sp) != NULL) {
+	/* We just initialized on the version number */
+	/* Now let's hunt for a lone, size number    */
+	while ((cps = strtok(NULL, sp)) != NULL) {
+	    cpd = cps;
+	    while (isdigit(UCH(*cpd)))
+		cpd++;
+	    if (*cpd == '\0') {
+		/* Assume it's blocks */
+		entry_info->size = (LYatoll(cps) * 512);
+		break;
+	    }
+	}
+    }
+
+    TRACE_ENTRY("VMS", entry_info);
+    return;
+}				/* parse_vms_dir_entry() */
+
+/*
+ * parse_ms_windows_dir_entry() --
+ *	Format the name, date, and size from an MS_WINDOWS LIST line into
+ *	the EntryInfo structure (assumes Chameleon NEWT format). - FM
+ */
+static void parse_ms_windows_dir_entry(char *line,
+				       EntryInfo *entry_info)
+{
+    char *cp = line;
+    char *cps, *cpd, date[16];
+    char *end = line + strlen(line);
+
+    /*  Get rid of blank or junk lines.  */
+    cp = LYSkipBlanks(cp);
+    if (!(*cp)) {
+	entry_info->display = FALSE;
+	return;
+    }
+
+    /* Cut out file or directory name. */
+    cps = LYSkipNonBlanks(cp);
+    *cps++ = '\0';
+    cpd = cps;
+    StrAllocCopy(entry_info->filename, cp);
+
+    /* Track down the size */
+    if (cps < end) {
+	cps = LYSkipBlanks(cps);
+	cpd = LYSkipNonBlanks(cps);
+	*cpd++ = '\0';
+	if (isdigit(UCH(*cps))) {
+	    entry_info->size = LYatoll(cps);
+	} else {
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	}
+    } else {
+	StrAllocCopy(entry_info->type, "");
+    }
+
+    /* Set the years and date, if we don't have them yet. * */
+    if (!HaveYears) {
+	set_years_and_date();
+    }
+
+    /* Track down the date. */
+    if (cpd < end) {
+	cpd = LYSkipBlanks(cpd);
+	if (strlen(cpd) > 17) {
+	    *(cpd + 6) = '\0';	/* Month and Day */
+	    *(cpd + 11) = '\0';	/* Year */
+	    *(cpd + 17) = '\0';	/* Time */
+	    if (strcmp(ThisYear, cpd + 7))
+		/* Not this year, so show the year */
+		sprintf(date, "%.6s  %.4s", cpd, (cpd + 7));
+	    else
+		/* Is this year, so show the time */
+		sprintf(date, "%.6s %.5s", cpd, (cpd + 12));
+	    StrAllocCopy(entry_info->date, date);
+	    if (entry_info->date[4] == ' ' || entry_info->date[4] == '0') {
+		entry_info->date[4] = HT_NON_BREAK_SPACE;
+	    }
+	}
+    }
+
+    TRACE_ENTRY("MS Windows", entry_info);
+    return;
+}				/* parse_ms_windows_dir_entry */
+
+/*
+ * parse_windows_nt_dir_entry() --
+ *	Format the name, date, and size from a WINDOWS_NT LIST line into
+ *	the EntryInfo structure (assumes Chameleon NEWT format). - FM
+ */
+#ifdef NOTDEFINED
+static void parse_windows_nt_dir_entry(char *line,
+				       EntryInfo *entry_info)
+{
+    char *cp = line;
+    char *cps, *cpd, date[16];
+    char *end = line + strlen(line);
+    int i;
+
+    /*  Get rid of blank or junk lines.  */
+    cp = LYSkipBlanks(cp);
+    if (!(*cp)) {
+	entry_info->display = FALSE;
+	return;
+    }
+
+    /* Cut out file or directory name. */
+    cpd = cp;
+    cps = LYSkipNonBlanks(end - 1);
+    cp = (cps + 1);
+    if (!strcmp(cp, ".") || !strcmp(cp, "..")) {
+	entry_info->display = FALSE;
+	return;
+    }
+    StrAllocCopy(entry_info->filename, cp);
+    if (cps < cpd)
+	return;
+    *cp = '\0';
+    end = cp;
+
+    /* Set the years and date, if we don't have them yet. * */
+    if (!HaveYears) {
+	set_years_and_date();
+    }
+
+    /* Cut out the date. */
+    cp = cps = cpd;
+    cps = LYSkipNonBlanks(cps);
+    *cps++ = '\0';
+    if (cps > end) {
+	entry_info->display = FALSE;
+	return;
+    }
+    cps = LYSkipBlanks(cps);
+    cpd = LYSkipNonBlanks(cps);
+    *cps++ = '\0';
+    if (cps > end || cpd == cps || strlen(cpd) < 7) {
+	entry_info->display = FALSE;
+	return;
+    }
+    if (strlen(cp) == 8 &&
+	isdigit(*cp) && isdigit(*(cp + 1)) && *(cp + 2) == '-' &&
+	isdigit(*(cp + 3)) && isdigit(*(cp + 4)) && *(cp + 5) == '-') {
+	*(cp + 2) = '\0';	/* Month */
+	i = atoi(cp) - 1;
+	*(cp + 5) = '\0';	/* Day */
+	sprintf(date, "%.3s %.2s", months[i], (cp + 3));
+	if (date[4] == '0')
+	    date[4] = ' ';
+	cp += 6;		/* Year */
+	if (strcmp((ThisYear + 2), cp)) {
+	    /* Not this year, so show the year */
+	    if (atoi(cp) < 70) {
+		sprintf(&date[6], "  20%.2s", cp);
+	    } else {
+		sprintf(&date[6], "  19%.2s", cp);
+	    }
+	} else {
+	    /* Is this year, so show the time */
+	    *(cpd + 2) = '\0';	/* Hour */
+	    i = atoi(cpd);
+	    if (*(cpd + 5) == 'P' || *(cpd + 5) == 'p')
+		i += 12;
+	    sprintf(&date[6], " %02d:%.2s", i, (cpd + 3));
+	}
+	StrAllocCopy(entry_info->date, date);
+	if (entry_info->date[4] == ' ' || entry_info->date[4] == '0') {
+	    entry_info->date[4] = HT_NON_BREAK_SPACE;
+	}
+    }
+
+    /* Track down the size */
+    if (cps < end) {
+	cps = LYSkipBlanks(cps);
+	cpd = LYSkipNonBlanks(cps);
+	*cpd = '\0';
+	if (isdigit(*cps)) {
+	    entry_info->size = LYatoll(cps);
+	} else {
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	}
+    } else {
+	StrAllocCopy(entry_info->type, "");
+    }
+
+    /* Wrap it up */
+    CTRACE((tfp, "HTFTP: Windows NT filename: %s  date: %s  size: %d\n",
+	    entry_info->filename,
+	    NonNull(entry_info->date),
+	    entry_info->size));
+    return;
+}				/* parse_windows_nt_dir_entry */
+#endif /* NOTDEFINED */
+
+/*
+ * parse_cms_dir_entry() --
+ *	Format the name, date, and size from a VM/CMS line into
+ *	the EntryInfo structure. - FM
+ */
+static void parse_cms_dir_entry(char *line,
+				EntryInfo *entry_info)
+{
+    char *cp = line;
+    char *cps, *cpd, date[16];
+    char *end = line + strlen(line);
+    int RecordLength = 0;
+    int Records = 0;
+    int i;
+
+    /*  Get rid of blank or junk lines.  */
+    cp = LYSkipBlanks(cp);
+    if (!(*cp)) {
+	entry_info->display = FALSE;
+	return;
+    }
+
+    /* Cut out file or directory name. */
+    cps = LYSkipNonBlanks(cp);
+    *cps++ = '\0';
+    StrAllocCopy(entry_info->filename, cp);
+    if (StrChr(entry_info->filename, '.') != NULL)
+	/* If we already have a dot, we did an NLST. */
+	return;
+    cp = LYSkipBlanks(cps);
+    if (!(*cp)) {
+	/* If we don't have more, we've misparsed. */
+	FREE(entry_info->filename);
+	FREE(entry_info->type);
+	entry_info->display = FALSE;
+	return;
+    }
+    cps = LYSkipNonBlanks(cp);
+    *cps++ = '\0';
+    if ((0 == strcasecomp(cp, "DIR")) && (cp - line) > 17) {
+	/* It's an SFS directory. */
+	StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	entry_info->size = 0;
+    } else {
+	/* It's a file. */
+	cp--;
+	*cp = '.';
+	StrAllocCat(entry_info->filename, cp);
+
+	/* Track down the VM/CMS RECFM or type. */
+	cp = cps;
+	if (cp < end) {
+	    cp = LYSkipBlanks(cp);
+	    cps = LYSkipNonBlanks(cp);
+	    *cps++ = '\0';
+	    /* Check cp here, if it's relevant someday. */
+	}
+    }
+
+    /* Track down the record length or dash. */
+    cp = cps;
+    if (cp < end) {
+	cp = LYSkipBlanks(cp);
+	cps = LYSkipNonBlanks(cp);
+	*cps++ = '\0';
+	if (isdigit(UCH(*cp))) {
+	    RecordLength = atoi(cp);
+	}
+    }
+
+    /* Track down the number of records or the dash. */
+    cp = cps;
+    if (cps < end) {
+	cp = LYSkipBlanks(cp);
+	cps = LYSkipNonBlanks(cp);
+	*cps++ = '\0';
+	if (isdigit(UCH(*cp))) {
+	    Records = atoi(cp);
+	}
+	if (Records > 0 && RecordLength > 0) {
+	    /* Compute an approximate size. */
+	    entry_info->size = ((off_t) Records * (off_t) RecordLength);
+	}
+    }
+
+    /* Set the years and date, if we don't have them yet. */
+    if (!HaveYears) {
+	set_years_and_date();
+    }
+
+    /* Track down the date. */
+    cpd = cps;
+    if (((cps < end) &&
+	 (cps = StrChr(cpd, ':')) != NULL) &&
+	(cps < (end - 3) &&
+	 isdigit(UCH(*(cps + 1))) && isdigit(UCH(*(cps + 2))) && *(cps + 3) == ':')) {
+	cps += 3;
+	*cps = '\0';
+	if ((cps - cpd) >= 14) {
+	    cpd = (cps - 14);
+	    *(cpd + 2) = '\0';	/* Month */
+	    *(cpd + 5) = '\0';	/* Day */
+	    *(cpd + 8) = '\0';	/* Year */
+	    cps -= 5;		/* Time */
+	    if (*cpd == ' ')
+		*cpd = '0';
+	    i = atoi(cpd) - 1;
+	    sprintf(date, "%.3s %.2s", months[i], (cpd + 3));
+	    if (date[4] == '0')
+		date[4] = ' ';
+	    cpd += 6;		/* Year */
+	    if (strcmp((ThisYear + 2), cpd)) {
+		/* Not this year, so show the year. */
+		if (atoi(cpd) < 70) {
+		    sprintf(&date[6], "  20%.2s", cpd);
+		} else {
+		    sprintf(&date[6], "  19%.2s", cpd);
+		}
+	    } else {
+		/* Is this year, so show the time. */
+		*(cps + 2) = '\0';	/* Hour */
+		i = atoi(cps);
+		sprintf(&date[6], " %02d:%.2s", i, (cps + 3));
+	    }
+	    StrAllocCopy(entry_info->date, date);
+	    if (entry_info->date[4] == ' ' || entry_info->date[4] == '0') {
+		entry_info->date[4] = HT_NON_BREAK_SPACE;
+	    }
+	}
+    }
+
+    TRACE_ENTRY("VM/CMS", entry_info);
+    return;
+}				/* parse_cms_dir_entry */
+
+/*
+ * Given a line of LIST/NLST output in entry, return results and a file/dir
+ * name in entry_info struct
+ *
+ * If first is true, this is the first name in a directory.
+ */
+static EntryInfo *parse_dir_entry(char *entry,
+				  BOOLEAN *first,
+				  char **pspilledname)
+{
+    EntryInfo *entry_info;
+    int i;
+    int len;
+    BOOLEAN remove_size = FALSE;
+    char *cp;
+
+    entry_info = typecalloc(EntryInfo);
+
+    if (entry_info == NULL)
+	outofmem(__FILE__, "parse_dir_entry");
+
+    entry_info->display = TRUE;
+
+    switch (server_type) {
+    case DLS_SERVER:
+
+	/*
+	 * Interpret and edit LIST output from a Unix server in "dls" format. 
+	 * This one must have claimed to be Unix in order to get here; if the
+	 * first line looks fishy, we revert to Unix and hope that fits better
+	 * (this recovery is untested).  - kw
+	 */
+
+	if (*first) {
+	    len = (int) strlen(entry);
+	    if (!len || entry[0] == ' ' ||
+		(len >= 24 && entry[23] != ' ') ||
+		(len < 24 && StrChr(entry, ' '))) {
+		server_type = UNIX_SERVER;
+		CTRACE((tfp,
+			"HTFTP: Falling back to treating as Unix server.\n"));
+	    } else {
+		*first = FALSE;
+	    }
+	}
+
+	if (server_type == DLS_SERVER) {
+	    /* if still unchanged... */
+	    parse_dls_line(entry, entry_info, pspilledname);
+
+	    if (isEmpty(entry_info->filename)) {
+		entry_info->display = FALSE;
+		return (entry_info);
+	    }
+	    if (!strcmp(entry_info->filename, "..") ||
+		!strcmp(entry_info->filename, "."))
+		entry_info->display = FALSE;
+	    if (entry_info->type && *entry_info->type == '\0') {
+		FREE(entry_info->type);
+		return (entry_info);
+	    }
+	    /*
+	     * Goto the bottom and get real type.
+	     */
+	    break;
+	}
+	/* fall through if server_type changed for *first == TRUE ! */
+	/* FALLTHRU */
+    case UNIX_SERVER:
+    case PETER_LEWIS_SERVER:
+    case MACHTEN_SERVER:
+    case MSDOS_SERVER:
+    case WINDOWS_NT_SERVER:
+    case WINDOWS_2K_SERVER:
+    case APPLESHARE_SERVER:
+    case NETPRESENZ_SERVER:
+	/*
+	 * Check for EPLF output (local times).
+	 */
+	if (*entry == '+') {
+	    parse_eplf_line(entry, entry_info);
+	    break;
+	}
+
+	/*
+	 * Interpret and edit LIST output from Unix server.
+	 */
+	len = (int) strlen(entry);
+	if (*first) {
+	    /* don't gettext() this -- incoming text: */
+	    if (!strcmp(entry, "can not access directory .")) {
+		/*
+		 * Don't reset *first, nothing real will follow.  - KW
+		 */
+		entry_info->display = FALSE;
+		return (entry_info);
+	    }
+	    *first = FALSE;
+	    if (!StrNCmp(entry, "total ", 6) ||
+		strstr(entry, "not available") != NULL) {
+		entry_info->display = FALSE;
+		return (entry_info);
+	    } else if (unsure_type) {
+		/* this isn't really a unix server! */
+		server_type = GENERIC_SERVER;
+		entry_info->display = FALSE;
+		return (entry_info);
+	    }
+	}
+
+	/*
+	 * Check first character of ls -l output.
+	 */
+	if (TOUPPER(entry[0]) == 'D') {
+	    /*
+	     * It's a directory.
+	     */
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    remove_size = TRUE;	/* size is not useful */
+	} else if (entry[0] == 'l') {
+	    /*
+	     * It's a symbolic link, does the user care about knowing if it is
+	     * symbolic?  I think so since it might be a directory.
+	     */
+	    StrAllocCopy(entry_info->type, ENTRY_IS_SYMBOLIC_LINK);
+	    remove_size = TRUE;	/* size is not useful */
+
+	    /*
+	     * Strip off " -> pathname".
+	     */
+	    for (i = len - 1; (i > 3) &&
+		 (!isspace(UCH(entry[i])) ||
+		  (entry[i - 1] != '>') ||
+		  (entry[i - 2] != '-') ||
+		  (entry[i - 3] != ' ')); i--) ;	/* null body */
+	    if (i > 3) {
+		entry[i - 3] = '\0';
+		StrAllocCopy(entry_info->linkname, LYSkipBlanks(entry + i));
+	    }
+	}
+	/* link */
+	parse_ls_line(entry, entry_info);
+
+	if (!strcmp(entry_info->filename, "..") ||
+	    !strcmp(entry_info->filename, "."))
+	    entry_info->display = FALSE;
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+
+    case VMS_SERVER:
+	/*
+	 * Interpret and edit LIST output from VMS server and convert
+	 * information lines to zero length.
+	 */
+	parse_vms_dir_entry(entry, entry_info);
+
+	/*
+	 * Get rid of any junk lines.
+	 */
+	if (!entry_info->display)
+	    return (entry_info);
+
+	/*
+	 * Trim off VMS directory extensions.
+	 */
+	len = (int) strlen(entry_info->filename);
+	if ((len > 4) && !strcmp(&entry_info->filename[len - 4], ".dir")) {
+	    entry_info->filename[len - 4] = '\0';
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    remove_size = TRUE;	/* size is not useful */
+	}
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+
+    case MS_WINDOWS_SERVER:
+	/*
+	 * Interpret and edit LIST output from MS_WINDOWS server and convert
+	 * information lines to zero length.
+	 */
+	parse_ms_windows_dir_entry(entry, entry_info);
+
+	/*
+	 * Get rid of any junk lines.
+	 */
+	if (!entry_info->display)
+	    return (entry_info);
+	if (entry_info->type && *entry_info->type == '\0') {
+	    FREE(entry_info->type);
+	    return (entry_info);
+	}
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+
+#ifdef NOTDEFINED
+    case WINDOWS_NT_SERVER:
+	/*
+	 * Interpret and edit LIST output from MS_WINDOWS server and convert
+	 * information lines to zero length.
+	 */
+	parse_windows_nt_dir_entry(entry, entry_info);
+
+	/*
+	 * Get rid of any junk lines.
+	 */
+	if (!entry_info->display)
+	    return (entry_info);
+	if (entry_info->type && *entry_info->type == '\0') {
+	    FREE(entry_info->type);
+	    return (entry_info);
+	}
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+#endif /* NOTDEFINED */
+
+    case CMS_SERVER:
+	{
+	    /*
+	     * Interpret and edit LIST output from VM/CMS server and convert
+	     * any information lines to zero length.
+	     */
+	    parse_cms_dir_entry(entry, entry_info);
+
+	    /*
+	     * Get rid of any junk lines.
+	     */
+	    if (!entry_info->display)
+		return (entry_info);
+	    if (entry_info->type && *entry_info->type == '\0') {
+		FREE(entry_info->type);
+		return (entry_info);
+	    }
+	    /*
+	     * Goto the bottom and get real type.
+	     */
+	    break;
+	}
+
+    case NCSA_SERVER:
+    case TCPC_SERVER:
+	/*
+	 * Directories identified by trailing "/" characters.
+	 */
+	StrAllocCopy(entry_info->filename, entry);
+	len = (int) strlen(entry);
+	if (entry[len - 1] == '/') {
+	    /*
+	     * It's a dir, remove / and mark it as such.
+	     */
+	    entry[len - 1] = '\0';
+	    StrAllocCopy(entry_info->type, ENTRY_IS_DIRECTORY);
+	    remove_size = TRUE;	/* size is not useful */
+	}
+	/*
+	 * Goto the bottom and get real type.
+	 */
+	break;
+
+    default:
+	/*
+	 * We can't tell if it is a directory since we only did an NLST :( List
+	 * bad file types anyways?  NOT!
+	 */
+	StrAllocCopy(entry_info->filename, entry);
+	return (entry_info);	/* mostly empty info */
+
+    }				/* switch (server_type) */
+
+#ifdef LONG_LIST
+    (void) remove_size;
+#else
+    if (remove_size && entry_info->size) {
+	entry_info->size = 0;
+    }
+#endif
+
+    if (isEmpty(entry_info->filename)) {
+	entry_info->display = FALSE;
+	return (entry_info);
+    }
+    if (strlen(entry_info->filename) > 3) {
+	if (((cp = strrchr(entry_info->filename, '.')) != NULL &&
+	     0 == strncasecomp(cp, ".me", 3)) &&
+	    (cp[3] == '\0' || cp[3] == ';')) {
+	    /*
+	     * Don't treat this as application/x-Troff-me if it's a Unix server
+	     * but has the string "read.me", or if it's not a Unix server.  -
+	     * FM
+	     */
+	    if ((server_type != UNIX_SERVER) ||
+		(cp > (entry_info->filename + 3) &&
+		 0 == strncasecomp((cp - 4), "read.me", 7))) {
+		StrAllocCopy(entry_info->type, STR_PLAINTEXT);
+	    }
+	}
+    }
+
+    /*
+     * Get real types eventually.
+     */
+    if (!entry_info->type) {
+	const char *cp2;
+	HTFormat format;
+	HTAtom *encoding;	/* @@ not used at all */
+
+	format = HTFileFormat(entry_info->filename, &encoding, &cp2);
+
+	if (cp2 == NULL) {
+	    if (!StrNCmp(HTAtom_name(format), "application", 11)) {
+		cp2 = HTAtom_name(format) + 12;
+		if (!StrNCmp(cp2, "x-", 2))
+		    cp2 += 2;
+	    } else {
+		cp2 = HTAtom_name(format);
+	    }
+	}
+
+	StrAllocCopy(entry_info->type, cp2);
+    }
+
+    return (entry_info);
+}
+
+static void formatDate(char target[16], EntryInfo *entry)
+{
+    char temp[8], month[4];
+    int i;
+
+    /*
+     * Set up for sorting in reverse chronological order. - FM
+     */
+    if (entry->date[9] == ':') {
+	strcpy(target, "9999");
+	LYStrNCpy(temp, &entry->date[7], 5);
+	if (temp[0] == ' ') {
+	    temp[0] = '0';
+	}
+    } else {
+	LYStrNCpy(target, &entry->date[8], 4);
+	strcpy(temp, "00:00");
+    }
+    LYStrNCpy(month, entry->date, 3);
+    for (i = 0; i < 12; i++) {
+	if (!strcasecomp(month, months[i])) {
+	    break;
+	}
+    }
+    i++;
+    sprintf(month, "%02d", i % 100);
+    strcat(target, month);
+    StrNCat(target, &entry->date[4], 2);
+    if (target[6] == ' ' || target[6] == HT_NON_BREAK_SPACE) {
+	target[6] = '0';
+    }
+
+    /* If no year given, assume last year if it would otherwise be in the
+     * future by more than one day.  The one day tolerance is to account for a
+     * possible timezone difference. - kw
+     */
+    if (target[0] == '9' && atoi(target) > TheDate + 1) {
+	for (i = 0; i < 4; i++) {
+	    target[i] = LastYear[i];
+	}
+    }
+    strcat(target, temp);
+}
+
+static int compare_EntryInfo_structs(EntryInfo *entry1, EntryInfo *entry2)
+{
+    int status;
+    char date1[16], date2[16];
+    int result = strcmp(entry1->filename, entry2->filename);
+
+    switch (HTfileSortMethod) {
+    case FILE_BY_SIZE:
+	/* both equal or both 0 */
+	if (entry1->size > entry2->size)
+	    result = 1;
+	else if (entry1->size < entry2->size)
+	    result = -1;
+	break;
+
+    case FILE_BY_TYPE:
+	if (entry1->type && entry2->type) {
+	    status = strcasecomp(entry1->type, entry2->type);
+	    if (status)
+		result = status;
+	}
+	break;
+
+    case FILE_BY_DATE:
+	if (entry1->date && entry2->date &&
+	    strlen(entry1->date) == 12 &&
+	    strlen(entry2->date) == 12) {
+	    /*
+	     * Set the years and date, if we don't have them yet.
+	     */
+	    if (!HaveYears) {
+		set_years_and_date();
+	    }
+	    formatDate(date1, entry1);
+	    formatDate(date2, entry2);
+	    /*
+	     * Do the comparison. - FM
+	     */
+	    status = strcasecomp(date2, date1);
+	    if (status)
+		result = status;
+	}
+	break;
+
+    case FILE_BY_NAME:
+    default:
+	break;
+    }
+    return result;
+}
+
+#ifdef LONG_LIST
+static char *FormatStr(char **bufp,
+		       char *start,
+		       const char *value)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*ss", (int) sizeof(fmt) - 3, start);
+	HTSprintf(bufp, fmt, value);
+    } else if (*bufp && !(value && *value)) {
+	;
+    } else if (value) {
+	StrAllocCat(*bufp, value);
+    }
+    return *bufp;
+}
+
+static char *FormatSize(char **bufp,
+			char *start,
+			off_t value)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*s" PRI_off_t,
+		  (int) sizeof(fmt) - DigitsOf(start) - 3, start);
+
+	HTSprintf(bufp, fmt, value);
+    } else {
+	sprintf(fmt, "%" PRI_off_t, CAST_off_t (value));
+
+	StrAllocCat(*bufp, fmt);
+    }
+    return *bufp;
+}
+
+static char *FormatNum(char **bufp,
+		       char *start,
+		       unsigned long value)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*sld",
+		(int) sizeof(fmt) - DigitsOf(start) - 3, start);
+	HTSprintf(bufp, fmt, value);
+    } else {
+	sprintf(fmt, "%lu", value);
+	StrAllocCat(*bufp, fmt);
+    }
+    return *bufp;
+}
+
+static void FlushParse(HTStructured * target, char **buf)
+{
+    if (*buf && **buf) {
+	PUTS(*buf);
+	**buf = '\0';
+    }
+}
+
+static void LYListFmtParse(const char *fmtstr,
+			   EntryInfo *data,
+			   HTStructured * target,
+			   char *tail)
+{
+    char c;
+    char *s;
+    char *end;
+    char *start;
+    char *str = NULL;
+    char *buf = NULL;
+    BOOL is_directory = (BOOL) (data->file_mode != 0 &&
+				(TOUPPER(data->file_mode[0]) == 'D'));
+    BOOL is_symlinked = (BOOL) (data->file_mode != 0 &&
+				(TOUPPER(data->file_mode[0]) == 'L'));
+    BOOL remove_size = (BOOL) (is_directory || is_symlinked);
+
+    StrAllocCopy(str, fmtstr);
+    s = str;
+    end = str + strlen(str);
+    while (*s) {
+	start = s;
+	while (*s) {
+	    if (*s == '%') {
+		if (*(s + 1) == '%')	/* literal % */
+		    s++;
+		else
+		    break;
+	    }
+	    s++;
+	}
+	/* s is positioned either at a % or at \0 */
+	*s = '\0';
+	if (s > start) {	/* some literal chars. */
+	    StrAllocCat(buf, start);
+	}
+	if (s == end)
+	    break;
+	start = ++s;
+	while (isdigit(UCH(*s)) || *s == '.' || *s == '-' || *s == ' ' ||
+	       *s == '#' || *s == '+' || *s == '\'')
+	    s++;
+	c = *s;			/* the format char. or \0 */
+	*s = '\0';
+
+	switch (c) {
+	case '\0':
+	    StrAllocCat(buf, start);
+	    continue;
+
+	case 'A':
+	case 'a':		/* anchor */
+	    FlushParse(target, &buf);
+	    HTDirEntry(target, tail, data->filename);
+	    FormatStr(&buf, start, data->filename);
+	    PUTS(buf);
+	    END(HTML_A);
+	    if (buf != 0)
+		*buf = '\0';
+	    if (c != 'A' && data->linkname != 0) {
+		PUTS(" -> ");
+		PUTS(data->linkname);
+	    }
+	    break;
+
+	case 'T':		/* MIME type */
+	case 't':		/* MIME type description */
+	    if (is_directory) {
+		if (c != 'T') {
+		    FormatStr(&buf, start, ENTRY_IS_DIRECTORY);
+		} else {
+		    FormatStr(&buf, start, "");
+		}
+	    } else if (is_symlinked) {
+		if (c != 'T') {
+		    FormatStr(&buf, start, ENTRY_IS_SYMBOLIC_LINK);
+		} else {
+		    FormatStr(&buf, start, "");
+		}
+	    } else {
+		const char *cp2;
+		HTFormat format;
+
+		format = HTFileFormat(data->filename, NULL, &cp2);
+
+		if (c != 'T') {
+		    if (cp2 == NULL) {
+			if (!StrNCmp(HTAtom_name(format),
+				     "application", 11)) {
+			    cp2 = HTAtom_name(format) + 12;
+			    if (!StrNCmp(cp2, "x-", 2))
+				cp2 += 2;
+			} else {
+			    cp2 = HTAtom_name(format);
+			}
+		    }
+		    FormatStr(&buf, start, cp2);
+		} else {
+		    FormatStr(&buf, start, HTAtom_name(format));
+		}
+	    }
+	    break;
+
+	case 'd':		/* date */
+	    if (data->date) {
+		FormatStr(&buf, start, data->date);
+	    } else {
+		FormatStr(&buf, start, " * ");
+	    }
+	    break;
+
+	case 's':		/* size in bytes */
+	    FormatSize(&buf, start, data->size);
+	    break;
+
+	case 'K':		/* size in Kilobytes but not for directories */
+	    if (remove_size) {
+		FormatStr(&buf, start, "");
+		StrAllocCat(buf, " ");
+		break;
+	    }
+	    /* FALL THROUGH */
+	case 'k':		/* size in Kilobytes */
+	    /* FIXME - this is inconsistent with HTFile.c, but historical */
+	    if (data->size < 1024) {
+		FormatSize(&buf, start, data->size);
+		StrAllocCat(buf, " bytes");
+	    } else {
+		FormatSize(&buf, start, data->size / 1024);
+		StrAllocCat(buf, "Kb");
+	    }
+	    break;
+
+#ifdef LONG_LIST
+	case 'p':		/* unix-style permission bits */
+	    FormatStr(&buf, start, NonNull(data->file_mode));
+	    break;
+
+	case 'o':		/* owner */
+	    FormatStr(&buf, start, NonNull(data->file_user));
+	    break;
+
+	case 'g':		/* group */
+	    FormatStr(&buf, start, NonNull(data->file_group));
+	    break;
+
+	case 'l':		/* link count */
+	    FormatNum(&buf, start, data->file_links);
+	    break;
+#endif
+
+	case '%':		/* literal % with flags/width */
+	    FormatStr(&buf, start, "%");
+	    break;
+
+	default:
+	    fprintf(stderr,
+		    "Unknown format character `%c' in list format\n", c);
+	    break;
+	}
+
+	s++;
+    }
+    if (buf) {
+	LYTrimTrailing(buf);
+	FlushParse(target, &buf);
+	FREE(buf);
+    }
+    PUTC('\n');
+    FREE(str);
+}
+#endif /* LONG_LIST */
+
+/*	Read a directory into an hypertext object from the data socket
+ *	--------------------------------------------------------------
+ *
+ * On entry,
+ *	anchor		Parent anchor to link the this node to
+ *	address		Address of the directory
+ * On exit,
+ *	returns		HT_LOADED if OK
+ *			<0 if error.
+ */
+static int read_directory(HTParentAnchor *parent,
+			  const char *address,
+			  HTFormat format_out,
+			  HTStream *sink)
+{
+    int status;
+    BOOLEAN WasInterrupted = FALSE;
+    HTStructured *target = HTML_new(parent, format_out, sink);
+    char *filename = HTParse(address, "", PARSE_PATH + PARSE_PUNCTUATION);
+    EntryInfo *entry_info;
+    BOOLEAN first = TRUE;
+    char *lastpath = NULL;	/* prefix for link, either "" (for root) or xxx  */
+    BOOL tildeIsTop = FALSE;
+
+#ifndef LONG_LIST
+    char string_buffer[64];
+#endif
+
+    _HTProgress(gettext("Receiving FTP directory."));
+
+    /*
+     * Force the current Date and Year (TheDate, ThisYear, and LastYear) to be
+     * recalculated for each directory request.  Otherwise we have a problem
+     * with long-running sessions assuming the wrong date for today.  - kw
+     */
+    HaveYears = FALSE;
+    /*
+     * Check whether we always want the home directory treated as Welcome.  -
+     * FM
+     */
+    if (server_type == VMS_SERVER)
+	tildeIsTop = TRUE;
+
+    /*
+     * This should always come back FALSE, since the flag is set only for local
+     * directory listings if LONG_LIST was defined on compilation, but we could
+     * someday set up an equivalent listing for Unix ftp servers.  - FM
+     */
+    (void) HTDirTitles(target, parent, format_out, tildeIsTop);
+
+    data_read_pointer = data_write_pointer = data_buffer;
+
+    if (*filename == '\0') {	/* Empty filename: use root. */
+	StrAllocCopy(lastpath, "/");
+    } else if (!strcmp(filename, "/")) {	/* Root path. */
+	StrAllocCopy(lastpath, "/foo/..");
+    } else {
+	char *p = strrchr(filename, '/');	/* Find the lastslash. */
+	char *cp;
+
+	if (server_type == CMS_SERVER) {
+	    StrAllocCopy(lastpath, filename);	/* Use absolute path for CMS. */
+	} else {
+	    StrAllocCopy(lastpath, p + 1);	/* Take slash off the beginning. */
+	}
+	if ((cp = strrchr(lastpath, ';')) != NULL) {	/* Trim type= param. */
+	    if (!strncasecomp((cp + 1), "type=", 5)) {
+		if (TOUPPER(*(cp + 6)) == 'D' ||
+		    TOUPPER(*(cp + 6)) == 'A' ||
+		    TOUPPER(*(cp + 6)) == 'I')
+		    *cp = '\0';
+	    }
+	}
+    }
+    FREE(filename);
+
+    {
+	HTBTree *bt = HTBTree_new((HTComparer) compare_EntryInfo_structs);
+	int ic;
+	HTChunk *chunk = HTChunkCreate(128);
+	int BytesReceived = 0;
+	int BytesReported = 0;
+	char NumBytes[64];
+	char *spilledname = NULL;
+
+	PUTC('\n');		/* prettier LJM */
+	for (ic = 0; ic != EOF;) {	/* For each entry in the directory */
+	    HTChunkClear(chunk);
+
+	    if (HTCheckForInterrupt()) {
+		CTRACE((tfp,
+			"read_directory: interrupted after %d bytes\n",
+			BytesReceived));
+		WasInterrupted = TRUE;
+		if (BytesReceived) {
+		    goto unload_btree;	/* unload btree */
+		} else {
+		    ABORT_TARGET;
+		    HTBTreeAndObject_free(bt);
+		    FREE(spilledname);
+		    HTChunkFree(chunk);
+		    return HT_INTERRUPTED;
+		}
+	    }
+
+	    /*   read directory entry
+	     */
+	    interrupted_in_next_data_char = FALSE;
+	    for (;;) {		/* Read in one line as filename */
+		ic = NEXT_DATA_CHAR;
+	      AgainForMultiNet:
+		if (interrupted_in_next_data_char) {
+		    CTRACE((tfp,
+			    "read_directory: interrupted_in_next_data_char after %d bytes\n",
+			    BytesReceived));
+		    WasInterrupted = TRUE;
+		    if (BytesReceived) {
+			goto unload_btree;	/* unload btree */
+		    } else {
+			ABORT_TARGET;
+			HTBTreeAndObject_free(bt);
+			FREE(spilledname);
+			HTChunkFree(chunk);
+			return HT_INTERRUPTED;
+		    }
+		} else if ((char) ic == CR || (char) ic == LF) {	/* Terminator? */
+		    if (chunk->size != 0) {	/* got some text */
+			/* Deal with MultiNet's wrapping of long lines */
+			if (server_type == VMS_SERVER) {
+			    /* Deal with MultiNet's wrapping of long lines - F.M. */
+			    if (data_read_pointer < data_write_pointer &&
+				*(data_read_pointer + 1) == ' ')
+				data_read_pointer++;
+			    else if (data_read_pointer >= data_write_pointer) {
+				status = NETREAD(data_soc, data_buffer,
+						 DATA_BUFFER_SIZE);
+				if (status == HT_INTERRUPTED) {
+				    interrupted_in_next_data_char = 1;
+				    goto AgainForMultiNet;
+				}
+				if (status <= 0) {
+				    ic = EOF;
+				    break;
+				}
+				data_write_pointer = data_buffer + status;
+				data_read_pointer = data_buffer;
+				if (*data_read_pointer == ' ')
+				    data_read_pointer++;
+				else
+				    break;
+			    } else
+				break;
+			} else
+			    break;	/* finish getting one entry */
+		    }
+		} else if (ic == EOF) {
+		    break;	/* End of file */
+		} else {
+		    HTChunkPutc(chunk, UCH(ic));
+		}
+	    }
+	    HTChunkTerminate(chunk);
+
+	    BytesReceived += chunk->size;
+	    if (BytesReceived > BytesReported + 1024) {
+#ifdef _WINDOWS
+		sprintf(NumBytes, gettext("Transferred %d bytes (%5d)"),
+			BytesReceived, ws_read_per_sec);
+#else
+		sprintf(NumBytes, TRANSFERRED_X_BYTES, BytesReceived);
+#endif
+		HTProgress(NumBytes);
+		BytesReported = BytesReceived;
+	    }
+
+	    if (ic == EOF && chunk->size == 1)
+		/* 1 means empty: includes terminating 0 */
+		break;
+	    CTRACE((tfp, "HTFTP: Line in %s is %s\n",
+		    lastpath, chunk->data));
+
+	    entry_info = parse_dir_entry(chunk->data, &first, &spilledname);
+	    if (entry_info->display) {
+		FREE(spilledname);
+		CTRACE((tfp, "Adding file to BTree: %s\n",
+			entry_info->filename));
+		HTBTree_add(bt, entry_info);
+	    } else {
+		free_entryinfo_struct_contents(entry_info);
+		FREE(entry_info);
+	    }
+
+	}			/* next entry */
+
+      unload_btree:
+
+	HTChunkFree(chunk);
+	FREE(spilledname);
+
+	/* print out the handy help message if it exists :) */
+	if (help_message_cache_non_empty()) {
+	    START(HTML_PRE);
+	    START(HTML_HR);
+	    PUTC('\n');
+	    PUTS(help_message_cache_contents());
+	    init_help_message_cache();	/* to free memory */
+	    START(HTML_HR);
+	    PUTC('\n');
+	} else {
+	    START(HTML_PRE);
+	    PUTC('\n');
+	}
+
+	/* Run through tree printing out in order
+	 */
+	{
+#ifndef LONG_LIST
+#ifdef SH_EX			/* 1997/10/18 (Sat) 14:14:28 */
+	    char *p, name_buff[256];
+	    int name_len, dot_len;
+
+#define	FNAME_WIDTH	30
+#define	FILE_GAP	1
+
+#endif
+	    int i;
+#endif
+	    HTBTElement *ele;
+
+	    for (ele = HTBTree_next(bt, NULL);
+		 ele != NULL;
+		 ele = HTBTree_next(bt, ele)) {
+		entry_info = (EntryInfo *) HTBTree_object(ele);
+
+#ifdef LONG_LIST
+		LYListFmtParse(ftp_format,
+			       entry_info,
+			       target,
+			       lastpath);
+#else
+		if (entry_info->date) {
+		    PUTS(entry_info->date);
+		    PUTS("  ");
+		} else {
+		    PUTS("     * ");
+		}
+
+		if (entry_info->type) {
+		    for (i = 0; entry_info->type[i] != '\0' && i < 16; i++)
+			PUTC(entry_info->type[i]);
+		    for (; i < 17; i++)
+			PUTC(' ');
+		}
+		/* start the anchor */
+		HTDirEntry(target, lastpath, entry_info->filename);
+#ifdef SH_EX			/* 1997/10/18 (Sat) 16:00 */
+		name_len = strlen(entry_info->filename);
+
+		sprintf(name_buff, "%-*s", FNAME_WIDTH, entry_info->filename);
+
+		if (name_len < FNAME_WIDTH) {
+		    dot_len = FNAME_WIDTH - FILE_GAP - name_len;
+		    if (dot_len > 0) {
+			p = name_buff + name_len + 1;
+			while (dot_len-- > 0)
+			    *p++ = '.';
+		    }
+		} else {
+		    name_buff[FNAME_WIDTH] = '\0';
+		}
+
+		PUTS(name_buff);
+#else
+		PUTS(entry_info->filename);
+#endif
+		END(HTML_A);
+
+		if (entry_info->size) {
+#ifdef SH_EX			/* 1998/02/02 (Mon) 16:34:52 */
+		    if (entry_info->size < 1024)
+			sprintf(string_buffer, "%6ld bytes",
+				entry_info->size);
+		    else
+			sprintf(string_buffer, "%6ld Kb",
+				entry_info->size / 1024);
+#else
+		    if (entry_info->size < 1024)
+			sprintf(string_buffer, "  %lu bytes",
+				(unsigned long) entry_info->size);
+		    else
+			sprintf(string_buffer, "  %luKb",
+				(unsigned long) entry_info->size / 1024);
+#endif
+		    PUTS(string_buffer);
+		} else if (entry_info->linkname != 0) {
+		    PUTS(" -> ");
+		    PUTS(entry_info->linkname);
+		}
+
+		PUTC('\n');	/* end of this entry */
+#endif
+
+		free_entryinfo_struct_contents(entry_info);
+	    }
+	}
+	END(HTML_PRE);
+	END(HTML_BODY);
+	FREE_TARGET;
+	HTBTreeAndObject_free(bt);
+    }
+
+    FREE(lastpath);
+
+    if (WasInterrupted || data_soc != -1) {	/* should always be true */
+	/*
+	 * Without closing the data socket first, the response(NULL) later may
+	 * hang.  Some servers expect the client to fin/ack the close of the
+	 * data connection before proceeding with the conversation on the
+	 * control connection.  - kw
+	 */
+	CTRACE((tfp, "HTFTP: Closing data socket %d\n", data_soc));
+	status = NETCLOSE(data_soc);
+	if (status == -1)
+	    HTInetStatus("close");	/* Comment only */
+	data_soc = -1;
+    }
+
+    if (WasInterrupted || HTCheckForInterrupt()) {
+	_HTProgress(TRANSFER_INTERRUPTED);
+    }
+    return HT_LOADED;
+}
+
+/*
+ * Setup an FTP connection.
+ */
+static int setup_connection(const char *name,
+			    HTParentAnchor *anchor)
+{
+    int retry;			/* How many times tried? */
+    int status = HT_NO_CONNECTION;
+
+    CTRACE((tfp, "setup_connection(%s)\n", name));
+
+    /* set use_list to NOT since we don't know what kind of server
+     * this is yet.  And set the type to GENERIC
+     */
+    use_list = FALSE;
+    server_type = GENERIC_SERVER;
+    Broken_RETR = FALSE;
+
+#ifdef INET6
+    Broken_EPSV = FALSE;
+#endif
+
+    for (retry = 0; retry < 2; retry++) {	/* For timed out/broken connections */
+	status = get_connection(name, anchor);
+	if (status < 0) {
+	    break;
+	}
+
+	if (!ftp_local_passive) {
+	    status = get_listen_socket();
+	    if (status < 0) {
+		NETCLOSE(control->socket);
+		control->socket = -1;
+#ifdef INET6
+		if (have_socket)
+		    (void) close_master_socket();
+#else
+		close_master_socket();
+#endif /* INET6 */
+		/* HT_INTERRUPTED would fall through, if we could interrupt
+		   somehow in the middle of it, which we currently can't. */
+		break;
+	    }
+#ifdef REPEAT_PORT
+	    /*  Inform the server of the port number we will listen on
+	     */
+	    status = response(port_command);
+	    FREE(port_command);
+	    if (status == HT_INTERRUPTED) {
+		CTRACE((tfp, "HTFTP: Interrupted in response (port_command)\n"));
+		_HTProgress(CONNECTION_INTERRUPTED);
+		NETCLOSE(control->socket);
+		control->socket = -1;
+		close_master_socket();
+		status = HT_INTERRUPTED;
+		break;
+	    }
+	    if (status != 2) {	/* Could have timed out */
+		if (status < 0)
+		    continue;	/* try again - net error */
+		status = -status;	/* bad reply */
+		break;
+	    }
+	    CTRACE((tfp, "HTFTP: Port defined.\n"));
+#endif /* REPEAT_PORT */
+	} else {		/* Tell the server to be passive */
+	    char *command = NULL;
+	    const char *p = "?";
+	    int h0, h1, h2, h3, p0, p1;		/* Parts of reply */
+
+#ifdef INET6
+	    char dst[LINE_LENGTH + 1];
+#endif
+
+	    data_soc = status;
+
+#ifdef INET6
+	    /* see RFC 2428 */
+	    if (Broken_EPSV)
+		status = 1;
+	    else
+		status = send_cmd_1(p = "EPSV");
+	    if (status < 0)	/* retry or Bad return */
+		continue;
+	    else if (status != 2) {
+		status = send_cmd_1(p = "PASV");
+		if (status < 0) {	/* retry or Bad return */
+		    continue;
+		} else if (status != 2) {
+		    status = -status;	/* bad reply */
+		    break;
+		}
+	    }
+
+	    if (strcmp(p, "PASV") == 0) {
+		for (p = response_text; *p && *p != ','; p++) {
+		    ;		/* null body */
+		}
+
+		while (--p > response_text && '0' <= *p && *p <= '9') {
+		    ;		/* null body */
+		}
+		status = sscanf(p + 1, "%d,%d,%d,%d,%d,%d",
+				&h0, &h1, &h2, &h3, &p0, &p1);
+		if (status < 4) {
+		    fprintf(tfp, "HTFTP: PASV reply has no inet address!\n");
+		    status = HT_NO_CONNECTION;
+		    break;
+		}
+		passive_port = (PortNumber) ((p0 << 8) + p1);
+		sprintf(dst, "%d.%d.%d.%d", h0, h1, h2, h3);
+	    } else if (strcmp(p, "EPSV") == 0) {
+		char c0, c1, c2, c3;
+		LY_SOCKADDR ss;
+		LY_SOCKLEN sslen;
+
+		/*
+		 * EPSV bla (|||port|)
+		 */
+		for (p = response_text; *p && !isspace(UCH(*p)); p++) {
+		    ;		/* null body */
+		}
+		for ( /*nothing */ ;
+		     *p && *p != '(';
+		     p++) {	/*) */
+		    ;		/* null body */
+		}
+		status = sscanf(p, "(%c%c%c%d%c)", &c0, &c1, &c2, &p0, &c3);
+		if (status != 5) {
+		    fprintf(tfp, "HTFTP: EPSV reply has invalid format!\n");
+		    status = HT_NO_CONNECTION;
+		    break;
+		}
+		passive_port = (PortNumber) p0;
+
+		sslen = (LY_SOCKLEN) sizeof(ss);
+		if (getpeername(control->socket, SOCKADDR_OF(ss), &sslen) < 0) {
+		    fprintf(tfp, "HTFTP: getpeername(control) failed\n");
+		    status = HT_NO_CONNECTION;
+		    break;
+		}
+		if (getnameinfo(SOCKADDR_OF(ss),
+				sslen,
+				dst,
+				(socklen_t) sizeof(dst),
+				NULL, 0, NI_NUMERICHOST)) {
+		    fprintf(tfp, "HTFTP: getnameinfo failed\n");
+		    status = HT_NO_CONNECTION;
+		    break;
+		}
+	    }
+#else
+	    status = send_cmd_1("PASV");
+	    if (status != 2) {
+		if (status < 0)
+		    continue;	/* retry or Bad return */
+		status = -status;	/* bad reply */
+		break;
+	    }
+	    for (p = response_text; *p && *p != ','; p++) {
+		;		/* null body */
+	    }
+
+	    while (--p > response_text && '0' <= *p && *p <= '9') {
+		;		/* null body */
+	    }
+
+	    status = sscanf(p + 1, "%d,%d,%d,%d,%d,%d",
+			    &h0, &h1, &h2, &h3, &p0, &p1);
+	    if (status < 4) {
+		fprintf(tfp, "HTFTP: PASV reply has no inet address!\n");
+		status = HT_NO_CONNECTION;
+		break;
+	    }
+	    passive_port = (PortNumber) ((p0 << 8) + p1);
+#endif /* INET6 */
+	    CTRACE((tfp, "HTFTP: Server is listening on port %d\n",
+		    passive_port));
+
+	    /* Open connection for data:  */
+
+#ifdef INET6
+	    HTSprintf0(&command, "%s//%s:%d/", STR_FTP_URL, dst, passive_port);
+#else
+	    HTSprintf0(&command, "%s//%d.%d.%d.%d:%d/",
+		       STR_FTP_URL, h0, h1, h2, h3, passive_port);
+#endif
+	    status = HTDoConnect(command, "FTP data", passive_port, &data_soc);
+	    FREE(command);
+
+	    if (status < 0) {
+		(void) HTInetStatus(gettext("connect for data"));
+		NETCLOSE(data_soc);
+		break;
+	    }
+
+	    CTRACE((tfp, "FTP data connected, socket %d\n", data_soc));
+	}
+	status = 0;
+	break;			/* No more retries */
+
+    }				/* for retries */
+    CTRACE((tfp, "setup_connection returns %d\n", status));
+    return status;
+}
+
+/*	Retrieve File from Server
+ *	-------------------------
+ *
+ * On entry,
+ *	name		WWW address of a file: document, including hostname
+ * On exit,
+ *	returns		Socket number for file if good.
+ *			<0 if bad.
+ */
+int HTFTPLoad(const char *name,
+	      HTParentAnchor *anchor,
+	      HTFormat format_out,
+	      HTStream *sink)
+{
+    BOOL isDirectory = NO;
+    HTAtom *encoding = NULL;
+    int status, final_status;
+    int outstanding = 1;	/* outstanding control connection responses
+
+				   that we are willing to wait for, if we
+				   get to the point of reading data - kw */
+    HTFormat format;
+
+    CTRACE((tfp, "HTFTPLoad(%s) %s connection\n",
+	    name,
+	    (ftp_local_passive
+	     ? "passive"
+	     : "normal")));
+
+    HTReadProgress((off_t) 0, (off_t) 0);
+
+    status = setup_connection(name, anchor);
+    if (status < 0)
+	return status;		/* Failed with this code */
+
+    /*  Ask for the file:
+     */
+    {
+	char *filename = HTParse(name, "", PARSE_PATH + PARSE_PUNCTUATION);
+	char *fname = filename;	/* Save for subsequent free() */
+	char *vmsname = NULL;
+	BOOL binary;
+	const char *type = NULL;
+	char *types = NULL;
+	char *cp;
+
+	if (server_type == CMS_SERVER) {
+	    /* If the unescaped path has a %2f, reject it as illegal. - FM */
+	    if (((cp = strstr(filename, "%2")) != NULL) &&
+		TOUPPER(cp[2]) == 'F') {
+		FREE(fname);
+		init_help_message_cache();	/* to free memory */
+		NETCLOSE(control->socket);
+		control->socket = -1;
+		CTRACE((tfp,
+			"HTFTP: Rejecting path due to illegal escaped slash.\n"));
+		return -1;
+	    }
+	}
+
+	if (!*filename) {
+	    StrAllocCopy(filename, "/");
+	    type = "D";
+	} else if ((type = types = strrchr(filename, ';')) != NULL) {
+	    /*
+	     * Check and trim the type= parameter.  - FM
+	     */
+	    if (!strncasecomp((type + 1), "type=", 5)) {
+		switch (TOUPPER(*(type + 6))) {
+		case 'D':
+		    *types = '\0';
+		    type = "D";
+		    break;
+		case 'A':
+		    *types = '\0';
+		    type = "A";
+		    break;
+		case 'I':
+		    *types = '\0';
+		    type = "I";
+		    break;
+		default:
+		    type = "";
+		    break;
+		}
+		if (!*filename) {
+		    *filename = '/';
+		    *(filename + 1) = '\0';
+		}
+	    }
+	    if (*type != '\0') {
+		CTRACE((tfp, "HTFTP: type=%s\n", type));
+	    }
+	}
+	HTUnEscape(filename);
+	CTRACE((tfp, "HTFTP: UnEscaped %s\n", filename));
+	if (filename[1] == '~') {
+	    /*
+	     * Check if translation of HOME as tilde is supported,
+	     * and adjust filename if so. - FM
+	     */
+	    char *cp2 = NULL;
+	    char *fn = NULL;
+
+	    if ((cp2 = StrChr((filename + 1), '/')) != NULL) {
+		*cp2 = '\0';
+	    }
+	    status = send_cmd_1("PWD");
+	    if (status == 2 && response_text[5] == '/') {
+		status = send_cwd(filename + 1);
+		if (status == 2) {
+		    StrAllocCopy(fn, (filename + 1));
+		    if (cp2) {
+			*cp2 = '/';
+			if (fn[strlen(fn) - 1] != '/') {
+			    StrAllocCat(fn, cp2);
+			} else {
+			    StrAllocCat(fn, (cp2 + 1));
+			}
+			cp2 = NULL;
+		    }
+		    FREE(fname);
+		    fname = filename = fn;
+		}
+	    }
+	    if (cp2) {
+		*cp2 = '/';
+	    }
+	}
+	if (strlen(filename) > 3) {
+	    char *cp2;
+
+	    if (((cp2 = strrchr(filename, '.')) != NULL &&
+		 0 == strncasecomp(cp2, ".me", 3)) &&
+		(cp2[3] == '\0' || cp2[3] == ';')) {
+		/*
+		 * Don't treat this as application/x-Troff-me if it's a Unix
+		 * server but has the string "read.me", or if it's not a Unix
+		 * server.  - FM
+		 */
+		if ((server_type != UNIX_SERVER) ||
+		    (cp2 > (filename + 3) &&
+		     0 == strncasecomp((cp2 - 4), "read.me", 7))) {
+		    *cp2 = '\0';
+		    format = HTFileFormat(filename, &encoding, NULL);
+		    *cp2 = '.';
+		} else {
+		    format = HTFileFormat(filename, &encoding, NULL);
+		}
+	    } else {
+		format = HTFileFormat(filename, &encoding, NULL);
+	    }
+	} else {
+	    format = HTFileFormat(filename, &encoding, NULL);
+	}
+	format = HTCharsetFormat(format, anchor, -1);
+	binary = (BOOL) (encoding != WWW_ENC_8BIT &&
+			 encoding != WWW_ENC_7BIT);
+	if (!binary &&
+	/*
+	 * Force binary if we're in source, download or dump mode and this is
+	 * not a VM/CMS server, so we don't get CRLF instead of LF (or CR) for
+	 * newlines in text files.  Can't do this for VM/CMS or we'll get raw
+	 * EBCDIC.  - FM
+	 */
+	    (format_out == WWW_SOURCE ||
+	     format_out == WWW_DOWNLOAD ||
+	     format_out == WWW_DUMP) &&
+	    (server_type != CMS_SERVER))
+	    binary = TRUE;
+	if (!binary && type && *type == 'I') {
+	    /*
+	     * Force binary if we had ;type=I - FM
+	     */
+	    binary = TRUE;
+	} else if (binary && type && *type == 'A') {
+	    /*
+	     * Force ASCII if we had ;type=A - FM
+	     */
+	    binary = FALSE;
+	}
+	if (binary != control->is_binary) {
+	    /*
+	     * Act on our setting if not already set.  - FM
+	     */
+	    const char *mode = binary ? "I" : "A";
+
+	    status = send_cmd_2("TYPE", mode);
+	    if (status != 2) {
+		init_help_message_cache();	/* to free memory */
+		return ((status < 0) ? status : -status);
+	    }
+	    control->is_binary = binary;
+	}
+	switch (server_type) {
+	    /*
+	     * Handle what for Lynx are special case servers, e.g., for which
+	     * we respect RFC 1738, or which have known conflicts in suffix
+	     * mappings.  - FM
+	     */
+	case VMS_SERVER:
+	    {
+		char *cp1, *cp2;
+		BOOL included_device = FALSE;
+		BOOL found_tilde = FALSE;
+
+		/* Accept only Unix-style filename */
+		if (StrChr(filename, ':') != NULL ||
+		    StrChr(filename, '[') != NULL) {
+		    FREE(fname);
+		    init_help_message_cache();	/* to free memory */
+		    NETCLOSE(control->socket);
+		    control->socket = -1;
+		    CTRACE((tfp,
+			    "HTFTP: Rejecting path due to non-Unix-style syntax.\n"));
+		    return -1;
+		}
+		/* Handle any unescaped "/%2F" path */
+		if (!StrNCmp(filename, "//", 2)) {
+		    int i;
+
+		    included_device = TRUE;
+		    for (i = 0; filename[(i + 1)]; i++)
+			filename[i] = filename[(i + 1)];
+		    filename[i] = '\0';
+		    CTRACE((tfp, "HTFTP: Trimmed '%s'\n", filename));
+		    cp = HTVMS_name("", filename);
+		    CTRACE((tfp, "HTFTP: VMSized '%s'\n", cp));
+		    if ((cp1 = strrchr(cp, ']')) != NULL) {
+			strcpy(filename, ++cp1);
+			CTRACE((tfp, "HTFTP: Filename '%s'\n", filename));
+			*cp1 = '\0';
+			status = send_cwd(cp);
+			if (status != 2) {
+			    char *dotslash = 0;
+
+			    if ((cp1 = StrChr(cp, '[')) != NULL) {
+				*cp1++ = '\0';
+				status = send_cwd(cp);
+				if (status != 2) {
+				    FREE(fname);
+				    init_help_message_cache();	/* to free memory */
+				    NETCLOSE(control->socket);
+				    control->socket = -1;
+				    return ((status < 0) ? status : -status);
+				}
+				HTSprintf0(&dotslash, "[.%s", cp1);
+				status = send_cwd(dotslash);
+				FREE(dotslash);
+				if (status != 2) {
+				    FREE(fname);
+				    init_help_message_cache();	/* to free memory */
+				    NETCLOSE(control->socket);
+				    control->socket = -1;
+				    return ((status < 0) ? status : -status);
+				}
+			    } else {
+				FREE(fname);
+				init_help_message_cache();	/* to free memory */
+				NETCLOSE(control->socket);
+				control->socket = -1;
+				return ((status < 0) ? status : -status);
+			    }
+			}
+		    } else if ((cp1 = StrChr(cp, ':')) != NULL &&
+			       StrChr(cp, '[') == NULL &&
+			       StrChr(cp, ']') == NULL) {
+			cp1++;
+			if (*cp1 != '\0') {
+			    int cplen = (int) (cp1 - cp);
+
+			    strcpy(filename, cp1);
+			    CTRACE((tfp, "HTFTP: Filename '%s'\n", filename));
+			    HTSprintf0(&vmsname, "%.*s[%s]", cplen, cp, filename);
+			    status = send_cwd(vmsname);
+			    if (status != 2) {
+				HTSprintf(&vmsname, "%.*s[000000]", cplen, cp);
+				status = send_cwd(vmsname);
+				if (status != 2) {
+				    HTSprintf(&vmsname, "%.*s", cplen, cp);
+				    status = send_cwd(vmsname);
+				    if (status != 2) {
+					FREE(fname);
+					init_help_message_cache();
+					NETCLOSE(control->socket);
+					control->socket = -1;
+					return ((status < 0) ? status : -status);
+				    }
+				}
+			    } else {
+				HTSprintf0(&vmsname, "000000");
+				filename = vmsname;
+			    }
+			}
+		    } else if (0 == strcmp(cp, (filename + 1))) {
+			status = send_cwd(cp);
+			if (status != 2) {
+			    HTSprintf0(&vmsname, "%s:", cp);
+			    status = send_cwd(vmsname);
+			    if (status != 2) {
+				FREE(fname);
+				init_help_message_cache();	/* to free memory */
+				NETCLOSE(control->socket);
+				control->socket = -1;
+				return ((status < 0) ? status : -status);
+			    }
+			}
+			HTSprintf0(&vmsname, "000000");
+			filename = vmsname;
+		    }
+		}
+		/* Trim trailing slash if filename is not the top directory */
+		if (strlen(filename) > 1 && filename[strlen(filename) - 1] == '/')
+		    filename[strlen(filename) - 1] = '\0';
+
+#ifdef MAINTAIN_CONNECTION	/* Don't need this if always new connection - F.M. */
+		if (!included_device) {
+		    /* Get the current default VMS device:[directory] */
+		    status = send_cmd_1("PWD");
+		    if (status != 2) {
+			FREE(fname);
+			init_help_message_cache();	/* to free memory */
+			NETCLOSE(control->socket);
+			control->socket = -1;
+			return ((status < 0) ? status : -status);
+		    }
+		    /* Go to the VMS account's top directory */
+		    if ((cp = StrChr(response_text, '[')) != NULL &&
+			(cp1 = strrchr(response_text, ']')) != NULL) {
+			char *tmp = 0;
+			unsigned len = 4;
+
+			StrAllocCopy(tmp, cp);
+			if ((cp2 = StrChr(cp, '.')) != NULL && cp2 < cp1) {
+			    len += (cp2 - cp);
+			} else {
+			    len += (cp1 - cp);
+			}
+			tmp[len] = 0;
+			StrAllocCat(tmp, "]");
+
+			status = send_cwd(tmp);
+			FREE(tmp);
+
+			if (status != 2) {
+			    FREE(fname);
+			    init_help_message_cache();	/* to free memory */
+			    NETCLOSE(control->socket);
+			    control->socket = -1;
+			    return ((status < 0) ? status : -status);
+			}
+		    }
+		}
+#endif /* MAINTAIN_CONNECTION */
+
+		/* If we want the VMS account's top directory, list it now */
+		if (!(strcmp(filename, "/~")) ||
+		    (included_device && 0 == strcmp(filename, "000000")) ||
+		    (strlen(filename) == 1 && *filename == '/')) {
+		    isDirectory = YES;
+		    status = send_cmd_1("LIST");
+		    FREE(fname);
+		    if (status != 1) {
+			/* Action not started */
+			init_help_message_cache();	/* to free memory */
+			NETCLOSE(control->socket);
+			control->socket = -1;
+			return ((status < 0) ? status : -status);
+		    }
+		    /* Big goto! */
+		    goto listen;
+		}
+		/* Otherwise, go to appropriate directory and doctor filename */
+		if (!StrNCmp(filename, "/~", 2)) {
+		    filename += 2;
+		    found_tilde = TRUE;
+		}
+		CTRACE((tfp, "check '%s' to translate x/y/ to [.x.y]\n", filename));
+		if (!included_device &&
+		    (cp = StrChr(filename, '/')) != NULL &&
+		    (cp1 = strrchr(cp, '/')) != NULL &&
+		    (cp1 - cp) > 1) {
+		    char *tmp = 0;
+
+		    HTSprintf0(&tmp, "[.%.*s]", (int) (cp1 - cp - 1), cp + 1);
+
+		    CTRACE((tfp, "change path '%s'\n", tmp));
+		    while ((cp2 = strrchr(tmp, '/')) != NULL)
+			*cp2 = '.';
+		    CTRACE((tfp, "...to  path '%s'\n", tmp));
+
+		    status = send_cwd(tmp);
+		    FREE(tmp);
+
+		    if (status != 2) {
+			FREE(fname);
+			init_help_message_cache();	/* to free memory */
+			NETCLOSE(control->socket);
+			control->socket = -1;
+			return ((status < 0) ? status : -status);
+		    }
+		    filename = cp1 + 1;
+		} else {
+		    if (!included_device && !found_tilde) {
+			filename += 1;
+		    }
+		}
+		break;
+	    }
+	case CMS_SERVER:
+	    {
+		/*
+		 * If we want the CMS account's top directory, or a base SFS or
+		 * anonymous directory path (i.e., without a slash), list it
+		 * now.  FM
+		 */
+		if ((strlen(filename) == 1 && *filename == '/') ||
+		    ((0 == strncasecomp((filename + 1), "vmsysu:", 7)) &&
+		     (cp = StrChr((filename + 1), '.')) != NULL &&
+		     StrChr(cp, '/') == NULL) ||
+		    (0 == strncasecomp(filename + 1, "anonymou.", 9) &&
+		     StrChr(filename + 1, '/') == NULL)) {
+		    if (filename[1] != '\0') {
+			status = send_cwd(filename + 1);
+			if (status != 2) {
+			    /* Action not started */
+			    init_help_message_cache();	/* to free memory */
+			    NETCLOSE(control->socket);
+			    control->socket = -1;
+			    return ((status < 0) ? status : -status);
+			}
+		    }
+		    isDirectory = YES;
+		    if (use_list)
+			status = send_cmd_1("LIST");
+		    else
+			status = send_cmd_1("NLST");
+		    FREE(fname);
+		    if (status != 1) {
+			/* Action not started */
+			init_help_message_cache();	/* to free memory */
+			NETCLOSE(control->socket);
+			control->socket = -1;
+			return ((status < 0) ? status : -status);
+		    }
+		    /* Big goto! */
+		    goto listen;
+		}
+		filename++;
+
+		/* Otherwise, go to appropriate directory and adjust filename */
+		while ((cp = StrChr(filename, '/')) != NULL) {
+		    *cp++ = '\0';
+		    status = send_cwd(filename);
+		    if (status == 2) {
+			if (*cp == '\0') {
+			    isDirectory = YES;
+			    if (use_list)
+				status = send_cmd_1("LIST");
+			    else
+				status = send_cmd_1("NLST");
+			    FREE(fname);
+			    if (status != 1) {
+				/* Action not started */
+				init_help_message_cache();	/* to free memory */
+				NETCLOSE(control->socket);
+				control->socket = -1;
+				return ((status < 0) ? status : -status);
+			    }
+			    /* Clear any messages from the login directory */
+			    init_help_message_cache();
+			    /* Big goto! */
+			    goto listen;
+			}
+			filename = cp;
+		    }
+		}
+		break;
+	    }
+	default:
+	    /* Shift for any unescaped "/%2F" path */
+	    if (!StrNCmp(filename, "//", 2))
+		filename++;
+	    break;
+	}
+	/*
+	 * Act on a file or listing request, or try to figure out which we're
+	 * dealing with if we don't know yet.  - FM
+	 */
+	if (!(type) || (type && *type != 'D')) {
+	    /*
+	     * If we are retrieving a file we will (except for CMS) use
+	     * binary mode, which lets us use the size command supported by
+	     * ftp servers which implement RFC 3659.  Knowing the size lets
+	     * us in turn display ETA in the progress message -TD
+	     */
+	    if (control->is_binary) {
+		int code;
+
+		status = send_cmd_2("SIZE", filename);
+		if (status == 2) {
+#if !defined(HAVE_LONG_LONG) && defined(GUESS_PRI_off_t)
+		    long size;
+
+		    if (sscanf(response_text, "%d %ld", &code, &size) == 2) {
+			anchor->content_length = (off_t) size;
+		    }
+#else
+		    off_t size;
+		    if (sscanf(response_text, "%d %" SCN_off_t, &code, &size)
+			== 2) {
+			anchor->content_length = size;
+		    }
+#endif
+		}
+	    }
+	    status = send_cmd_2("RETR", filename);
+	    if (status >= 5) {
+		int check;
+
+		if (Broken_RETR) {
+		    CTRACE((tfp, "{{reconnecting...\n"));
+		    close_connection(control);
+		    check = setup_connection(name, anchor);
+		    CTRACE((tfp, "...done }}reconnecting\n"));
+		    if (check < 0)
+			return check;
+		}
+	    }
+	} else {
+	    status = 5;		/* Failed status set as flag. - FM */
+	}
+	if (status != 1) {	/* Failed : try to CWD to it */
+	    /* Clear any login messages if this isn't the login directory */
+	    if (strcmp(filename, "/"))
+		init_help_message_cache();
+
+	    status = send_cwd(filename);
+	    if (status == 2) {	/* Succeeded : let's NAME LIST it */
+		isDirectory = YES;
+		if (use_list)
+		    status = send_cmd_1("LIST");
+		else
+		    status = send_cmd_1("NLST");
+	    }
+	}
+	FREE(fname);
+	FREE(vmsname);
+	if (status != 1) {
+	    init_help_message_cache();	/* to free memory */
+	    NETCLOSE(control->socket);
+	    control->socket = -1;
+	    if (status < 0)
+		return status;
+	    else
+		return -status;
+	}
+    }
+
+  listen:
+    if (!ftp_local_passive) {
+	/* Wait for the connection */
+	LY_SOCKADDR soc_A;
+	LY_SOCKLEN soc_addrlen = (LY_SOCKLEN) sizeof(soc_A);
+
+#ifdef SOCKS
+	if (socks_flag)
+	    status = Raccept((int) master_socket,
+			     SOCKADDR_OF(soc_A),
+			     &soc_addrlen);
+	else
+#endif /* SOCKS */
+	    status = accept((int) master_socket,
+			    SOCKADDR_OF(soc_A),
+			    &soc_addrlen);
+	if (status < 0) {
+	    init_help_message_cache();	/* to free memory */
+	    return HTInetStatus("accept");
+	}
+	CTRACE((tfp, "TCP: Accepted new socket %d\n", status));
+	data_soc = status;
+    }
+
+    if (isDirectory) {
+	if (server_type == UNIX_SERVER && !unsure_type &&
+	    !strcmp(response_text,
+		    "150 Opening ASCII mode data connection for /bin/dl.\n")) {
+	    CTRACE((tfp, "HTFTP: Treating as \"dls\" server.\n"));
+	    server_type = DLS_SERVER;
+	}
+	final_status = read_directory(anchor, name, format_out, sink);
+	if (final_status > 0) {
+	    if (server_type != CMS_SERVER)
+		if (outstanding-- > 0) {
+		    status = response(NULL);
+		    if (status < 0 ||
+			(status == 2 && !StrNCmp(response_text, "221", 3)))
+			outstanding = 0;
+		}
+	} else {		/* HT_INTERRUPTED */
+	    /* User may have pressed 'z' to give up because no
+	       packets got through, so let's not make them wait
+	       any longer - kw */
+	    outstanding = 0;
+	}
+
+	if (data_soc != -1) {	/* normally done in read_directory */
+	    CTRACE((tfp, "HTFTP: Closing data socket %d\n", data_soc));
+	    status = NETCLOSE(data_soc);
+	    if (status == -1)
+		HTInetStatus("close");	/* Comment only */
+	}
+	status = final_status;
+    } else {
+	int rv;
+	char *FileName = HTParse(name, "", PARSE_PATH + PARSE_PUNCTUATION);
+
+	/* Clear any login messages */
+	init_help_message_cache();
+
+	/* Fake a Content-Encoding for compressed files. - FM */
+	HTUnEscape(FileName);
+	if (!IsUnityEnc(encoding)) {
+	    /*
+	     * We already know from the call to HTFileFormat above that this is
+	     * a compressed file, no need to look at the filename again.  - kw
+	     */
+	    StrAllocCopy(anchor->content_type, format->name);
+	    StrAllocCopy(anchor->content_encoding, HTAtom_name(encoding));
+	    format = HTAtom_for("www/compressed");
+
+	} else {
+	    int rootlen;
+	    CompressFileType cft = HTCompressFileType(FileName, "._-", &rootlen);
+
+	    if (cft != cftNone) {
+		FileName[rootlen] = '\0';
+		format = HTFileFormat(FileName, &encoding, NULL);
+		format = HTCharsetFormat(format, anchor, -1);
+		StrAllocCopy(anchor->content_type, format->name);
+		format = HTAtom_for("www/compressed");
+	    }
+
+	    switch (cft) {
+	    case cftCompress:
+		StrAllocCopy(anchor->content_encoding, "x-compress");
+		break;
+	    case cftGzip:
+		StrAllocCopy(anchor->content_encoding, "x-gzip");
+		break;
+	    case cftDeflate:
+		StrAllocCopy(anchor->content_encoding, "x-deflate");
+		break;
+	    case cftBzip2:
+		StrAllocCopy(anchor->content_encoding, "x-bzip2");
+		break;
+	    case cftBrotli:
+		StrAllocCopy(anchor->content_encoding, "x-brotli");
+		break;
+	    case cftNone:
+		break;
+	    }
+	}
+	FREE(FileName);
+
+	_HTProgress(gettext("Receiving FTP file."));
+	rv = HTParseSocket(format, format_out, anchor, data_soc, sink);
+
+	HTInitInput(control->socket);
+	/* Reset buffering to control connection DD 921208 */
+
+	if (rv < 0) {
+	    if (rv == -2)	/* weird error, don't expect much response */
+		outstanding--;
+	    else if (rv == HT_INTERRUPTED || rv == -1)
+		/* User may have pressed 'z' to give up because no
+		   packets got through, so let's not make them wait
+		   longer - kw */
+		outstanding = 0;
+	    CTRACE((tfp, "HTFTP: Closing data socket %d\n", data_soc));
+	    status = NETCLOSE(data_soc);
+	} else {
+	    status = 2;		/* data_soc already closed in HTCopy - kw */
+	}
+
+	if (status < 0 && rv != HT_INTERRUPTED && rv != -1) {
+	    (void) HTInetStatus("close");	/* Comment only */
+	} else {
+	    if (rv != HT_LOADED && outstanding--) {
+		status = response(NULL);	/* Pick up final reply */
+		if (status != 2 && rv != HT_INTERRUPTED && rv != -1) {
+		    data_soc = -1;	/* invalidate it */
+		    init_help_message_cache();	/* to free memory */
+		    return HTLoadError(sink, 500, response_text);
+		} else if (status == 2 && !StrNCmp(response_text, "221", 3)) {
+		    outstanding = 0;
+		}
+	    }
+	}
+	final_status = HT_LOADED;
+    }
+    while (outstanding-- > 0 &&
+	   (status > 0)) {
+	status = response(NULL);
+	if (status == 2 && !StrNCmp(response_text, "221", 3))
+	    break;
+    }
+    data_soc = -1;		/* invalidate it */
+    CTRACE((tfp, "HTFTPLoad: normal end; "));
+    if (control->socket < 0) {
+	CTRACE((tfp, "control socket is %d\n", control->socket));
+    } else {
+	CTRACE((tfp, "closing control socket %d\n", control->socket));
+	status = NETCLOSE(control->socket);
+	if (status == -1)
+	    HTInetStatus("control connection close");	/* Comment only */
+    }
+    control->socket = -1;
+    init_help_message_cache();	/* to free memory */
+    /* returns HT_LOADED (always for file if we get here) or error */
+    return final_status;
+}				/* open_file_read */
+
+/*
+ *  This function frees any user entered password, so that
+ *  it must be entered again for a future request. - FM
+ */
+void HTClearFTPPassword(void)
+{
+    /*
+     * Need code to check cached documents from non-anonymous ftp accounts and
+     * do something to ensure that they no longer can be accessed without a new
+     * retrieval.  - FM
+     */
+
+    /*
+     * Now free the current user entered password, if any.  - FM
+     */
+    FREE(user_entered_password);
+}
+
+#endif /* ifndef DISABLE_FTP */
diff --git a/WWW/Library/Implementation/HTFTP.h b/WWW/Library/Implementation/HTFTP.h
new file mode 100644
index 0000000..a903bbb
--- /dev/null
+++ b/WWW/Library/Implementation/HTFTP.h
@@ -0,0 +1,70 @@
+/*                                                               FTP access module for libwww
+                                   FTP ACCESS FUNCTIONS
+
+   This isn't really  a valid protocol module -- it is lumped together with HTFile . That
+   could be changed easily.
+
+   Author: Tim Berners-Lee.  Public Domain.  Please mail changes to timbl@info.cern.ch
+
+ */
+#ifndef HTFTP_H
+#define HTFTP_H
+
+#include <HTAnchor.h>
+#include <HTStream.h>
+#include <HTParse.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define FILE_BY_NAME 0
+#define FILE_BY_TYPE 1
+#define FILE_BY_SIZE 2
+#define FILE_BY_DATE 3
+    extern int HTfileSortMethod;	/* specifies the method of sorting */
+
+/* PUBLIC						 HTVMS_name()
+ *		CONVERTS WWW name into a VMS name
+ * ON ENTRY:
+ *	nn		Node Name (optional)
+ *	fn		WWW file name
+ *
+ * ON EXIT:
+ *	returns		vms file specification
+ *
+ * Bug:	Returns pointer to static -- non-reentrant
+ */
+    extern char *HTVMS_name(const char *nn,
+			    const char *fn);
+
+/*
+
+Retrieve File from Server
+
+  ON EXIT,
+
+  returns                 Socket number for file if good.<0 if bad.
+
+ */
+    extern int HTFTPLoad(const char *name,
+			 HTParentAnchor *anchor,
+			 HTFormat format_out,
+			 HTStream *sink);
+
+/*
+ *  This function frees any user entered password, so that
+ *  it must be entered again for a future request. - FM
+ */
+    extern void HTClearFTPPassword(void);
+
+/*
+
+Return Host Name
+
+ */
+    extern const char *HTHostName(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/WWW/Library/Implementation/HTFWriter.h b/WWW/Library/Implementation/HTFWriter.h
new file mode 100644
index 0000000..015ea15
--- /dev/null
+++ b/WWW/Library/Implementation/HTFWriter.h
@@ -0,0 +1,30 @@
+/*                                                                     File Writer for libwww
+                                      C FILE WRITER
+
+   It is useful to have both FWriter and Writer for environments in which fdopen() doesn't
+   exist for example.
+
+ */
+#ifndef HTFWRITE_H
+#define HTFWRITE_H
+
+#include <HTStream.h>
+#include <HTFormat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern HTStream *HTFWriter_new(FILE *fp);
+
+    extern HTStream *HTSaveAndExecute(HTPresentation *pres,
+				      HTParentAnchor *anchor,	/* Not used */
+				      HTStream *sink);
+
+    extern HTStream *HTSaveLocally(HTPresentation *pres,
+				   HTParentAnchor *anchor,	/* Not used */
+				   HTStream *sink);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTFWRITE_H */
diff --git a/WWW/Library/Implementation/HTFile.c b/WWW/Library/Implementation/HTFile.c
new file mode 100644
index 0000000..8fdaa2c
--- /dev/null
+++ b/WWW/Library/Implementation/HTFile.c
@@ -0,0 +1,3395 @@
+/*
+ * $LynxId: HTFile.c,v 1.158 2022/07/25 23:52:05 tom Exp $
+ *
+ *			File Access				HTFile.c
+ *			===========
+ *
+ *	This is unix-specific code in general, with some VMS bits.
+ *	These are routines for file access used by browsers.
+ *	Development of this module for Unix DIRED_SUPPORT in Lynx
+ *	 regrettably has has been conducted in a manner with now
+ *	 creates a major impediment for hopes of adapting Lynx to
+ *	 a newer version of the library.
+ *
+ *  History:
+ *	   Feb 91	Written Tim Berners-Lee CERN/CN
+ *	   Apr 91	vms-vms access included using DECnet syntax
+ *	26 Jun 92 (JFG) When running over DECnet, suppressed FTP.
+ *			Fixed access bug for relative names on VMS.
+ *	   Sep 93 (MD)	Access to VMS files allows sharing.
+ *	15 Nov 93 (MD)	Moved HTVMSname to HTVMSUTILS.C
+ *	27 Dec 93 (FM)	FTP now works with VMS hosts.
+ *			FTP path must be Unix-style and cannot include
+ *			the device or top directory.
+ */
+
+#include <HTUtils.h>
+
+#ifndef VMS
+#if defined(DOSPATH)
+#undef LONG_LIST
+#define LONG_LIST		/* Define this for long style unix listings (ls -l),
+				   the actual style is configurable from lynx.cfg */
+#endif
+/* #define NO_PARENT_DIR_REFERENCE */
+/* Define this for no parent links */
+#endif /* !VMS */
+
+#if defined(DOSPATH)
+#define HAVE_READDIR 1
+#define USE_DIRENT
+#endif
+
+#if defined(USE_DOS_DRIVES)
+#include <HTDOS.h>
+#endif
+
+#include <HTFile.h>		/* Implemented here */
+
+#ifdef VMS
+#include <stat.h>
+#endif /* VMS */
+
+#if defined (USE_ZLIB) || defined (USE_BZLIB)
+#include <GridText.h>
+#endif
+
+#define MULTI_SUFFIX ".multi"	/* Extension for scanning formats */
+
+#include <HTParse.h>
+#include <HTTCP.h>
+#ifndef DECNET
+#include <HTFTP.h>
+#endif /* !DECNET */
+#include <HTAnchor.h>
+#include <HTAtom.h>
+#include <HTAAProt.h>
+#include <HTFWriter.h>
+#include <HTInit.h>
+#include <HTBTree.h>
+#include <HTAlert.h>
+#include <HTCJK.h>
+#include <UCDefs.h>
+#include <UCMap.h>
+#include <UCAux.h>
+
+#include <LYexit.h>
+#include <LYCharSets.h>
+#include <LYGlobalDefs.h>
+#include <LYStrings.h>
+#include <LYUtils.h>
+
+#ifdef USE_PRETTYSRC
+# include <LYPrettySrc.h>
+#endif
+
+#include <LYLeaks.h>
+
+typedef struct _HTSuffix {
+    char *suffix;
+    HTAtom *rep;
+    HTAtom *encoding;
+    char *desc;
+    float quality;
+} HTSuffix;
+
+typedef struct {
+    struct stat file_info;
+    char sort_tags;
+    char file_name[1];		/* on the end of the struct, since its length varies */
+} DIRED;
+
+#ifndef NGROUPS
+#ifdef NGROUPS_MAX
+#define NGROUPS NGROUPS_MAX
+#else
+#define NGROUPS 32
+#endif /* NGROUPS_MAX */
+#endif /* NGROUPS */
+
+#ifndef GETGROUPS_T
+#define GETGROUPS_T int
+#endif
+
+#include <HTML.h>		/* For directory object building */
+
+#define PUTC(c)      (*target->isa->put_character)(target, c)
+#define PUTS(s)      (*target->isa->put_string)(target, s)
+#define START(e)     (*target->isa->start_element)(target, e, 0, 0, -1, 0)
+#define END(e)       (*target->isa->end_element)(target, e, 0)
+#define MAYBE_END(e) if (HTML_dtd.tags[e].contents != SGML_EMPTY) \
+			(*target->isa->end_element)(target, e, 0)
+#define FREE_TARGET  (*target->isa->_free)(target)
+#define ABORT_TARGET (*targetClass._abort)(target, NULL);
+
+struct _HTStructured {
+    const HTStructuredClass *isa;
+    /* ... */
+};
+
+/*
+ *  Controlling globals.
+ */
+int HTDirAccess = HT_DIR_OK;
+
+#ifdef DIRED_SUPPORT
+int HTDirReadme = HT_DIR_README_NONE;
+
+#else
+int HTDirReadme = HT_DIR_README_TOP;
+#endif /* DIRED_SUPPORT */
+
+static const char *HTMountRoot = "/Net/";	/* Where to find mounts */
+
+#ifdef VMS
+static const char *HTCacheRoot = "/WWW$SCRATCH";	/* Where to cache things */
+
+#else
+static const char *HTCacheRoot = "/tmp/W3_Cache_";	/* Where to cache things */
+#endif /* VMS */
+
+static char s_no_suffix[] = "*";
+static char s_unknown_suffix[] = "*.*";
+
+/*
+ *  Suffix registration.
+ */
+static HTList *HTSuffixes = 0;
+
+static HTSuffix no_suffix =
+{
+    s_no_suffix, NULL, NULL, NULL, 1.0
+};
+
+static HTSuffix unknown_suffix =
+{
+    s_unknown_suffix, NULL, NULL, NULL, 1.0
+};
+
+/*	To free up the suffixes at program exit.
+ *	----------------------------------------
+ */
+#ifdef LY_FIND_LEAKS
+static void free_suffixes(void);
+#endif
+
+#define FindSearch(filename) strchr(filename, '?')
+
+#ifdef LONG_LIST
+static char *FormatStr(char **bufp,
+		       char *start,
+		       const char *entry)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*ss", (int) sizeof(fmt) - 3, start);
+	HTSprintf0(bufp, fmt, entry);
+    } else if (*bufp && !(entry && *entry)) {
+	**bufp = '\0';
+    } else if (entry) {
+	StrAllocCopy(*bufp, entry);
+    }
+    return *bufp;
+}
+
+static char *FormatSize(char **bufp,
+			char *start,
+			off_t entry)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*s" PRI_off_t,
+		  (int) sizeof(fmt) - DigitsOf(start) - 3, start);
+
+	HTSprintf0(bufp, fmt, entry);
+    } else {
+	sprintf(fmt, "%" PRI_off_t, CAST_off_t (entry));
+
+	StrAllocCopy(*bufp, fmt);
+    }
+    return *bufp;
+}
+
+static char *FormatNum(char **bufp,
+		       char *start,
+		       int entry)
+{
+    char fmt[512];
+
+    if (*start) {
+	sprintf(fmt, "%%%.*sd", (int) sizeof(fmt) - 3, start);
+	HTSprintf0(bufp, fmt, entry);
+    } else {
+	sprintf(fmt, "%d", entry);
+	StrAllocCopy(*bufp, fmt);
+    }
+    return *bufp;
+}
+
+static void LYListFmtParse(const char *fmtstr,
+			   DIRED * data,
+			   char *file,
+			   HTStructured * target,
+			   char *tail)
+{
+    char c;
+    char *s;
+    char *end;
+    char *start;
+    char *str = NULL;
+    char *buf = NULL;
+    char tmp[LY_MAXPATH];
+    char type;
+
+#ifndef NOUSERS
+    const char *name;
+#endif
+    time_t now;
+    char *datestr;
+
+#ifdef S_IFLNK
+    int len;
+#endif
+#define SEC_PER_YEAR	(60 * 60 * 24 * 365)
+
+#ifdef _WINDOWS			/* 1998/01/06 (Tue) 21:20:53 */
+    static const char *pbits[] =
+    {
+	"---", "--x", "-w-", "-wx",
+	"r--", "r-x", "rw-", "rwx",
+	0};
+
+#define PBIT(a, n, s)  pbits[((a) >> (n)) & 0x7]
+
+#else
+    static const char *pbits[] =
+    {"---", "--x", "-w-", "-wx",
+     "r--", "r-x", "rw-", "rwx", 0};
+    static const char *psbits[] =
+    {"--S", "--s", "-wS", "-ws",
+     "r-S", "r-s", "rwS", "rws", 0};
+
+#define PBIT(a, n, s)  (s) ? psbits[((a) >> (n)) & 0x7] : \
+	pbits[((a) >> (n)) & 0x7]
+#endif
+#if defined(S_ISVTX) && !defined(_WINDOWS)
+    static const char *ptbits[] =
+    {"--T", "--t", "-wT", "-wt",
+     "r-T", "r-t", "rwT", "rwt", 0};
+
+#define PTBIT(a, s)  (s) ? ptbits[(a) & 0x7] : pbits[(a) & 0x7]
+#else
+#define PTBIT(a, s)  PBIT(a, 0, 0)
+#endif
+
+    if (data->file_info.st_mode == 0)
+	fmtstr = "    %a";	/* can't stat so just do anchor */
+
+    StrAllocCopy(str, fmtstr);
+    s = str;
+    end = str + strlen(str);
+    while (*s) {
+	start = s;
+	while (*s) {
+	    if (*s == '%') {
+		if (*(s + 1) == '%')	/* literal % */
+		    s++;
+		else
+		    break;
+	    }
+	    s++;
+	}
+	/* s is positioned either at a % or at \0 */
+	*s = '\0';
+	if (s > start) {	/* some literal chars. */
+	    PUTS(start);
+	}
+	if (s == end)
+	    break;
+	start = ++s;
+	while (isdigit(UCH(*s)) || *s == '.' || *s == '-' || *s == ' ' ||
+	       *s == '#' || *s == '+' || *s == '\'')
+	    s++;
+	c = *s;			/* the format char. or \0 */
+	*s = '\0';
+
+	switch (c) {
+	case '\0':
+	    PUTS(start);
+	    continue;
+
+	case 'A':
+	case 'a':		/* anchor */
+	    HTDirEntry(target, tail, data->file_name);
+	    FormatStr(&buf, start, data->file_name);
+	    PUTS(buf);
+	    END(HTML_A);
+	    *buf = '\0';
+#ifdef S_IFLNK
+	    if (c != 'A' && S_ISLNK(data->file_info.st_mode) &&
+		(len = (int) readlink(file, tmp, sizeof(tmp) - 1)) >= 0) {
+		PUTS(" -> ");
+		tmp[len] = '\0';
+		PUTS(tmp);
+	    }
+#endif
+	    break;
+
+	case 'T':		/* MIME type */
+	case 't':		/* MIME type description */
+	    if (S_ISDIR(data->file_info.st_mode)) {
+		if (c != 'T') {
+		    FormatStr(&buf, start, ENTRY_IS_DIRECTORY);
+		} else {
+		    FormatStr(&buf, start, "");
+		}
+	    } else {
+		const char *cp2;
+		HTFormat format;
+
+		format = HTFileFormat(file, NULL, &cp2);
+
+		if (c != 'T') {
+		    if (cp2 == NULL) {
+			if (!StrNCmp(HTAtom_name(format),
+				     "application", 11)) {
+			    cp2 = HTAtom_name(format) + 12;
+			    if (!StrNCmp(cp2, "x-", 2))
+				cp2 += 2;
+			} else {
+			    cp2 = HTAtom_name(format);
+			}
+		    }
+		    FormatStr(&buf, start, cp2);
+		} else {
+		    FormatStr(&buf, start, HTAtom_name(format));
+		}
+	    }
+	    break;
+
+	case 'd':		/* date */
+	    now = time(0);
+	    datestr = ctime(&data->file_info.st_mtime);
+	    if ((now - data->file_info.st_mtime) < SEC_PER_YEAR / 2)
+		/*
+		 * MMM DD HH:MM
+		 */
+		sprintf(tmp, "%.12s", datestr + 4);
+	    else
+		/*
+		 * MMM DD YYYY
+		 */
+		sprintf(tmp, "%.7s %.4s ", datestr + 4,
+			datestr + 20);
+	    FormatStr(&buf, start, tmp);
+	    break;
+
+	case 's':		/* size in bytes */
+	    FormatSize(&buf, start, data->file_info.st_size);
+	    break;
+
+	case 'K':		/* size in Kilobytes but not for directories */
+	    if (S_ISDIR(data->file_info.st_mode)) {
+		FormatStr(&buf, start, "");
+		StrAllocCat(buf, " ");
+		break;
+	    }
+	    /* FALL THROUGH */
+	case 'k':		/* size in Kilobytes */
+	    FormatSize(&buf, start, ((data->file_info.st_size + 1023) / 1024));
+	    StrAllocCat(buf, "K");
+	    break;
+
+	case 'p':		/* unix-style permission bits */
+	    switch (data->file_info.st_mode & S_IFMT) {
+#if defined(_MSC_VER) && defined(_S_IFIFO)
+	    case _S_IFIFO:
+		type = 'p';
+		break;
+#else
+	    case S_IFIFO:
+		type = 'p';
+		break;
+#endif
+	    case S_IFCHR:
+		type = 'c';
+		break;
+	    case S_IFDIR:
+		type = 'd';
+		break;
+	    case S_IFREG:
+		type = '-';
+		break;
+#ifdef S_IFBLK
+	    case S_IFBLK:
+		type = 'b';
+		break;
+#endif
+#ifdef S_IFLNK
+	    case S_IFLNK:
+		type = 'l';
+		break;
+#endif
+#ifdef S_IFSOCK
+# ifdef S_IFIFO			/* some older machines (e.g., apollo) have a conflict */
+#  if S_IFIFO != S_IFSOCK
+	    case S_IFSOCK:
+		type = 's';
+		break;
+#  endif
+# else
+	    case S_IFSOCK:
+		type = 's';
+		break;
+# endif
+#endif /* S_IFSOCK */
+	    default:
+		type = '?';
+		break;
+	    }
+#ifdef _WINDOWS
+	    sprintf(tmp, "%c%s", type,
+		    PBIT(data->file_info.st_mode, 6, data->file_info.st_mode & S_IRWXU));
+#else
+	    sprintf(tmp, "%c%s%s%s", type,
+		    PBIT(data->file_info.st_mode, 6, data->file_info.st_mode & S_ISUID),
+		    PBIT(data->file_info.st_mode, 3, data->file_info.st_mode & S_ISGID),
+		    PTBIT(data->file_info.st_mode, data->file_info.st_mode & S_ISVTX));
+#endif
+	    FormatStr(&buf, start, tmp);
+	    break;
+
+	case 'o':		/* owner */
+#ifndef NOUSERS
+	    name = HTAA_UidToName((int) data->file_info.st_uid);
+	    if (*name) {
+		FormatStr(&buf, start, name);
+	    } else {
+		FormatNum(&buf, start, (int) data->file_info.st_uid);
+	    }
+#endif
+	    break;
+
+	case 'g':		/* group */
+#ifndef NOUSERS
+	    name = HTAA_GidToName((int) data->file_info.st_gid);
+	    if (*name) {
+		FormatStr(&buf, start, name);
+	    } else {
+		FormatNum(&buf, start, (int) data->file_info.st_gid);
+	    }
+#endif
+	    break;
+
+	case 'l':		/* link count */
+	    FormatNum(&buf, start, (int) data->file_info.st_nlink);
+	    break;
+
+	case '%':		/* literal % with flags/width */
+	    FormatStr(&buf, start, "%");
+	    break;
+
+	default:
+	    fprintf(stderr,
+		    "Unknown format character `%c' in list format\n", c);
+	    break;
+	}
+	if (buf)
+	    PUTS(buf);
+
+	s++;
+    }
+    FREE(buf);
+    PUTC('\n');
+    FREE(str);
+}
+#endif /* LONG_LIST */
+
+/*	Define the representation associated with a file suffix.
+ *	--------------------------------------------------------
+ *
+ *	Calling this with suffix set to "*" will set the default
+ *	representation.
+ *	Calling this with suffix set to "*.*" will set the default
+ *	representation for unknown suffix files which contain a ".".
+ *
+ *	The encoding parameter can give a trivial (8bit, 7bit, binary)
+ *	or real (gzip, compress) encoding.
+ *
+ *	If filename suffix is already defined with the same encoding
+ *	its previous definition is overridden.
+ */
+void HTSetSuffix5(const char *suffix,
+		  const char *representation,
+		  const char *encoding,
+		  const char *desc,
+		  double value)
+{
+    HTSuffix *suff;
+    BOOL trivial_enc = (BOOL) IsUnityEncStr(encoding);
+
+    if (strcmp(suffix, s_no_suffix) == 0)
+	suff = &no_suffix;
+    else if (strcmp(suffix, s_unknown_suffix) == 0)
+	suff = &unknown_suffix;
+    else {
+	HTList *cur = HTSuffixes;
+
+	while (NULL != (suff = (HTSuffix *) HTList_nextObject(cur))) {
+	    if (suff->suffix && 0 == strcmp(suff->suffix, suffix) &&
+		((trivial_enc && IsUnityEnc(suff->encoding)) ||
+		 (!trivial_enc && !IsUnityEnc(suff->encoding) &&
+		  strcmp(encoding, HTAtom_name(suff->encoding)) == 0)))
+		break;
+	}
+	if (!suff) {		/* Not found -- create a new node */
+	    suff = typecalloc(HTSuffix);
+	    if (suff == NULL)
+		outofmem(__FILE__, "HTSetSuffix");
+
+	    if (!HTSuffixes) {
+		HTSuffixes = HTList_new();
+#ifdef LY_FIND_LEAKS
+		atexit(free_suffixes);
+#endif
+	    }
+
+	    HTList_addObject(HTSuffixes, suff);
+
+	    StrAllocCopy(suff->suffix, suffix);
+	}
+    }
+
+    if (representation)
+	suff->rep = HTAtom_for(representation);
+
+    /*
+     * Memory leak fixed.
+     * 05-28-94 Lynx 2-3-1 Garrett Arch Blythe
+     * Invariant code removed.
+     */
+    suff->encoding = HTAtom_for(encoding);
+
+    StrAllocCopy(suff->desc, desc);
+
+    suff->quality = (float) value;
+}
+
+#ifdef LY_FIND_LEAKS
+/*
+ *	Purpose:	Free all added suffixes.
+ *	Arguments:	void
+ *	Return Value:	void
+ *	Remarks/Portability/Dependencies/Restrictions:
+ *		To be used at program exit.
+ *	Revision History:
+ *		05-28-94	created Lynx 2-3-1 Garrett Arch Blythe
+ */
+static void free_suffixes(void)
+{
+    HTSuffix *suff = NULL;
+
+    /*
+     * Loop through all suffixes.
+     */
+    while (!HTList_isEmpty(HTSuffixes)) {
+	/*
+	 * Free off each item and its members if need be.
+	 */
+	suff = (HTSuffix *) HTList_removeLastObject(HTSuffixes);
+	FREE(suff->suffix);
+	FREE(suff->desc);
+	FREE(suff);
+    }
+    /*
+     * Free off the list itself.
+     */
+    HTList_delete(HTSuffixes);
+    HTSuffixes = NULL;
+}
+#endif /* LY_FIND_LEAKS */
+
+/*	Make the cache file name for a W3 document.
+ *	-------------------------------------------
+ *	Make up a suitable name for saving the node in
+ *
+ *	E.g.	/tmp/WWW_Cache_news/1234@cernvax.cern.ch
+ *		/tmp/WWW_Cache_http/crnvmc/FIND/xx.xxx.xx
+ *
+ *  On exit:
+ *	Returns a malloc'ed string which must be freed by the caller.
+ */
+char *HTCacheFileName(const char *name)
+{
+    char *acc_method = HTParse(name, "", PARSE_ACCESS);
+    char *host = HTParse(name, "", PARSE_HOST);
+    char *path = HTParse(name, "", PARSE_PATH + PARSE_PUNCTUATION);
+    char *result = NULL;
+
+    HTSprintf0(&result, "%s/WWW/%s/%s%s", HTCacheRoot, acc_method, host, path);
+
+    FREE(path);
+    FREE(acc_method);
+    FREE(host);
+    return result;
+}
+
+/*	Open a file for write, creating the path.
+ *	-----------------------------------------
+ */
+#ifdef NOT_IMPLEMENTED
+static int HTCreatePath(const char *path)
+{
+    return -1;
+}
+#endif /* NOT_IMPLEMENTED */
+
+/*	Convert filename from URL-path syntax to local path format
+ *	----------------------------------------------------------
+ *	Input name is assumed to be the URL-path of a local file
+ *      URL, i.e. what comes after the "file://localhost".
+ *      '#'-fragments to be treated as such must already be stripped.
+ *      If expand_all is FALSE, unescape only escaped '/'. - kw
+ *
+ *  On exit:
+ *	Returns a malloc'ed string which must be freed by the caller.
+ */
+char *HTURLPath_toFile(const char *name,
+		       int expand_all,
+		       int is_remote GCC_UNUSED)
+{
+    char *path = NULL;
+    char *result = NULL;
+
+    StrAllocCopy(path, name);
+    if (expand_all)
+	HTUnEscape(path);	/* Interpret all % signs */
+    else
+	HTUnEscapeSome(path, "/");	/* Interpret % signs for path delims */
+
+    CTRACE((tfp, "URLPath `%s' means path `%s'\n", name, path));
+#if defined(USE_DOS_DRIVES)
+    StrAllocCopy(result, is_remote ? path : HTDOS_name(path));
+#else
+    StrAllocCopy(result, path);
+#endif
+
+    FREE(path);
+
+    return result;
+}
+/*	Convert filenames between local and WWW formats.
+ *	------------------------------------------------
+ *	Make up a suitable name for saving the node in
+ *
+ *	E.g.	$(HOME)/WWW/news/1234@cernvax.cern.ch
+ *		$(HOME)/WWW/http/crnvmc/FIND/xx.xxx.xx
+ *
+ *  On exit:
+ *	Returns a malloc'ed string which must be freed by the caller.
+ */
+/* NOTE: Don't use this function if you know that the input is a URL path
+	 rather than a full URL, use HTURLPath_toFile instead.  Otherwise
+	 this function will return the wrong thing for some unusual
+	 paths (like ones containing "//", possibly escaped). - kw
+*/
+char *HTnameOfFile_WWW(const char *name,
+		       int WWW_prefix,
+		       int expand_all)
+{
+    char *acc_method = HTParse(name, "", PARSE_ACCESS);
+    char *host = HTParse(name, "", PARSE_HOST);
+    char *path = HTParse(name, "", PARSE_PATH + PARSE_PUNCTUATION);
+    const char *home;
+    char *result = NULL;
+
+    if (expand_all) {
+	HTUnEscape(path);	/* Interpret all % signs */
+    } else
+	HTUnEscapeSome(path, "/");	/* Interpret % signs for path delims */
+
+    if (0 == strcmp(acc_method, "file")		/* local file */
+	||!*acc_method) {	/* implicitly local? */
+	if ((0 == strcasecomp(host, HTHostName())) ||
+	    (0 == strcasecomp(host, "localhost")) || !*host) {
+	    CTRACE((tfp, "Node `%s' means path `%s'\n", name, path));
+	    StrAllocCopy(result, HTSYS_name(path));
+	} else if (WWW_prefix) {
+	    HTSprintf0(&result, "%s%s%s", "/Net/", host, path);
+	    CTRACE((tfp, "Node `%s' means file `%s'\n", name, result));
+	} else {
+	    StrAllocCopy(result, path);
+	}
+    } else if (WWW_prefix) {	/* other access */
+#ifdef VMS
+	if ((home = LYGetEnv("HOME")) == NULL)
+	    home = HTCacheRoot;
+	else
+	    home = HTVMS_wwwName(home);
+#else
+#if defined(_WINDOWS)		/* 1997/10/16 (Thu) 20:42:51 */
+	home = Home_Dir();
+#else
+	home = LYGetEnv("HOME");
+#endif
+	if (home == NULL)
+	    home = "/tmp";
+#endif /* VMS */
+	HTSprintf0(&result, "%s/WWW/%s/%s%s", home, acc_method, host, path);
+    } else {
+	StrAllocCopy(result, path);
+    }
+
+    FREE(host);
+    FREE(path);
+    FREE(acc_method);
+
+    CTRACE((tfp, "HTnameOfFile_WWW(%s,%d,%d) = %s\n",
+	    name, WWW_prefix, expand_all, result));
+
+    return result;
+}
+
+/*	Make a WWW name from a full local path name.
+ *	--------------------------------------------
+ *
+ *  Bugs:
+ *	At present, only the names of two network root nodes are hand-coded
+ *	in and valid for the NeXT only.  This should be configurable in
+ *	the general case.
+ */
+char *WWW_nameOfFile(const char *name)
+{
+    char *result = NULL;
+
+#ifdef NeXT
+    if (0 == StrNCmp("/private/Net/", name, 13)) {
+	HTSprintf0(&result, "%s//%s", STR_FILE_URL, name + 13);
+    } else
+#endif /* NeXT */
+    if (0 == StrNCmp(HTMountRoot, name, 5)) {
+	HTSprintf0(&result, "%s//%s", STR_FILE_URL, name + 5);
+    } else {
+	HTSprintf0(&result, "%s//%s%s", STR_FILE_URL, HTHostName(), name);
+    }
+    CTRACE((tfp, "File `%s'\n\tmeans node `%s'\n", name, result));
+    return result;
+}
+
+/*	Determine a suitable suffix, given the representation.
+ *	------------------------------------------------------
+ *
+ *  On entry,
+ *	rep	is the atomized MIME style representation
+ *	enc	is an encoding, trivial (8bit, binary, etc.) or gzip etc.
+ *
+ *  On exit:
+ *	Returns a pointer to a suitable suffix string if one has been
+ *	found, else "".
+ */
+const char *HTFileSuffix(HTAtom *rep,
+			 const char *enc)
+{
+    HTSuffix *suff;
+
+#ifdef FNAMES_8_3
+    HTSuffix *first_found = NULL;
+#endif
+    BOOL trivial_enc;
+    int n;
+    int i;
+
+#define NO_INIT			/* don't init anymore since I do it in Lynx at startup */
+#ifndef NO_INIT
+    if (!HTSuffixes)
+	HTFileInit();
+#endif /* !NO_INIT */
+
+    trivial_enc = (BOOL) IsUnityEncStr(enc);
+    n = HTList_count(HTSuffixes);
+    for (i = 0; i < n; i++) {
+	suff = (HTSuffix *) HTList_objectAt(HTSuffixes, i);
+	if (suff->rep == rep &&
+#if defined(VMS) || defined(FNAMES_8_3)
+	/*  Don't return a suffix whose first char is a dot, and which
+	   has more dots or asterisks after that, for
+	   these systems - kw */
+	    (!suff->suffix || !suff->suffix[0] || suff->suffix[0] != '.' ||
+	     (StrChr(suff->suffix + 1, '.') == NULL &&
+	      StrChr(suff->suffix + 1, '*') == NULL)) &&
+#endif
+	    ((trivial_enc && IsUnityEnc(suff->encoding)) ||
+	     (!trivial_enc && !IsUnityEnc(suff->encoding) &&
+	      strcmp(enc, HTAtom_name(suff->encoding)) == 0))) {
+#ifdef FNAMES_8_3
+	    if (suff->suffix && (strlen(suff->suffix) <= 4)) {
+		/*
+		 * If length of suffix (including dot) is 4 or smaller, return
+		 * this one even if we found a longer one earlier - kw
+		 */
+		return suff->suffix;
+	    } else if (!first_found) {
+		first_found = suff;	/* remember this one */
+	    }
+#else
+	    return suff->suffix;	/* OK -- found */
+#endif
+	}
+    }
+#ifdef FNAMES_8_3
+    if (first_found)
+	return first_found->suffix;
+#endif
+    return "";			/* Dunno */
+}
+
+/*
+ * Trim version from VMS filenames to avoid confusing comparisons.
+ */
+#ifdef VMS
+static const char *VMS_trim_version(const char *filename)
+{
+    const char *result = filename;
+    const char *version = StrChr(filename, ';');
+
+    if (version != 0) {
+	static char *stripped;
+
+	StrAllocCopy(stripped, filename);
+	stripped[version - filename] = '\0';
+	result = (const char *) stripped;
+    }
+    return result;
+}
+#define VMS_DEL_VERSION(name) name = VMS_trim_version(name)
+#else
+#define VMS_DEL_VERSION(name)	/* nothing */
+#endif
+
+/*	Determine file format from file name.
+ *	-------------------------------------
+ *
+ *	This version will return the representation and also set
+ *	a variable for the encoding.
+ *
+ *	Encoding may be a unity encoding (binary, 8bit, etc.) or
+ *	a content-coding like gzip, compress.
+ *
+ *	It will handle for example  x.txt, x.txt,Z, x.Z
+ */
+HTFormat HTFileFormat(const char *filename,
+		      HTAtom **pencoding,
+		      const char **pdesc)
+{
+    HTSuffix *suff;
+    int n;
+    int i;
+    int lf;
+    char *search;
+
+    VMS_DEL_VERSION(filename);
+
+    if ((search = FindSearch(filename)) != 0) {
+	char *newname = NULL;
+	HTFormat result;
+
+	StrAllocCopy(newname, filename);
+	newname[((const char *) search) - filename] = '\0';
+	result = HTFileFormat(newname, pencoding, pdesc);
+	free(newname);
+	return result;
+    }
+
+    if (pencoding)
+	*pencoding = NULL;
+    if (pdesc)
+	*pdesc = NULL;
+    if (LYforce_HTML_mode) {
+	if (pencoding)
+	    *pencoding = WWW_ENC_8BIT;
+	return WWW_HTML;
+    }
+#ifndef NO_INIT
+    if (!HTSuffixes)
+	HTFileInit();
+#endif /* !NO_INIT */
+    lf = (int) strlen(filename);
+    n = HTList_count(HTSuffixes);
+    for (i = 0; i < n; i++) {
+	int ls;
+
+	suff = (HTSuffix *) HTList_objectAt(HTSuffixes, i);
+	ls = (int) strlen(suff->suffix);
+	if ((ls <= lf) && 0 == strcasecomp(suff->suffix, filename + lf - ls)) {
+	    int j;
+
+	    if (pencoding)
+		*pencoding = suff->encoding;
+	    if (pdesc)
+		*pdesc = suff->desc;
+	    if (suff->rep) {
+		return suff->rep;	/* OK -- found */
+	    }
+	    for (j = 0; j < n; j++) {	/* Got encoding, need representation */
+		int ls2;
+
+		suff = (HTSuffix *) HTList_objectAt(HTSuffixes, j);
+		ls2 = (int) strlen(suff->suffix);
+		if ((ls + ls2 <= lf) &&
+		    !strncasecomp(suff->suffix,
+				  filename + lf - ls - ls2, ls2)) {
+		    if (suff->rep) {
+			if (pdesc && !(*pdesc))
+			    *pdesc = suff->desc;
+			if (pencoding && IsUnityEnc(*pencoding) &&
+			    *pencoding != WWW_ENC_7BIT &&
+			    !IsUnityEnc(suff->encoding))
+			    *pencoding = suff->encoding;
+			return suff->rep;
+		    }
+		}
+	    }
+
+	}
+    }
+
+    /* defaults tree */
+
+    suff = (StrChr(filename, '.')
+	    ? (unknown_suffix.rep
+	       ? &unknown_suffix
+	       : &no_suffix)
+	    : &no_suffix);
+
+    /*
+     * Set default encoding unless found with suffix already.
+     */
+    if (pencoding && !*pencoding) {
+	*pencoding = (suff->encoding
+		      ? suff->encoding
+		      : HTAtom_for("binary"));
+    }
+    return suff->rep ? suff->rep : WWW_BINARY;
+}
+
+/*	Revise the file format in relation to the Lynx charset. - FM
+ *	-------------------------------------------------------
+ *
+ *	This checks the format associated with an anchor for
+ *	an extended MIME Content-Type, and if a charset is
+ *	indicated, sets Lynx up for proper handling in relation
+ *	to the currently selected character set. - FM
+ */
+HTFormat HTCharsetFormat(HTFormat format,
+			 HTParentAnchor *anchor,
+			 int default_LYhndl)
+{
+    char *cp = NULL, *cp1, *cp2, *cp3 = NULL, *cp4;
+    BOOL chartrans_ok = FALSE;
+    int chndl = -1;
+    const char *format_name = format->name;
+
+    FREE(anchor->charset);
+    if (format_name == 0)
+	format_name = "";
+    StrAllocCopy(cp, format_name);
+    LYLowerCase(cp);
+    if (((cp1 = StrChr(cp, ';')) != NULL) &&
+	(cp2 = strstr(cp1, "charset")) != NULL) {
+	CTRACE((tfp, "HTCharsetFormat: Extended MIME Content-Type is %s\n",
+		format_name));
+	cp2 += 7;
+	while (*cp2 == ' ' || *cp2 == '=')
+	    cp2++;
+	StrAllocCopy(cp3, cp2);	/* copy to mutilate more */
+	for (cp4 = cp3; (*cp4 != '\0' && *cp4 != '"' &&
+			 *cp4 != ';' && *cp4 != ':' &&
+			 !WHITE(*cp4)); cp4++) {
+	    ;			/* do nothing */
+	}
+	*cp4 = '\0';
+	cp4 = cp3;
+	chndl = UCGetLYhndl_byMIME(cp3);
+	if (UCCanTranslateFromTo(chndl, current_char_set)) {
+	    chartrans_ok = YES;
+	    *cp1 = '\0';
+	    format = HTAtom_for(cp);
+	    StrAllocCopy(anchor->charset, cp4);
+	    HTAnchor_setUCInfoStage(anchor, chndl,
+				    UCT_STAGE_MIME,
+				    UCT_SETBY_MIME);
+	} else if (chndl < 0) {
+	    /*
+	     * Got something but we don't recognize it.
+	     */
+	    chndl = UCLYhndl_for_unrec;
+	    if (chndl < 0)
+		/*
+		 * UCLYhndl_for_unrec not defined :-( fallback to
+		 * UCLYhndl_for_unspec which always valid.
+		 */
+		chndl = UCLYhndl_for_unspec;	/* always >= 0 */
+	    if (UCCanTranslateFromTo(chndl, current_char_set)) {
+		chartrans_ok = YES;
+		HTAnchor_setUCInfoStage(anchor, chndl,
+					UCT_STAGE_MIME,
+					UCT_SETBY_DEFAULT);
+	    }
+	}
+	if (chartrans_ok) {
+	    LYUCcharset *p_in = HTAnchor_getUCInfoStage(anchor,
+							UCT_STAGE_MIME);
+	    LYUCcharset *p_out = HTAnchor_setUCInfoStage(anchor,
+							 current_char_set,
+							 UCT_STAGE_HTEXT,
+							 UCT_SETBY_DEFAULT);
+
+	    if (!p_out) {
+		/*
+		 * Try again.
+		 */
+		p_out = HTAnchor_getUCInfoStage(anchor, UCT_STAGE_HTEXT);
+	    }
+	    if (!strcmp(p_in->MIMEname, "x-transparent")) {
+		HTPassEightBitRaw = TRUE;
+		HTAnchor_setUCInfoStage(anchor,
+					HTAnchor_getUCLYhndl(anchor,
+							     UCT_STAGE_HTEXT),
+					UCT_STAGE_MIME,
+					UCT_SETBY_DEFAULT);
+	    }
+	    if (!strcmp(p_out->MIMEname, "x-transparent")) {
+		HTPassEightBitRaw = TRUE;
+		HTAnchor_setUCInfoStage(anchor,
+					HTAnchor_getUCLYhndl(anchor,
+							     UCT_STAGE_MIME),
+					UCT_STAGE_HTEXT,
+					UCT_SETBY_DEFAULT);
+	    }
+	    if (p_in->enc != UCT_ENC_CJK) {
+		HTCJK = NOCJK;
+		if (!(p_in->codepoints &
+		      UCT_CP_SUBSETOF_LAT1) &&
+		    chndl == current_char_set) {
+		    HTPassEightBitRaw = TRUE;
+		}
+	    } else if (p_out->enc == UCT_ENC_CJK) {
+		Set_HTCJK(p_in->MIMEname, p_out->MIMEname);
+	    }
+	} else {
+	    /*
+	     * Cannot translate.  If according to some heuristic the given
+	     * charset and the current display character both are likely to be
+	     * like ISO-8859 in structure, pretend we have some kind of match.
+	     */
+	    BOOL given_is_8859 = (BOOL) (!StrNCmp(cp4, "iso-8859-", 9) &&
+					 isdigit(UCH(cp4[9])));
+	    BOOL given_is_8859like = (BOOL) (given_is_8859 ||
+					     !StrNCmp(cp4, "windows-", 8) ||
+					     !StrNCmp(cp4, "cp12", 4) ||
+					     !StrNCmp(cp4, "cp-12", 5));
+	    BOOL given_and_display_8859like = (BOOL) (given_is_8859like &&
+						      (strstr(LYchar_set_names[current_char_set],
+							      "ISO-8859") ||
+						       strstr(LYchar_set_names[current_char_set],
+							      "windows-")));
+
+	    if (given_and_display_8859like) {
+		*cp1 = '\0';
+		format = HTAtom_for(cp);
+	    }
+	    if (given_is_8859) {
+		cp1 = &cp4[10];
+		while (*cp1 &&
+		       isdigit(UCH(*cp1)))
+		    cp1++;
+		*cp1 = '\0';
+	    }
+	    if (given_and_display_8859like) {
+		StrAllocCopy(anchor->charset, cp4);
+		HTPassEightBitRaw = TRUE;
+	    }
+	    HTAlert(*cp4 ? cp4 : anchor->charset);
+	}
+	FREE(cp3);
+    } else if (cp1 != NULL) {
+	/*
+	 * No charset parameter is present.  Ignore all other parameters, as we
+	 * do when charset is present.  - FM
+	 */
+	*cp1 = '\0';
+	format = HTAtom_for(cp);
+    }
+    FREE(cp);
+
+    /*
+     * Set up defaults, if needed.  - FM
+     */
+    if (!chartrans_ok && !anchor->charset && default_LYhndl >= 0) {
+	HTAnchor_setUCInfoStage(anchor, default_LYhndl,
+				UCT_STAGE_MIME,
+				UCT_SETBY_DEFAULT);
+    }
+    HTAnchor_copyUCInfoStage(anchor,
+			     UCT_STAGE_PARSER,
+			     UCT_STAGE_MIME,
+			     -1);
+
+    return format;
+}
+
+/*	Get various pieces of meta info from file name.
+ *	-----------------------------------------------
+ *
+ *  LYGetFileInfo fills in information that can be determined without
+ *  an actual (new) access to the filesystem, based on current suffix
+ *  and character set configuration.  If the file has been loaded and
+ *  parsed before  (with the same URL generated here!) and the anchor
+ *  is still around, some results may be influenced by that (in
+ *  particular, charset info from a META tag - this is not actually
+ *  tested!).
+ *  The caller should not keep pointers to the returned objects around
+ *  for too long, the valid lifetimes vary. In particular, the returned
+ *  charset string should be copied if necessary.  If return of the
+ *  file_anchor is requested, that one can be used to retrieve
+ *  additional bits of info that are stored in the anchor object and
+ *  are not covered here; as usual, don't keep pointers to the
+ *  file_anchor longer than necessary since the object may disappear
+ *  through HTuncache_current_document or at the next document load.
+ *  - kw
+ */
+void LYGetFileInfo(const char *filename,
+		   HTParentAnchor **pfile_anchor,
+		   HTFormat *pformat,
+		   HTAtom **pencoding,
+		   const char **pdesc,
+		   const char **pcharset,
+		   int *pfile_cs)
+{
+    char *Afn;
+    char *Aname = NULL;
+    HTFormat format;
+    HTAtom *myEnc = NULL;
+    HTParentAnchor *file_anchor;
+    const char *file_csname;
+    int file_cs;
+
+    /*
+     * Convert filename to URL.  Note that it is always supposed to be a
+     * filename, not maybe-filename-maybe-URL, so we don't use
+     * LYFillLocalFileURL and LYEnsureAbsoluteURL.  - kw
+     */
+    Afn = HTEscape(filename, URL_PATH);
+    LYLocalFileToURL(&Aname, Afn);
+    file_anchor = HTAnchor_findSimpleAddress(Aname);
+
+    format = HTFileFormat(filename, &myEnc, pdesc);
+    format = HTCharsetFormat(format, file_anchor, UCLYhndl_HTFile_for_unspec);
+    file_cs = HTAnchor_getUCLYhndl(file_anchor, UCT_STAGE_MIME);
+    file_csname = file_anchor->charset;
+    if (!file_csname) {
+	if (file_cs >= 0)
+	    file_csname = LYCharSet_UC[file_cs].MIMEname;
+	else
+	    file_csname = "display character set";
+    }
+    CTRACE((tfp, "GetFileInfo: '%s' is a%s %s %s file, charset=%s (%d).\n",
+	    filename,
+	    ((myEnc && *HTAtom_name(myEnc) == '8') ? "n" : myEnc ? "" :
+	     *HTAtom_name(format) == 'a' ? "n" : ""),
+	    myEnc ? HTAtom_name(myEnc) : "",
+	    HTAtom_name(format),
+	    file_csname,
+	    file_cs));
+    FREE(Afn);
+    FREE(Aname);
+    if (pfile_anchor)
+	*pfile_anchor = file_anchor;
+    if (pformat)
+	*pformat = format;
+    if (pencoding)
+	*pencoding = myEnc;
+    if (pcharset)
+	*pcharset = file_csname;
+    if (pfile_cs)
+	*pfile_cs = file_cs;
+}
+
+/*	Determine value from file name.
+ *	-------------------------------
+ *
+ */
+float HTFileValue(const char *filename)
+{
+    HTSuffix *suff;
+    int n;
+    int i;
+    int lf = (int) strlen(filename);
+
+#ifndef NO_INIT
+    if (!HTSuffixes)
+	HTFileInit();
+#endif /* !NO_INIT */
+    n = HTList_count(HTSuffixes);
+    for (i = 0; i < n; i++) {
+	int ls;
+
+	suff = (HTSuffix *) HTList_objectAt(HTSuffixes, i);
+	ls = (int) strlen(suff->suffix);
+	if ((ls <= lf) && 0 == strcmp(suff->suffix, filename + lf - ls)) {
+	    CTRACE((tfp, "File: Value of %s is %.3f\n",
+		    filename, suff->quality));
+	    return suff->quality;	/* OK -- found */
+	}
+    }
+    return (float) 0.3;		/* Dunno! */
+}
+
+/*
+ *  Determine compression type from file name, by looking at its suffix.
+ *  Sets as side-effect a pointer to the "dot" that begins the suffix.
+ */
+CompressFileType HTCompressFileType(const char *filename,
+				    const char *dots,
+				    int *rootlen)
+{
+    CompressFileType result = cftNone;
+    char *search;
+
+    if ((search = FindSearch(filename)) != 0) {
+	char *newname = NULL;
+
+	StrAllocCopy(newname, filename);
+	newname[((const char *) search) - filename] = '\0';
+	result = HTCompressFileType(newname, dots, rootlen);
+	free(newname);
+    } else {
+	size_t len;
+	const char *ftype;
+
+	VMS_DEL_VERSION(filename);
+	len = strlen(filename);
+	ftype = filename + len;
+
+	if ((len > 3)
+	    && !strcasecomp((ftype - 2), "br")
+	    && StrChr(dots, ftype[-3]) != 0) {
+	    result = cftBrotli;
+	    ftype -= 3;
+	} else if ((len > 4)
+		   && !strcasecomp((ftype - 3), "bz2")
+		   && StrChr(dots, ftype[-4]) != 0) {
+	    result = cftBzip2;
+	    ftype -= 4;
+	} else if ((len > 3)
+		   && !strcasecomp((ftype - 2), "gz")
+		   && StrChr(dots, ftype[-3]) != 0) {
+	    result = cftGzip;
+	    ftype -= 3;
+	} else if ((len > 3)
+		   && !strcasecomp((ftype - 2), "zz")
+		   && StrChr(dots, ftype[-3]) != 0) {
+	    result = cftDeflate;
+	    ftype -= 3;
+	} else if ((len > 2)
+		   && !strcmp((ftype - 1), "Z")
+		   && StrChr(dots, ftype[-2]) != 0) {
+	    result = cftCompress;
+	    ftype -= 2;
+	}
+
+	*rootlen = (int) (ftype - filename);
+
+	CTRACE((tfp, "HTCompressFileType(%s) returns %d:%s\n",
+		filename, (int) result, filename + *rootlen));
+    }
+    return result;
+}
+
+/*
+ *  Determine expected file-suffix from the compression method.
+ */
+const char *HTCompressTypeToSuffix(CompressFileType method)
+{
+    const char *result = "";
+
+    switch (method) {
+    default:
+    case cftNone:
+	result = "";
+	break;
+    case cftGzip:
+	result = ".gz";
+	break;
+    case cftCompress:
+	result = ".Z";
+	break;
+    case cftBzip2:
+	result = ".bz2";
+	break;
+    case cftDeflate:
+	result = ".zz";
+	break;
+    case cftBrotli:
+	result = ".br";
+	break;
+    }
+    return result;
+}
+
+/*
+ *  Determine compression encoding from the compression method.
+ */
+const char *HTCompressTypeToEncoding(CompressFileType method)
+{
+    const char *result = NULL;
+
+    switch (method) {
+    default:
+    case cftNone:
+	result = NULL;
+	break;
+    case cftGzip:
+	result = "gzip";
+	break;
+    case cftCompress:
+	result = "compress";
+	break;
+    case cftBzip2:
+	result = "bzip2";
+	break;
+    case cftDeflate:
+	result = "deflate";
+	break;
+    case cftBrotli:
+	result = "brotli";
+	break;
+    }
+    return result;
+}
+
+/*
+ * Check if the token from "Content-Encoding" corresponds to a compression
+ * type.  RFC 2068 (and cut/paste into RFC 2616) lists these:
+ *	gzip
+ *	compress
+ *	deflate
+ * as well as "identity" (but that does nothing).
+ */
+CompressFileType HTEncodingToCompressType(const char *coding)
+{
+    CompressFileType result = cftNone;
+
+    if (coding == NULL) {
+	result = cftNone;
+    } else if (!strcasecomp(coding, "gzip") ||
+	       !strcasecomp(coding, "x-gzip")) {
+	result = cftGzip;
+    } else if (!strcasecomp(coding, "compress") ||
+	       !strcasecomp(coding, "x-compress")) {
+	result = cftCompress;
+    } else if (!strcasecomp(coding, "bzip2") ||
+	       !strcasecomp(coding, "x-bzip2")) {
+	result = cftBzip2;
+    } else if (!strcasecomp(coding, "br") ||	/* actual */
+	       !strcasecomp(coding, "brotli") ||	/* expected */
+	       !strcasecomp(coding, "x-brotli")) {
+	result = cftBrotli;
+    } else if (!strcasecomp(coding, "deflate") ||
+	       !strcasecomp(coding, "x-deflate")) {
+	result = cftDeflate;
+    }
+    return result;
+}
+
+CompressFileType HTContentTypeToCompressType(const char *ct)
+{
+    CompressFileType method = cftNone;
+
+    if (ct == NULL) {
+	method = cftNone;
+    } else if (!strncasecomp(ct, "application/gzip", 16) ||
+	       !strncasecomp(ct, "application/x-gzip", 18)) {
+	method = cftGzip;
+    } else if (!strncasecomp(ct, "application/compress", 20) ||
+	       !strncasecomp(ct, "application/x-compress", 22)) {
+	method = cftCompress;
+    } else if (!strncasecomp(ct, "application/bzip2", 17) ||
+	       !strncasecomp(ct, "application/x-bzip2", 19)) {
+	method = cftBzip2;
+    } else if (!strncasecomp(ct, "application/br", 14) ||
+	       !strncasecomp(ct, "application/brotli", 18) ||
+	       !strncasecomp(ct, "application/x-brotli", 20)) {
+	method = cftBrotli;
+    }
+    return method;
+}
+
+/*
+ * Check the anchor's content_type and content_encoding elements for a gzip or
+ * Unix compressed file -FM, TD
+ */
+CompressFileType HTContentToCompressType(HTParentAnchor *anchor)
+{
+    CompressFileType method = cftNone;
+    const char *ct = HTAnchor_content_type(anchor);
+    const char *ce = HTAnchor_content_encoding(anchor);
+
+    if (ct != 0) {
+	method = HTContentTypeToCompressType(ct);
+    } else if (ce != 0) {
+	method = HTEncodingToCompressType(ce);
+    }
+    return method;
+}
+
+/*	Determine write access to a file.
+ *	---------------------------------
+ *
+ *  On exit:
+ *	Returns YES if file can be accessed and can be written to.
+ *
+ *  Bugs:
+ *	1.	No code for non-unix systems.
+ *	2.	Isn't there a quicker way?
+ */
+BOOL HTEditable(const char *filename GCC_UNUSED)
+{
+#ifndef NO_GROUPS
+    GETGROUPS_T groups[NGROUPS];
+    uid_t myUid;
+    int ngroups;		/* The number of groups  */
+    struct stat fileStatus;
+    int i;
+
+    if (stat(filename, &fileStatus))	/* Get details of filename */
+	return NO;		/* Can't even access file! */
+
+    ngroups = getgroups(NGROUPS, groups);	/* Groups to which I belong  */
+    myUid = geteuid();		/* Get my user identifier */
+
+    if (TRACE) {
+	int i2;
+
+	fprintf(tfp,
+		"File mode is 0%o, uid=%d, gid=%d. My uid=%d, %d groups (",
+		(unsigned int) fileStatus.st_mode,
+		(int) fileStatus.st_uid,
+		(int) fileStatus.st_gid,
+		(int) myUid,
+		(int) ngroups);
+	for (i2 = 0; i2 < ngroups; i2++)
+	    fprintf(tfp, " %d", (int) groups[i2]);
+	fprintf(tfp, ")\n");
+    }
+
+    if (fileStatus.st_mode & 0002)	/* I can write anyway? */
+	return YES;
+
+    if ((fileStatus.st_mode & 0200)	/* I can write my own file? */
+	&&(fileStatus.st_uid == myUid))
+	return YES;
+
+    if (fileStatus.st_mode & 0020)	/* Group I am in can write? */
+    {
+	for (i = 0; i < ngroups; i++) {
+	    if (groups[i] == fileStatus.st_gid)
+		return YES;
+	}
+    }
+    CTRACE((tfp, "\tFile is not editable.\n"));
+#endif /* NO_GROUPS */
+    return NO;			/* If no excuse, can't do */
+}
+
+/*	Make a save stream.
+ *	-------------------
+ *
+ *	The stream must be used for writing back the file.
+ *	@@@ no backup done
+ */
+HTStream *HTFileSaveStream(HTParentAnchor *anchor)
+{
+    const char *addr = anchor->address;
+    char *localname = HTLocalName(addr);
+    FILE *fp = fopen(localname, BIN_W);
+
+    FREE(localname);
+    if (!fp)
+	return NULL;
+
+    return HTFWriter_new(fp);
+}
+
+/*	Output one directory entry.
+ *	---------------------------
+ */
+void HTDirEntry(HTStructured * target, const char *tail, const char *entry)
+{
+    char *relative = NULL;
+    char *stripped = NULL;
+    char *escaped = NULL;
+    int len;
+
+    if (entry == NULL)
+	entry = "";
+    StrAllocCopy(escaped, entry);
+    LYTrimPathSep(escaped);
+    if (strcmp(escaped, "..") != 0) {
+	stripped = escaped;
+	escaped = HTEscape(stripped, URL_XPALPHAS);
+	if (((len = (int) strlen(escaped)) > 2) &&
+	    escaped[(len - 3)] == '%' &&
+	    escaped[(len - 2)] == '2' &&
+	    TOUPPER(escaped[(len - 1)]) == 'F') {
+	    escaped[(len - 3)] = '\0';
+	}
+    }
+
+    if (isEmpty(tail)) {
+	/*
+	 * Handle extra slash at end of path.
+	 */
+	HTStartAnchor(target, NULL, (escaped[0] != '\0' ? escaped : "/"));
+    } else {
+	/*
+	 * If empty tail, gives absolute ref below.
+	 */
+	relative = 0;
+	HTSprintf0(&relative, "%s%s%s",
+		   tail,
+		   (*escaped != '\0' ? "/" : ""),
+		   escaped);
+	HTStartAnchor(target, NULL, relative);
+	FREE(relative);
+    }
+    FREE(stripped);
+    FREE(escaped);
+}
+
+static BOOL view_structured(HTFormat format_out)
+{
+    BOOL result = FALSE;
+
+#ifdef USE_PRETTYSRC
+    if (psrc_view
+	|| (format_out == WWW_DUMP))
+	result = TRUE;
+#else
+    if (format_out == WWW_SOURCE)
+	result = TRUE;
+#endif
+    return result;
+}
+
+/*
+ * Write a DOCTYPE to the given stream if we happen to want to see the
+ * source view, or are dumping source.  This is not needed when the source
+ * is not visible, since the document is rendered from a HTStructured object.
+ */
+void HTStructured_doctype(HTStructured * target, HTFormat format_out)
+{
+    if (view_structured(format_out))
+	PUTS(LYNX_DOCTYPE "\n");
+}
+
+void HTStructured_meta(HTStructured * target, HTFormat format_out)
+{
+    if (view_structured(format_out))
+	PUTS("<meta http-equiv=\"Content-Type\" content=\"" STR_HTML
+	     "; charset=iso-8859-1\">\n");
+}
+/*	Output parent directory entry.
+ *	------------------------------
+ *
+ *    This gives the TITLE and H1 header, and also a link
+ *    to the parent directory if appropriate.
+ *
+ *  On exit:
+ *	Returns TRUE if an "Up to <parent>" link was not created
+ *	for a readable local directory because LONG_LIST is defined
+ *	and NO_PARENT_DIR_REFERENCE is not defined, so that the
+ *	calling function should use LYListFmtParse() to create a link
+ *	to the parent directory.  Otherwise, it returns FALSE. - FM
+ */
+BOOL HTDirTitles(HTStructured * target, HTParentAnchor *anchor,
+		 HTFormat format_out,
+		 int tildeIsTop)
+{
+    const char *logical = anchor->address;
+    char *path = HTParse(logical, "", PARSE_PATH + PARSE_PUNCTUATION);
+    char *current;
+    char *cp = NULL;
+    BOOL need_parent_link = FALSE;
+    int i;
+
+#if defined(USE_DOS_DRIVES)
+    BOOL local_link = (strlen(logical) > 18
+		       && !strncasecomp(logical, "file://localhost/", 17)
+		       && LYIsDosDrive(logical + 17));
+    BOOL is_remote = !local_link;
+
+#else
+#define is_remote TRUE
+#endif
+
+    /*
+     * Check tildeIsTop for treating home directory as Welcome (assume the
+     * tilde is not followed by a username).  - FM
+     */
+    if (tildeIsTop && !StrNCmp(path, "/~", 2)) {
+	if (path[2] == '\0') {
+	    path[1] = '\0';
+	} else {
+	    for (i = 0; path[(i + 2)]; i++) {
+		path[i] = path[(i + 2)];
+	    }
+	    path[i] = '\0';
+	}
+    }
+
+    /*
+     * Trim out the ;type= parameter, if present.  - FM
+     */
+    if ((cp = strrchr(path, ';')) != NULL) {
+	if (!strncasecomp((cp + 1), "type=", 5)) {
+	    if (TOUPPER(*(cp + 6)) == 'D' ||
+		TOUPPER(*(cp + 6)) == 'A' ||
+		TOUPPER(*(cp + 6)) == 'I')
+		*cp = '\0';
+	}
+	cp = NULL;
+    }
+    current = LYPathLeaf(path);	/* last part or "" */
+
+    {
+	char *printable = NULL;
+
+#ifdef DIRED_SUPPORT
+	printable = HTURLPath_toFile(((!strncasecomp(path, "/%2F", 4))	/* "//" ? */
+				      ? (path + 1)
+				      : path),
+				     TRUE,
+				     is_remote);
+	if (0 == strncasecomp(printable, "/vmsysu:", 8) ||
+	    0 == strncasecomp(printable, "/anonymou.", 10)) {
+	    StrAllocCopy(cp, (printable + 1));
+	    StrAllocCopy(printable, cp);
+	    FREE(cp);
+	}
+#else
+	StrAllocCopy(printable, current);
+	HTUnEscape(printable);
+#endif /* DIRED_SUPPORT */
+
+	HTStructured_doctype(target, format_out);
+
+	START(HTML_HEAD);
+	PUTC('\n');
+	START(HTML_TITLE);
+	PUTS(*printable ? printable : WELCOME_MSG);
+	PUTS(SEGMENT_DIRECTORY);
+	END(HTML_TITLE);
+	PUTC('\n');
+	HTStructured_meta(target, format_out);
+	END(HTML_HEAD);
+	PUTC('\n');
+
+	START(HTML_BODY);
+	PUTC('\n');
+
+#ifdef DIRED_SUPPORT
+	START(HTML_H2);
+	PUTS(*printable ? SEGMENT_CURRENT_DIR : "");
+	PUTS(*printable ? printable : WELCOME_MSG);
+	END(HTML_H2);
+	PUTC('\n');
+#else
+	START(HTML_H1);
+	PUTS(*printable ? printable : WELCOME_MSG);
+	END(HTML_H1);
+	PUTC('\n');
+#endif /* DIRED_SUPPORT */
+	if (((0 == strncasecomp(printable, "vmsysu:", 7)) &&
+	     (cp = StrChr(printable, '.')) != NULL &&
+	     StrChr(cp, '/') == NULL) ||
+	    (0 == strncasecomp(printable, "anonymou.", 9) &&
+	     StrChr(printable, '/') == NULL)) {
+	    FREE(printable);
+	    FREE(path);
+	    return (need_parent_link);
+	}
+	FREE(printable);
+    }
+
+#ifndef NO_PARENT_DIR_REFERENCE
+    /*
+     * Make link back to parent directory.
+     */
+    if (current - path > 0
+	&& LYIsPathSep(current[-1])
+	&& current[0] != '\0') {	/* was a slash AND something else too */
+	char *parent = NULL;
+	char *relative = NULL;
+
+	current[-1] = '\0';
+	parent = strrchr(path, '/');	/* penultimate slash */
+
+	if ((parent &&
+	     (!strcmp(parent, "/..") ||
+	      !strncasecomp(parent, "/%2F", 4))) ||
+	    !strncasecomp(current, "%2F", 3)) {
+	    FREE(path);
+	    return (need_parent_link);
+	}
+
+	relative = 0;
+	HTSprintf0(&relative, "%s/..", current);
+
+#if defined(DOSPATH) || defined(__EMX__)
+	if (local_link) {
+	    if (parent != 0 && strlen(parent) == 3) {
+		StrAllocCat(relative, "/.");
+	    }
+	} else
+#endif
+
+#if !defined (VMS)
+	{
+	    /*
+	     * On Unix, if it's not ftp and the directory cannot be read, don't
+	     * put out a link.
+	     *
+	     * On VMS, this problem is dealt with internally by
+	     * HTVMSBrowseDir().
+	     */
+	    DIR *dp = NULL;
+
+	    if (LYisLocalFile(logical)) {
+		/*
+		 * We need an absolute file path for the opendir.  We also need
+		 * to unescape for this test.  Don't worry about %2F now, they
+		 * presumably have been dealt with above, and shouldn't appear
+		 * for local files anyway...  Assume OS / filesystem will just
+		 * ignore superfluous slashes.  - KW
+		 */
+		char *fullparentpath = NULL;
+
+		/*
+		 * Path has been shortened above.
+		 */
+		StrAllocCopy(fullparentpath, *path ? path : "/");
+
+		/*
+		 * Guard against weirdness.
+		 */
+		if (0 == strcmp(current, "..")) {
+		    StrAllocCat(fullparentpath, "/../..");
+		} else if (0 == strcmp(current, ".")) {
+		    StrAllocCat(fullparentpath, "/..");
+		}
+
+		HTUnEscape(fullparentpath);
+		if ((dp = opendir(fullparentpath)) == NULL) {
+		    FREE(fullparentpath);
+		    FREE(relative);
+		    FREE(path);
+		    return (need_parent_link);
+		}
+		closedir(dp);
+		FREE(fullparentpath);
+#ifdef LONG_LIST
+		need_parent_link = TRUE;
+		FREE(path);
+		FREE(relative);
+		return (need_parent_link);
+#endif /* LONG_LIST */
+	    }
+	}
+#endif /* !VMS */
+	HTStartAnchor(target, "", relative);
+	FREE(relative);
+
+	PUTS(SEGMENT_UP_TO);
+	if (parent) {
+	    if ((0 == strcmp(current, ".")) ||
+		(0 == strcmp(current, ".."))) {
+		/*
+		 * Should not happen, but if it does, at least avoid giving
+		 * misleading info.  - KW
+		 */
+		PUTS("..");
+	    } else {
+		char *printable = NULL;
+
+		StrAllocCopy(printable, parent + 1);
+		HTUnEscape(printable);
+		PUTS(printable);
+		FREE(printable);
+	    }
+	} else {
+	    PUTC('/');
+	}
+	END(HTML_A);
+	PUTC('\n');
+    }
+#endif /* !NO_PARENT_DIR_REFERENCE */
+
+    FREE(path);
+    return (need_parent_link);
+}
+
+#if defined HAVE_READDIR
+/*	Send README file.
+ *	-----------------
+ *
+ *  If a README file exists, then it is inserted into the document here.
+ */
+static void do_readme(HTStructured * target, const char *localname)
+{
+    FILE *fp;
+    char *readme_file_name = NULL;
+    int ch;
+
+    HTSprintf0(&readme_file_name, "%s/%s", localname, HT_DIR_README_FILE);
+
+    fp = fopen(readme_file_name, "r");
+
+    if (fp) {
+	START(HTML_PRE);
+	while ((ch = fgetc(fp)) != EOF) {
+	    PUTC((char) ch);
+	}
+	END(HTML_PRE);
+	HTDisplayPartial();
+	fclose(fp);
+    }
+    FREE(readme_file_name);
+}
+
+#define DIRED_BLOK(obj) (((DIRED *)(obj))->sort_tags)
+#define DIRED_NAME(obj) (((DIRED *)(obj))->file_name)
+
+#define NM_cmp(a,b) ((a) < (b) ? -1 : ((a) > (b) ? 1 : 0))
+
+#if defined(LONG_LIST) && defined(DIRED_SUPPORT)
+static const char *file_type(const char *path)
+{
+    const char *type;
+
+    while (*path == '.')
+	++path;
+    type = StrChr(path, '.');
+    if (type == NULL)
+	type = "";
+    return type;
+}
+#endif /* LONG_LIST && DIRED_SUPPORT */
+
+static int dired_cmp(void *a, void *b)
+{
+    DIRED *p = (DIRED *) a;
+    DIRED *q = (DIRED *) b;
+    int code = p->sort_tags - q->sort_tags;
+
+#if defined(LONG_LIST) && defined(DIRED_SUPPORT)
+    if (code == 0) {
+	switch (dir_list_order) {
+	case ORDER_BY_SIZE:
+	    code = -NM_cmp(p->file_info.st_size, q->file_info.st_size);
+	    break;
+	case ORDER_BY_DATE:
+	    code = -NM_cmp(p->file_info.st_mtime, q->file_info.st_mtime);
+	    break;
+	case ORDER_BY_MODE:
+	    code = NM_cmp(p->file_info.st_mode, q->file_info.st_mode);
+	    break;
+	case ORDER_BY_USER:
+	    code = NM_cmp(p->file_info.st_uid, q->file_info.st_uid);
+	    break;
+	case ORDER_BY_GROUP:
+	    code = NM_cmp(p->file_info.st_gid, q->file_info.st_gid);
+	    break;
+	case ORDER_BY_TYPE:
+	    code = AS_cmp(file_type(p->file_name), file_type(q->file_name));
+	    break;
+	default:
+	    code = 0;
+	    break;
+	}
+    }
+#endif /* LONG_LIST && DIRED_SUPPORT */
+    if (code == 0)
+	code = AS_cmp(p->file_name, q->file_name);
+#if 0
+    CTRACE((tfp, "dired_cmp(%d) ->%d\n\t%c:%s (%s)\n\t%c:%s (%s)\n",
+	    dir_list_order,
+	    code,
+	    p->sort_tags, p->file_name, file_type(p->file_name),
+	    q->sort_tags, q->file_name, file_type(q->file_name)));
+#endif
+    return code;
+}
+
+static int print_local_dir(DIR *dp, char *localname,
+			   HTParentAnchor *anchor,
+			   HTFormat format_out,
+			   HTStream *sink)
+{
+    HTStructured *target;	/* HTML object */
+    HTBTree *bt;
+    HTStructuredClass targetClass;
+    STRUCT_DIRENT *dirbuf;
+    char *pathname = NULL;
+    char *tail = NULL;
+    const char *p;
+    char *tmpfilename = NULL;
+    BOOL need_parent_link = FALSE;
+    BOOL preformatted = FALSE;
+    int status;
+    struct stat *actual_info;
+
+#ifdef DISP_PARTIAL
+    int num_of_entries = 0;	/* lines counter */
+#endif
+
+#ifdef S_IFLNK
+    struct stat link_info;
+#endif
+
+    CTRACE((tfp, "print_local_dir() started\n"));
+
+    pathname = HTParse(anchor->address, "",
+		       PARSE_PATH + PARSE_PUNCTUATION);
+
+    if ((p = strrchr(pathname, '/')) == NULL)
+	p = "/";
+    StrAllocCopy(tail, (p + 1));
+    FREE(pathname);
+
+    if (UCLYhndl_HTFile_for_unspec >= 0) {
+	HTAnchor_setUCInfoStage(anchor,
+				UCLYhndl_HTFile_for_unspec,
+				UCT_STAGE_PARSER,
+				UCT_SETBY_DEFAULT);
+    }
+
+    target = HTML_new(anchor, format_out, sink);
+    targetClass = *target->isa;	/* Copy routine entry points */
+
+    /*
+     * The need_parent_link flag will be set if an "Up to <parent>" link was
+     * not created for a readable parent in HTDirTitles() because LONG_LIST is
+     * defined and NO_PARENT_DIR_REFERENCE is not defined so that need we to
+     * create the link via an LYListFmtParse() call.  - FM
+     */
+    need_parent_link = HTDirTitles(target, anchor, format_out, FALSE);
+
+#ifdef DIRED_SUPPORT
+    if (!isLYNXCGI(anchor->address)) {
+	HTAnchor_setFormat(anchor, WWW_DIRED);
+	lynx_edit_mode = TRUE;
+    }
+#endif /* DIRED_SUPPORT */
+    if (HTDirReadme == HT_DIR_README_TOP)
+	do_readme(target, localname);
+
+    bt = HTBTree_new(dired_cmp);
+
+    _HTProgress(READING_DIRECTORY);
+    status = HT_LOADED;		/* assume we don't get interrupted */
+    while ((dirbuf = readdir(dp)) != NULL) {
+	/*
+	 * While there are directory entries to be read...
+	 */
+	DIRED *data = NULL;
+
+#ifdef STRUCT_DIRENT__D_INO
+	if (dirbuf->d_ino == 0)
+	    /*
+	     * If the entry is not being used, skip it.
+	     */
+	    continue;
+#endif
+	/*
+	 * Skip self, parent if handled in HTDirTitles() or if
+	 * NO_PARENT_DIR_REFERENCE is not defined, and any dot files if
+	 * no_dotfiles is set or show_dotfiles is not set.  - FM
+	 */
+	if (!strcmp(dirbuf->d_name, ".") /* self       */ ||
+	    (!strcmp(dirbuf->d_name, "..") /* parent */ &&
+	     need_parent_link == FALSE) ||
+	    ((strcmp(dirbuf->d_name, "..")) &&
+	     (dirbuf->d_name[0] == '.' &&
+	      (no_dotfiles || !show_dotfiles))))
+	    continue;
+
+	StrAllocCopy(tmpfilename, localname);
+	/*
+	 * If filename is not root directory, add trailing separator.
+	 */
+	LYAddPathSep(&tmpfilename);
+
+	StrAllocCat(tmpfilename, dirbuf->d_name);
+	data = (DIRED *) malloc(sizeof(DIRED) + strlen(dirbuf->d_name) + 4);
+	if (data == NULL) {
+	    status = HT_PARTIAL_CONTENT;
+	    break;
+	}
+	LYTrimPathSep(tmpfilename);
+
+	actual_info = &(data->file_info);
+#ifdef S_IFLNK
+	if (lstat(tmpfilename, actual_info) < 0) {
+	    actual_info->st_mode = 0;
+	} else {
+	    if (S_ISLNK(actual_info->st_mode)) {
+		actual_info = &link_info;
+		if (stat(tmpfilename, actual_info) < 0)
+		    actual_info->st_mode = 0;
+	    }
+	}
+#else
+	if (stat(tmpfilename, actual_info) < 0)
+	    actual_info->st_mode = 0;
+#endif
+
+	strcpy(data->file_name, dirbuf->d_name);
+#ifndef DIRED_SUPPORT
+	if (S_ISDIR(actual_info->st_mode)) {
+	    data->sort_tags = 'D';
+	} else {
+	    data->sort_tags = 'F';
+	    /* D & F to have first directories, then files */
+	}
+#else
+	if (S_ISDIR(actual_info->st_mode)) {
+	    if (dir_list_style == MIXED_STYLE) {
+		data->sort_tags = ' ';
+		LYAddPathSep0(data->file_name);
+	    } else if (!strcmp(dirbuf->d_name, "..")) {
+		data->sort_tags = 'A';
+	    } else {
+		data->sort_tags = 'D';
+	    }
+	} else if (dir_list_style == MIXED_STYLE) {
+	    data->sort_tags = ' ';
+	} else if (dir_list_style == FILES_FIRST) {
+	    data->sort_tags = 'C';
+	    /* C & D to have first files, then directories */
+	} else {
+	    data->sort_tags = 'F';
+	}
+#endif /* !DIRED_SUPPORT */
+	/*
+	 * Sort dirname in the tree bt.
+	 */
+	HTBTree_add(bt, data);
+
+#ifdef DISP_PARTIAL
+	/* optimize for expensive operation: */
+	if (num_of_entries % (partial_threshold > 0 ?
+			      partial_threshold : display_lines) == 0) {
+	    if (HTCheckForInterrupt()) {
+		status = HT_PARTIAL_CONTENT;
+		break;
+	    }
+	}
+	num_of_entries++;
+#endif /* DISP_PARTIAL */
+
+    }				/* end while directory entries left to read */
+
+    if (status != HT_PARTIAL_CONTENT)
+	_HTProgress(OPERATION_OK);
+    else
+	CTRACE((tfp, "Reading the directory interrupted by user\n"));
+
+    /*
+     * Run through tree printing out in order.
+     */
+    {
+	HTBTElement *next_element = HTBTree_next(bt, NULL);
+
+	/* pick up the first element of the list */
+	int num_of_entries_output = 0;	/* lines counter */
+
+	char state;
+
+	/* I for initial (.. file),
+	   D for directory file,
+	   F for file */
+
+#ifdef DIRED_SUPPORT
+	char test;
+#endif /* DIRED_SUPPORT */
+	state = 'I';
+
+	while (next_element != NULL) {
+	    DIRED *entry;
+
+#ifndef DISP_PARTIAL
+	    if (num_of_entries_output % HTMAX(display_lines, 10) == 0) {
+		if (HTCheckForInterrupt()) {
+		    _HTProgress(TRANSFER_INTERRUPTED);
+		    status = HT_PARTIAL_CONTENT;
+		    break;
+		}
+	    }
+#endif
+	    StrAllocCopy(tmpfilename, localname);
+	    /*
+	     * If filename is not root directory.
+	     */
+	    LYAddPathSep(&tmpfilename);
+
+	    entry = (DIRED *) (HTBTree_object(next_element));
+	    /*
+	     * Append the current entry's filename to the path.
+	     */
+	    StrAllocCat(tmpfilename, entry->file_name);
+	    HTSimplify(tmpfilename, LYIsPathSep(*tmpfilename));
+	    /*
+	     * Output the directory entry.
+	     */
+	    if (strcmp(DIRED_NAME(HTBTree_object(next_element)), "..")) {
+#ifdef DIRED_SUPPORT
+		test =
+		    (char) (DIRED_BLOK(HTBTree_object(next_element))
+			    == 'D' ? 'D' : 'F');
+		if (state != test) {
+#ifndef LONG_LIST
+		    if (dir_list_style == FILES_FIRST) {
+			if (state == 'F') {
+			    END(HTML_DIR);
+			    PUTC('\n');
+			}
+		    } else if (dir_list_style != MIXED_STYLE)
+			if (state == 'D') {
+			    END(HTML_DIR);
+			    PUTC('\n');
+			}
+#endif /* !LONG_LIST */
+		    state =
+			(char) (DIRED_BLOK(HTBTree_object(next_element))
+				== 'D' ? 'D' : 'F');
+		    if (preformatted) {
+			END(HTML_PRE);
+			PUTC('\n');
+			preformatted = FALSE;
+		    }
+		    START(HTML_H2);
+		    if (dir_list_style != MIXED_STYLE) {
+			START(HTML_EM);
+			PUTS(state == 'D'
+			     ? LABEL_SUBDIRECTORIES
+			     : LABEL_FILES);
+			END(HTML_EM);
+		    }
+		    END(HTML_H2);
+		    PUTC('\n');
+#ifndef LONG_LIST
+		    START(HTML_DIR);
+		    PUTC('\n');
+#endif /* !LONG_LIST */
+		}
+#else
+		if (state != DIRED_BLOK(HTBTree_object(next_element))) {
+#ifndef LONG_LIST
+		    if (state == 'D') {
+			END(HTML_DIR);
+			PUTC('\n');
+		    }
+#endif /* !LONG_LIST */
+		    state =
+			(char) (DIRED_BLOK(HTBTree_object(next_element))
+				== 'D' ? 'D' : 'F');
+		    if (preformatted) {
+			END(HTML_PRE);
+			PUTC('\n');
+			preformatted = FALSE;
+		    }
+		    START(HTML_H2);
+		    START(HTML_EM);
+		    PUTS(state == 'D'
+			 ? LABEL_SUBDIRECTORIES
+			 : LABEL_FILES);
+		    END(HTML_EM);
+		    END(HTML_H2);
+		    PUTC('\n');
+#ifndef LONG_LIST
+		    START(HTML_DIR);
+		    PUTC('\n');
+#endif /* !LONG_LIST */
+		}
+#endif /* DIRED_SUPPORT */
+#ifndef LONG_LIST
+		START(HTML_LI);
+#endif /* !LONG_LIST */
+	    }
+	    if (!preformatted) {
+		START(HTML_PRE);
+		PUTC('\n');
+		preformatted = TRUE;
+	    }
+#ifdef LONG_LIST
+	    LYListFmtParse(list_format, entry, tmpfilename, target, tail);
+#else
+	    HTDirEntry(target, tail, entry->file_name);
+	    PUTS(entry->file_name);
+	    END(HTML_A);
+	    MAYBE_END(HTML_LI);
+	    PUTC('\n');
+#endif /* LONG_LIST */
+
+	    next_element = HTBTree_next(bt, next_element);
+	    /* pick up the next element of the list;
+	       if none, return NULL */
+
+	    /* optimize for expensive operation: */
+#ifdef DISP_PARTIAL
+	    if (num_of_entries_output %
+		((partial_threshold > 0)
+		 ? partial_threshold
+		 : display_lines) == 0) {
+		/* num_of_entries, num_of_entries_output... */
+		HTDisplayPartial();
+
+		if (HTCheckForInterrupt()) {
+		    _HTProgress(TRANSFER_INTERRUPTED);
+		    status = HT_PARTIAL_CONTENT;
+		    break;
+		}
+	    }
+	    num_of_entries_output++;
+#endif /* DISP_PARTIAL */
+
+	}			/* end while next_element */
+
+	if (status == HT_LOADED) {
+	    if (state == 'I') {
+		START(HTML_P);
+		PUTS("Empty Directory");
+	    }
+#ifndef LONG_LIST
+	    else
+		END(HTML_DIR);
+#endif /* !LONG_LIST */
+	}
+    }				/* end printing out the tree in order */
+    if (preformatted) {
+	END(HTML_PRE);
+	PUTC('\n');
+    }
+    END(HTML_BODY);
+    PUTC('\n');
+
+    FREE(tmpfilename);
+    FREE(tail);
+    HTBTreeAndObject_free(bt);
+
+    if (status == HT_LOADED) {
+	if (HTDirReadme == HT_DIR_README_BOTTOM)
+	    do_readme(target, localname);
+	FREE_TARGET;
+    } else {
+	ABORT_TARGET;
+    }
+    HTFinishDisplayPartial();
+    return status;		/* document loaded, maybe partial */
+}
+#endif /* HAVE_READDIR */
+
+#ifndef VMS
+int HTStat(const char *filename,
+	   struct stat *data)
+{
+    int result = -1;
+    size_t len = strlen(filename);
+
+    if (len != 0 && LYIsPathSep(filename[len - 1])) {
+	char *temp_name = NULL;
+
+	HTSprintf0(&temp_name, "%s.", filename);
+	result = HTStat(temp_name, data);
+	FREE(temp_name);
+    } else {
+	result = stat(filename, data);
+#ifdef _WINDOWS
+	/*
+	 * Someone claims that stat() doesn't give the proper result for a
+	 * directory on Windows.
+	 */
+	if (result == -1
+	    && access(filename, 0) == 0) {
+	    data->st_mode = S_IFDIR;
+	    result = 0;
+	}
+#endif
+    }
+    return result;
+}
+#endif
+
+#if defined(USE_ZLIB) || defined(USE_BZLIB)
+static BOOL sniffStream(FILE *fp, char *buffer, size_t needed)
+{
+    long offset = ftell(fp);
+    BOOL result = FALSE;
+
+    if (offset >= 0) {
+	if (fread(buffer, sizeof(char), needed, fp) == needed) {
+	    result = TRUE;
+	}
+	if (fseek(fp, offset, SEEK_SET) < 0) {
+	    CTRACE((tfp, "error seeking in stream\n"));
+	    result = FALSE;
+	}
+    }
+    return result;
+}
+#endif
+
+#ifdef USE_ZLIB
+static BOOL isGzipStream(FILE *fp)
+{
+    char buffer[3];
+    BOOL result;
+
+    if (sniffStream(fp, buffer, sizeof(buffer))
+	&& !MemCmp(buffer, "\037\213", sizeof(buffer) - 1)) {
+	result = TRUE;
+    } else {
+	CTRACE((tfp, "not a gzip-stream\n"));
+	result = FALSE;
+    }
+    return result;
+}
+
+/*
+ * Strictly speaking, DEFLATE has no header bytes.  But decode what we can,
+ * (to eliminate the one "reserved" pattern) and provide a trace.  See RFC-1951
+ * discussion of BFINAL and BTYPE.
+ */
+static BOOL isDeflateStream(FILE *fp)
+{
+    char buffer[3];
+    BOOL result = FALSE;
+
+    if (sniffStream(fp, buffer, sizeof(buffer))) {
+	int bit1 = ((buffer[0] >> 0) & 1);
+	int bit2 = ((buffer[0] >> 1) & 1);
+	int bit3 = ((buffer[0] >> 2) & 1);
+	int btype = ((bit3 << 1) + bit2);
+
+	if (!MemCmp(buffer, "\170\234", sizeof(buffer) - 1)) {
+	    result = TRUE;
+	    CTRACE((tfp, "isDeflate: assume zlib-wrapped deflate\n"));
+	} else if (btype == 3) {
+	    CTRACE((tfp, "isDeflate: not a deflate-stream\n"));
+	} else {
+	    CTRACE((tfp, "isDeflate: %send block, %s compression\n",
+		    (bit1 ? "" : "non-"),
+		    (btype == 0
+		     ? "no"
+		     : (btype == 1
+			? "static Huffman"
+			: "dynamic Huffman"))));
+	    result = TRUE;
+	}
+    }
+    return result;
+}
+#endif
+
+#ifdef USE_BZLIB
+static BOOL isBzip2Stream(FILE *fp)
+{
+    char buffer[6];
+    BOOL result;
+
+    if (sniffStream(fp, buffer, sizeof(buffer))
+	&& !MemCmp(buffer, "BZh", 3)
+	&& isdigit(UCH(buffer[3]))
+	&& isdigit(UCH(buffer[4]))) {
+	result = TRUE;
+    } else {
+	CTRACE((tfp, "not a bzip2-stream\n"));
+	result = FALSE;
+    }
+    return result;
+}
+#endif
+
+#ifdef VMS
+#define FOPEN_MODE(bin) "r", "shr=put", "shr=upd"
+#define DOT_STRING "._-"	/* FIXME: should we check if suffix is after ']' or ':' ? */
+#else
+#define FOPEN_MODE(bin) (bin ? BIN_R : "r")
+#define DOT_STRING "."
+#endif
+
+#ifdef USE_BROTLI
+static FILE *brotli_open(const char *localname, const char *mode)
+{
+    CTRACE((tfp, "brotli_open file=%s, mode=%s\n", localname, mode));
+    return fopen(localname, mode);
+}
+#endif
+
+static int decompressAndParse(HTParentAnchor *anchor,
+			      HTFormat format_out,
+			      HTStream *sink,
+			      char *nodename GCC_UNUSED,
+			      char *filename,
+			      HTAtom *myEncoding,
+			      HTFormat format,
+			      int *statusp)
+{
+    HTAtom *encoding = 0;
+
+#ifdef USE_ZLIB
+    FILE *zzfp = 0;
+    gzFile gzfp = 0;
+#endif /* USE_ZLIB */
+#ifdef USE_BZLIB
+    BZFILE *bzfp = 0;
+#endif /* USE_BZLIB */
+#ifdef USE_BROTLI
+    FILE *brfp = 0;
+#endif /* USE_BROTLI */
+#if defined(USE_ZLIB) || defined(USE_BZLIB)
+    CompressFileType internal_decompress = cftNone;
+    BOOL failed_decompress = NO;
+#endif
+    int rootlen = 0;
+    char *localname = filename;
+    int bin;
+    FILE *fp;
+    int result = FALSE;
+
+#ifdef VMS
+    /*
+     * Assume that the file is in Unix-style syntax if it contains a '/' after
+     * the leading one.  @@
+     */
+    localname = (StrChr(localname + 1, '/')
+		 ? HTVMS_name(nodename, localname)
+		 : localname + 1);
+#endif /* VMS */
+
+    bin = HTCompressFileType(filename, ".", &rootlen) != cftNone;
+    fp = fopen(localname, FOPEN_MODE(bin));
+
+#ifdef VMS
+    /*
+     * If the file wasn't VMS syntax, then perhaps it is Ultrix.
+     */
+    if (!fp) {
+	char *ultrixname = 0;
+
+	CTRACE((tfp, "HTLoadFile: Can't open as %s\n", localname));
+	HTSprintf0(&ultrixname, "%s::\"%s\"", nodename, filename);
+	fp = fopen(ultrixname, FOPEN_MODE(bin));
+	if (!fp) {
+	    CTRACE((tfp, "HTLoadFile: Can't open as %s\n", ultrixname));
+	}
+	FREE(ultrixname);
+    }
+#endif /* VMS */
+    CTRACE((tfp, "HTLoadFile: Opening `%s' gives %p\n", localname, (void *) fp));
+    if (fp) {			/* Good! */
+	if (HTEditable(localname)) {
+	    HTAtom *put = HTAtom_for("PUT");
+	    HTList *methods = HTAnchor_methods(anchor);
+
+	    if (HTList_indexOf(methods, put) == (-1)) {
+		HTList_addObject(methods, put);
+	    }
+	}
+	/*
+	 * Fake a Content-Encoding for compressed files.  - FM
+	 */
+	if (!IsUnityEnc(myEncoding)) {
+	    /*
+	     * We already know from the call to HTFileFormat that
+	     * this is a compressed file, no need to look at the filename
+	     * again.  - kw
+	     */
+#if defined(USE_ZLIB) || defined(USE_BZLIB)
+	    CompressFileType method = HTEncodingToCompressType(HTAtom_name(myEncoding));
+#endif
+
+#define isDOWNLOAD(m) (strcmp(format_out->name, STR_DOWNLOAD) && (method == m))
+#ifdef USE_ZLIB
+	    if (isDOWNLOAD(cftGzip)) {
+		if (isGzipStream(fp)) {
+		    fclose(fp);
+		    fp = 0;
+		    gzfp = gzopen(localname, BIN_R);
+
+		    CTRACE((tfp, "HTLoadFile: gzopen of `%s' gives %p\n",
+			    localname, (void *) gzfp));
+		}
+		internal_decompress = cftGzip;
+	    } else if (isDOWNLOAD(cftDeflate)) {
+		if (isDeflateStream(fp)) {
+		    zzfp = fp;
+		    fp = 0;
+
+		    CTRACE((tfp, "HTLoadFile: zzopen of `%s' gives %p\n",
+			    localname, (void *) zzfp));
+		}
+		internal_decompress = cftDeflate;
+	    } else
+#endif /* USE_ZLIB */
+#ifdef USE_BZLIB
+	    if (isDOWNLOAD(cftBzip2)) {
+		if (isBzip2Stream(fp)) {
+		    fclose(fp);
+		    fp = 0;
+		    bzfp = BZ2_bzopen(localname, BIN_R);
+
+		    CTRACE((tfp, "HTLoadFile: bzopen of `%s' gives %p\n",
+			    localname, bzfp));
+		}
+		internal_decompress = cftBzip2;
+	    } else
+#endif /* USE_BZLIB */
+#ifdef USE_BROTLI
+	    if (isDOWNLOAD(cftBrotli)) {
+		fclose(fp);
+		fp = 0;
+		brfp = brotli_open(localname, BIN_R);
+
+		CTRACE((tfp, "HTLoadFile: brotli_open of `%s' gives %p\n",
+			localname, (void *) brfp));
+		internal_decompress = cftBrotli;
+	    } else
+#endif /* USE_BROTLI */
+	    {
+		StrAllocCopy(anchor->content_type, format->name);
+		StrAllocCopy(anchor->content_encoding, HTAtom_name(myEncoding));
+		format = HTAtom_for("www/compressed");
+	    }
+	} else {
+	    CompressFileType cft = HTCompressFileType(localname, DOT_STRING, &rootlen);
+
+	    if (cft != cftNone) {
+		char *cp = NULL;
+
+		StrAllocCopy(cp, localname);
+		cp[rootlen] = '\0';
+		format = HTFileFormat(cp, &encoding, NULL);
+		FREE(cp);
+		format = HTCharsetFormat(format, anchor,
+					 UCLYhndl_HTFile_for_unspec);
+		StrAllocCopy(anchor->content_type, format->name);
+	    }
+
+	    switch (cft) {
+	    case cftCompress:
+		StrAllocCopy(anchor->content_encoding, "x-compress");
+		format = HTAtom_for("www/compressed");
+		break;
+	    case cftDeflate:
+		StrAllocCopy(anchor->content_encoding, "x-deflate");
+#ifdef USE_ZLIB
+		if (strcmp(format_out->name, STR_DOWNLOAD) != 0) {
+		    if (isDeflateStream(fp)) {
+			zzfp = fp;
+			fp = 0;
+
+			CTRACE((tfp, "HTLoadFile: zzopen of `%s' gives %p\n",
+				localname, (void *) zzfp));
+		    }
+		    internal_decompress = cftDeflate;
+		}
+#else /* USE_ZLIB */
+		format = HTAtom_for("www/compressed");
+#endif /* USE_ZLIB */
+		break;
+	    case cftGzip:
+		StrAllocCopy(anchor->content_encoding, "x-gzip");
+#ifdef USE_ZLIB
+		if (strcmp(format_out->name, STR_DOWNLOAD) != 0) {
+		    if (isGzipStream(fp)) {
+			fclose(fp);
+			fp = 0;
+			gzfp = gzopen(localname, BIN_R);
+
+			CTRACE((tfp, "HTLoadFile: gzopen of `%s' gives %p\n",
+				localname, (void *) gzfp));
+		    }
+		    internal_decompress = cftGzip;
+		}
+#else /* USE_ZLIB */
+		format = HTAtom_for("www/compressed");
+#endif /* USE_ZLIB */
+		break;
+	    case cftBzip2:
+		StrAllocCopy(anchor->content_encoding, "x-bzip2");
+#ifdef USE_BZLIB
+		if (strcmp(format_out->name, STR_DOWNLOAD) != 0) {
+		    if (isBzip2Stream(fp)) {
+			fclose(fp);
+			fp = 0;
+			bzfp = BZ2_bzopen(localname, BIN_R);
+
+			CTRACE((tfp, "HTLoadFile: bzopen of `%s' gives %p\n",
+				localname, bzfp));
+		    }
+		    internal_decompress = cftBzip2;
+		}
+#else /* USE_BZLIB */
+		format = HTAtom_for("www/compressed");
+#endif /* USE_BZLIB */
+		break;
+	    case cftBrotli:
+		StrAllocCopy(anchor->content_encoding, "x-brotli");
+#ifdef USE_BROTLI
+		if (strcmp(format_out->name, STR_DOWNLOAD) != 0) {
+		    fclose(fp);
+		    fp = 0;
+		    brfp = brotli_open(localname, BIN_R);
+
+		    CTRACE((tfp, "HTLoadFile: brotli_open of `%s' gives %p\n",
+			    localname, (void *) brfp));
+		    internal_decompress = cftBrotli;
+		}
+#else /* USE_BROTLI */
+		format = HTAtom_for("www/compressed");
+#endif /* USE_BROTLI */
+		break;
+	    case cftNone:
+		break;
+	    }
+	}
+#if defined(USE_ZLIB) || defined(USE_BZLIB)
+	if (internal_decompress != cftNone) {
+	    switch (internal_decompress) {
+#ifdef USE_ZLIB
+	    case cftDeflate:
+		failed_decompress = (BOOLEAN) (zzfp == NULL);
+		break;
+	    case cftCompress:
+	    case cftGzip:
+		failed_decompress = (BOOLEAN) (gzfp == NULL);
+		break;
+#endif
+#ifdef USE_BZLIB
+	    case cftBzip2:
+		failed_decompress = (BOOLEAN) (bzfp == NULL);
+		break;
+#endif
+#ifdef USE_BROTLI
+	    case cftBrotli:
+		failed_decompress = (BOOLEAN) (brfp == NULL);
+		break;
+#endif
+	    default:
+		failed_decompress = YES;
+		break;
+	    }
+	    if (failed_decompress) {
+		*statusp = HTLoadError(NULL,
+				       -(HT_ERROR),
+				       FAILED_OPEN_COMPRESSED_FILE);
+	    } else {
+		char *sugfname = NULL;
+
+		if (anchor->SugFname) {
+		    StrAllocCopy(sugfname, anchor->SugFname);
+		} else {
+		    char *anchor_path = HTParse(anchor->address, "",
+						PARSE_PATH + PARSE_PUNCTUATION);
+		    char *lastslash;
+
+		    HTUnEscape(anchor_path);
+		    lastslash = strrchr(anchor_path, '/');
+		    if (lastslash)
+			StrAllocCopy(sugfname, lastslash + 1);
+		    FREE(anchor_path);
+		}
+		FREE(anchor->content_encoding);
+		if (sugfname && *sugfname)
+		    HTCheckFnameForCompression(&sugfname, anchor,
+					       TRUE);
+		if (sugfname && *sugfname)
+		    StrAllocCopy(anchor->SugFname, sugfname);
+		FREE(sugfname);
+#ifdef USE_BROTLI
+		if (brfp)
+		    *statusp = HTParseBrFile(format, format_out,
+					     anchor,
+					     brfp, sink);
+#endif
+#ifdef USE_BZLIB
+		if (bzfp)
+		    *statusp = HTParseBzFile(format, format_out,
+					     anchor,
+					     bzfp, sink);
+#endif
+#ifdef USE_ZLIB
+		if (gzfp)
+		    *statusp = HTParseGzFile(format, format_out,
+					     anchor,
+					     gzfp, sink);
+		else if (zzfp)
+		    *statusp = HTParseZzFile(format, format_out,
+					     anchor,
+					     zzfp, sink);
+#endif
+	    }
+	} else
+#endif /* USE_ZLIB || USE_BZLIB */
+	{
+	    *statusp = HTParseFile(format, format_out, anchor, fp, sink);
+	}
+	if (fp != 0) {
+	    fclose(fp);
+	    fp = 0;
+	}
+	result = TRUE;
+    }				/* If successful open */
+    return result;
+}
+
+/*	Load a document.
+ *	----------------
+ *
+ *  On entry:
+ *	addr		must point to the fully qualified hypertext reference.
+ *			This is the physical address of the file
+ *
+ *  On exit:
+ *	returns		<0		Error has occurred.
+ *			HTLOADED	OK
+ *
+ */
+int HTLoadFile(const char *addr,
+	       HTParentAnchor *anchor,
+	       HTFormat format_out,
+	       HTStream *sink)
+{
+    char *filename = NULL;
+    char *acc_method = NULL;
+    HTFormat format;
+    char *nodename = NULL;
+    char *newname = NULL;	/* Simplified name of file */
+    HTAtom *myEncoding = NULL;	/* enc of this file, may be gzip etc. */
+    int status = -1;
+
+#ifndef DISABLE_FTP
+    char *ftp_newhost;
+#endif
+
+#ifdef VMS
+    struct stat stat_info;
+#endif /* VMS */
+
+    /*
+     * Reduce the filename to a basic form (hopefully unique!).
+     */
+    StrAllocCopy(newname, addr);
+    filename = HTParse(newname, "", PARSE_PATH | PARSE_PUNCTUATION);
+    nodename = HTParse(newname, "", PARSE_HOST);
+
+    /*
+     * If access is ftp, or file is on another host, invoke ftp now.
+     */
+    acc_method = HTParse(newname, "", PARSE_ACCESS);
+    if (strcmp("ftp", acc_method) == 0 ||
+	(!LYSameHostname("localhost", nodename) &&
+	 !LYSameHostname(nodename, HTHostName()))) {
+	status = -1;
+	FREE(newname);
+	FREE(filename);
+	FREE(nodename);
+	FREE(acc_method);
+#ifndef DISABLE_FTP
+	ftp_newhost = HTParse(addr, "", PARSE_HOST);
+	if (strcmp(ftp_lasthost, ftp_newhost))
+	    ftp_local_passive = ftp_passive;
+
+	status = HTFTPLoad(addr, anchor, format_out, sink);
+
+	if (ftp_passive == ftp_local_passive) {
+	    if ((status >= 400) || (status < 0)) {
+		ftp_local_passive = (BOOLEAN) !ftp_passive;
+		status = HTFTPLoad(addr, anchor, format_out, sink);
+	    }
+	}
+
+	free(ftp_lasthost);
+	ftp_lasthost = ftp_newhost;
+#endif /* DISABLE_FTP */
+	return status;
+    } else {
+	FREE(newname);
+	FREE(acc_method);
+    }
+#if defined(VMS) || defined(USE_DOS_DRIVES)
+    HTUnEscape(filename);
+#endif /* VMS */
+
+    /*
+     * Determine the format and encoding mapped to any suffix.
+     */
+    if (anchor->content_type && anchor->content_encoding) {
+	/*
+	 * If content_type and content_encoding are BOTH already set in the
+	 * anchor object, we believe it and don't try to derive format and
+	 * encoding from the filename.  - kw
+	 */
+	format = HTAtom_for(anchor->content_type);
+	myEncoding = HTAtom_for(anchor->content_encoding);
+    } else {
+	int default_UCLYhndl = UCLYhndl_HTFile_for_unspec;
+
+	if (force_old_UCLYhndl_on_reload) {
+	    force_old_UCLYhndl_on_reload = FALSE;
+	    default_UCLYhndl = forced_UCLYhdnl;
+	}
+
+	format = HTFileFormat(filename, &myEncoding, NULL);
+
+	/*
+	 * Check the format for an extended MIME charset value, and act on it
+	 * if present.  Otherwise, assume what is indicated by the last
+	 * parameter (fallback will effectively be UCLYhndl_for_unspec, by
+	 * default ISO-8859-1).  - kw
+	 */
+	format = HTCharsetFormat(format, anchor, default_UCLYhndl);
+    }
+
+#ifdef VMS
+    /*
+     * Check to see if the 'filename' is in fact a directory.  If it is create
+     * a new hypertext object containing a list of files and subdirectories
+     * contained in the directory.  All of these are links to the directories
+     * or files listed.
+     */
+    if (HTStat(filename, &stat_info) == -1) {
+	CTRACE((tfp, "HTLoadFile: Can't stat %s\n", filename));
+    } else {
+	if (S_ISDIR(stat_info.st_mode)) {
+	    if (HTDirAccess == HT_DIR_FORBID) {
+		FREE(filename);
+		FREE(nodename);
+		return HTLoadError(sink, 403, DISALLOWED_DIR_SCAN);
+	    }
+
+	    if (HTDirAccess == HT_DIR_SELECTIVE) {
+		char *enable_file_name = NULL;
+
+		HTSprintf0(&enable_file_name, "%s/%s", filename, HT_DIR_ENABLE_FILE);
+		if (HTStat(enable_file_name, &stat_info) == -1) {
+		    FREE(filename);
+		    FREE(nodename);
+		    FREE(enable_file_name);
+		    return HTLoadError(sink, 403, DISALLOWED_SELECTIVE_ACCESS);
+		}
+	    }
+
+	    FREE(filename);
+	    FREE(nodename);
+	    return HTVMSBrowseDir(addr, anchor, format_out, sink);
+	}
+    }
+
+    if (decompressAndParse(anchor,
+			   format_out,
+			   sink,
+			   nodename,
+			   filename,
+			   myEncoding,
+			   format,
+			   &status)) {
+	FREE(nodename);
+	FREE(filename);
+	return status;
+    }
+    FREE(filename);
+
+#else /* not VMS: */
+
+    FREE(filename);
+
+    /*
+     * For unix, we try to translate the name into the name of a transparently
+     * mounted file.
+     *
+     * Not allowed in secure (HTClientHost) situations.  TBL 921019
+     */
+#ifndef NO_UNIX_IO
+    /*  Need protection here for telnet server but not httpd server. */
+
+    if (!HTSecure) {		/* try local file system */
+	char *localname = HTLocalName(addr);
+	struct stat dir_info;
+
+#ifdef HAVE_READDIR
+	/*
+	 * Multiformat handling.
+	 *
+	 * If needed, scan directory to find a good file.  Bug:  We don't stat
+	 * the file to find the length.
+	 */
+	if ((strlen(localname) > strlen(MULTI_SUFFIX)) &&
+	    (0 == strcmp(localname + strlen(localname) - strlen(MULTI_SUFFIX),
+			 MULTI_SUFFIX))) {
+	    DIR *dp = 0;
+	    BOOL forget_multi = NO;
+
+	    STRUCT_DIRENT *dirbuf;
+	    float best = (float) NO_VALUE_FOUND;	/* So far best is bad */
+	    HTFormat best_rep = NULL;	/* Set when rep found */
+	    HTAtom *best_enc = NULL;
+	    char *best_name = NULL;	/* Best dir entry so far */
+
+	    char *base = strrchr(localname, '/');
+	    size_t baselen = 0;
+
+	    if (!base || base == localname) {
+		forget_multi = YES;
+	    } else {
+		*base++ = '\0';	/* Just got directory name */
+		baselen = strlen(base) - strlen(MULTI_SUFFIX);
+		base[baselen] = '\0';	/* Chop off suffix */
+
+		dp = opendir(localname);
+	    }
+	    if (forget_multi || !dp) {
+		FREE(localname);
+		FREE(nodename);
+		return HTLoadError(sink, 500, FAILED_DIR_SCAN);
+	    }
+
+	    while ((dirbuf = readdir(dp)) != NULL) {
+		/*
+		 * While there are directory entries to be read...
+		 */
+#ifdef STRUCT_DIRENT__D_INO
+		if (dirbuf->d_ino == 0)
+		    continue;	/* if the entry is not being used, skip it */
+#endif
+		if (strlen(dirbuf->d_name) > baselen &&		/* Match? */
+		    !StrNCmp(dirbuf->d_name, base, baselen)) {
+		    HTAtom *enc;
+		    HTFormat rep = HTFileFormat(dirbuf->d_name, &enc, NULL);
+		    float filevalue = HTFileValue(dirbuf->d_name);
+		    float value = HTStackValue(rep, format_out,
+					       filevalue,
+					       0L /* @@@@@@ */ );
+
+		    if (value <= 0.0) {
+			int rootlen = 0;
+			const char *atomname = NULL;
+			CompressFileType cft =
+			HTCompressFileType(dirbuf->d_name, ".", &rootlen);
+			char *cp = NULL;
+
+			enc = NULL;
+			if (cft != cftNone) {
+			    StrAllocCopy(cp, dirbuf->d_name);
+			    cp[rootlen] = '\0';
+			    format = HTFileFormat(cp, NULL, NULL);
+			    FREE(cp);
+			    value = HTStackValue(format, format_out,
+						 filevalue, 0L);
+			}
+			switch (cft) {
+			case cftCompress:
+			    atomname = "application/x-compressed";
+			    break;
+			case cftGzip:
+			    atomname = "application/x-gzip";
+			    break;
+			case cftDeflate:
+			    atomname = "application/x-deflate";
+			    break;
+			case cftBzip2:
+			    atomname = "application/x-bzip2";
+			    break;
+			case cftBrotli:
+			    atomname = "application/x-brotli";
+			    break;
+			case cftNone:
+			    break;
+			}
+
+			if (atomname != NULL) {
+			    value = HTStackValue(format, format_out,
+						 filevalue, 0L);
+			    if (value <= 0.0) {
+				format = HTAtom_for(atomname);
+				value = HTStackValue(format, format_out,
+						     filevalue, 0L);
+			    }
+			    if (value <= 0.0) {
+				format = HTAtom_for("www/compressed");
+				value = HTStackValue(format, format_out,
+						     filevalue, 0L);
+			    }
+			}
+		    }
+		    if (value < NO_VALUE_FOUND) {
+			CTRACE((tfp,
+				"HTLoadFile: value of presenting %s is %f\n",
+				HTAtom_name(rep), value));
+			if (value > best) {
+			    best_rep = rep;
+			    best_enc = enc;
+			    best = value;
+			    StrAllocCopy(best_name, dirbuf->d_name);
+			}
+		    }		/* if best so far */
+		}
+		/* if match */
+	    }			/* end while directory entries left to read */
+	    closedir(dp);
+
+	    if (best_rep) {
+		format = best_rep;
+		myEncoding = best_enc;
+		base[-1] = '/';	/* Restore directory name */
+		base[0] = '\0';
+		StrAllocCat(localname, best_name);
+		FREE(best_name);
+	    } else {		/* If not found suitable file */
+		FREE(localname);
+		FREE(nodename);
+		return HTLoadError(sink, 403, FAILED_NO_REPRESENTATION);
+	    }
+	    /*NOTREACHED */
+	}
+	/* if multi suffix */
+	/*
+	 * Check to see if the 'localname' is in fact a directory.  If it is
+	 * create a new hypertext object containing a list of files and
+	 * subdirectories contained in the directory.  All of these are links
+	 * to the directories or files listed.  NB This assumes the existence
+	 * of a type 'STRUCT_DIRENT', which will hold the directory entry, and
+	 * a type 'DIR' which is used to point to the current directory being
+	 * read.
+	 */
+#if defined(USE_DOS_DRIVES)
+	if (strlen(localname) == 2 && LYIsDosDrive(localname))
+	    LYAddPathSep(&localname);
+#endif
+	if (HTStat(localname, &dir_info) == -1)		/* get file information */
+	{
+	    /* if can't read file information */
+	    CTRACE((tfp, "HTLoadFile: can't stat %s\n", localname));
+
+	} else {		/* Stat was OK */
+
+	    if (S_ISDIR(dir_info.st_mode)) {
+		/*
+		 * If localname is a directory.
+		 */
+		DIR *dp;
+		struct stat file_info;
+
+		CTRACE((tfp, "%s is a directory\n", localname));
+
+		/*
+		 * Check directory access.  Selective access means only those
+		 * directories containing a marker file can be browsed.
+		 */
+		if (HTDirAccess == HT_DIR_FORBID) {
+		    FREE(localname);
+		    FREE(nodename);
+		    return HTLoadError(sink, 403, DISALLOWED_DIR_SCAN);
+		}
+
+		if (HTDirAccess == HT_DIR_SELECTIVE) {
+		    char *enable_file_name = NULL;
+
+		    HTSprintf0(&enable_file_name, "%s/%s", localname, HT_DIR_ENABLE_FILE);
+		    if (stat(enable_file_name, &file_info) != 0) {
+			FREE(localname);
+			FREE(nodename);
+			FREE(enable_file_name);
+			return HTLoadError(sink, 403, DISALLOWED_SELECTIVE_ACCESS);
+		    }
+		}
+
+		CTRACE((tfp, "Opening directory %s\n", localname));
+		dp = opendir(localname);
+		if (!dp) {
+		    FREE(localname);
+		    FREE(nodename);
+		    return HTLoadError(sink, 403, FAILED_DIR_UNREADABLE);
+		}
+
+		/*
+		 * Directory access is allowed and possible.
+		 */
+
+		status = print_local_dir(dp, localname,
+					 anchor, format_out, sink);
+		closedir(dp);
+		FREE(localname);
+		FREE(nodename);
+		return status;	/* document loaded, maybe partial */
+
+	    }
+	    /* end if localname is a directory */
+	    if (S_ISREG(dir_info.st_mode)) {
+#ifdef LONG_MAX
+		if (dir_info.st_size <= LONG_MAX)
+#endif
+		    anchor->content_length = (long) dir_info.st_size;
+	    }
+
+	}			/* end if file stat worked */
+
+/* End of directory reading section
+*/
+#endif /* HAVE_READDIR */
+	if (decompressAndParse(anchor,
+			       format_out,
+			       sink,
+			       nodename,
+			       localname,
+			       myEncoding,
+			       format,
+			       &status)) {
+	    FREE(nodename);
+	    FREE(localname);
+	    return status;
+	}
+	FREE(localname);
+    }				/* local unix file system */
+#endif /* !NO_UNIX_IO */
+#endif /* VMS */
+
+#ifndef DECNET
+    /*
+     * Now, as transparently mounted access has failed, we try FTP.
+     */
+    {
+	/*
+	 * Deal with case-sensitivity differences on VMS versus Unix.
+	 */
+#ifdef VMS
+	if (strcasecomp(nodename, HTHostName()) != 0)
+#else
+	if (strcmp(nodename, HTHostName()) != 0)
+#endif /* VMS */
+	{
+	    status = -1;
+	    FREE(nodename);
+	    if (StrNCmp(addr, "file://localhost", 16)) {
+		/* never go to ftp site when URL
+		 * is file://localhost
+		 */
+#ifndef DISABLE_FTP
+		status = HTFTPLoad(addr, anchor, format_out, sink);
+#endif /* DISABLE_FTP */
+	    }
+	    return status;
+	}
+	FREE(nodename);
+    }
+#endif /* !DECNET */
+
+    /*
+     * All attempts have failed.
+     */
+    {
+	CTRACE((tfp, "Can't open `%s', errno=%d\n", addr, SOCKET_ERRNO));
+
+	return HTLoadError(sink, 403, FAILED_FILE_UNREADABLE);
+    }
+}
+
+static const char *program_paths[pp_Last];
+
+/*
+ * Given a program number, return its path
+ */
+const char *HTGetProgramPath(ProgramPaths code)
+{
+    const char *result = NULL;
+
+    if (code > ppUnknown && code < pp_Last)
+	result = program_paths[code];
+    return result;
+}
+
+/*
+ * Store a program's path.  The caller must allocate the string used for 'path',
+ * since HTInitProgramPaths() may free it.
+ */
+void HTSetProgramPath(ProgramPaths code, const char *path)
+{
+    if (code > ppUnknown && code < pp_Last) {
+	program_paths[code] = isEmpty(path) ? 0 : path;
+    }
+}
+
+/*
+ * Reset the list of known program paths to the ones that are compiled-in
+ */
+void HTInitProgramPaths(BOOL init)
+{
+    ProgramPaths code;
+    int n;
+    const char *path;
+    const char *test;
+
+    for (n = (int) ppUnknown + 1; n < (int) pp_Last; ++n) {
+	switch (code = (ProgramPaths) n) {
+#ifdef BROTLI_PATH
+	case ppBROTLI:
+	    path = BROTLI_PATH;
+	    break;
+#endif
+#ifdef BZIP2_PATH
+	case ppBZIP2:
+	    path = BZIP2_PATH;
+	    break;
+#endif
+#ifdef CHMOD_PATH
+	case ppCHMOD:
+	    path = CHMOD_PATH;
+	    break;
+#endif
+#ifdef COMPRESS_PATH
+	case ppCOMPRESS:
+	    path = COMPRESS_PATH;
+	    break;
+#endif
+#ifdef COPY_PATH
+	case ppCOPY:
+	    path = COPY_PATH;
+	    break;
+#endif
+#ifdef CSWING_PATH
+	case ppCSWING:
+	    path = CSWING_PATH;
+	    break;
+#endif
+#ifdef GZIP_PATH
+	case ppGZIP:
+	    path = GZIP_PATH;
+	    break;
+#endif
+#ifdef INFLATE_PATH
+	case ppINFLATE:
+	    path = INFLATE_PATH;
+	    break;
+#endif
+#ifdef INSTALL_PATH
+	case ppINSTALL:
+	    path = INSTALL_PATH;
+	    break;
+#endif
+#ifdef MKDIR_PATH
+	case ppMKDIR:
+	    path = MKDIR_PATH;
+	    break;
+#endif
+#ifdef MV_PATH
+	case ppMV:
+	    path = MV_PATH;
+	    break;
+#endif
+#ifdef RLOGIN_PATH
+	case ppRLOGIN:
+	    path = RLOGIN_PATH;
+	    break;
+#endif
+#ifdef RM_PATH
+	case ppRM:
+	    path = RM_PATH;
+	    break;
+#endif
+#ifdef RMDIR_PATH
+	case ppRMDIR:
+	    path = RMDIR_PATH;
+	    break;
+#endif
+#ifdef SETFONT_PATH
+	case ppSETFONT:
+	    path = SETFONT_PATH;
+	    break;
+#endif
+#ifdef TAR_PATH
+	case ppTAR:
+	    path = TAR_PATH;
+	    break;
+#endif
+#ifdef TELNET_PATH
+	case ppTELNET:
+	    path = TELNET_PATH;
+	    break;
+#endif
+#ifdef TN3270_PATH
+	case ppTN3270:
+	    path = TN3270_PATH;
+	    break;
+#endif
+#ifdef TOUCH_PATH
+	case ppTOUCH:
+	    path = TOUCH_PATH;
+	    break;
+#endif
+#ifdef UNCOMPRESS_PATH
+	case ppUNCOMPRESS:
+	    path = UNCOMPRESS_PATH;
+	    break;
+#endif
+#ifdef UNZIP_PATH
+	case ppUNZIP:
+	    path = UNZIP_PATH;
+	    break;
+#endif
+#ifdef UUDECODE_PATH
+	case ppUUDECODE:
+	    path = UUDECODE_PATH;
+	    break;
+#endif
+#ifdef ZCAT_PATH
+	case ppZCAT:
+	    path = ZCAT_PATH;
+	    break;
+#endif
+#ifdef ZIP_PATH
+	case ppZIP:
+	    path = ZIP_PATH;
+	    break;
+#endif
+	default:
+	    path = NULL;
+	    break;
+	}
+	test = HTGetProgramPath(code);
+	if (test != NULL && test != path) {
+	    free(DeConst(test));
+	}
+	if (init) {
+	    HTSetProgramPath(code, path);
+	}
+    }
+}
+
+/*
+ *	Protocol descriptors
+ */
+#ifdef GLOBALDEF_IS_MACRO
+#define _HTFILE_C_1_INIT { "ftp", HTLoadFile, 0 }
+GLOBALDEF(HTProtocol, HTFTP, _HTFILE_C_1_INIT);
+#define _HTFILE_C_2_INIT { "file", HTLoadFile, HTFileSaveStream }
+GLOBALDEF(HTProtocol, HTFile, _HTFILE_C_2_INIT);
+#else
+GLOBALDEF HTProtocol HTFTP =
+{"ftp", HTLoadFile, 0};
+GLOBALDEF HTProtocol HTFile =
+{"file", HTLoadFile, HTFileSaveStream};
+#endif /* GLOBALDEF_IS_MACRO */
diff --git a/WWW/Library/Implementation/HTFile.h b/WWW/Library/Implementation/HTFile.h
new file mode 100644
index 0000000..0bdfb79
--- /dev/null
+++ b/WWW/Library/Implementation/HTFile.h
@@ -0,0 +1,368 @@
+/*
+ * $LynxId: HTFile.h,v 1.35 2021/07/29 22:54:21 tom Exp $
+ *							File access in libwww
+ *				FILE ACCESS
+ *
+ *  These are routines for local file access used by WWW browsers and servers.
+ *  Implemented by HTFile.c.
+ *
+ *  If the file is not a local file, then we pass it on to HTFTP in case it
+ *  can be reached by FTP.
+ */
+#ifndef HTFILE_H
+#define HTFILE_H
+
+#include <HTFormat.h>
+#include <HTAccess.h>
+
+#ifndef HTML_H
+#include <HTML.h>		/* SCW */
+#endif /* HTML_H */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ *  Controlling globals
+ *
+ *  These flags control how directories and files are represented as
+ *  hypertext, and are typically set by the application from command
+ *  line options, etc.
+				 */ extern int HTDirAccess;
+    /* Directory access level */
+
+#define HT_DIR_FORBID           0	/* Altogether forbidden */
+#define HT_DIR_SELECTIVE        1	/* If HT_DIR_ENABLE_FILE exists */
+#define HT_DIR_OK               2	/* Any accessible directory */
+
+#define HT_DIR_ENABLE_FILE      ".www_browsable"	/* If exists, can browse */
+
+    extern int HTDirReadme;	/* Include readme files in listing? */
+
+    /* Values: */
+#define HT_DIR_README_NONE      0	/* No */
+#define HT_DIR_README_TOP       1	/* Yes, first */
+#define HT_DIR_README_BOTTOM    2	/* Yes, at the end */
+
+#define HT_DIR_README_FILE              "README"
+
+/*
+ *  Convert filenames between local and WWW formats
+ */
+    extern char *HTURLPath_toFile(const char *name, int expand_all, int is_remote);
+    extern char *HTnameOfFile_WWW(const char *name, int WWW_prefix, int expand_all);
+
+#define HTLocalName(name)      HTnameOfFile_WWW(name,TRUE,TRUE)
+#define HTfullURL_toFile(name) HTnameOfFile_WWW(name,FALSE,TRUE)
+#define HTpartURL_toFile(name) HTnameOfFile_WWW(name,FALSE,FALSE)
+
+/*
+ *  Make a WWW name from a full local path name
+ */
+    extern char *WWW_nameOfFile(const char *name);
+
+/*
+ *  Generate the name of a cache file
+ */
+    extern char *HTCacheFileName(const char *name);
+
+/*
+ *  Generate fragments of HTML for source-view:
+ */
+    extern void HTStructured_doctype(HTStructured * target, HTFormat format_out);
+
+    extern void HTStructured_meta(HTStructured * target, HTFormat format_out);
+/*
+ *  Output directory titles
+ *
+ * This is (like the next one) used by HTFTP. It is common code to generate
+ * the title and heading 1 and the parent directory link for any anchor.
+ *
+ * changed to return TRUE if parent directory link was generated,
+ * FALSE otherwise - KW
+ */
+    extern BOOL HTDirTitles(HTStructured * target, HTParentAnchor *anchor,
+			    HTFormat format_out,
+			    int tildeIsTop);
+
+/*
+ *	Check existence.
+ */
+    extern int HTStat(const char *filename,
+		      struct stat *data);
+
+/*	Load a document.
+ *	----------------
+ */
+    extern int HTLoadFile(const char *addr,
+			  HTParentAnchor *anchor,
+			  HTFormat format_out,
+			  HTStream *sink);
+
+/*
+ *  Output a directory entry
+ *
+ * This is used by HTFTP.c for example -- it is a common routine for
+ *  generating a linked directory entry.
+ */
+    extern void HTDirEntry(HTStructured * target, /* in which to put the linked text */ const char *tail,	/* last part of directory name */
+			   const char *entry);	/* name of this entry */
+
+/*
+ *  HTSetSuffix: Define the representation for a file suffix
+ *
+ *  This defines a mapping between local file suffixes and file content
+ *  types and encodings.
+ *
+ *  ON ENTRY,
+ *
+ *  suffix		includes the "." if that is important (normally, yes!)
+ *
+ *  representation	is MIME-style content-type
+ *
+ *  encoding		is MIME-style content-transfer-encoding
+ *			(8bit, 7bit, etc) or HTTP-style content-encoding
+ *			(gzip, compress etc.)
+ *
+ *  quality		an a priori judgement of the quality of such files
+ *			(0.0..1.0)
+ *
+ *  HTSetSuffix5 has one more parameter for a short description of the type
+ *  which is otherwise derived from the representation:
+ *
+ *  desc		is a short textual description, or NULL
+ *
+ *  Examples:   HTSetSuffix(".ps", "application/postscript", "8bit", 1.0);
+ *  Examples:   HTSetSuffix(".psz", "application/postscript", "gzip", 1.0);
+ *  A MIME type could also indicate a non-trivial encoding on its own
+ *  ("application/x-compressed-tar"), but in that case don't use encoding
+ *  to also indicate it but use "binary" etc.
+ */
+    extern void HTSetSuffix5(const char *suffix,
+			     const char *representation,
+			     const char *encoding,
+			     const char *desc,
+			     double quality);
+
+#define HTSetSuffix(suff,rep,enc,q) HTSetSuffix5(suff, rep, enc, NULL, q)
+
+/*
+ *  HTFileFormat: Get Representation and Encoding from file name.
+ *
+ *  ON EXIT,
+ *
+ *  return		The represntation it imagines the file is in.
+ *
+ *  *pEncoding		The encoding (binary, 7bit, etc). See HTSetSuffix.
+ */
+    extern HTFormat HTFileFormat(const char *filename,
+				 HTAtom **pEncoding,
+				 const char **pDesc);
+
+/*
+ *  HTCharsetFormat: Revise the file format in relation to the Lynx charset.
+ *
+ *  This checks the format associated with an anchor for
+ *  for an extended MIME Content-Type, and if a charset is
+ *  indicated, sets Lynx up for proper handling in relation
+ *  to the currently selected character set. - FM
+ */
+    extern HTFormat HTCharsetFormat(HTFormat format,
+				    HTParentAnchor *anchor,
+				    int default_LYhndl);
+
+/*	Get various pieces of meta info from file name.
+ *	-----------------------------------------------
+ *
+ *  LYGetFileInfo fills in information that can be determined without
+ *  an actual (new) access to the filesystem, based on current suffix
+ *  and character set configuration.  If the file has been loaded and
+ *  parsed before  (with the same URL generated here!) and the anchor
+ *  is still around, some results may be influenced by that (in
+ *  particular, charset info from a META tag - this is not actually
+ *  tested!).
+ *  The caller should not keep pointers to the returned objects around
+ *  for too long, the valid lifetimes vary. In particular, the returned
+ *  charset string should be copied if necessary.  If return of the
+ *  file_anchor is requested, that one can be used to retrieve
+ *  additional bits of info that are stored in the anchor object and
+ *  are not covered here; as usual, don't keep pointers to the
+ *  file_anchor longer than necessary since the object may disappear
+ *  through HTuncache_current_document or at the next document load.
+ *  - kw
+ */
+    extern void LYGetFileInfo(const char *filename,
+			      HTParentAnchor **pfile_anchor,
+			      HTFormat *pformat,
+			      HTAtom **pencoding,
+			      const char **pdesc,
+			      const char **pcharset,
+			      int *pfile_cs);
+
+/*
+ *  Determine file value from file name.
+ */
+    extern float HTFileValue(const char *filename);
+
+/*
+ *  Known compression types.
+ */
+    typedef enum {
+	cftNone
+	,cftCompress
+	,cftGzip
+	,cftBzip2
+	,cftDeflate
+	,cftBrotli
+    } CompressFileType;
+
+/*
+ *  Determine compression type from file name, by looking at its suffix.
+ */
+    extern CompressFileType HTCompressFileType(const char *filename,
+					       const char *dots,
+					       int *rootlen);
+
+/*
+ *  Determine compression type from the content-encoding.
+ */
+    extern CompressFileType HTEncodingToCompressType(const char *encoding);
+/*
+ *  Determine compression type from the content-encoding.
+ */
+    extern CompressFileType HTContentTypeToCompressType(const char *ct);
+/*
+ *  Determine compression type from the content-type and/or content-encoding.
+ */
+    extern CompressFileType HTContentToCompressType(HTParentAnchor *anchor);
+/*
+ *  Determine compression encoding from the compression method.
+ */
+    extern const char *HTCompressTypeToEncoding(CompressFileType method);
+/*
+ *  Determine expected file-suffix from the compression method.
+ */
+    extern const char *HTCompressTypeToSuffix(CompressFileType method);
+/*
+ *  Determine write access to a file.
+ *
+ *  ON EXIT,
+ *
+ *  return value	YES if file can be accessed and can be written to.
+ *
+ *  BUGS
+ *
+ *   Isn't there a quicker way?
+ */
+
+#if defined(HAVE_CONFIG_H)
+
+#ifndef HAVE_GETGROUPS
+#define NO_GROUPS
+#endif
+
+#else
+
+#ifdef VMS
+#define NO_GROUPS
+#endif				/* VMS */
+#ifdef NO_UNIX_IO
+#define NO_GROUPS
+#endif				/* NO_UNIX_IO */
+#ifdef PCNFS
+#define NO_GROUPS
+#endif				/* PCNFS */
+#ifdef NOUSERS
+#define NO_GROUPS
+#endif				/* PCNFS */
+
+#endif				/* HAVE_CONFIG_H */
+
+    extern BOOL HTEditable(const char *filename);
+
+/*	Make a save stream.
+ *	-------------------
+ */
+    extern HTStream *HTFileSaveStream(HTParentAnchor *anchor);
+
+/*
+ * Determine a suitable suffix, given the representation.
+ *
+ *  ON ENTRY,
+ *
+ *  rep			is the atomized MIME style representation
+ *  enc			is an encoding (8bit, binary, gzip, compress,..)
+ *
+ *  ON EXIT,
+ *
+ *  returns		a pointer to a suitable suffix string if one has
+ *			been found, else NULL.
+ */
+    extern const char *HTFileSuffix(HTAtom *rep,
+				    const char *enc);
+
+/*
+ * Enumerate external programs that lynx may assume exists.  Unlike those
+ * given in download scripts, etc., lynx would really like to know their
+ * absolute paths, for better security.
+ */
+    typedef enum {
+	ppUnknown = 0
+	,ppBROTLI
+	,ppBZIP2
+	,ppCHMOD
+	,ppCOMPRESS
+	,ppCOPY
+	,ppCSWING
+	,ppGZIP
+	,ppINFLATE
+	,ppINSTALL
+	,ppMKDIR
+	,ppMV
+	,ppRLOGIN
+	,ppRM
+	,ppRMDIR
+	,ppSETFONT
+	,ppTAR
+	,ppTELNET
+	,ppTN3270
+	,ppTOUCH
+	,ppUNCOMPRESS
+	,ppUNZIP
+	,ppUUDECODE
+	,ppZCAT
+	,ppZIP
+	,pp_Last
+    } ProgramPaths;
+
+/*
+ * Given a program number, return its path
+ */
+    extern const char *HTGetProgramPath(ProgramPaths code);
+
+/*
+ * Store a program's path 
+ */
+    extern void HTSetProgramPath(ProgramPaths code,
+				 const char *path);
+
+/*
+ * Reset the list of known program paths to the ones that are compiled-in
+ */
+    extern void HTInitProgramPaths(BOOL init);
+
+/*
+ *  The Protocols
+ */
+#ifdef GLOBALREF_IS_MACRO
+    extern GLOBALREF (HTProtocol, HTFTP);
+    extern GLOBALREF (HTProtocol, HTFile);
+
+#else
+    GLOBALREF HTProtocol HTFTP, HTFile;
+#endif				/* GLOBALREF_IS_MACRO */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTFILE_H */
diff --git a/WWW/Library/Implementation/HTFinger.c b/WWW/Library/Implementation/HTFinger.c
new file mode 100644
index 0000000..566761a
--- /dev/null
+++ b/WWW/Library/Implementation/HTFinger.c
@@ -0,0 +1,418 @@
+/*
+ * $LynxId: HTFinger.c,v 1.31 2013/11/28 11:27:50 tom Exp $
+ *
+ *			FINGER ACCESS				HTFinger.c
+ *			=============
+ * Authors:
+ *  ARB  Andrew Brooks
+ *
+ * History:
+ *	21 Apr 94   First version (ARB, from HTNews.c by TBL)
+ *	12 Mar 96   Made the URL and command buffering secure from
+ *		     stack modifications, beautified the HTLoadFinger()
+ *		     and response() functions, and added support for the
+ *		     following URL formats for sending a "", "/w",
+ *		     "username[@host]", or "/w username[@host]" command
+ *		     to the server:
+ *			finger://host
+ *			finger://host/
+ *			finger://host/%2fw
+ *			finger://host/%2fw%20username[@host]
+ *			finger://host/w/username[@host]
+ *			finger://host/username[@host]
+ *			finger://host/username[@host]/w
+ *			finger://username@host
+ *			finger://username@host/
+ *			finger://username@host/w
+ *	15 Mar 96   Added support for port 79 gtype 0 gopher URLs
+ *		     relayed from HTLoadGopher. - FM
+ */
+
+#include <HTUtils.h>
+
+#ifndef DISABLE_FINGER
+
+#include <HTAlert.h>
+#include <HTML.h>
+#include <HTParse.h>
+#include <HTFormat.h>
+#include <HTTCP.h>
+#include <HTString.h>
+#include <HTFinger.h>
+
+#include <LYUtils.h>
+#include <LYLeaks.h>
+
+#define FINGER_PORT 79		/* See rfc742 */
+#define BIG 1024		/* Bug */
+
+#define PUTC(c) (*targetClass.put_character)(target, c)
+#define PUTS(s) (*targetClass.put_string)(target, s)
+#define START(e) (*targetClass.start_element)(target, e, 0, 0, -1, 0)
+#define END(e) (*targetClass.end_element)(target, e, 0)
+#define FREE_TARGET (*targetClass._free)(target)
+#define NEXT_CHAR HTGetCharacter()
+
+/*	Module-wide variables
+*/
+static int finger_fd;		/* Socket for FingerHost */
+
+struct _HTStructured {
+    const HTStructuredClass *isa;	/* For gopher streams */
+    /* ... */
+};
+
+static HTStructured *target;	/* The output sink */
+static HTStructuredClass targetClass;	/* Copy of fn addresses */
+
+/*	Initialisation for this module
+ *	------------------------------
+ */
+static BOOL initialized = NO;
+static BOOL initialize(void)
+{
+    finger_fd = -1;		/* Disconnected */
+    return YES;
+}
+
+/*	Start anchor element
+ *	--------------------
+ */
+static void start_anchor(const char *href)
+{
+    BOOL present[HTML_A_ATTRIBUTES];
+    const char *value[HTML_A_ATTRIBUTES];
+
+    {
+	int i;
+
+	for (i = 0; i < HTML_A_ATTRIBUTES; i++)
+	    present[i] = (BOOL) (i == HTML_A_HREF);
+    }
+    ((const char **) value)[HTML_A_HREF] = href;
+    (*targetClass.start_element) (target, HTML_A, present,
+				  (const char **) value, -1, 0);
+
+}
+
+/*	Send Finger Command line to remote host & Check Response
+ *	--------------------------------------------------------
+ *
+ * On entry,
+ *	command	points to the command to be sent, including CRLF, or is null
+ *		pointer if no command to be sent.
+ * On exit,
+ *	Negative status indicates transmission error, socket closed.
+ *	Positive status is a Finger status.
+ */
+
+static int response(char *command,
+		    char *sitename,
+		    HTParentAnchor *anAnchor,
+		    HTFormat format_out,
+		    HTStream *sink)
+{
+    int status;
+    int length = (int) strlen(command);
+    int ch, i;
+    char line[BIG], *l, *cmd = NULL;
+    char *p = line, *href = NULL;
+
+    if (length == 0)
+	return (-1);
+
+    /* Set up buffering.
+     */
+    HTInitInput(finger_fd);
+
+    /* Send the command.
+     */
+    CTRACE((tfp, "HTFinger command to be sent: %s", command));
+    status = (int) NETWRITE(finger_fd, (char *) command, (unsigned) length);
+    if (status < 0) {
+	CTRACE((tfp, "HTFinger: Unable to send command. Disconnecting.\n"));
+	NETCLOSE(finger_fd);
+	finger_fd = -1;
+	return status;
+    }
+    /* if bad status */
+    /* Make a hypertext object with an anchor list.
+     */
+    target = HTML_new(anAnchor, format_out, sink);
+    targetClass = *target->isa;	/* Copy routine entry points */
+
+    /* Create the results report.
+     */
+    CTRACE((tfp, "HTFinger: Reading finger information\n"));
+    START(HTML_HTML);
+    PUTC('\n');
+    START(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_TITLE);
+    PUTS("Finger server on ");
+    PUTS(sitename);
+    END(HTML_TITLE);
+    PUTC('\n');
+    END(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_BODY);
+    PUTC('\n');
+    START(HTML_H1);
+    PUTS("Finger server on ");
+    START(HTML_EM);
+    PUTS(sitename);
+    END(HTML_EM);
+    PUTS(": ");
+    StrAllocCopy(cmd, command);
+    for (i = ((int) strlen(cmd) - 1); i >= 0; i--) {
+	if (cmd[i] == LF || cmd[i] == CR) {
+	    cmd[i] = '\0';
+	} else {
+	    break;
+	}
+    }
+    PUTS(cmd);
+    FREE(cmd);
+    END(HTML_H1);
+    PUTC('\n');
+    START(HTML_PRE);
+
+    while ((ch = NEXT_CHAR) != EOF) {
+
+	if (interrupted_in_htgetcharacter) {
+	    CTRACE((tfp,
+		    "HTFinger: Interrupted in HTGetCharacter, apparently.\n"));
+	    _HTProgress(CONNECTION_INTERRUPTED);
+	    goto end_html;
+	}
+
+	if (ch != LF) {
+	    *p = (char) ch;	/* Put character in line */
+	    if (p < &line[BIG - 1]) {
+		p++;
+	    }
+	} else {
+	    *p = '\0';		/* Terminate line */
+	    /*
+	     * OK we now have a line.
+	     * Load it as 'l' and parse it.
+	     */
+	    p = l = line;
+	    while (*l) {
+		if (StrNCmp(l, STR_NEWS_URL, LEN_NEWS_URL) &&
+		    StrNCmp(l, "snews://", 8) &&
+		    StrNCmp(l, "nntp://", 7) &&
+		    StrNCmp(l, "snewspost:", 10) &&
+		    StrNCmp(l, "snewsreply:", 11) &&
+		    StrNCmp(l, "newspost:", 9) &&
+		    StrNCmp(l, "newsreply:", 10) &&
+		    StrNCmp(l, "ftp://", 6) &&
+		    StrNCmp(l, "file:/", 6) &&
+		    StrNCmp(l, "finger://", 9) &&
+		    StrNCmp(l, "http://", 7) &&
+		    StrNCmp(l, "https://", 8) &&
+		    StrNCmp(l, "wais://", 7) &&
+		    StrNCmp(l, STR_MAILTO_URL, LEN_MAILTO_URL) &&
+		    StrNCmp(l, "cso://", 6) &&
+		    StrNCmp(l, "gopher://", 9))
+		    PUTC(*l++);
+		else {
+		    StrAllocCopy(href, l);
+		    start_anchor(strtok(href, " \r\n\t,>)\""));
+		    while (*l && !StrChr(" \r\n\t,>)\"", *l))
+			PUTC(*l++);
+		    END(HTML_A);
+		    FREE(href);
+		}
+	    }
+	    PUTC('\n');
+	}
+    }
+    NETCLOSE(finger_fd);
+    finger_fd = -1;
+
+  end_html:
+    END(HTML_PRE);
+    PUTC('\n');
+    END(HTML_BODY);
+    PUTC('\n');
+    END(HTML_HTML);
+    PUTC('\n');
+    FREE_TARGET;
+    return (0);
+}
+
+/*		Load by name					HTLoadFinger
+ *		============
+ */
+int HTLoadFinger(const char *arg,
+		 HTParentAnchor *anAnchor,
+		 HTFormat format_out,
+		 HTStream *stream)
+{
+    static char empty[1];
+
+    char *username, *sitename;	/* Fields extracted from URL */
+    char *slash, *at_sign;	/* Fields extracted from URL */
+    char *command, *str, *param;	/* Buffers */
+    int port;			/* Port number from URL */
+    int status;			/* tcp return */
+    int result = HT_LOADED;
+    BOOL IsGopherURL = FALSE;
+    const char *p1 = arg;
+
+    CTRACE((tfp, "HTFinger: Looking for %s\n", (arg ? arg : "NULL")));
+
+    if (!(arg && *arg)) {
+	HTAlert(COULD_NOT_LOAD_DATA);
+	return HT_NOT_LOADED;	/* Ignore if no name */
+    }
+
+    if (!initialized)
+	initialized = initialize();
+    if (!initialized) {
+	HTAlert(gettext("Could not set up finger connection."));
+	return HT_NOT_LOADED;	/* FAIL */
+    }
+
+    /*  Set up the host and command fields.
+     */
+    if (!strncasecomp(arg, "finger://", 9)) {
+	p1 = arg + 9;		/* Skip "finger://" prefix */
+    } else if (!strncasecomp(arg, "gopher://", 9)) {
+	p1 = arg + 9;		/* Skip "gopher://" prefix */
+	IsGopherURL = TRUE;
+    }
+
+    param = 0;
+    sitename = StrAllocCopy(param, p1);
+    if (param == 0) {
+	HTAlert(COULD_NOT_LOAD_DATA);
+	return HT_NOT_LOADED;
+    } else if ((slash = StrChr(sitename, '/')) != NULL) {
+	*slash++ = '\0';
+	HTUnEscape(slash);
+	if (IsGopherURL) {
+	    if (*slash != '0') {
+		HTAlert(COULD_NOT_LOAD_DATA);
+		return HT_NOT_LOADED;	/* FAIL */
+	    }
+	    *slash++ = '\0';
+	}
+    }
+
+    if ((at_sign = StrChr(sitename, '@')) != NULL) {
+	if (IsGopherURL) {
+	    HTAlert(COULD_NOT_LOAD_DATA);
+	    return HT_NOT_LOADED;	/* FAIL */
+	} else {
+	    *at_sign++ = '\0';
+	    username = sitename;
+	    sitename = at_sign;
+	    HTUnEscape(username);
+	}
+    } else if (slash) {
+	username = slash;
+    } else {
+	username = empty;
+    }
+
+    if (*sitename == '\0') {
+	HTAlert(gettext("Could not load data (no sitename in finger URL)"));
+	result = HT_NOT_LOADED;	/* Ignore if no name */
+    } else if (HTParsePort(sitename, &port) != NULL) {
+	if (port != 79) {
+	    HTAlert(gettext("Invalid port number - will only use port 79!"));
+	    result = HT_NOT_LOADED;	/* Ignore if wrong port */
+	}
+    }
+
+    if (result == HT_LOADED) {
+	/* Load the string for making a connection/
+	 */
+	str = 0;
+	HTSprintf0(&str, "lose://%s/", sitename);
+
+	/* Load the command for the finger server.
+	 */
+	command = 0;
+	if (at_sign && slash) {
+	    if (*slash == 'w' || *slash == 'W') {
+		HTSprintf0(&command, "/w %s%c%c", username, CR, LF);
+	    } else {
+		HTSprintf0(&command, "%s%c%c", username, CR, LF);
+	    }
+	} else if (at_sign) {
+	    HTSprintf0(&command, "%s%c%c", username, CR, LF);
+	} else if (*username == '/') {
+	    if ((slash = StrChr((username + 1), '/')) != NULL) {
+		*slash = ' ';
+	    }
+	    HTSprintf0(&command, "%s%c%c", username, CR, LF);
+	} else if ((*username == 'w' || *username == 'W') &&
+		   *(username + 1) == '/') {
+	    if (*username + 2 != '\0') {
+		*(username + 1) = ' ';
+	    } else {
+		*(username + 1) = '\0';
+	    }
+	    HTSprintf0(&command, "/%s%c%c", username, CR, LF);
+	} else if ((*username == 'w' || *username == 'W') &&
+		   *(username + 1) == '\0') {
+	    HTSprintf0(&command, "/%s%c%c", username, CR, LF);
+	} else if ((slash = StrChr(username, '/')) != NULL) {
+	    *slash++ = '\0';
+	    if (*slash == 'w' || *slash == 'W') {
+		HTSprintf0(&command, "/w %s%c%c", username, CR, LF);
+	    } else {
+		HTSprintf0(&command, "%s%c%c", username, CR, LF);
+	    }
+	} else {
+	    HTSprintf0(&command, "%s%c%c", username, CR, LF);
+	}
+
+	/* Now, let's get a stream setup up from the FingerHost:
+	 * CONNECTING to finger host
+	 */
+	CTRACE((tfp, "HTFinger: doing HTDoConnect on '%s'\n", str));
+	status = HTDoConnect(str, "finger", FINGER_PORT, &finger_fd);
+	CTRACE((tfp, "HTFinger: Done DoConnect; status %d\n", status));
+
+	if (status == HT_INTERRUPTED) {
+	    /* Interrupt cleanly */
+	    CTRACE((tfp,
+		    "HTFinger: Interrupted on connect; recovering cleanly.\n"));
+	    HTProgress(CONNECTION_INTERRUPTED);
+	    result = HT_NOT_LOADED;
+	} else if (status < 0) {
+	    NETCLOSE(finger_fd);
+	    finger_fd = -1;
+	    CTRACE((tfp, "HTFinger: Unable to connect to finger host.\n"));
+	    HTAlert(gettext("Could not access finger host."));
+	    result = HT_NOT_LOADED;	/* FAIL */
+	} else {
+	    CTRACE((tfp, "HTFinger: Connected to finger host '%s'.\n", str));
+
+	    /* Send the command, and process response if successful.
+	     */
+	    if (response(command, sitename, anAnchor, format_out, stream) != 0) {
+		HTAlert(gettext("No response from finger server."));
+		result = HT_NOT_LOADED;
+	    }
+	}
+	FREE(str);
+	FREE(command);
+    }
+    FREE(param);
+    return result;
+}
+
+#ifdef GLOBALDEF_IS_MACRO
+#define _HTFINGER_C_1_INIT { "finger", HTLoadFinger, NULL }
+GLOBALDEF(HTProtocol, HTFinger, _HTFINGER_C_1_INIT);
+#else
+GLOBALDEF HTProtocol HTFinger =
+{"finger", HTLoadFinger, NULL};
+#endif /* GLOBALDEF_IS_MACRO */
+
+#endif /* not DISABLE_FINGER */
diff --git a/WWW/Library/Implementation/HTFinger.h b/WWW/Library/Implementation/HTFinger.h
new file mode 100644
index 0000000..071d43b
--- /dev/null
+++ b/WWW/Library/Implementation/HTFinger.h
@@ -0,0 +1,30 @@
+/* Finger protocol module for the WWW library */
+/* History:
+ *      21 Apr 94       Andrew Brooks
+ */
+
+#ifndef HTFINGER_H
+#define HTFINGER_H
+
+#include <HTAccess.h>
+#include <HTAnchor.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef GLOBALREF_IS_MACRO
+    extern GLOBALREF (HTProtocol, HTFinger);
+
+#else
+    GLOBALREF HTProtocol HTFinger;
+#endif				/* GLOBALREF_IS_MACRO */
+
+    extern int HTLoadFinger(const char *arg,
+			    HTParentAnchor *anAnchor,
+			    HTFormat format_out,
+			    HTStream *stream);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTFINGER_H */
diff --git a/WWW/Library/Implementation/HTFormat.c b/WWW/Library/Implementation/HTFormat.c
new file mode 100644
index 0000000..a830387
--- /dev/null
+++ b/WWW/Library/Implementation/HTFormat.c
@@ -0,0 +1,2181 @@
+/*
+ * $LynxId: HTFormat.c,v 1.96 2022/03/31 23:39:38 tom Exp $
+ *
+ *		Manage different file formats			HTFormat.c
+ *		=============================
+ *
+ * Bugs:
+ *	Not reentrant.
+ *
+ *	Assumes the incoming stream is ASCII, rather than a local file
+ *	format, and so ALWAYS converts from ASCII on non-ASCII machines.
+ *	Therefore, non-ASCII machines can't read local files.
+ *
+ */
+
+#define HTSTREAM_INTERNAL 1
+
+#include <HTUtils.h>
+
+/* Implements:
+*/
+#include <HTFormat.h>
+
+static float HTMaxSecs = 1e10;	/* No effective limit */
+
+#ifdef UNIX
+#ifdef NeXT
+#define PRESENT_POSTSCRIPT "open %s; /bin/rm -f %s\n"
+#else
+#define PRESENT_POSTSCRIPT "(ghostview %s ; /bin/rm -f %s)&\n"
+			   /* Full pathname would be better! */
+#endif /* NeXT */
+#endif /* UNIX */
+
+#include <HTML.h>
+#include <HTMLDTD.h>
+#include <HText.h>
+#include <HTAlert.h>
+#include <HTList.h>
+#include <HTInit.h>
+#include <HTTCP.h>
+#include <HTTP.h>
+/*	Streams and structured streams which we use:
+*/
+#include <HTFWriter.h>
+#include <HTPlain.h>
+#include <SGML.h>
+#include <HTMLGen.h>
+
+#include <LYexit.h>
+#include <LYUtils.h>
+#include <GridText.h>
+#include <LYGlobalDefs.h>
+#include <LYLeaks.h>
+
+#ifdef DISP_PARTIAL
+#include <LYMainLoop.h>
+#endif
+
+#ifdef USE_BROTLI
+#include <brotli/decode.h>
+#endif
+
+BOOL HTOutputSource = NO;	/* Flag: shortcut parser to stdout */
+
+/* this version used by the NetToText stream */
+struct _HTStream {
+    const HTStreamClass *isa;
+    BOOL had_cr;
+    HTStream *sink;
+};
+
+/*	Presentation methods
+ *	--------------------
+ */
+HTList *HTPresentations = NULL;
+HTPresentation *default_presentation = NULL;
+
+/*
+ *	To free off the presentation list.
+ */
+#ifdef LY_FIND_LEAKS
+static void HTFreePresentations(void);
+#endif
+
+/*	Define a presentation system command for a content-type
+ *	-------------------------------------------------------
+ */
+void HTSetPresentation(const char *representation,
+		       const char *command,
+		       const char *testcommand,
+		       double quality,
+		       double secs,
+		       double secs_per_byte,
+		       long int maxbytes,
+		       AcceptMedia media)
+{
+    HTPresentation *pres = typecalloc(HTPresentation);
+
+    if (pres == NULL)
+	outofmem(__FILE__, "HTSetPresentation");
+
+    assert(representation != NULL);
+
+    CTRACE2(TRACE_CFG,
+	    (tfp,
+	     "HTSetPresentation rep=%s, command=%s, test=%s, qual=%f\n",
+	     NonNull(representation),
+	     NonNull(command),
+	     NonNull(testcommand),
+	     quality));
+
+    pres->rep = HTAtom_for(representation);
+    pres->rep_out = WWW_PRESENT;	/* Fixed for now ... :-) */
+    pres->converter = HTSaveAndExecute;		/* Fixed for now ...     */
+    pres->quality = (float) quality;
+    pres->secs = (float) secs;
+    pres->secs_per_byte = (float) secs_per_byte;
+    pres->maxbytes = maxbytes;
+    pres->get_accept = 0;
+    pres->accept_opt = media;
+
+    pres->command = NULL;
+    StrAllocCopy(pres->command, command);
+
+    pres->testcommand = NULL;
+    StrAllocCopy(pres->testcommand, testcommand);
+
+    /*
+     * Memory leak fixed.
+     * 05-28-94 Lynx 2-3-1 Garrett Arch Blythe
+     */
+    if (!HTPresentations) {
+	HTPresentations = HTList_new();
+#ifdef LY_FIND_LEAKS
+	atexit(HTFreePresentations);
+#endif
+    }
+
+    if (strcmp(representation, "*") == 0) {
+	FREE(default_presentation);
+	default_presentation = pres;
+    } else {
+	HTList_addObject(HTPresentations, pres);
+    }
+}
+
+/*	Define a built-in function for a content-type
+ *	---------------------------------------------
+ */
+void HTSetConversion(const char *representation_in,
+		     const char *representation_out,
+		     HTConverter *converter,
+		     double quality,
+		     double secs,
+		     double secs_per_byte,
+		     long int maxbytes,
+		     AcceptMedia media)
+{
+    HTPresentation *pres = typecalloc(HTPresentation);
+
+    if (pres == NULL)
+	outofmem(__FILE__, "HTSetConversion");
+
+    CTRACE2(TRACE_CFG,
+	    (tfp,
+	     "HTSetConversion rep_in=%s, rep_out=%s, qual=%f\n",
+	     NonNull(representation_in),
+	     NonNull(representation_out),
+	     quality));
+
+    pres->rep = HTAtom_for(representation_in);
+    pres->rep_out = HTAtom_for(representation_out);
+    pres->converter = converter;
+    pres->command = NULL;
+    pres->testcommand = NULL;
+    pres->quality = (float) quality;
+    pres->secs = (float) secs;
+    pres->secs_per_byte = (float) secs_per_byte;
+    pres->maxbytes = maxbytes;
+    pres->get_accept = TRUE;
+    pres->accept_opt = media;
+
+    /*
+     * Memory Leak fixed.
+     * 05-28-94 Lynx 2-3-1 Garrett Arch Blythe
+     */
+    if (!HTPresentations) {
+	HTPresentations = HTList_new();
+#ifdef LY_FIND_LEAKS
+	atexit(HTFreePresentations);
+#endif
+    }
+
+    HTList_addObject(HTPresentations, pres);
+}
+
+#ifdef LY_FIND_LEAKS
+/*
+ *	Purpose:	Free the presentation list.
+ *	Arguments:	void
+ *	Return Value:	void
+ *	Remarks/Portability/Dependencies/Restrictions:
+ *		Made to clean up Lynx's bad leakage.
+ *	Revision History:
+ *		05-28-94	created Lynx 2-3-1 Garrett Arch Blythe
+ */
+static void HTFreePresentations(void)
+{
+    HTPresentation *pres = NULL;
+
+    /*
+     * Loop through the list.
+     */
+    while (!HTList_isEmpty(HTPresentations)) {
+	/*
+	 * Free off each item.  May also need to free off it's items, but not
+	 * sure as of yet.
+	 */
+	pres = (HTPresentation *) HTList_removeLastObject(HTPresentations);
+	FREE(pres->command);
+	FREE(pres->testcommand);
+	FREE(pres);
+    }
+    /*
+     * Free the list itself.
+     */
+    HTList_delete(HTPresentations);
+    HTPresentations = NULL;
+}
+#endif /* LY_FIND_LEAKS */
+
+/*	File buffering
+ *	--------------
+ *
+ *	The input file is read using the macro which can read from
+ *	a socket or a file.
+ *	The input buffer size, if large will give greater efficiency and
+ *	release the server faster, and if small will save space on PCs etc.
+ */
+#define INPUT_BUFFER_SIZE 4096	/* Tradeoff */
+static char input_buffer[INPUT_BUFFER_SIZE];
+static char *input_pointer;
+static char *input_limit;
+static int input_file_number;
+
+/*	Set up the buffering
+ *
+ *	These routines are public because they are in fact needed by
+ *	many parsers, and on PCs and Macs we should not duplicate
+ *	the static buffer area.
+ */
+void HTInitInput(int file_number)
+{
+    input_file_number = file_number;
+    input_pointer = input_limit = input_buffer;
+}
+
+int interrupted_in_htgetcharacter = 0;
+int HTGetCharacter(void)
+{
+    char ch;
+
+    interrupted_in_htgetcharacter = 0;
+    do {
+	if (input_pointer >= input_limit) {
+	    int status = NETREAD(input_file_number,
+				 input_buffer, INPUT_BUFFER_SIZE);
+
+	    if (status <= 0) {
+		if (status == 0)
+		    return EOF;
+		if (status == HT_INTERRUPTED) {
+		    CTRACE((tfp, "HTFormat: Interrupted in HTGetCharacter\n"));
+		    interrupted_in_htgetcharacter = 1;
+		    return EOF;
+		}
+		CTRACE((tfp, "HTFormat: File read error %d\n", status));
+		return EOF;	/* -1 is returned by UCX
+				   at end of HTTP link */
+	    }
+	    input_pointer = input_buffer;
+	    input_limit = input_buffer + status;
+	}
+	ch = *input_pointer++;
+    } while (ch == (char) 13);	/* Ignore ASCII carriage return */
+
+    return FROMASCII(UCH(ch));
+}
+
+#ifdef USE_SSL
+int HTGetSSLCharacter(void *handle)
+{
+    char ch;
+
+    interrupted_in_htgetcharacter = 0;
+    if (!handle)
+	return (char) EOF;
+    do {
+	if (input_pointer >= input_limit) {
+	    int status = SSL_read((SSL *) handle,
+				  input_buffer, INPUT_BUFFER_SIZE);
+
+	    if (status <= 0) {
+		if (status == 0)
+		    return (char) EOF;
+		if (status == HT_INTERRUPTED) {
+		    CTRACE((tfp,
+			    "HTFormat: Interrupted in HTGetSSLCharacter\n"));
+		    interrupted_in_htgetcharacter = 1;
+		    return (char) EOF;
+		}
+		CTRACE((tfp, "HTFormat: SSL_read error %d\n", status));
+		return (char) EOF;	/* -1 is returned by UCX
+					   at end of HTTP link */
+	    }
+	    input_pointer = input_buffer;
+	    input_limit = input_buffer + status;
+	}
+	ch = *input_pointer++;
+    } while (ch == (char) 13);	/* Ignore ASCII carriage return */
+
+    return FROMASCII(ch);
+}
+#endif /* USE_SSL */
+
+/* Match maintype to any MIME type starting with maintype, for example: 
+ * image/gif should match image
+ */
+static int half_match(char *trial_type, char *target)
+{
+    char *cp = StrChr(trial_type, '/');
+
+    /* if no '/' or no '*' */
+    if (!cp || *(cp + 1) != '*')
+	return 0;
+
+    CTRACE((tfp, "HTFormat: comparing %s and %s for half match\n",
+	    trial_type, target));
+
+    /* main type matches */
+    if (!StrNCmp(trial_type, target, ((cp - trial_type) - 1)))
+	return 1;
+
+    return 0;
+}
+
+/*
+ * Evaluate a deferred mailcap test command, i.e.,. one that substitutes the
+ * document's charset or other values in %{name} format.
+ */
+static BOOL failsMailcap(HTPresentation *pres, HTParentAnchor *anchor)
+{
+    if (pres->testcommand != NULL &&
+	anchor != NULL &&
+	anchor->content_type_params != NULL) {
+	if (LYTestMailcapCommand(pres->testcommand,
+				 anchor->content_type_params) != 0)
+	    return TRUE;
+    }
+    return FALSE;
+}
+
+#define WWW_WILDCARD_REP_OUT HTAtom_for("*")
+
+/*		Look up a presentation
+ *		----------------------
+ *
+ *	If fill_in is NULL, only look for an exact match.
+ *	If a wildcard match is made, *fill_in is used to store
+ *	a possibly modified presentation, and a pointer to it is
+ *	returned.  For an exact match, a pointer to the presentation
+ *	in the HTPresentations list is returned.  Returns NULL if
+ *	nothing found. - kw
+ *
+ */
+static HTPresentation *HTFindPresentation(HTFormat rep_in,
+					  HTFormat rep_out,
+					  HTPresentation *fill_in,
+					  HTParentAnchor *anchor)
+{
+#undef THIS_FUNC
+#define THIS_FUNC "HTFindPresentation"
+    HTAtom *wildcard = NULL;	/* = HTAtom_for("*"); lookup when needed - kw */
+    int n;
+    int i;
+    HTPresentation *pres;
+    HTPresentation *match;
+    HTPresentation *strong_wildcard_match = 0;
+    HTPresentation *weak_wildcard_match = 0;
+    HTPresentation *last_default_match = 0;
+    HTPresentation *strong_subtype_wildcard_match = 0;
+
+    CTRACE((tfp, THIS_FUNC ": Looking up presentation for %s to %s\n",
+	    HTAtom_name(rep_in), HTAtom_name(rep_out)));
+
+    n = HTList_count(HTPresentations);
+    for (i = 0; i < n; i++) {
+	pres = (HTPresentation *) HTList_objectAt(HTPresentations, i);
+	if (pres->rep == rep_in) {
+	    if (pres->rep_out == rep_out) {
+		if (failsMailcap(pres, anchor))
+		    continue;
+		CTRACE((tfp, THIS_FUNC ": found exact match: %s -> %s\n",
+			HTAtom_name(pres->rep),
+			HTAtom_name(pres->rep_out)));
+		return pres;
+
+	    } else if (!fill_in) {
+		continue;
+	    } else {
+		if (!wildcard)
+		    wildcard = WWW_WILDCARD_REP_OUT;
+		if (pres->rep_out == wildcard) {
+		    if (failsMailcap(pres, anchor))
+			continue;
+		    if (!strong_wildcard_match)
+			strong_wildcard_match = pres;
+		    /* otherwise use the first one */
+		    CTRACE((tfp, THIS_FUNC
+			    ": found strong wildcard match: %s -> %s\n",
+			    HTAtom_name(pres->rep),
+			    HTAtom_name(pres->rep_out)));
+		}
+	    }
+
+	} else if (!fill_in) {
+	    continue;
+
+	} else if (half_match(HTAtom_name(pres->rep),
+			      HTAtom_name(rep_in))) {
+	    if (pres->rep_out == rep_out) {
+		if (failsMailcap(pres, anchor))
+		    continue;
+		if (!strong_subtype_wildcard_match)
+		    strong_subtype_wildcard_match = pres;
+		/* otherwise use the first one */
+		CTRACE((tfp, THIS_FUNC
+			": found strong subtype wildcard match: %s -> %s\n",
+			HTAtom_name(pres->rep),
+			HTAtom_name(pres->rep_out)));
+	    }
+	}
+
+	if (pres->rep == WWW_SOURCE) {
+	    if (pres->rep_out == rep_out) {
+		if (failsMailcap(pres, anchor))
+		    continue;
+		if (!weak_wildcard_match)
+		    weak_wildcard_match = pres;
+		/* otherwise use the first one */
+		CTRACE((tfp,
+			THIS_FUNC ": found weak wildcard match: %s\n",
+			HTAtom_name(pres->rep_out)));
+
+	    } else if (!last_default_match) {
+		if (!wildcard)
+		    wildcard = WWW_WILDCARD_REP_OUT;
+		if (pres->rep_out == wildcard) {
+		    if (failsMailcap(pres, anchor))
+			continue;
+		    last_default_match = pres;
+		    /* otherwise use the first one */
+		}
+	    }
+	}
+    }
+
+    match = (strong_subtype_wildcard_match
+	     ? strong_subtype_wildcard_match
+	     : (strong_wildcard_match
+		? strong_wildcard_match
+		: (weak_wildcard_match
+		   ? weak_wildcard_match
+		   : last_default_match)));
+
+    if (match) {
+	*fill_in = *match;	/* Specific instance */
+	fill_in->rep = rep_in;	/* yuk */
+	fill_in->rep_out = rep_out;	/* yuk */
+	return fill_in;
+    }
+
+    return NULL;
+#undef THIS_FUNC
+}
+
+/*		Create a filter stack
+ *		---------------------
+ *
+ *	If a wildcard match is made, a temporary HTPresentation
+ *	structure is made to hold the destination format while the
+ *	new stack is generated. This is just to pass the out format to
+ *	MIME so far.  Storing the format of a stream in the stream might
+ *	be a lot neater.
+ *
+ */
+HTStream *HTStreamStack(HTFormat rep_in,
+			HTFormat rep_out,
+			HTStream *sink,
+			HTParentAnchor *anchor)
+{
+#undef THIS_FUNC
+#define THIS_FUNC "HTStreamStack"
+    HTPresentation temp;
+    HTPresentation *match;
+    HTStream *result;
+
+    CTRACE((tfp, THIS_FUNC ": Constructing stream stack for %s to %s (%s)\n",
+	    HTAtom_name(rep_in),
+	    HTAtom_name(rep_out),
+	    NONNULL(anchor->content_type_params)));
+
+    if (rep_out == rep_in) {
+	result = sink;
+
+    } else if ((match = HTFindPresentation(rep_in, rep_out, &temp, anchor))) {
+	if (match == &temp) {
+	    CTRACE((tfp, THIS_FUNC ": Using %s\n", HTAtom_name(temp.rep_out)));
+	} else {
+	    CTRACE((tfp, THIS_FUNC ": found exact match: %s -> %s\n",
+		    HTAtom_name(match->rep),
+		    HTAtom_name(match->rep_out)));
+	}
+	result = (*match->converter) (match, anchor, sink);
+    } else {
+	result = NULL;
+    }
+    if (TRACE) {
+	if (result && result->isa && result->isa->name) {
+	    CTRACE((tfp, THIS_FUNC ": Returning \"%s\"\n", result->isa->name));
+	} else if (result) {
+	    CTRACE((tfp, THIS_FUNC ": Returning *unknown* stream!\n"));
+	} else {
+	    CTRACE((tfp, THIS_FUNC ": Returning NULL!\n"));
+	    CTRACE_FLUSH(tfp);	/* a crash may be imminent... - kw */
+	}
+    }
+    return result;
+#undef THIS_FUNC
+}
+
+/*		Put a presentation near start of list
+ *		-------------------------------------
+ *
+ *	Look up a presentation (exact match only) and, if found, reorder
+ *	it to the start of the HTPresentations list. - kw
+ */
+void HTReorderPresentation(HTFormat rep_in,
+			   HTFormat rep_out)
+{
+    HTPresentation *match;
+
+    if ((match = HTFindPresentation(rep_in, rep_out, NULL, NULL))) {
+	HTList_removeObject(HTPresentations, match);
+	HTList_addObject(HTPresentations, match);
+    }
+}
+
+/*
+ * Setup 'get_accept' flag to denote presentations that are not redundant,
+ * and will be listed in "Accept:" header.
+ */
+void HTFilterPresentations(void)
+{
+    int i, j;
+    int n = HTList_count(HTPresentations);
+    HTPresentation *p, *q;
+    BOOL matched;
+    char *s, *t;
+
+    CTRACE((tfp, "HTFilterPresentations (AcceptMedia %#x)\n", LYAcceptMedia));
+    for (i = 0; i < n; i++) {
+	p = (HTPresentation *) HTList_objectAt(HTPresentations, i);
+	s = HTAtom_name(p->rep);
+
+	p->get_accept = FALSE;
+	if ((LYAcceptMedia & p->accept_opt) != 0
+	    && p->rep_out == WWW_PRESENT
+	    && p->rep != WWW_SOURCE
+	    && strcasecomp(s, "www/mime")
+	    && strcasecomp(s, "www/compressed")
+	    && p->quality <= 1.0 && p->quality >= 0.0) {
+	    matched = TRUE;
+	    for (j = 0; j < i; j++) {
+		q = (HTPresentation *) HTList_objectAt(HTPresentations, j);
+		t = HTAtom_name(q->rep);
+
+		if (!strcasecomp(s, t)) {
+		    matched = FALSE;
+		    CTRACE((tfp, "  match %s %s\n", s, t));
+		    break;
+		}
+	    }
+	    p->get_accept = matched;
+	}
+    }
+}
+
+/*		Find the cost of a filter stack
+ *		-------------------------------
+ *
+ *	Must return the cost of the same stack which HTStreamStack would set up.
+ *
+ * On entry,
+ *	length	The size of the data to be converted
+ */
+float HTStackValue(HTFormat rep_in,
+		   HTFormat rep_out,
+		   double initial_value,
+		   long int length)
+{
+    HTAtom *wildcard = WWW_WILDCARD_REP_OUT;
+
+    CTRACE((tfp, "HTFormat: Evaluating stream stack for %s worth %.3f to %s\n",
+	    HTAtom_name(rep_in), initial_value, HTAtom_name(rep_out)));
+
+    if (rep_out == WWW_SOURCE || rep_out == rep_in)
+	return 0.0;
+
+    {
+	int n = HTList_count(HTPresentations);
+	int i;
+	HTPresentation *pres;
+
+	for (i = 0; i < n; i++) {
+	    pres = (HTPresentation *) HTList_objectAt(HTPresentations, i);
+	    if (pres->rep == rep_in &&
+		(pres->rep_out == rep_out || pres->rep_out == wildcard)) {
+		float value = (float) (initial_value * pres->quality);
+
+		if (HTMaxSecs > 0.0)
+		    value = (value
+			     - ((float) length * pres->secs_per_byte
+				+ pres->secs)
+			     / HTMaxSecs);
+		return value;
+	    }
+	}
+    }
+
+    return (float) -1e30;	/* Really bad */
+
+}
+
+/*	Display the page while transfer in progress
+ *	-------------------------------------------
+ *
+ *   Repaint the page only when necessary.
+ *   This is a traverse call for HText_pageDisplay() - it works!.
+ *
+ */
+void HTDisplayPartial(void)
+{
+#ifdef DISP_PARTIAL
+    if (display_partial) {
+	/*
+	 * HText_getNumOfLines() = "current" number of complete lines received
+	 * NumOfLines_partial = number of lines at the moment of last repaint. 
+	 * (we update NumOfLines_partial only when we repaint the display.)
+	 *
+	 * display_partial could only be enabled in HText_new() so a new
+	 * HTMainText object available - all HText_ functions use it, lines
+	 * counter HText_getNumOfLines() in particular.
+	 *
+	 * Otherwise HTMainText holds info from the previous document and we
+	 * may repaint it instead of the new one:  prev doc scrolled to the
+	 * first line (=Newline_partial) is not good looking :-) 23 Aug 1998
+	 * Leonid Pauzner
+	 *
+	 * So repaint the page only when necessary:
+	 */
+	int Newline_partial = LYGetNewline();
+
+	if (((Newline_partial + display_lines) - 1 > NumOfLines_partial)
+	/* current page not complete... */
+	    && (partial_threshold > 0 ?
+		((Newline_partial + partial_threshold) - 1 <=
+		 HText_getNumOfLines()) :
+		((Newline_partial + display_lines) - 1 <= HText_getNumOfLines()))
+	/*
+	 * Originally we rendered by increments of 2 lines,
+	 * but that got annoying on slow network connections.
+	 * Then we switched to full-pages.  Now it's configurable.
+	 * If partial_threshold <= 0, then it's a full page
+	 */
+	    ) {
+	    if (LYMainLoop_pageDisplay(Newline_partial))
+		NumOfLines_partial = HText_getNumOfLines();
+	}
+    }
+#else /* nothing */
+#endif /* DISP_PARTIAL */
+}
+
+/* Put this as early as possible, OK just after HTDisplayPartial() */
+void HTFinishDisplayPartial(void)
+{
+#ifdef DISP_PARTIAL
+    /*
+     * End of incremental rendering stage here.
+     */
+    display_partial = FALSE;
+#endif /* DISP_PARTIAL */
+}
+
+/*	Push data from a socket down a stream
+ *	-------------------------------------
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *   The file number given is assumed to be a TELNET stream, i.e., containing
+ *   CRLF at the end of lines which need to be stripped to LF for unix
+ *   when the format is textual.
+ *
+ *  State of socket and target stream on entry:
+ *			socket (file_number) assumed open,
+ *			target (sink) assumed valid.
+ *
+ *  Return values:
+ *	HT_INTERRUPTED  Interruption or error after some data received.
+ *	-2		Unexpected disconnect before any data received.
+ *	-1		Interruption or error before any data received, or
+ *			(UNIX) other read error before any data received, or
+ *			download cancelled.
+ *	HT_LOADED	Normal close of socket (end of file indication
+ *			received), or
+ *			unexpected disconnect after some data received, or
+ *			other read error after some data received, or
+ *			(not UNIX) other read error before any data received.
+ *
+ *  State of socket and target stream on return depends on return value:
+ *	HT_INTERRUPTED	socket still open, target aborted.
+ *	-2		socket still open, target stream still valid.
+ *	-1		socket still open, target aborted.
+ *	otherwise	socket closed,	target stream still valid.
+ */
+int HTCopy(HTParentAnchor *anchor,
+	   int file_number,
+	   void *handle GCC_UNUSED,
+	   HTStream *sink)
+{
+    HTStreamClass targetClass;
+    BOOL suppress_readprogress = NO;
+    off_t limit = anchor ? anchor->content_length : 0;
+    off_t bytes = 0;
+    off_t header_length = 0;
+    int rv = 0;
+
+    /*  Push the data down the stream
+     */
+    targetClass = *(sink->isa);	/* Copy pointers to procedures */
+
+    /*
+     * Push binary from socket down sink
+     *
+     * This operation could be put into a main event loop
+     */
+    HTReadProgress(bytes, (off_t) 0);
+    for (;;) {
+	int status;
+
+	if (LYCancelDownload) {
+	    LYCancelDownload = FALSE;
+	    (*targetClass._abort) (sink, NULL);
+	    rv = -1;
+	    goto finished;
+	}
+
+	if (HTCheckForInterrupt()) {
+	    _HTProgress(TRANSFER_INTERRUPTED);
+	    (*targetClass._abort) (sink, NULL);
+	    if (bytes)
+		rv = HT_INTERRUPTED;
+	    else
+		rv = -1;
+	    goto finished;
+	}
+#ifdef USE_SSL
+	if (handle)
+	    status = SSL_read((SSL *) handle, input_buffer, INPUT_BUFFER_SIZE);
+	else
+	    status = NETREAD(file_number, input_buffer, INPUT_BUFFER_SIZE);
+#else
+	status = NETREAD(file_number, input_buffer, INPUT_BUFFER_SIZE);
+#endif /* USE_SSL */
+	if (status <= 0) {
+	    if (status == 0) {
+		break;
+	    } else if (status == HT_INTERRUPTED) {
+		_HTProgress(TRANSFER_INTERRUPTED);
+		(*targetClass._abort) (sink, NULL);
+		if (bytes)
+		    rv = HT_INTERRUPTED;
+		else
+		    rv = -1;
+		goto finished;
+	    } else if (SOCKET_ERRNO == ENOTCONN ||
+#ifdef _WINDOWS			/* 1997/11/10 (Mon) 16:57:18 */
+		       SOCKET_ERRNO == ETIMEDOUT ||
+#endif
+		       SOCKET_ERRNO == ECONNRESET ||
+		       SOCKET_ERRNO == EPIPE) {
+		/*
+		 * Arrrrgh, HTTP 0/1 compatibility problem, maybe.
+		 */
+		if (bytes <= 0) {
+		    /*
+		     * Don't have any data, so let the calling function decide
+		     * what to do about it.  - FM
+		     */
+		    rv = -2;
+		    goto finished;
+		} else {
+#ifdef UNIX
+		    /*
+		     * Treat what we've received already as the complete
+		     * transmission, but not without giving the user an alert. 
+		     * I don't know about all the different TCP stacks for VMS
+		     * etc., so this is currently only for UNIX.  - kw
+		     */
+		    HTInetStatus("NETREAD");
+		    HTAlert("Unexpected server disconnect.");
+		    CTRACE((tfp,
+			    "HTCopy: Unexpected server disconnect. Treating as completed.\n"));
+#else /* !UNIX */
+		    /*
+		     * Treat what we've gotten already as the complete
+		     * transmission.  - FM
+		     */
+		    CTRACE((tfp,
+			    "HTCopy: Unexpected server disconnect.  Treating as completed.\n"));
+		    status = 0;
+#endif /* UNIX */
+		}
+#ifdef UNIX
+	    } else {		/* status < 0 and other errno */
+		/*
+		 * Treat what we've received already as the complete
+		 * transmission, but not without giving the user an alert.  I
+		 * don't know about all the different TCP stacks for VMS etc.,
+		 * so this is currently only for UNIX.  - kw
+		 */
+		HTInetStatus("NETREAD");
+		HTAlert("Unexpected read error.");
+		if (bytes) {
+		    (void) NETCLOSE(file_number);
+		    rv = HT_LOADED;
+		} else {
+		    (*targetClass._abort) (sink, NULL);
+		    rv = -1;
+		}
+		goto finished;
+#endif
+	    }
+	    break;
+	}
+
+	/*
+	 * Suppress ReadProgress messages when collecting a redirection
+	 * message, at least initially (unless/until anchor->content_type gets
+	 * changed, probably by the MIME message parser).  That way messages
+	 * put up by the HTTP module or elsewhere can linger in the statusline
+	 * for a while.  - kw
+	 */
+	suppress_readprogress = (BOOL) (anchor && anchor->content_type &&
+					!strcmp(anchor->content_type,
+						"message/x-http-redirection"));
+#ifdef NOT_ASCII
+	{
+	    char *p;
+
+	    for (p = input_buffer; p < input_buffer + status; p++) {
+		*p = FROMASCII(*p);
+	    }
+	}
+#endif /* NOT_ASCII */
+
+	header_length = anchor != 0 ? anchor->header_length : 0;
+
+	(*targetClass.put_block) (sink, input_buffer, status);
+	if (anchor != 0 && anchor->inHEAD) {
+	    if (!suppress_readprogress) {
+		statusline(gettext("Reading headers..."));
+	    }
+	    CTRACE((tfp, "HTCopy read %" PRI_off_t " header bytes\n",
+		    CAST_off_t (anchor->header_length)));
+	} else {
+	    /*
+	     * If header-length is increased at this point, that is due to
+	     * HTMIME, which detects the end of the server headers.  There
+	     * may be additional (non-header) data in that block.
+	     */
+	    if (anchor != 0 && (anchor->header_length > header_length)) {
+		int header = (int) (anchor->header_length - header_length);
+
+		CTRACE((tfp, "HTCopy read %" PRI_off_t " header bytes "
+			"(%d extra vs %d total)\n",
+			CAST_off_t (anchor->header_length),
+			header, status));
+		if (status > header) {
+		    bytes += (status - header);
+		}
+	    } else {
+		bytes += status;
+	    }
+	    if (!suppress_readprogress) {
+		HTReadProgress(bytes, limit);
+	    }
+	    HTDisplayPartial();
+	}
+
+	/* a few buggy implementations do not close the connection properly
+	 * and will hang if we try to read past the declared content-length.
+	 */
+	if (limit > 0 && bytes >= limit)
+	    break;
+    }				/* next bufferload */
+    if (anchor != 0) {
+	CTRACE((tfp, "HTCopy copied %"
+		PRI_off_t " actual, %"
+		PRI_off_t " limit\n", CAST_off_t (bytes), CAST_off_t (limit)));
+	anchor->actual_length = bytes;
+    }
+
+    _HTProgress(TRANSFER_COMPLETE);
+    (void) NETCLOSE(file_number);
+    rv = HT_LOADED;
+
+  finished:
+    HTFinishDisplayPartial();
+    return (rv);
+}
+
+/*	Push data from a file pointer down a stream
+ *	-------------------------------------
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *
+ *  State of file and target stream on entry:
+ *			FILE* (fp) assumed open,
+ *			target (sink) assumed valid.
+ *
+ *  Return values:
+ *	HT_INTERRUPTED  Interruption after some data read.
+ *	HT_PARTIAL_CONTENT	Error after some data read.
+ *	-1		Error before any data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		fp still open, target stream still valid.
+ */
+int HTFileCopy(FILE *fp, HTStream *sink)
+{
+    HTStreamClass targetClass;
+    int status;
+    off_t bytes;
+    int rv = HT_OK;
+
+    /*  Push the data down the stream
+     */
+    targetClass = *(sink->isa);	/* Copy pointers to procedures */
+
+    /*  Push binary from socket down sink
+     */
+    HTReadProgress(bytes = 0, (off_t) 0);
+    for (;;) {
+	status = (int) fread(input_buffer,
+			     (size_t) 1,
+			     (size_t) INPUT_BUFFER_SIZE, fp);
+	if (status == 0) {	/* EOF or error */
+	    if (ferror(fp) == 0) {
+		rv = HT_LOADED;
+		break;
+	    }
+	    CTRACE((tfp, "HTFormat: Read error, read returns %d\n",
+		    ferror(fp)));
+	    if (bytes) {
+		rv = HT_PARTIAL_CONTENT;
+	    } else {
+		rv = -1;
+	    }
+	    break;
+	}
+
+	(*targetClass.put_block) (sink, input_buffer, status);
+	bytes += status;
+	HTReadProgress(bytes, (off_t) 0);
+	/* Suppress last screen update in partial mode - a regular update under
+	 * control of mainloop() should follow anyway.  - kw
+	 */
+#ifdef DISP_PARTIAL
+	if (display_partial && bytes != HTMainAnchor->content_length)
+	    HTDisplayPartial();
+#endif
+
+	if (HTCheckForInterrupt()) {
+	    _HTProgress(TRANSFER_INTERRUPTED);
+	    if (bytes) {
+		rv = HT_INTERRUPTED;
+	    } else {
+		rv = -1;
+	    }
+	    break;
+	}
+    }				/* next bufferload */
+
+    HTFinishDisplayPartial();
+    return rv;
+}
+
+#ifdef USE_SOURCE_CACHE
+/*	Push data from an HTChunk down a stream
+ *	---------------------------------------
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *  State of memory and target stream on entry:
+ *			HTChunk* (chunk) and target (sink) assumed valid.
+ *
+ *  Return values:
+ *	HT_LOADED	All data sent.
+ *	HT_INTERRUPTED  Interruption after some data read.
+ *
+ *  State of memory and target stream on return:
+ *	always		chunk unchanged, target stream still valid.
+ */
+int HTMemCopy(HTChunk *chunk, HTStream *sink)
+{
+    HTStreamClass targetClass;
+    off_t bytes;
+    int rv = HT_OK;
+
+    targetClass = *(sink->isa);
+    HTReadProgress(bytes = 0, (off_t) 0);
+    for (; chunk != NULL; chunk = chunk->next) {
+
+	/* Push the data down the stream a piece at a time, in case we're
+	 * running a large document on a slow machine.
+	 */
+	(*targetClass.put_block) (sink, chunk->data, chunk->size);
+	bytes += chunk->size;
+
+	HTReadProgress(bytes, (off_t) 0);
+	HTDisplayPartial();
+
+	if (HTCheckForInterrupt()) {
+	    _HTProgress(TRANSFER_INTERRUPTED);
+	    if (bytes) {
+		rv = HT_INTERRUPTED;
+	    } else {
+		rv = -1;
+	    }
+	    break;
+	}
+    }
+
+    HTFinishDisplayPartial();
+    return rv;
+}
+#endif
+
+#ifdef USE_ZLIB
+/*	Push data from a gzip file pointer down a stream
+ *	-------------------------------------
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *
+ *  State of file and target stream on entry:
+ *		      gzFile (gzfp) assumed open (should have gzipped content),
+ *		      target (sink) assumed valid.
+ *
+ *  Return values:
+ *	HT_INTERRUPTED  Interruption after some data read.
+ *	HT_PARTIAL_CONTENT	Error after some data read.
+ *	-1		Error before any data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		gzfp still open, target stream still valid.
+ */
+static int HTGzFileCopy(gzFile gzfp, HTStream *sink)
+{
+    HTStreamClass targetClass;
+    int status;
+    off_t bytes;
+    int gzerrnum;
+    int rv = HT_OK;
+
+    /*  Push the data down the stream
+     */
+    targetClass = *(sink->isa);	/* Copy pointers to procedures */
+
+    /*  read and inflate gzip'd file, and push binary down sink
+     */
+    HTReadProgress(bytes = 0, (off_t) 0);
+    for (;;) {
+	status = gzread(gzfp, input_buffer, INPUT_BUFFER_SIZE);
+	if (status <= 0) {	/* EOF or error */
+	    if (status == 0) {
+		rv = HT_LOADED;
+		break;
+	    }
+	    CTRACE((tfp, "HTGzFileCopy: Read error, gzread returns %d\n",
+		    status));
+	    CTRACE((tfp, "gzerror   : %s\n",
+		    gzerror(gzfp, &gzerrnum)));
+	    if (TRACE) {
+		if (gzerrnum == Z_ERRNO)
+		    perror("gzerror   ");
+	    }
+	    if (bytes) {
+		rv = HT_PARTIAL_CONTENT;
+	    } else {
+		rv = -1;
+	    }
+	    break;
+	}
+
+	(*targetClass.put_block) (sink, input_buffer, status);
+	bytes += status;
+	HTReadProgress(bytes, (off_t) -1);
+	HTDisplayPartial();
+
+	if (HTCheckForInterrupt()) {
+	    _HTProgress(TRANSFER_INTERRUPTED);
+	    rv = HT_INTERRUPTED;
+	    break;
+	}
+    }				/* next bufferload */
+
+    HTFinishDisplayPartial();
+    return rv;
+}
+
+#ifndef HAVE_ZERROR
+#define zError(s) LynxZError(s)
+static const char *zError(int status)
+{
+    static char result[80];
+
+    sprintf(result, "zlib error %d", status);
+    return result;
+}
+#endif
+
+/*	Push data from a deflate file pointer down a stream
+ *	-------------------------------------
+ *
+ *  This routine is responsible for creating and PRESENTING any
+ *  graphic (or other) objects described by the file.  The code is
+ *  loosely based on the inflate.c file from w3m.
+ *
+ *
+ *  State of file and target stream on entry:
+ *		      FILE (zzfp) assumed open (should have deflated content),
+ *		      target (sink) assumed valid.
+ *
+ *  Return values:
+ *	HT_INTERRUPTED  Interruption after some data read.
+ *	HT_PARTIAL_CONTENT	Error after some data read.
+ *	-1		Error before any data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		zzfp still open, target stream still valid.
+ */
+static int HTZzFileCopy(FILE *zzfp, HTStream *sink)
+{
+#undef THIS_FUNC
+#define THIS_FUNC "HTZzFileCopy"
+    static char dummy_head[1 + 1] =
+    {
+	0x8 + 0x7 * 0x10,
+	(((0x8 + 0x7 * 0x10) * 0x100 + 30) / 31 * 31) & 0xFF,
+    };
+
+    z_stream s;
+    HTStreamClass targetClass;
+    off_t bytes;
+    int rv = HT_OK;
+    char output_buffer[INPUT_BUFFER_SIZE];
+    int status;
+    int flush;
+    int retry = 0;
+    int len = 0;
+
+    /*  Push the data down the stream
+     */
+    targetClass = *(sink->isa);	/* Copy pointers to procedures */
+
+    memset(&s, 0, sizeof(s));
+    status = inflateInit(&s);
+    if (status != Z_OK) {
+	CTRACE((tfp, THIS_FUNC " inflateInit() %s\n", zError(status)));
+	exit_immediately(EXIT_FAILURE);
+    }
+    s.avail_in = 0;
+    s.next_out = (Bytef *) output_buffer;
+    s.avail_out = sizeof(output_buffer);
+    flush = Z_NO_FLUSH;
+
+    /*  read and inflate deflate'd file, and push binary down sink
+     */
+    HTReadProgress(bytes = 0, (off_t) 0);
+    for (;;) {
+	if (s.avail_in == 0) {
+	    s.next_in = (Bytef *) input_buffer;
+	    s.avail_in = (uInt) fread(input_buffer,
+				      (size_t) 1,
+				      (size_t) INPUT_BUFFER_SIZE, zzfp);
+	    len = (int) s.avail_in;
+	}
+	status = inflate(&s, flush);
+	if (status == Z_STREAM_END || status == Z_BUF_ERROR) {
+	    len = (int) sizeof(output_buffer) - (int) s.avail_out;
+	    if (len > 0) {
+		(*targetClass.put_block) (sink, output_buffer, len);
+		bytes += len;
+		HTReadProgress(bytes, (off_t) -1);
+		HTDisplayPartial();
+	    }
+	    rv = HT_LOADED;
+	    break;
+	} else if (status == Z_DATA_ERROR && !retry++) {
+	    status = inflateReset(&s);
+	    if (status != Z_OK) {
+		CTRACE((tfp, THIS_FUNC " inflateReset() %s\n", zError(status)));
+		rv = -1;
+		break;
+	    }
+	    s.next_in = (Bytef *) dummy_head;
+	    s.avail_in = sizeof(dummy_head);
+	    (void) inflate(&s, flush);
+	    s.next_in = (Bytef *) input_buffer;
+	    s.avail_in = (unsigned) len;
+	    continue;
+	} else if (status != Z_OK) {
+	    CTRACE((tfp, THIS_FUNC " inflate() %s\n", zError(status)));
+	    rv = bytes ? HT_PARTIAL_CONTENT : -1;
+	    break;
+	} else if (s.avail_out == 0) {
+	    len = sizeof(output_buffer);
+	    s.next_out = (Bytef *) output_buffer;
+	    s.avail_out = sizeof(output_buffer);
+
+	    (*targetClass.put_block) (sink, output_buffer, len);
+	    bytes += len;
+	    HTReadProgress(bytes, (off_t) -1);
+	    HTDisplayPartial();
+
+	    if (HTCheckForInterrupt()) {
+		_HTProgress(TRANSFER_INTERRUPTED);
+		rv = bytes ? HT_INTERRUPTED : -1;
+		break;
+	    }
+	}
+	retry = 1;
+    }				/* next bufferload */
+
+    inflateEnd(&s);
+    HTFinishDisplayPartial();
+    return rv;
+#undef THIS_FUNC
+}
+#endif /* USE_ZLIB */
+
+#ifdef USE_BZLIB
+/*	Push data from a bzip file pointer down a stream
+ *	-------------------------------------
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *
+ *  State of file and target stream on entry:
+ *		      BZFILE (bzfp) assumed open (should have bzipped content),
+ *		      target (sink) assumed valid.
+ *
+ *  Return values:
+ *	HT_INTERRUPTED  Interruption after some data read.
+ *	HT_PARTIAL_CONTENT	Error after some data read.
+ *	-1		Error before any data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		bzfp still open, target stream still valid.
+ */
+static int HTBzFileCopy(BZFILE * bzfp, HTStream *sink)
+{
+    HTStreamClass targetClass;
+    int status;
+    off_t bytes;
+    int bzerrnum;
+    int rv = HT_OK;
+
+    /*  Push the data down the stream
+     */
+    targetClass = *(sink->isa);	/* Copy pointers to procedures */
+
+    /*  read and inflate bzip'd file, and push binary down sink
+     */
+    HTReadProgress(bytes = 0, (off_t) 0);
+    for (;;) {
+	status = BZ2_bzread(bzfp, input_buffer, INPUT_BUFFER_SIZE);
+	if (status <= 0) {	/* EOF or error */
+	    if (status == 0) {
+		rv = HT_LOADED;
+		break;
+	    }
+	    CTRACE((tfp, "HTBzFileCopy: Read error, bzread returns %d\n",
+		    status));
+	    CTRACE((tfp, "bzerror   : %s\n",
+		    BZ2_bzerror(bzfp, &bzerrnum)));
+	    if (bytes) {
+		rv = HT_PARTIAL_CONTENT;
+	    } else {
+		rv = -1;
+	    }
+	    break;
+	}
+
+	(*targetClass.put_block) (sink, input_buffer, status);
+	bytes += status;
+	HTReadProgress(bytes, (off_t) -1);
+	HTDisplayPartial();
+
+	if (HTCheckForInterrupt()) {
+	    _HTProgress(TRANSFER_INTERRUPTED);
+	    rv = HT_INTERRUPTED;
+	    break;
+	}
+    }				/* next bufferload */
+
+    HTFinishDisplayPartial();
+    return rv;
+}
+#endif /* USE_BZLIB */
+
+#ifdef USE_BROTLI
+/*	Push data from a brotli file pointer down a stream
+ *	-------------------------------------
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *
+ *  State of file and target stream on entry:
+ *		      BZFILE (bzfp) assumed open (should have bzipped content),
+ *		      target (sink) assumed valid.
+ *
+ *  Return values:
+ *	HT_INTERRUPTED  Interruption after some data read.
+ *	HT_PARTIAL_CONTENT	Error after some data read.
+ *	-1		Error before any data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		bzfp still open, target stream still valid.
+ */
+static int HTBrFileCopy(FILE *brfp, HTStream *sink)
+{
+#undef THIS_FUNC
+#define THIS_FUNC "HTBrFileCopy"
+    HTStreamClass targetClass;
+    int status;
+    off_t bytes;
+    int rv = HT_OK;
+    BrotliDecoderResult status2 = BROTLI_DECODER_RESULT_ERROR;
+
+    char *brotli_buffer = NULL;
+    char *normal_buffer = NULL;
+    size_t brotli_size;
+    size_t brotli_limit = 0;
+    size_t brotli_offset = brotli_limit;
+    size_t normal_size;
+    size_t normal_limit = 0;
+
+    /*  Push the data down the stream
+     */
+    targetClass = *(sink->isa);	/* Copy pointers to procedures */
+
+    /*  read and inflate brotli'd file, and push binary down sink
+     */
+    HTReadProgress(bytes = 0, (off_t) 0);
+    /*
+     * first, read all of the brotli'd file into memory, to work with the
+     * library's limitations.
+     */
+    for (;;) {
+	size_t input_chunk = INPUT_BUFFER_SIZE;
+
+	brotli_offset = brotli_limit;
+	brotli_limit += input_chunk;
+	brotli_buffer = realloc(brotli_buffer, brotli_limit);
+	if (brotli_buffer == NULL)
+	    outofmem(__FILE__, THIS_FUNC);
+	status = (int) fread(brotli_buffer + brotli_offset, sizeof(char),
+			     input_chunk, brfp);
+
+	if (status <= 0) {	/* EOF or error */
+	    if (status == 0) {
+		rv = HT_LOADED;
+		break;
+	    }
+	    CTRACE((tfp, THIS_FUNC ": Read error, fread returns %d\n", status));
+	    if (bytes) {
+		if (!feof(brfp))
+		    rv = HT_PARTIAL_CONTENT;
+	    } else {
+		rv = -1;
+	    }
+	    break;
+	}
+	bytes += status;
+    }
+
+    /*
+     * next, unless we encountered an error (and have no data), try
+     * decompressing with increasing output buffer sizes until the brotli
+     * library succeeds.
+     */
+    if (bytes > 0) {
+	do {
+	    if (normal_limit == 0)
+		normal_limit = (10 * brotli_limit) + INPUT_BUFFER_SIZE;
+	    else
+		normal_limit *= 2;
+	    normal_buffer = realloc(normal_buffer, normal_limit);
+	    if (normal_buffer == NULL)
+		outofmem(__FILE__, THIS_FUNC);
+	    brotli_size = (size_t) bytes;
+	    normal_size = normal_limit;
+	    status2 = BrotliDecoderDecompress(brotli_size,
+					      (uint8_t *) brotli_buffer,
+					      &normal_size,
+					      (uint8_t *) normal_buffer);
+	    /*
+	     * brotli library should return
+	     *  BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT,
+	     * but actually returns
+	     *  BROTLI_DECODER_RESULT_ERROR 
+	     *
+	     * Accommodate possible improvements...
+	     */
+	} while (status2 != BROTLI_DECODER_RESULT_SUCCESS);
+    }
+
+    /*
+     * finally, pump that data into the output stream.
+     */
+    if (status2 == BROTLI_DECODER_RESULT_SUCCESS) {
+	CTRACE((tfp, THIS_FUNC ": decompressed %ld -> %ld (1:%.1f)\n",
+		brotli_size, normal_size,
+		(double) normal_size / (double) brotli_size));
+	(*targetClass.put_block) (sink, normal_buffer, (int) normal_size);
+	bytes += status;
+	HTReadProgress(bytes, (off_t) -1);
+	HTDisplayPartial();
+
+	if (HTCheckForInterrupt()) {
+	    _HTProgress(TRANSFER_INTERRUPTED);
+	    rv = HT_INTERRUPTED;
+	}
+    }
+    free(brotli_buffer);
+    free(normal_buffer);
+
+    /* next bufferload */
+    HTFinishDisplayPartial();
+    return rv;
+#undef THIS_FUNC
+}
+#endif /* USE_BZLIB */
+
+/*	Push data from a socket down a stream STRIPPING CR
+ *	--------------------------------------------------
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the socket.
+ *
+ *   The file number given is assumed to be a TELNET stream ie containing
+ *   CRLF at the end of lines which need to be stripped to LF for unix
+ *   when the format is textual.
+ *
+ */
+void HTCopyNoCR(HTParentAnchor *anchor GCC_UNUSED,
+		int file_number,
+		HTStream *sink)
+{
+    HTStreamClass targetClass;
+    int character;
+
+    /*  Push the data, ignoring CRLF, down the stream
+     */
+    targetClass = *(sink->isa);	/* Copy pointers to procedures */
+
+    /*
+     * Push text from telnet socket down sink
+     *
+     * @@@@@ To push strings could be faster?  (especially is we cheat and
+     * don't ignore CR!  :-}
+     */
+    HTInitInput(file_number);
+    for (;;) {
+	character = HTGetCharacter();
+	if (character == EOF)
+	    break;
+	(*targetClass.put_character) (sink, (char) character);
+    }
+}
+
+/*	Parse a socket given format and file number
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *   The file number given is assumed to be a TELNET stream ie containing
+ *   CRLF at the end of lines which need to be stripped to LF for unix
+ *   when the format is textual.
+ *
+ *  State of socket and target stream on entry:
+ *			socket (file_number) assumed open,
+ *			target (sink) usually NULL (will call stream stack).
+ *
+ *  Return values:
+ *	HT_INTERRUPTED  Interruption or error after some data received.
+ *	-501		Stream stack failed (cannot present or convert).
+ *	-2		Unexpected disconnect before any data received.
+ *	-1		Stream stack failed (cannot present or convert), or
+ *			Interruption or error before any data received, or
+ *			(UNIX) other read error before any data received, or
+ *			download cancelled.
+ *	HT_LOADED	Normal close of socket (end of file indication
+ *			received), or
+ *			unexpected disconnect after some data received, or
+ *			other read error after some data received, or
+ *			(not UNIX) other read error before any data received.
+ *
+ *  State of socket and target stream on return depends on return value:
+ *	HT_INTERRUPTED	socket still open, target aborted.
+ *	-501		socket still open, target stream NULL.
+ *	-2		socket still open, target freed.
+ *	-1		socket still open, target stream aborted or NULL.
+ *	otherwise	socket closed,	target stream freed.
+ */
+int HTParseSocket(HTFormat rep_in,
+		  HTFormat format_out,
+		  HTParentAnchor *anchor,
+		  int file_number,
+		  HTStream *sink)
+{
+    HTStream *stream;
+    HTStreamClass targetClass;
+    int rv;
+
+    stream = HTStreamStack(rep_in, format_out, sink, anchor);
+
+    if (!stream) {
+	char *buffer = 0;
+
+	if (LYCancelDownload) {
+	    LYCancelDownload = FALSE;
+	    return -1;
+	}
+	HTSprintf0(&buffer, CANNOT_CONVERT_I_TO_O,
+		   HTAtom_name(rep_in), HTAtom_name(format_out));
+	CTRACE((tfp, "HTFormat: %s\n", buffer));
+	rv = HTLoadError(sink, 501, buffer);	/* returns -501 */
+	FREE(buffer);
+    } else {
+	/*
+	 * Push the data, don't worry about CRLF we can strip them later.
+	 */
+	targetClass = *(stream->isa);	/* Copy pointers to procedures */
+	rv = HTCopy(anchor, file_number, NULL, stream);
+	if (rv != -1 && rv != HT_INTERRUPTED)
+	    (*targetClass._free) (stream);
+    }
+    return rv;
+    /* Originally:  full: HT_LOADED;  partial: HT_INTERRUPTED;  no bytes: -1 */
+}
+
+/*	Parse a file given format and file pointer
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *   The file number given is assumed to be a TELNET stream ie containing
+ *   CRLF at the end of lines which need to be stripped to \n for unix
+ *   when the format is textual.
+ *
+ *  State of file and target stream on entry:
+ *			FILE* (fp) assumed open,
+ *			target (sink) usually NULL (will call stream stack).
+ *
+ *  Return values:
+ *	-501		Stream stack failed (cannot present or convert).
+ *	-1		Download cancelled.
+ *	HT_NO_DATA	Error before any data read.
+ *	HT_PARTIAL_CONTENT	Interruption or error after some data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		fp still open; target freed, aborted, or NULL.
+ */
+int HTParseFile(HTFormat rep_in,
+		HTFormat format_out,
+		HTParentAnchor *anchor,
+		FILE *fp,
+		HTStream *sink)
+{
+    HTStream *stream;
+    HTStreamClass targetClass;
+    int rv;
+    int result;
+
+    if (fp == NULL) {
+	result = HT_LOADED;
+    } else {
+	stream = HTStreamStack(rep_in, format_out, sink, anchor);
+
+	if (!stream || !stream->isa) {
+	    char *buffer = 0;
+
+	    if (LYCancelDownload) {
+		LYCancelDownload = FALSE;
+		result = -1;
+	    } else {
+		HTSprintf0(&buffer, CANNOT_CONVERT_I_TO_O,
+			   HTAtom_name(rep_in), HTAtom_name(format_out));
+		CTRACE((tfp, "HTFormat(in HTParseFile): %s\n", buffer));
+		rv = HTLoadError(sink, 501, buffer);
+		FREE(buffer);
+		result = rv;
+	    }
+	} else {
+
+	    /*
+	     * Push the data down the stream
+	     *
+	     * @@ Bug:  This decision ought to be made based on "encoding"
+	     * rather than on content-type.  @@@ When we handle encoding.  The
+	     * current method smells anyway.
+	     */
+	    targetClass = *(stream->isa);	/* Copy pointers to procedures */
+	    rv = HTFileCopy(fp, stream);
+	    if (rv == -1 || rv == HT_INTERRUPTED) {
+		(*targetClass._abort) (stream, NULL);
+	    } else {
+		(*targetClass._free) (stream);
+	    }
+
+	    if (rv == -1) {
+		result = HT_NO_DATA;
+	    } else if (rv == HT_INTERRUPTED || (rv > 0 && rv != HT_LOADED)) {
+		result = HT_PARTIAL_CONTENT;
+	    } else {
+		result = HT_LOADED;
+	    }
+	}
+    }
+    return result;
+}
+
+#ifdef USE_SOURCE_CACHE
+/*	Parse a document in memory given format and memory block pointer
+ *
+ *   This routine is responsible for creating and PRESENTING any
+ *   graphic (or other) objects described by the file.
+ *
+ *  State of memory and target stream on entry:
+ *			HTChunk* (chunk) assumed valid,
+ *			target (sink) usually NULL (will call stream stack).
+ *
+ *  Return values:
+ *	-501		Stream stack failed (cannot present or convert).
+ *	HT_LOADED	All data sent.
+ *
+ *  State of memory and target stream on return:
+ *	always		chunk unchanged; target freed, aborted, or NULL.
+ */
+int HTParseMem(HTFormat rep_in,
+	       HTFormat format_out,
+	       HTParentAnchor *anchor,
+	       HTChunk *chunk,
+	       HTStream *sink)
+{
+    HTStream *stream;
+    HTStreamClass targetClass;
+    int rv;
+    int result;
+
+    stream = HTStreamStack(rep_in, format_out, sink, anchor);
+    if (!stream || !stream->isa) {
+	char *buffer = 0;
+
+	HTSprintf0(&buffer, CANNOT_CONVERT_I_TO_O,
+		   HTAtom_name(rep_in), HTAtom_name(format_out));
+	CTRACE((tfp, "HTFormat(in HTParseMem): %s\n", buffer));
+	rv = HTLoadError(sink, 501, buffer);
+	FREE(buffer);
+	result = rv;
+    } else {
+
+	/* Push the data down the stream
+	 */
+	targetClass = *(stream->isa);
+	(void) HTMemCopy(chunk, stream);
+	(*targetClass._free) (stream);
+	result = HT_LOADED;
+    }
+    return result;
+}
+#endif
+
+#ifdef USE_ZLIB
+static int HTCloseGzFile(gzFile gzfp)
+{
+    int gzres;
+
+    if (gzfp == NULL)
+	return 0;
+    gzres = gzclose(gzfp);
+    if (TRACE) {
+	if (gzres == Z_ERRNO) {
+	    perror("gzclose   ");
+	} else if (gzres != Z_OK) {
+	    CTRACE((tfp, "gzclose   : error number %d\n", gzres));
+	}
+    }
+    return (gzres);
+}
+
+/*	HTParseGzFile
+ *
+ *  State of file and target stream on entry:
+ *			gzFile (gzfp) assumed open,
+ *			target (sink) usually NULL (will call stream stack).
+ *
+ *  Return values:
+ *	-501		Stream stack failed (cannot present or convert).
+ *	-1		Download cancelled.
+ *	HT_NO_DATA	Error before any data read.
+ *	HT_PARTIAL_CONTENT	Interruption or error after some data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		gzfp closed; target freed, aborted, or NULL.
+ */
+int HTParseGzFile(HTFormat rep_in,
+		  HTFormat format_out,
+		  HTParentAnchor *anchor,
+		  gzFile gzfp,
+		  HTStream *sink)
+{
+    HTStream *stream;
+    HTStreamClass targetClass;
+    int rv;
+    int result;
+
+    stream = HTStreamStack(rep_in, format_out, sink, anchor);
+
+    if (!stream || !stream->isa) {
+	char *buffer = 0;
+
+	HTCloseGzFile(gzfp);
+	if (LYCancelDownload) {
+	    LYCancelDownload = FALSE;
+	    result = -1;
+	} else {
+	    HTSprintf0(&buffer, CANNOT_CONVERT_I_TO_O,
+		       HTAtom_name(rep_in), HTAtom_name(format_out));
+	    CTRACE((tfp, "HTFormat(in HTParseGzFile): %s\n", buffer));
+	    rv = HTLoadError(sink, 501, buffer);
+	    FREE(buffer);
+	    result = rv;
+	}
+    } else {
+
+	/*
+	 * Push the data down the stream
+	 *
+	 * @@ Bug:  This decision ought to be made based on "encoding" rather than
+	 * on content-type.  @@@ When we handle encoding.  The current method
+	 * smells anyway.
+	 */
+	targetClass = *(stream->isa);	/* Copy pointers to procedures */
+	rv = HTGzFileCopy(gzfp, stream);
+	if (rv == -1 || rv == HT_INTERRUPTED) {
+	    (*targetClass._abort) (stream, NULL);
+	} else {
+	    (*targetClass._free) (stream);
+	}
+
+	HTCloseGzFile(gzfp);
+	if (rv == -1) {
+	    result = HT_NO_DATA;
+	} else if (rv == HT_INTERRUPTED || (rv > 0 && rv != HT_LOADED)) {
+	    result = HT_PARTIAL_CONTENT;
+	} else {
+	    result = HT_LOADED;
+	}
+    }
+    return result;
+}
+
+/*	HTParseZzFile
+ *
+ *  State of file and target stream on entry:
+ *			FILE (zzfp) assumed open,
+ *			target (sink) usually NULL (will call stream stack).
+ *
+ *  Return values:
+ *	-501		Stream stack failed (cannot present or convert).
+ *	-1		Download cancelled.
+ *	HT_NO_DATA	Error before any data read.
+ *	HT_PARTIAL_CONTENT	Interruption or error after some data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		zzfp closed; target freed, aborted, or NULL.
+ */
+int HTParseZzFile(HTFormat rep_in,
+		  HTFormat format_out,
+		  HTParentAnchor *anchor,
+		  FILE *zzfp,
+		  HTStream *sink)
+{
+    HTStream *stream;
+    HTStreamClass targetClass;
+    int rv;
+    int result;
+
+    stream = HTStreamStack(rep_in, format_out, sink, anchor);
+
+    if (!stream || !stream->isa) {
+	char *buffer = 0;
+
+	fclose(zzfp);
+	if (LYCancelDownload) {
+	    LYCancelDownload = FALSE;
+	    result = -1;
+	} else {
+	    HTSprintf0(&buffer, CANNOT_CONVERT_I_TO_O,
+		       HTAtom_name(rep_in), HTAtom_name(format_out));
+	    CTRACE((tfp, "HTFormat(in HTParseGzFile): %s\n", buffer));
+	    rv = HTLoadError(sink, 501, buffer);
+	    FREE(buffer);
+	    result = rv;
+	}
+    } else {
+
+	/*
+	 * Push the data down the stream
+	 *
+	 * @@ Bug:  This decision ought to be made based on "encoding" rather than
+	 * on content-type.  @@@ When we handle encoding.  The current method
+	 * smells anyway.
+	 */
+	targetClass = *(stream->isa);	/* Copy pointers to procedures */
+	rv = HTZzFileCopy(zzfp, stream);
+	if (rv == -1 || rv == HT_INTERRUPTED) {
+	    (*targetClass._abort) (stream, NULL);
+	} else {
+	    (*targetClass._free) (stream);
+	}
+
+	fclose(zzfp);
+	if (rv == -1) {
+	    result = HT_NO_DATA;
+	} else if (rv == HT_INTERRUPTED || (rv > 0 && rv != HT_LOADED)) {
+	    result = HT_PARTIAL_CONTENT;
+	} else {
+	    result = HT_LOADED;
+	}
+    }
+    return result;
+}
+#endif /* USE_ZLIB */
+
+#ifdef USE_BZLIB
+static void HTCloseBzFile(BZFILE * bzfp)
+{
+    if (bzfp)
+	BZ2_bzclose(bzfp);
+}
+
+/*	HTParseBzFile
+ *
+ *  State of file and target stream on entry:
+ *			bzFile (bzfp) assumed open,
+ *			target (sink) usually NULL (will call stream stack).
+ *
+ *  Return values:
+ *	-501		Stream stack failed (cannot present or convert).
+ *	-1		Download cancelled.
+ *	HT_NO_DATA	Error before any data read.
+ *	HT_PARTIAL_CONTENT	Interruption or error after some data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		bzfp closed; target freed, aborted, or NULL.
+ */
+int HTParseBzFile(HTFormat rep_in,
+		  HTFormat format_out,
+		  HTParentAnchor *anchor,
+		  BZFILE * bzfp,
+		  HTStream *sink)
+{
+    HTStream *stream;
+    HTStreamClass targetClass;
+    int rv;
+    int result;
+
+    stream = HTStreamStack(rep_in, format_out, sink, anchor);
+
+    if (!stream || !stream->isa) {
+	char *buffer = 0;
+
+	HTCloseBzFile(bzfp);
+	if (LYCancelDownload) {
+	    LYCancelDownload = FALSE;
+	    result = -1;
+	} else {
+	    HTSprintf0(&buffer, CANNOT_CONVERT_I_TO_O,
+		       HTAtom_name(rep_in), HTAtom_name(format_out));
+	    CTRACE((tfp, "HTFormat(in HTParseBzFile): %s\n", buffer));
+	    rv = HTLoadError(sink, 501, buffer);
+	    FREE(buffer);
+	    result = rv;
+	}
+    } else {
+
+	/*
+	 * Push the data down the stream
+	 *
+	 * @@ Bug:  This decision ought to be made based on "encoding" rather than
+	 * on content-type.  @@@ When we handle encoding.  The current method
+	 * smells anyway.
+	 */
+	targetClass = *(stream->isa);	/* Copy pointers to procedures */
+	rv = HTBzFileCopy(bzfp, stream);
+	if (rv == -1 || rv == HT_INTERRUPTED) {
+	    (*targetClass._abort) (stream, NULL);
+	} else {
+	    (*targetClass._free) (stream);
+	}
+
+	HTCloseBzFile(bzfp);
+	if (rv == -1) {
+	    result = HT_NO_DATA;
+	} else if (rv == HT_INTERRUPTED || (rv > 0 && rv != HT_LOADED)) {
+	    result = HT_PARTIAL_CONTENT;
+	} else {
+	    result = HT_LOADED;
+	}
+    }
+    return result;
+}
+#endif /* USE_BZLIB */
+
+#ifdef USE_BROTLI
+/*	HTParseBrFile
+ *
+ *  State of file and target stream on entry:
+ *			FILE* (brfp) assumed open,
+ *			target (sink) usually NULL (will call stream stack).
+ *
+ *  Return values:
+ *	-501		Stream stack failed (cannot present or convert).
+ *	-1		Download cancelled.
+ *	HT_NO_DATA	Error before any data read.
+ *	HT_PARTIAL_CONTENT	Interruption or error after some data read.
+ *	HT_LOADED	Normal end of file indication on reading.
+ *
+ *  State of file and target stream on return:
+ *	always		brfp closed; target freed, aborted, or NULL.
+ */
+int HTParseBrFile(HTFormat rep_in,
+		  HTFormat format_out,
+		  HTParentAnchor *anchor,
+		  FILE *brfp,
+		  HTStream *sink)
+{
+#undef THIS_FUNC
+#define THIS_FUNC "HTParseBrFile"
+    HTStream *stream;
+    HTStreamClass targetClass;
+    int rv;
+    int result;
+
+    stream = HTStreamStack(rep_in, format_out, sink, anchor);
+
+    if (!stream || !stream->isa) {
+	char *buffer = 0;
+
+	fclose(brfp);
+	if (LYCancelDownload) {
+	    LYCancelDownload = FALSE;
+	    result = -1;
+	} else {
+	    HTSprintf0(&buffer, CANNOT_CONVERT_I_TO_O,
+		       HTAtom_name(rep_in), HTAtom_name(format_out));
+	    CTRACE((tfp, "HTFormat(in " THIS_FUNC "): %s\n", buffer));
+	    rv = HTLoadError(sink, 501, buffer);
+	    FREE(buffer);
+	    result = rv;
+	}
+    } else {
+
+	/*
+	 * Push the data down the stream
+	 *
+	 * @@ Bug:  This decision ought to be made based on "encoding" rather than
+	 * on content-type.  @@@ When we handle encoding.  The current method
+	 * smells anyway.
+	 */
+	targetClass = *(stream->isa);	/* Copy pointers to procedures */
+	rv = HTBrFileCopy(brfp, stream);
+	if (rv == -1 || rv == HT_INTERRUPTED) {
+	    (*targetClass._abort) (stream, NULL);
+	} else {
+	    (*targetClass._free) (stream);
+	}
+
+	fclose(brfp);
+	if (rv == -1) {
+	    result = HT_NO_DATA;
+	} else if (rv == HT_INTERRUPTED || (rv > 0 && rv != HT_LOADED)) {
+	    result = HT_PARTIAL_CONTENT;
+	} else {
+	    result = HT_LOADED;
+	}
+    }
+    return result;
+#undef THIS_FUNC
+}
+#endif /* USE_BROTLI */
+
+/*	Converter stream: Network Telnet to internal character text
+ *	-----------------------------------------------------------
+ *
+ *	The input is assumed to be in ASCII, with lines delimited
+ *	by (13,10) pairs, These pairs are converted into (CR,LF)
+ *	pairs in the local representation.  The (CR,LF) sequence
+ *	when found is changed to a '\n' character, the internal
+ *	C representation of a new line.
+ */
+
+static void NetToText_put_character(HTStream *me, int net_char)
+{
+    char c = (char) FROMASCII(net_char);
+
+    if (me->had_cr) {
+	if (c == LF) {
+	    me->sink->isa->put_character(me->sink, '\n');	/* Newline */
+	    me->had_cr = NO;
+	    return;
+	} else {
+	    me->sink->isa->put_character(me->sink, CR);		/* leftover */
+	}
+    }
+    me->had_cr = (BOOL) (c == CR);
+    if (!me->had_cr)
+	me->sink->isa->put_character(me->sink, c);	/* normal */
+}
+
+static void NetToText_put_string(HTStream *me, const char *s)
+{
+    const char *p;
+
+    for (p = s; *p; p++)
+	NetToText_put_character(me, *p);
+}
+
+static void NetToText_put_block(HTStream *me, const char *s, int l)
+{
+    const char *p;
+
+    for (p = s; p < (s + l); p++)
+	NetToText_put_character(me, *p);
+}
+
+static void NetToText_free(HTStream *me)
+{
+    (me->sink->isa->_free) (me->sink);	/* Close rest of pipe */
+    FREE(me);
+}
+
+static void NetToText_abort(HTStream *me, HTError e)
+{
+    me->sink->isa->_abort(me->sink, e);		/* Abort rest of pipe */
+    FREE(me);
+}
+
+/*	The class structure
+*/
+static HTStreamClass NetToTextClass =
+{
+    "NetToText",
+    NetToText_free,
+    NetToText_abort,
+    NetToText_put_character,
+    NetToText_put_string,
+    NetToText_put_block
+};
+
+/*	The creation method
+*/
+HTStream *HTNetToText(HTStream *sink)
+{
+    HTStream *me = typecalloc(HTStream);
+
+    if (me == NULL)
+	outofmem(__FILE__, "NetToText");
+
+    me->isa = &NetToTextClass;
+
+    me->had_cr = NO;
+    me->sink = sink;
+    return me;
+}
+
+static HTStream HTBaseStreamInstance;	/* Made static */
+
+/*
+ *	ERROR STREAM
+ *	------------
+ *	There is only one error stream shared by anyone who wants a
+ *	generic error returned from all stream methods.
+ */
+static void HTErrorStream_put_character(HTStream *me GCC_UNUSED, int c GCC_UNUSED)
+{
+    LYCancelDownload = TRUE;
+}
+
+static void HTErrorStream_put_string(HTStream *me GCC_UNUSED, const char *s)
+{
+    if (s && *s)
+	LYCancelDownload = TRUE;
+}
+
+static void HTErrorStream_write(HTStream *me GCC_UNUSED, const char *s, int l)
+{
+    if (l && s)
+	LYCancelDownload = TRUE;
+}
+
+static void HTErrorStream_free(HTStream *me GCC_UNUSED)
+{
+    return;
+}
+
+static void HTErrorStream_abort(HTStream *me GCC_UNUSED, HTError e GCC_UNUSED)
+{
+    return;
+}
+
+static const HTStreamClass HTErrorStreamClass =
+{
+    "ErrorStream",
+    HTErrorStream_free,
+    HTErrorStream_abort,
+    HTErrorStream_put_character,
+    HTErrorStream_put_string,
+    HTErrorStream_write
+};
+
+HTStream *HTErrorStream(void)
+{
+    CTRACE((tfp, "ErrorStream. Created\n"));
+    HTBaseStreamInstance.isa = &HTErrorStreamClass;	/* The rest is random */
+    return &HTBaseStreamInstance;
+}
diff --git a/WWW/Library/Implementation/HTFormat.h b/WWW/Library/Implementation/HTFormat.h
new file mode 100644
index 0000000..835daef
--- /dev/null
+++ b/WWW/Library/Implementation/HTFormat.h
@@ -0,0 +1,588 @@
+/*
+ * $LynxId: HTFormat.h,v 1.42 2022/04/01 07:54:14 tom Exp $
+ *
+ *                                            HTFormat: The format manager in the WWW Library
+ *                          MANAGE DIFFERENT DOCUMENT FORMATS
+ *
+ * Here we describe the functions of the HTFormat module which handles conversion between
+ * different data representations.  (In MIME parlance, a representation is known as a
+ * content-type.  In WWW the term "format" is often used as it is shorter).
+ *
+ * This module is implemented by HTFormat.c.  This hypertext document is used to generate
+ * the HTFormat.h include file.  Part of the WWW library.
+ */
+#ifndef HTFORMAT_H
+#define HTFORMAT_H
+
+#include <HTStream.h>
+#include <HTAtom.h>
+#include <HTList.h>
+#include <HTAnchor.h>
+
+#ifdef USE_SOURCE_CACHE
+#include <HTChunk.h>
+#endif
+
+#ifdef USE_BZLIB
+#include <bzlib.h>
+#endif
+
+#ifdef USE_ZLIB
+#include <zlib.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+
+   These macros (which used to be constants) define some basic internally
+   referenced representations.  The www/xxx ones are of course not MIME
+   standard.
+
+   www/source is an output format which leaves the input untouched.  It is
+   useful for diagnostics, and for users who want to see the original, whatever
+   it is.
+
+																	 */
+/* Internal ones */
+#define STR_SOURCE 	"www/source"
+    extern HTAtom *WWW_SOURCE;	/* calculated once, heavy used */
+
+/*
+
+   www/present represents the user's perception of the document.  If you
+   convert to www/present, you present the material to the user.
+
+ */
+#define STR_PRESENT	"www/present"
+#define WWW_PRESENT	HTAtom_for(STR_PRESENT)		/* The user's perception */
+
+#define WWW_DEBUG       HTAtom_for("www/debug")
+/*
+
+   WWW_DEBUG represents the user's perception of debug information, for example
+   sent as a HTML document in a HTTP redirection message.
+
+ */
+
+/*
+
+   The message/rfc822 format means a MIME message or a plain text message with
+   no MIME header.  This is what is returned by an HTTP server.
+
+ */
+#define WWW_MIME HTAtom_for("www/mime")		/* A MIME message */
+
+/*
+  For parsing only the header. - kw
+  */
+#define WWW_MIME_HEAD   HTAtom_for("message/x-rfc822-head")
+
+/*
+
+   www/print is like www/present except it represents a printed copy.
+
+ */
+#define WWW_PRINT HTAtom_for("www/print")	/* A printed copy */
+
+/*
+
+   www/unknown is a really unknown type.  Some default action is appropriate.
+
+ */
+#define WWW_UNKNOWN     HTAtom_for("www/unknown")
+
+#ifdef DIRED_SUPPORT
+/*
+   www/dired signals directory edit mode.
+*/
+#define WWW_DIRED      HTAtom_for("www/dired")
+#endif
+
+/*
+ * Miscellaneous internal MIME types.
+ */
+#define STR_DOWNLOAD    "www/download"
+#define WWW_DOWNLOAD    HTAtom_for(STR_DOWNLOAD)
+
+#define STR_DUMP        "www/dump"
+#define WWW_DUMP        HTAtom_for(STR_DUMP)
+
+/*
+
+   These are regular MIME types.  HTML is assumed to be added by the W3 code. 
+   application/octet-stream was mistakenly application/binary in earlier libwww
+   versions (pre 2.11).
+
+ */
+#define STR_BINARY      "application/octet-stream"
+#define STR_PLAINTEXT   "text/plain"
+#define STR_HTML        "text/html"
+
+#define WWW_BINARY      HTAtom_for(STR_BINARY)
+#define WWW_PLAINTEXT   HTAtom_for(STR_PLAINTEXT)
+#define WWW_HTML        HTAtom_for(STR_HTML)
+
+#define WWW_POSTSCRIPT  HTAtom_for("application/postscript")
+#define WWW_RICHTEXT    HTAtom_for("application/rtf")
+#define WWW_AUDIO       HTAtom_for("audio/basic")
+
+    typedef HTAtom *HTEncoding;
+
+/*
+ * The following are values for the MIME types:
+ */
+#define WWW_ENC_7BIT            HTAtom_for("7bit")
+#define WWW_ENC_8BIT            HTAtom_for("8bit")
+#define WWW_ENC_BINARY          HTAtom_for("binary")
+
+/*
+ * We also add
+ */
+#define WWW_ENC_COMPRESS        HTAtom_for("compress")
+
+/*
+ * Does a string designate a real encoding, or is it just
+ * a "dummy" as for example 7bit, 8bit, and binary?
+ */
+#define IsUnityEncStr(senc) \
+        ((senc)==NULL || *(senc)=='\0' || !strcmp(senc,"identity") ||\
+        !strcmp(senc,"8bit") || !strcmp(senc,"binary") || !strcmp(senc,"7bit"))
+
+#define IsUnityEnc(enc) \
+        ((enc)==NULL || (enc)==HTAtom_for("identity") ||\
+        (enc)==WWW_ENC_8BIT || (enc)==WWW_ENC_BINARY || (enc)==WWW_ENC_7BIT)
+
+/*
+
+The HTPresentation and HTConverter types
+
+   This HTPresentation structure represents a possible conversion algorithm
+   from one format to another.  It includes a pointer to a conversion routine. 
+   The conversion routine returns a stream to which data should be fed.  See
+   also HTStreamStack which scans the list of registered converters and calls
+   one.  See the initialisation module for a list of conversion routines.
+
+ */
+    typedef struct _HTPresentation HTPresentation;
+
+    typedef HTStream *HTConverter (HTPresentation *pres,
+				   HTParentAnchor *anchor,
+				   HTStream *sink);
+
+    struct _HTPresentation {
+	HTAtom *rep;		/* representation name atomized */
+	HTAtom *rep_out;	/* resulting representation */
+	HTConverter *converter;	/* routine to gen the stream stack */
+	char *command;		/* MIME-format command string */
+	char *testcommand;	/* MIME-format test string */
+	float quality;		/* Between 0 (bad) and 1 (good) */
+	float secs;
+	float secs_per_byte;
+	off_t maxbytes;
+	BOOL get_accept;	/* list in "Accept:" for GET */
+	int accept_opt;		/* matches against LYAcceptMedia */
+    };
+
+/*
+
+   The list of presentations is kept by this module.  It is also scanned by
+   modules which want to know the set of formats supported.  for example.
+
+ */
+    extern HTList *HTPresentations;
+
+/*
+
+   The default presentation is used when no other is appropriate
+
+ */
+    extern HTPresentation *default_presentation;
+
+/*
+ * Options used for "Content-Type" string
+ */
+    typedef enum {
+	contentBINARY = 0
+	,contentTEXT
+	,contentHTML
+    } ContentType;
+
+/*
+ * Options used for "Accept:" string
+ */
+    typedef enum {
+	/* make the components powers of two so we can add them */
+	mediaINT = 1		/* internal types predefined in HTInit.c */
+	,mediaEXT = 2		/* external types predefined in HTInit.c */
+	,mediaCFG = 4		/* types, e.g., viewers, from lynx.cfg */
+	,mediaUSR = 8		/* user's mime-types, etc. */
+	,mediaSYS = 16		/* system's mime-types, etc. */
+	/* these are useful flavors for the options menu */
+	,mediaOpt1 = mediaINT
+	,mediaOpt2 = mediaINT + mediaCFG
+	,mediaOpt3 = mediaINT + mediaCFG + mediaUSR
+	,mediaOpt4 = mediaINT + mediaCFG + mediaUSR + mediaSYS
+	/* this is the flavor from pre-2.8.6 */
+	,mediaALL = mediaINT + mediaEXT + mediaCFG + mediaUSR + mediaSYS
+    } AcceptMedia;
+
+/*
+ * Options used for "Accept-Encoding:" string
+ */
+    typedef enum {
+	encodingNONE = 0
+	,encodingGZIP = 1
+	,encodingDEFLATE = 2
+	,encodingCOMPRESS = 4
+	,encodingBZIP2 = 8
+	,encodingBROTLI = 16
+	,encodingALL = (encodingGZIP
+			+ encodingDEFLATE
+			+ encodingCOMPRESS
+			+ encodingBZIP2
+			+ encodingBROTLI)
+    } AcceptEncoding;
+
+/*
+
+HTSetPresentation: Register a system command to present a format
+
+  ON ENTRY,
+
+  rep                     is the MIME - style format name
+
+  command                 is the MAILCAP - style command template
+
+  testcommand             is the MAILCAP - style testcommand template
+
+  quality                 A degradation faction 0..1.0
+
+  secs                    A limit on the time user will wait (0.0 for infinity)
+  secs_per_byte
+
+  maxbytes                A limit on the length acceptable as input (0 infinite)
+
+  media                   Used in filtering presentation types for "Accept:"
+
+ */
+    extern void HTSetPresentation(const char *representation,
+				  const char *command,
+				  const char *testcommand,
+				  double quality,
+				  double secs,
+				  double secs_per_byte,
+				  long int maxbytes,
+				  AcceptMedia media
+    );
+
+/*
+
+HTSetConversion:   Register a conversion routine
+
+  ON ENTRY,
+
+  rep_in                  is the content-type input
+
+  rep_out                 is the resulting content-type
+
+  converter               is the routine to make the stream to do it
+
+ */
+
+    extern void HTSetConversion(const char *rep_in,
+				const char *rep_out,
+				HTConverter *converter,
+				double quality,
+				double secs,
+				double secs_per_byte,
+				long int maxbytes,
+				AcceptMedia media
+    );
+
+/*
+
+HTStreamStack:   Create a stack of streams
+
+   This is the routine which actually sets up the conversion.  It currently
+   checks only for direct conversions, but multi-stage conversions are forseen. 
+   It takes a stream into which the output should be sent in the final format,
+   builds the conversion stack, and returns a stream into which the data in the
+   input format should be fed.  The anchor is passed because hypertxet objects
+   load information into the anchor object which represents them.
+
+ */
+    extern HTStream *HTStreamStack(HTFormat format_in,
+				   HTFormat format_out,
+				   HTStream *stream_out,
+				   HTParentAnchor *anchor);
+
+/*
+HTReorderPresentation: put presentation near head of list
+
+    Look up a presentation (exact match only) and, if found, reorder it to the
+    start of the HTPresentations list.  - kw
+    */
+
+    extern void HTReorderPresentation(HTFormat format_in,
+				      HTFormat format_out);
+
+/*
+ * Setup 'get_accept' flag to denote presentations that are not redundant,
+ * and will be listed in "Accept:" header.
+ */
+    extern void HTFilterPresentations(void);
+
+/*
+
+HTStackValue: Find the cost of a filter stack
+
+   Must return the cost of the same stack which HTStreamStack would set up.
+
+  ON ENTRY,
+
+  format_in               The format of the data to be converted
+
+  format_out              The format required
+
+  initial_value           The intrinsic "value" of the data before conversion on a scale
+                         from 0 to 1
+
+  length                  The number of bytes expected in the input format
+
+ */
+    extern float HTStackValue(HTFormat format_in,
+			      HTFormat rep_out,
+			      double initial_value,
+			      long int length);
+
+#define NO_VALUE_FOUND  -1e20	/* returned if none found */
+
+/*	Display the page while transfer in progress
+ *	-------------------------------------------
+ *
+ *   Repaint the page only when necessary.
+ *   This is a traverse call for HText_pageDispaly() - it works!.
+ *
+ */
+    extern void HTDisplayPartial(void);
+
+    extern void HTFinishDisplayPartial(void);
+
+/*
+
+HTCopy:  Copy a socket to a stream
+
+   This is used by the protocol engines to send data down a stream, typically
+   one which has been generated by HTStreamStack.
+
+ */
+    extern int HTCopy(HTParentAnchor *anchor,
+		      int file_number,
+		      void *handle,
+		      HTStream *sink);
+
+/*
+
+HTFileCopy:  Copy a file to a stream
+
+   This is used by the protocol engines to send data down a stream, typically
+   one which has been generated by HTStreamStack.  It is currently called by
+   HTParseFile
+
+ */
+    extern int HTFileCopy(FILE *fp,
+			  HTStream *sink);
+
+#ifdef USE_SOURCE_CACHE
+/*
+
+HTMemCopy:  Copy a memory chunk to a stream
+
+   This is used by the protocol engines to send data down a stream, typically
+   one which has been generated by HTStreamStack.  It is currently called by
+   HTParseMem
+
+ */
+    extern int HTMemCopy(HTChunk *chunk,
+			 HTStream *sink);
+#endif
+
+/*
+
+HTCopyNoCR: Copy a socket to a stream, stripping CR characters.
+
+   It is slower than HTCopy .
+
+ */
+
+    extern void HTCopyNoCR(HTParentAnchor *anchor,
+			   int file_number,
+			   HTStream *sink);
+
+/*
+
+Clear input buffer and set file number
+
+   This routine and the one below provide simple character input from sockets. 
+   (They are left over from the older architecture and may not be used very
+   much.) The existence of a common routine and buffer saves memory space in
+   small implementations.
+
+ */
+    extern void HTInitInput(int file_number);
+
+/*
+
+Get next character from buffer
+
+ */
+    extern int interrupted_in_htgetcharacter;
+    extern int HTGetCharacter(void);
+
+/*
+
+HTParseSocket: Parse a socket given its format
+
+   This routine is called by protocol modules to load an object.  uses
+   HTStreamStack and the copy routines above.  Returns HT_LOADED if successful,
+   <0 if not.
+
+ */
+    extern int HTParseSocket(HTFormat format_in,
+			     HTFormat format_out,
+			     HTParentAnchor *anchor,
+			     int file_number,
+			     HTStream *sink);
+
+/*
+
+HTParseFile: Parse a File through a file pointer
+
+   This routine is called by protocols modules to load an object.  uses
+   HTStreamStack and HTFileCopy.  Returns HT_LOADED if successful, can also
+   return HT_PARTIAL_CONTENT, HT_NO_DATA, or other <0 for failure.
+
+ */
+    extern int HTParseFile(HTFormat format_in,
+			   HTFormat format_out,
+			   HTParentAnchor *anchor,
+			   FILE *fp,
+			   HTStream *sink);
+
+#ifdef USE_SOURCE_CACHE
+/*
+
+HTParseMem: Parse a document in memory
+
+   This routine is called by protocols modules to load an object.  uses
+   HTStreamStack and HTMemCopy.  Returns HT_LOADED if successful, can also
+   return <0 for failure.
+
+ */
+    extern int HTParseMem(HTFormat format_in,
+			  HTFormat format_out,
+			  HTParentAnchor *anchor,
+			  HTChunk *chunk,
+			  HTStream *sink);
+#endif
+
+#ifdef USE_ZLIB
+/*
+HTParseGzFile: Parse a gzip'ed File through a file pointer
+
+   This routine is called by protocols modules to load an object.  uses
+   HTStreamStack and HTGzFileCopy.  Returns HT_LOADED if successful, can also
+   return HT_PARTIAL_CONTENT, HT_NO_DATA, or other <0 for failure.
+ */
+    extern int HTParseGzFile(HTFormat format_in,
+			     HTFormat format_out,
+			     HTParentAnchor *anchor,
+			     gzFile gzfp,
+			     HTStream *sink);
+
+/*
+HTParseZzFile: Parse a deflate'd File through a file pointer
+
+   This routine is called by protocols modules to load an object.  uses
+   HTStreamStack and HTZzFileCopy.  Returns HT_LOADED if successful, can also
+   return HT_PARTIAL_CONTENT, HT_NO_DATA, or other <0 for failure.
+ */
+    extern int HTParseZzFile(HTFormat format_in,
+			     HTFormat format_out,
+			     HTParentAnchor *anchor,
+			     FILE *zzfp,
+			     HTStream *sink);
+
+#endif				/* USE_ZLIB */
+
+#ifdef USE_BZLIB
+/*
+HTParseBzFile: Parse a bzip2'ed File through a file pointer
+
+   This routine is called by protocols modules to load an object.  uses
+   HTStreamStack and HTBzFileCopy.  Returns HT_LOADED if successful, can also
+   return HT_PARTIAL_CONTENT, HT_NO_DATA, or other <0 for failure.
+ */
+    extern int HTParseBzFile(HTFormat format_in,
+			     HTFormat format_out,
+			     HTParentAnchor *anchor,
+			     BZFILE * bzfp,
+			     HTStream *sink);
+
+#endif				/* USE_BZLIB */
+
+#ifdef USE_BROTLI
+/*
+HTParseBrFile: Parse a brotli'ed File through a file pointer
+
+   This routine is called by protocols modules to load an object.  uses
+   HTStreamStack and HTBrFileCopy.  Returns HT_LOADED if successful, can also
+   return HT_PARTIAL_CONTENT, HT_NO_DATA, or other <0 for failure.
+ */
+    extern int HTParseBrFile(HTFormat format_in,
+			     HTFormat format_out,
+			     HTParentAnchor *anchor,
+			     FILE *brfp,
+			     HTStream *sink);
+
+#endif				/* USE_BROTLI */
+
+/*
+
+HTNetToText: Convert Net ASCII to local representation
+
+   This is a filter stream suitable for taking text from a socket and passing
+   it into a stream which expects text in the local C representation.  It does
+   ASCII and newline conversion.  As usual, pass its output stream to it when
+   creating it.
+
+ */
+    extern HTStream *HTNetToText(HTStream *sink);
+
+/*
+
+HTFormatInit: Set up default presentations and conversions
+
+   These are defined in HTInit.c or HTSInit.c if these have been replaced.  If
+   you don't call this routine, and you don't define any presentations, then
+   this routine will automatically be called the first time a conversion is
+   needed.  However, if you explicitly add some conversions (eg using
+   HTLoadRules) then you may want also to explicitly call this to get the
+   defaults as well.
+
+ */
+    extern void HTFormatInit(void);
+
+/*
+
+Epilogue
+
+ */
+    extern BOOL HTOutputSource;	/* Flag: shortcut parser */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTFORMAT_H */
diff --git a/WWW/Library/Implementation/HTGopher.c b/WWW/Library/Implementation/HTGopher.c
new file mode 100644
index 0000000..0314179
--- /dev/null
+++ b/WWW/Library/Implementation/HTGopher.c
@@ -0,0 +1,2071 @@
+/*
+ * $LynxId: HTGopher.c,v 1.77 2022/04/01 00:18:09 tom Exp $
+ *
+ *			GOPHER ACCESS				HTGopher.c
+ *			=============
+ *
+ *  History:
+ *	26 Sep 90	Adapted from other accesses (News, HTTP) TBL
+ *	29 Nov 91	Downgraded to C, for portable implementation.
+ *	10 Mar 96	Foteos Macrides (macrides@sci.wfbr.edu).  Added a
+ *			  form-based CSO/PH gateway.  Can be invoked via a
+ *			  "cso://host[:port]/" or "gopher://host:105/2"
+ *			  URL.	If a gopher URL is used with a query token
+ *			  ('?'), the old ISINDEX procedure will be used
+ *			  instead of the form-based gateway.
+ *	15 Mar 96	Foteos Macrides (macrides@sci.wfbr.edu).  Pass
+ *			  port 79, gtype 0 gopher URLs to the finger
+ *			  gateway.
+ */
+
+#define HTSTREAM_INTERNAL 1
+
+#include <HTUtils.h>		/* Coding convention macros */
+#include <HTFile.h>		/* For HTFileFormat() */
+
+#ifndef DISABLE_GOPHER
+#include <HTAlert.h>
+#include <HTParse.h>
+#include <HTTCP.h>
+#include <HTFinger.h>
+#include <LYGlobalDefs.h>
+
+/*
+ *  Implements.
+ */
+#include <HTGopher.h>
+
+#define GOPHER_PORT 70		/* See protocol spec */
+#define CSO_PORT 105		/* See protocol spec */
+#define BIG 1024		/* Bug */
+#define LINE_LENGTH 256		/* Bug */
+
+/*
+ *  Gopher entity types.
+ */
+#define GOPHER_TEXT		'0'
+#define GOPHER_MENU		'1'
+#define GOPHER_CSO		'2'
+#define GOPHER_ERROR		'3'
+#define GOPHER_MACBINHEX	'4'
+#define GOPHER_PCBINARY		'5'
+#define GOPHER_UUENCODED	'6'
+#define GOPHER_INDEX		'7'
+#define GOPHER_TELNET		'8'
+#define GOPHER_BINARY		'9'
+#define GOPHER_GIF		'g'
+#define GOPHER_HTML		'h'	/* HTML */
+#define GOPHER_CHTML		'H'	/* HTML */
+#define GOPHER_SOUND		's'
+#define GOPHER_WWW		'w'	/* W3 address */
+#define GOPHER_IMAGE		'I'
+#define GOPHER_TN3270		'T'
+#define GOPHER_INFO		'i'
+#define GOPHER_DUPLICATE	'+'
+#define GOPHER_PLUS_IMAGE	':'	/* Addition from Gopher Plus */
+#define GOPHER_PLUS_MOVIE	';'
+#define GOPHER_PLUS_SOUND	'<'
+#define GOPHER_PLUS_PDF		'P'
+
+#include <HTFormat.h>
+
+/*
+ *  Hypertext object building machinery.
+ */
+#include <HTML.h>
+
+#include <LYStrings.h>
+#include <LYUtils.h>
+#include <LYLeaks.h>
+
+#define PUTC(c) (*targetClass.put_character)(target, c)
+#define PUTS(s) (*targetClass.put_string)(target, s)
+#define START(e) (*targetClass.start_element)(target, e, 0, 0, -1, 0)
+#define END(e) (*targetClass.end_element)(target, e, 0)
+#define FREE_TARGET (*targetClass._free)(target)
+
+#define NEXT_CHAR HTGetCharacter()
+
+/*
+ *  Module-wide variables.
+ */
+static int s;			/* Socket for gopher or CSO host */
+
+struct _HTStructured {
+    const HTStructuredClass *isa;	/* For gopher streams */
+    /* ... */
+};
+
+static HTStructured *target;	/* the new gopher hypertext */
+static HTStructuredClass targetClass;	/* Its action routines */
+
+struct _HTStream {
+    HTStreamClass *isa;		/* For form-based CSO  gateway - FM */
+};
+
+typedef struct _CSOfield_info {	/* For form-based CSO gateway - FM */
+    struct _CSOfield_info *next;
+    char *name;
+    char *attributes;
+    char *description;
+    int id;
+    int lookup;
+    int indexed;
+    int url;
+    int max_size;
+    int defreturn;
+    int explicit_return;
+    int reserved;
+    int gpublic;
+    char name_buf[16];		/* Avoid malloc if we can */
+    char desc_buf[32];		/* Avoid malloc if we can */
+    char attr_buf[80];		/* Avoid malloc if we can */
+} CSOfield_info;
+
+static CSOfield_info *CSOfields = NULL;		/* For form-based CSO gateway - FM */
+
+typedef struct _CSOformgen_context {	/* For form-based CSO gateway - FM */
+    const char *host;
+    const char *seek;
+    CSOfield_info *fld;
+    int port;
+    int cur_line;
+    int cur_off;
+    int rep_line;
+    int rep_off;
+    int public_override;
+    int field_select;
+} CSOformgen_context;
+
+/*	Matrix of allowed characters in filenames
+ *	=========================================
+ */
+static BOOL acceptable_html[256];
+static BOOL acceptable_file[256];
+static BOOL acceptable_inited = NO;
+
+static void init_acceptable(void)
+{
+    unsigned int i;
+    const char *good =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./-_$";
+
+    for (i = 0; i < 256; i++) {
+	acceptable_html[i] = NO;
+	acceptable_file[i] = NO;
+    }
+    for (; *good; good++) {
+	acceptable_html[(unsigned int) *good] = YES;
+	acceptable_file[(unsigned int) *good] = YES;
+    }
+    for (good = ";?=#"; *good; ++good) {
+	acceptable_html[(unsigned int) *good] = YES;
+    }
+    acceptable_inited = YES;
+}
+
+/*	Decode one hex character
+ *	========================
+ */
+static const char hex[17] = "0123456789abcdef";
+
+static char from_hex(int c)
+{
+    return (char) ((c >= '0') && (c <= '9') ? c - '0'
+		   : (c >= 'A') && (c <= 'F') ? c - 'A' + 10
+		   : (c >= 'a') && (c <= 'f') ? c - 'a' + 10
+		   : 0);
+}
+
+/*	Paste in an Anchor
+ *	==================
+ *
+ *	The title of the destination is set, as there is no way
+ *	of knowing what the title is when we arrive.
+ *
+ * On entry,
+ *	HT	is in append mode.
+ *	text	points to the text to be put into the file, 0 terminated.
+ *	addr	points to the hypertext reference address 0 terminated.
+ */
+BOOLEAN HT_Is_Gopher_URL = FALSE;
+
+static void write_anchor(const char *text, const char *addr)
+{
+    BOOL present[HTML_A_ATTRIBUTES];
+    const char *value[HTML_A_ATTRIBUTES];
+
+    int i;
+
+    for (i = 0; i < HTML_A_ATTRIBUTES; i++)
+	present[i] = 0;
+    present[HTML_A_HREF] = YES;
+    ((const char **) value)[HTML_A_HREF] = addr;
+    present[HTML_A_TITLE] = YES;
+    ((const char **) value)[HTML_A_TITLE] = text;
+
+    CTRACE((tfp, "HTGopher: adding URL: %s\n", addr));
+
+    HT_Is_Gopher_URL = TRUE;	/* tell HTML.c that this is a Gopher URL */
+    (*targetClass.start_element) (target, HTML_A, present,
+				  (const char **) value, -1, 0);
+
+    PUTS(text);
+    END(HTML_A);
+}
+
+/*	Parse a Gopher Menu document
+ *	============================
+ */
+static void parse_menu(const char *arg GCC_UNUSED,
+		       HTParentAnchor *anAnchor)
+{
+    char gtype;
+    char this_type;
+    int ich;
+    char line[BIG];
+    char *name = NULL, *selector = NULL;	/* Gopher menu fields */
+    char *host = NULL;
+    char *port;
+    char *p = line;
+    const char *title;
+    int bytes = 0;
+    int BytesReported = 0;
+    char buffer[128];
+    BOOL *valid_chars;
+
+#define TAB		'\t'
+#define HEX_ESCAPE	'%'
+
+    START(HTML_HTML);
+    PUTC('\n');
+    START(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_TITLE);
+    if ((title = HTAnchor_title(anAnchor)))
+	PUTS(title);
+    else
+	PUTS(GOPHER_MENU_TITLE);
+    END(HTML_TITLE);
+    PUTC('\n');
+    END(HTML_HEAD);
+    PUTC('\n');
+
+    START(HTML_BODY);
+    PUTC('\n');
+    START(HTML_H1);
+    if ((title = HTAnchor_title(anAnchor)))
+	PUTS(title);
+    else
+	PUTS(GOPHER_MENU_TITLE);
+    END(HTML_H1);
+    PUTC('\n');
+    START(HTML_PRE);
+    PUTC('\n');			/* newline after HTML_PRE forces split-line */
+    this_type = GOPHER_ERROR;
+    while ((ich = NEXT_CHAR) != EOF) {
+
+	if (interrupted_in_htgetcharacter) {
+	    CTRACE((tfp,
+		    "HTGopher: Interrupted in HTGetCharacter, apparently.\n"));
+	    goto end_html;
+	}
+
+	if ((char) ich != LF) {
+	    const char *ss = NULL;
+
+	    /*
+	     * Help the -source output to look like the HTML equivalent of the
+	     * Gopher menu.
+	     */
+	    if (dump_output_immediately
+		&& HTOutputFormat == WWW_DUMP) {
+		if (ich == '<') {
+		    ss = "&lt;";
+		} else if (ich == '>') {
+		    ss = "&gt;";
+		} else if (ich == '&') {
+		    ss = "&amp;";
+		}
+	    }
+	    if (ss != NULL) {
+		if ((p + 5) < &line[BIG - 1]) {
+		    while (*ss != '\0') {
+			*p++ = *ss++;
+		    }
+		}
+	    } else {
+		*p = (char) ich;	/* Put character in line */
+		if (p < &line[BIG - 1])
+		    p++;
+	    }
+
+	} else {
+	    *p++ = '\0';	/* Terminate line */
+	    bytes += (int) (p - line);	/* add size */
+	    p = line;		/* Scan it to parse it */
+	    port = 0;		/* Flag "not parsed" */
+	    CTRACE((tfp, "HTGopher: Menu item: %s\n", line));
+	    gtype = *p++;
+
+	    if (bytes > BytesReported + 1024) {
+		sprintf(buffer, TRANSFERRED_X_BYTES, bytes);
+		HTProgress(buffer);
+		BytesReported = bytes;
+	    }
+
+	    /* Break on line with a dot by itself */
+	    if ((gtype == '.') && ((*p == '\r') || (*p == 0)))
+		break;
+
+	    if (gtype && *p) {
+		name = p;
+		selector = StrChr(name, TAB);
+		if (selector) {
+		    *selector++ = '\0';		/* Terminate name */
+		    /*
+		     * Gopher+ Type=0+ objects can be binary, and will
+		     * have 9 or 5 beginning their selector.  Make sure
+		     * we don't trash the terminal by treating them as
+		     * text. - FM
+		     */
+		    if (gtype == GOPHER_TEXT && (*selector == GOPHER_BINARY ||
+						 *selector == GOPHER_PCBINARY))
+			gtype = *selector;
+		    host = StrChr(selector, TAB);
+		    if (host) {
+			*host++ = '\0';		/* Terminate selector */
+			port = StrChr(host, TAB);
+			if (port) {
+			    char *junk;
+
+			    port[0] = ':';	/* delimit host a la W3 */
+			    junk = StrChr(port, TAB);
+			    if (junk)
+				*junk = '\0';	/* Chop port */
+			    if ((port[1] == '0') && (!port[2]))
+				port[0] = '\0';		/* 0 means none */
+			}	/* no port */
+		    }		/* host ok */
+		}		/* selector ok */
+	    }
+	    /* gtype and name ok */
+	    /* Nameless files are a separator line */
+	    if (name != NULL && gtype == GOPHER_TEXT) {
+		int i = (int) strlen(name) - 1;
+
+		while (name[i] == ' ' && i >= 0)
+		    name[i--] = '\0';
+		if (i < 0)
+		    gtype = GOPHER_INFO;
+	    }
+
+	    if (gtype == GOPHER_WWW) {	/* Gopher pointer to W3 */
+		PUTS("(HTML) ");
+		write_anchor(name, selector);
+
+	    } else if (gtype == GOPHER_INFO) {
+		/* Information or separator line */
+		PUTS("       ");
+		PUTS(name);
+
+	    } else if (port &&	/* Other types need port */
+		       (gtype != GOPHER_DUPLICATE ||
+			this_type != GOPHER_ERROR)) {
+		char *address = 0;
+		const char *format = *selector ? "%s//%s@%s/" : "%s//%s/";
+
+		if (gtype == GOPHER_TELNET) {
+		    PUTS(" (TEL) ");
+		    if (*selector == '/')
+			++selector;
+		    HTSprintf0(&address, format, STR_TELNET_URL, selector, host);
+		} else if (gtype == GOPHER_TN3270) {
+		    PUTS("(3270) ");
+		    if (*selector == '/')
+			++selector;
+		    HTSprintf0(&address, format, STR_TN3270_URL, selector, host);
+		} else {	/* If parsed ok */
+		    char *r;
+
+		    switch (gtype) {
+		    case GOPHER_TEXT:
+			PUTS("(FILE) ");
+			break;
+		    case GOPHER_MENU:
+			PUTS(" (DIR) ");
+			break;
+		    case GOPHER_DUPLICATE:
+			PUTS(" (+++) ");
+			break;
+		    case GOPHER_CSO:
+			PUTS(" (CSO) ");
+			break;
+		    case GOPHER_PCBINARY:
+			PUTS(" (BIN) ");
+			break;
+		    case GOPHER_UUENCODED:
+			PUTS(" (UUE) ");
+			break;
+		    case GOPHER_INDEX:
+			PUTS("  (?)  ");
+			break;
+		    case GOPHER_BINARY:
+			PUTS(" (BIN) ");
+			break;
+		    case GOPHER_GIF:
+		    case GOPHER_IMAGE:
+		    case GOPHER_PLUS_IMAGE:
+			PUTS(" (IMG) ");
+			break;
+		    case GOPHER_SOUND:
+		    case GOPHER_PLUS_SOUND:
+			PUTS(" (SND) ");
+			break;
+		    case GOPHER_MACBINHEX:
+			PUTS(" (HQX) ");
+			break;
+		    case GOPHER_HTML:
+		    case GOPHER_CHTML:
+			PUTS("(HTML) ");
+			break;
+		    case 'm':
+			PUTS("(MIME) ");
+			break;
+		    case GOPHER_PLUS_MOVIE:
+			PUTS(" (MOV) ");
+			break;
+		    case GOPHER_PLUS_PDF:
+			PUTS(" (PDF) ");
+			break;
+		    default:
+			PUTS("(UNKN) ");
+			break;
+		    }
+
+		    if (gtype != GOPHER_DUPLICATE)
+			this_type = gtype;
+
+		    HTSprintf0(&address, "//%s/%c", host, this_type);
+		    if (gtype == GOPHER_HTML) {
+			valid_chars = acceptable_html;
+			if (*selector == '/')
+			    ++selector;
+		    } else {
+			valid_chars = acceptable_file;
+		    }
+
+		    for (r = selector; *r; r++) {	/* Encode selector string */
+			if (valid_chars[UCH(*r)]) {
+			    HTSprintf(&address, "%c", *r);
+			} else {
+			    HTSprintf(&address, "%c%c%c",
+				      HEX_ESCAPE,	/* Means hex coming */
+				      hex[(TOASCII(*r)) >> 4],
+				      hex[(TOASCII(*r)) & 15]);
+			}
+		    }
+		}
+		/* Error response from Gopher doesn't deserve to
+		   be a hyperlink. */
+		if (strcmp(address, "gopher://error.host:1/0"))
+		    write_anchor(name, address);
+		else
+		    PUTS(name);
+		FREE(address);
+	    } else {		/* parse error */
+		CTRACE((tfp, "HTGopher: Bad menu item (type %d, port %s).\n",
+			gtype, NonNull(port)));
+		PUTS(line);
+
+	    }			/* parse error */
+
+	    PUTC('\n');
+	    p = line;		/* Start again at beginning of line */
+
+	}			/* if end of line */
+
+    }				/* Loop over characters */
+
+  end_html:
+    END(HTML_PRE);
+    PUTC('\n');
+    END(HTML_BODY);
+    PUTC('\n');
+    END(HTML_HTML);
+    PUTC('\n');
+    FREE_TARGET;
+
+    return;
+}
+
+/*	Parse a Gopher CSO document from an ISINDEX query.
+ *	==================================================
+ *
+ *   Accepts an open socket to a CSO server waiting to send us
+ *   data and puts it on the screen in a reasonable manner.
+ *
+ *   Perhaps this data can be automatically linked to some
+ *   other source as well???
+ *
+ *  Taken from hacking by Lou Montulli@ukanaix.cc.ukans.edu
+ *  on XMosaic-1.1, and put on libwww 2.11 by Arthur Secret,
+ *  secret@dxcern.cern.ch .
+ */
+static void parse_cso(const char *arg,
+		      HTParentAnchor *anAnchor)
+{
+    int ich;
+    char line[BIG];
+    char *p = line;
+    char *first_colon, *second_colon, last_char = '\0';
+    const char *title;
+
+    START(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_TITLE);
+    if ((title = HTAnchor_title(anAnchor)))
+	PUTS(title);
+    else
+	PUTS(GOPHER_CSO_SEARCH_RESULTS);
+    END(HTML_TITLE);
+    PUTC('\n');
+    END(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_H1);
+    if ((title = HTAnchor_title(anAnchor)))
+	PUTS(title);
+    else {
+	PUTS(arg);
+	PUTS(GOPHER_SEARCH_RESULTS);
+    }
+    END(HTML_H1);
+    PUTC('\n');
+    START(HTML_PRE);
+
+    /*
+     * Start grabbing chars from the network.
+     */
+    while ((ich = NEXT_CHAR) != EOF) {
+	if ((char) ich != LF) {
+	    *p = (char) ich;	/* Put character in line */
+	    if (p < &line[BIG - 1])
+		p++;
+	} else {
+	    *p = '\0';		/* Terminate line */
+	    p = line;		/* Scan it to parse it */
+	    /*
+	     * OK we now have a line in 'p'.  Lets parse it and print it.
+	     */
+
+	    /*
+	     * Break on line that begins with a 2.  It's the end of data.
+	     */
+	    if (*p == '2')
+		break;
+
+	    /*
+	     * Lines beginning with 5 are errors.  Print them and quit.
+	     */
+	    if (*p == '5') {
+		START(HTML_H2);
+		PUTS(p + 4);
+		END(HTML_H2);
+		break;
+	    }
+
+	    if (*p == '-') {
+		/*
+		 * Data lines look like -200:#:
+		 * where # is the search result number and can be multiple
+		 * digits (infinite?).
+		 * Find the second colon and check the digit to the left of it
+		 * to see if they are different.  If they are then a different
+		 * person is starting.  Make this line an <h2>.
+		 */
+
+		/*
+		 * Find the second_colon.
+		 */
+		second_colon = NULL;
+		first_colon = StrChr(p, ':');
+		if (first_colon != NULL) {
+		    second_colon = StrChr(first_colon + 1, ':');
+		}
+
+		if (second_colon != NULL) {	/* error check */
+
+		    if (*(second_colon - 1) != last_char)
+			/* print separator */
+		    {
+			END(HTML_PRE);
+			START(HTML_H2);
+		    }
+
+		    /*
+		     * Right now the record appears with the alias (first line)
+		     * as the header and the rest as <pre> text.
+		     *
+		     * It might look better with the name as the header and the
+		     * rest as a <ul> with <li> tags.  I'm not sure whether the
+		     * name field comes in any special order or if its even
+		     * required in a record, so for now the first line is the
+		     * header no matter what it is (it's almost always the
+		     * alias).
+		     *
+		     * A <dl> with the first line as the <DT> and the rest as
+		     * some form of <DD> might good also?
+		     */
+
+		    /*
+		     * Print data.
+		     */
+		    PUTS(second_colon + 1);
+		    PUTC('\n');
+
+		    if (*(second_colon - 1) != last_char)
+			/* end separator */
+		    {
+			END(HTML_H2);
+			START(HTML_PRE);
+		    }
+
+		    /*
+		     * Save the char before the second colon for comparison on
+		     * the next pass.
+		     */
+		    last_char = *(second_colon - 1);
+
+		}		/* end if second_colon */
+	    }			/* end if *p == '-' */
+	}			/* if end of line */
+
+    }				/* Loop over characters */
+
+    /* end the text block */
+    PUTC('\n');
+    END(HTML_PRE);
+    PUTC('\n');
+    FREE_TARGET;
+
+    return;			/* all done */
+}				/* end of procedure */
+
+/*	Display a Gopher CSO ISINDEX cover page.
+ *	========================================
+ */
+static void display_cso(const char *arg,
+			HTParentAnchor *anAnchor)
+{
+    const char *title;
+
+    START(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_TITLE);
+    if ((title = HTAnchor_title(anAnchor)))
+	PUTS(title);
+    else
+	PUTS(GOPHER_CSO_INDEX);
+    END(HTML_TITLE);
+    PUTC('\n');
+    START(HTML_ISINDEX);
+    PUTC('\n');
+    END(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_H1);
+    if ((title = HTAnchor_title(anAnchor)))
+	PUTS(title);
+    else {
+	PUTS(arg);
+	PUTS(INDEX_SEGMENT);
+    }
+    END(HTML_H1);
+    PUTS(GOPHER_CSO_INDEX_SUBTITLE);
+    START(HTML_P);
+    PUTS(GOPHER_CSO_SOLICIT_KEYWORDS);
+    START(HTML_P);
+    PUTS(SEGMENT_KEYWORDS_WILL);
+    PUTS(SEGMENT_PERSONS_DB_NAME);
+
+    if (!HTAnchor_title(anAnchor))
+	HTAnchor_setTitle(anAnchor, arg);
+
+    FREE_TARGET;
+    return;
+}
+
+/*	Display a Gopher Index document.
+ *	================================
+ */
+static void display_index(const char *arg,
+			  HTParentAnchor *anAnchor)
+{
+    const char *title;
+
+    START(HTML_HEAD);
+    PUTC('\n');
+    PUTC('\n');
+    START(HTML_TITLE);
+    if ((title = HTAnchor_title(anAnchor)))
+	PUTS(title);
+    else
+	PUTS(GOPHER_INDEX_TITLE);
+    END(HTML_TITLE);
+    PUTC('\n');
+    START(HTML_ISINDEX);
+    PUTC('\n');
+    END(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_H1);
+    if ((title = HTAnchor_title(anAnchor)))
+	PUTS(title);
+    else {
+	PUTS(arg);
+	PUTS(INDEX_SEGMENT);
+    }
+    END(HTML_H1);
+    PUTS(GOPHER_INDEX_SUBTITLE);
+    START(HTML_P);
+    PUTS(GOPHER_SOLICIT_KEYWORDS);
+
+    if (!HTAnchor_title(anAnchor))
+	HTAnchor_setTitle(anAnchor, arg);
+
+    FREE_TARGET;
+    return;
+}
+
+/*	De-escape a selector into a command.
+ *	====================================
+ *
+ *	The % hex escapes are converted. Otherwise, the string is copied.
+ */
+static void de_escape(char *command, const char *selector)
+{
+    const char *p = selector;
+    char *q;
+
+    if (command == NULL)
+	outofmem(__FILE__, "HTLoadGopher");
+
+    q = command;
+    while (*p) {		/* Decode hex */
+	if (*p == HEX_ESCAPE) {
+	    char c;
+	    unsigned int b;
+
+	    p++;
+	    c = *p++;
+	    b = UCH(from_hex(c));
+	    c = *p++;
+	    if (!c)
+		break;		/* Odd number of chars! */
+	    *q++ = (char) FROMASCII((b << 4) + UCH(from_hex(c)));
+	} else {
+	    *q++ = *p++;	/* Record */
+	}
+    }
+    *q = '\0';			/* Terminate command */
+}
+
+/*	Free the CSOfields structures. - FM
+ *	===================================
+ */
+static void free_CSOfields(void)
+{
+    CSOfield_info *cur = CSOfields;
+    CSOfield_info *prev;
+
+    while (cur) {
+	if (cur->name != cur->name_buf)
+	    FREE(cur->name);
+	if (cur->attributes != cur->attr_buf)
+	    FREE(cur->attributes);
+	if (cur->description != cur->desc_buf)
+	    FREE(cur->description);
+	prev = cur;
+	cur = cur->next;
+	FREE(prev);
+    }
+
+    return;
+}
+
+/*	Interpret CSO/PH form template keys. - FM
+ *	=========================================
+ */
+static void interpret_cso_key(const char *key,
+			      char *buf,
+			      size_t bufsize,
+			      int *length,
+			      CSOformgen_context * ctx,
+			      HTStream *Target)
+{
+    CSOfield_info *fld;
+
+    if ((fld = ctx->fld) != 0) {
+	/*
+	 * Most substitutions only recognized inside of loops.
+	 */
+	int error = 0;
+
+	if (0 == StrNCmp(key, "$(FID)", 6)) {
+	    sprintf(buf, "%d", fld->id);
+	} else if (0 == StrNCmp(key, "$(FDESC)", 8)) {
+	    sprintf(buf, "%.2046s", fld->description);
+	} else if (0 == StrNCmp(key, "$(FDEF)", 7)) {
+	    strcpy(buf, fld->defreturn ? " checked" : "");
+	} else if (0 == StrNCmp(key, "$(FNDX)", 7)) {
+	    strcpy(buf, fld->indexed ? "*" : "");
+	} else if (0 == StrNCmp(key, "$(FSIZE)", 8)) {
+	    sprintf(buf, " size=%d maxlength=%d",
+		    fld->max_size > 55 ? 55 : fld->max_size,
+		    fld->max_size);
+	} else if (0 == StrNCmp(key, "$(FSIZE2)", 9)) {
+	    sprintf(buf, " maxlength=%d", fld->max_size);
+	} else {
+	    error = 1;
+	}
+	if (!error) {
+	    *length = (int) strlen(buf);
+	    return;
+	}
+    }
+    buf[0] = '\0';
+    if (0 == StrNCmp(key, "$(NEXTFLD)", 10)) {
+	if (!ctx->fld)
+	    fld = CSOfields;
+	else
+	    fld = ctx->fld->next;
+	switch (ctx->field_select) {
+	case 0:
+	    /*
+	     * 'Query' fields, public and lookup attributes.
+	     */
+	    for (; fld; fld = fld->next)
+		if (fld->gpublic && (fld->lookup == 1))
+		    break;
+	    break;
+	case 1:
+	    /*
+	     * 'Query' fields, accept lookup attribute.
+	     */
+	    for (; fld; fld = fld->next)
+		if (fld->lookup == 1)
+		    break;
+	    break;
+	case 2:
+	    /*
+	     * 'Return' fields, public only.
+	     */
+	    for (; fld; fld = fld->next)
+		if (fld->gpublic)
+		    break;
+	    break;
+	case 3:
+	    /*
+	     * All fields.
+	     */
+	    break;
+	}
+	if (fld) {
+	    ctx->cur_line = ctx->rep_line;
+	    ctx->cur_off = ctx->rep_off;
+	}
+	ctx->fld = fld;
+
+    } else if ((0 == StrNCmp(key, "$(QFIELDS)", 10)) ||
+	       (0 == StrNCmp(key, "$(RFIELDS)", 10))) {
+	/*
+	 * Begin iteration sequence.
+	 */
+	ctx->rep_line = ctx->cur_line;
+	ctx->rep_off = ctx->cur_off;
+	ctx->fld = (CSOfield_info *) 0;
+	ctx->seek = "$(NEXTFLD)";
+	ctx->field_select = (key[2] == 'Q') ? 0 : 2;
+	if (ctx->public_override)
+	    ctx->field_select++;
+
+    } else if (0 == StrNCmp(key, "$(NAMEFLD)", 10)) {
+	/*
+	 * Special, locate name field.  Flag lookup so QFIELDS will skip it.
+	 */
+	for (fld = CSOfields; fld; fld = fld->next)
+	    if (strcmp(fld->name, "name") == 0 ||
+		strcmp(fld->name, "Name") == 0) {
+		if (fld->lookup)
+		    fld->lookup = 2;
+		break;
+	    }
+	ctx->fld = fld;
+    } else if (0 == StrNCmp(key, "$(HOST)", 7)) {
+	strcpy(buf, ctx->host);
+    } else if (0 == StrNCmp(key, "$(PORT)", 7)) {
+	sprintf(buf, "%d", ctx->port);
+    } else {
+	/*
+	 * No match, dump key to buffer so client sees it for debugging.
+	 */
+	size_t out = 0;
+
+	while (*key && (*key != ')')) {
+	    buf[out++] = (*key++);
+	    if (out > bufsize - 2) {
+		buf[out] = '\0';
+		(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		out = 0;
+	    }
+	}
+	buf[out++] = ')';
+	buf[out] = '\0';
+    }
+    *length = (int) strlen(buf);
+    return;
+}
+
+/*	Parse the elements in a CSO/PH fields structure. - FM
+ *	=====================================================
+ */
+static int parse_cso_field_info(CSOfield_info *blk)
+{
+    char *info, *max_spec;
+
+    /*
+     * Initialize all fields to default values.
+     */
+    blk->indexed = blk->lookup = blk->reserved = blk->max_size = blk->url = 0;
+    blk->defreturn = blk->explicit_return = blk->gpublic = 0;
+
+    /*
+     * Search for keywords in info string and set values.  Attributes are
+     * converted to all lower-case for comparison.
+     */
+    info = blk->attributes;
+    LYLowerCase(info);
+    if (strstr(info, "indexed "))
+	blk->indexed = 1;
+    if (strstr(info, "default "))
+	blk->defreturn = 1;
+    if (strstr(info, "public "))
+	blk->gpublic = 1;
+    if (strstr(info, "lookup "))
+	blk->lookup = 1;
+    if (strstr(info, "url ")) {
+	blk->url = 1;
+	blk->defreturn = 1;
+    }
+    max_spec = strstr(info, "max ");
+    if (max_spec) {
+	sscanf(&max_spec[4], "%d", &blk->max_size);
+    } else {
+	blk->max_size = 32;
+    }
+
+    return 0;
+}
+
+/*	Parse a reply from a CSO/PH fields request. - FM
+ *	================================================
+ */
+static int parse_cso_fields(char *buf,
+			    size_t size)
+{
+    int ich;
+    char *p = buf;
+    int i, code = 0, prev_code;
+    size_t alen;
+    char *indx, *name;
+    CSOfield_info *last, *newf;
+
+    last = CSOfields = (CSOfield_info *) 0;
+    prev_code = -2555;
+    buf[0] = '\0';
+
+    /*
+     * Start grabbing chars from the network.
+     */
+    while ((ich = NEXT_CHAR) != EOF) {
+	if (interrupted_in_htgetcharacter) {
+	    CTRACE((tfp,
+		    "HTLoadCSO: Interrupted in HTGetCharacter, apparently.\n"));
+	    free_CSOfields();
+	    buf[0] = '\0';
+	    return HT_INTERRUPTED;
+	}
+
+	if ((char) ich != LF) {
+	    *p = (char) ich;	/* Put character in buffer */
+	    if (p < &buf[size - 1]) {
+		p++;
+	    }
+	} else {
+	    *p = '\0';		/* Terminate line */
+	    p = buf;		/* Scan it to parse it */
+
+	    /* OK we now have a line in 'p' lets parse it.
+	     */
+
+	    /*
+	     * Break on line that begins with a 2.  It's the end of data.
+	     */
+	    if (*p == '2')
+		break;
+
+	    /*
+	     * Lines beginning with 5 are errors.  Print them and quit.
+	     */
+	    if (*p == '5') {
+		return 5;
+	    }
+
+	    if (*p == '-') {
+		/*
+		 * Data lines look like -200:#:
+		 * where # is the search result number and can be multiple
+		 * digits (infinite?).
+		 */
+
+		/*
+		 * Check status, ignore any non-success.
+		 */
+		if (p[1] != '2')
+		    continue;
+
+		/*
+		 * Parse fields within returned line into status, ndx, name,
+		 * data.
+		 */
+		indx = NULL;
+		name = NULL;
+		for (i = 0; p[i]; i++) {
+		    if (p[i] == ':') {
+			p[i] = '\0';
+			if (!indx) {
+			    indx = (char *) &p[i + 1];
+			    code = atoi(indx);
+			} else if (!name) {
+			    name = (char *) &p[i + 1];
+			} else {
+			    i++;
+			    break;
+			}
+		    }
+		}
+		/*
+		 * Add data to field structure.
+		 */
+		if (name) {
+		    if (code == prev_code) {
+			/*
+			 * Remaining data are description.  Save in current
+			 * info block.
+			 */
+			if (last != NULL) {
+			    alen = strlen((char *) &p[i]) + 1;
+			    if (alen > sizeof(last->desc_buf)) {
+				if (last->description != last->desc_buf)
+				    FREE(last->description);
+				if (!(last->description = (char *) malloc(alen))) {
+				    outofmem(__FILE__, "HTLoadCSO");
+				}
+			    }
+			    strcpy(last->description, (char *) &p[i]);
+			}
+		    } else {
+			/*
+			 * Initialize new block, append to end of list to
+			 * preserve order.
+			 */
+			newf = typecalloc(CSOfield_info);
+
+			if (!newf) {
+			    outofmem(__FILE__, "HTLoadCSO");
+			}
+
+			if (last)
+			    last->next = newf;
+			else
+			    CSOfields = newf;
+			last = newf;
+
+			newf->next = (CSOfield_info *) 0;
+			newf->name = newf->name_buf;
+			alen = strlen(name) + 1;
+			if (alen > sizeof(newf->name_buf)) {
+			    if (!(newf->name = (char *) malloc(alen))) {
+				outofmem(__FILE__, "HTLoadCSO");
+			    }
+			}
+			strcpy(newf->name, name);
+
+			newf->attributes = newf->attr_buf;
+			alen = strlen((char *) &p[i]) + 2;
+			if (alen > sizeof(newf->attr_buf)) {
+			    if (!(newf->attributes = (char *) malloc(alen))) {
+				outofmem(__FILE__, "HTLoadCSO");
+			    }
+			}
+			strcpy(newf->attributes, (char *) &p[i]);
+			strcpy((char *) &newf->attributes[alen - 2], " ");
+			newf->description = newf->desc_buf;
+			newf->desc_buf[0] = '\0';
+			newf->id = atoi(indx);
+			/*
+			 * Scan for keywords.
+			 */
+			parse_cso_field_info(newf);
+		    }
+		    prev_code = code;
+		} else
+		    break;
+	    }			/* end if *p == '-' */
+	}			/* if end of line */
+
+    }				/* Loop over characters */
+
+    /* end the text block */
+
+    if (buf[0] == '\0') {
+	return -1;		/* no response */
+    }
+    buf[0] = '\0';
+    return 0;			/* all done */
+}				/* end of procedure */
+
+/*	Generate a form for submitting CSO/PH searches. - FM
+ *	====================================================
+ */
+static int generate_cso_form(char *host,
+			     int port,
+			     char *buf,
+			     size_t bufsize,
+			     HTStream *Target)
+{
+    int i, j, length;
+    size_t out;
+    int full_flag = 1;
+    const char *key;
+    const char *line;
+    CSOformgen_context ctx;
+    static const char *ctemplate[] =
+    {
+	"<HTML>\n<HEAD>\n<TITLE>CSO/PH Query Form for $(HOST)</TITLE>\n</HEAD>\n<BODY>",
+	"<H2><I>CSO/PH Query Form</I> for <EM>$(HOST)</EM></H2>",
+	"To search the database for a name, fill in one or more of the fields",
+	"in the form below and activate the 'Submit query' button.  At least",
+	"one of the entered fields must be flagged as indexed.",
+	"<HR><FORM method=\"POST\" action=\"cso://$(HOST)/\">",
+	"[ <input type=\"submit\" value=\"Submit query\"> | ",
+	"<input type=\"reset\" value=\"Clear fields\"> ]",
+	"<P><DL>",
+	"   <DT>Search parameters (* indicates indexed field):",
+	"   <DD>",
+	"$(NAMEFLD)    <DL COMPACT>\n    <DT><I>$(FDESC)</I>$(FNDX)",
+	"    <DD>Last: <input name=\"q_$(FID)\" type=\"text\" size=49$(FSIZE2)>",
+	"    <DD>First: <input name=\"q_$(FID)\" type=\"text\" size=48$(FSIZE2)>",
+	"$(QFIELDS)    <DT><I>$(FDESC)</I>$(FNDX)",
+	"    <DD><input name=\"q_$(FID)\" type=\"text\" $(FSIZE)>\n$(NEXTFLD)",
+	"    </DL>",
+	"   </DL>\n<P><DL>",
+	"   <DT>Output format:",
+	"   <DD>Returned data option: <select name=\"return\">",
+	"    <option>default<option selected>all<option>selected</select><BR>",
+	"$(RFIELDS)    <input type=\"checkbox\" name=\"r_$(FID)\"$(FDEF)> $(FDESC)<BR>",
+	"$(NEXTFLD)    ",
+	"   </DL></FORM><HR>\n</BODY>\n</HTML>",
+	(char *) 0
+    };
+
+    memset(&ctx, 0, sizeof(ctx));
+    ctx.host = host;
+    ctx.seek = (char *) 0;
+    ctx.port = port;
+    ctx.fld = (CSOfield_info *) 0;
+    ctx.public_override = full_flag;
+    /*
+     * Parse the strings in the template array to produce HTML document to send
+     * to client.  First line is skipped for 'full' lists.
+     */
+    out = 0;
+    buf[out] = '\0';
+    for (i = 0; ctemplate[i]; i++) {
+	/*
+	 * Search the current string for substitution, flagged by $(
+	 */
+	for (line = ctemplate[i], j = 0; line[j]; j++) {
+	    if ((line[j] == '$') && (line[j + 1] == '(')) {
+		/*
+		 * Command detected, flush output buffer and find closing ')'
+		 * that delimits the command.
+		 */
+		buf[out] = '\0';
+		if (out > 0)
+		    (*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		for (key = &line[j]; line[j + 1] && (line[j] != ')'); j++) {
+		    ;
+		}
+		/*
+		 * Save context, interpret command and restore updated context.
+		 */
+		ctx.cur_line = i;
+		ctx.cur_off = j;
+		interpret_cso_key(key, buf, bufsize, &length, &ctx, Target);
+		i = ctx.cur_line;
+		j = ctx.cur_off;
+		line = ctemplate[i];
+		out = (size_t) length;
+
+		if (ctx.seek) {
+		    /*
+		     * Command wants us to skip (forward) to indicated token.
+		     * Start at current position.
+		     */
+		    size_t slen = strlen(ctx.seek);
+
+		    for (; ctemplate[i]; i++) {
+			for (line = ctemplate[i]; line[j]; j++) {
+			    if (line[j] == '$')
+				if (0 == StrNCmp(ctx.seek, &line[j], slen)) {
+				    if (j == 0)
+					j = (int) strlen(ctemplate[--i]) - 1;
+				    else
+					--j;
+				    line = ctemplate[i];
+				    ctx.seek = (char *) 0;
+				    break;
+				}
+			}
+			if (!ctx.seek)
+			    break;
+			j = 0;
+		    }
+		    if (ctx.seek) {
+			char *temp = 0;
+
+			HTSprintf0(&temp, GOPHER_CSO_SEEK_FAILED, ctx.seek);
+			(*Target->isa->put_block) (Target, temp, (int) strlen(temp));
+			FREE(temp);
+		    }
+		}
+	    } else {
+		/*
+		 * Non-command text, add to output buffer.
+		 */
+		buf[out++] = line[j];
+		if (out > (bufsize - 3)) {
+		    buf[out] = '\0';
+		    (*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		    out = 0;
+		}
+	    }
+	}
+	buf[out++] = '\n';
+	buf[out] = '\0';
+    }
+    if (out > 0)
+	(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+
+    return 0;
+}
+
+/*	Generate a results report for CSO/PH form-based searches. - FM
+ *	==============================================================
+ */
+static int generate_cso_report(HTStream *Target)
+{
+    int ich;
+    char line[BIG];
+    char *buf = 0;
+    char *p = line, *href = NULL;
+    int i, prev_ndx, ndx;
+    char *rcode, *ndx_str, *fname, *fvalue, *l;
+    CSOfield_info *fld;
+    BOOL stop = FALSE;
+
+    /*
+     * Read lines until non-negative status.
+     */
+    prev_ndx = -100;
+    /*
+     * Start grabbing chars from the network.
+     */
+    while (!stop && (ich = NEXT_CHAR) != EOF) {
+	if (interrupted_in_htgetcharacter) {
+	    CTRACE((tfp,
+		    "HTLoadCSO: Interrupted in HTGetCharacter, apparently.\n"));
+	    _HTProgress(CONNECTION_INTERRUPTED);
+	    goto end_CSOreport;
+	}
+
+	if ((char) ich != LF) {
+	    *p = (char) ich;	/* Put character in line */
+	    if (p < &line[BIG - 1]) {
+		p++;
+	    }
+	} else {
+	    *p = '\0';		/* Terminate line */
+	    /*
+	     * OK we now have a line.  Load it as 'p' and parse it.
+	     */
+	    p = line;
+	    if (p[0] != '-' && p[0] != '1') {
+		stop = TRUE;
+	    }
+	    rcode = (p[0] == '-') ? &p[1] : p;
+	    ndx_str = fname = NULL;
+	    for (i = 0; p[i] != '\0'; i++) {
+		if (p[i] == ':') {
+		    p[i] = '\0';
+		    fname = &p[i + 1];
+		    if (ndx_str) {
+			break;
+		    }
+		    ndx_str = fname;
+		}
+	    }
+	    if (ndx_str) {
+		ndx = atoi(ndx_str);
+		if (prev_ndx != ndx) {
+		    if (prev_ndx != -100) {
+			HTSprintf0(&buf, "</DL></DL>\n");
+			(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		    }
+		    if (ndx == 0) {
+			HTSprintf0(&buf,
+				   "<HR><DL><DT>Information/status<DD><DL><DT>\n");
+			(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		    } else {
+			HTSprintf0(&buf,
+				   "<HR><DL><DT>Entry %d:<DD><DL COMPACT><DT>\n", ndx);
+			(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		    }
+		    prev_ndx = ndx;
+		}
+	    } else {
+		HTSprintf0(&buf, "<DD>%s\n", rcode);
+		(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		continue;
+	    }
+	    if ((*rcode >= '2') && (*rcode <= '5') && (fname != ndx_str)) {
+		while (*fname == ' ') {
+		    fname++;	/* trim leading spaces */
+		}
+		for (fvalue = fname; *fvalue; fvalue++) {
+		    if (*fvalue == ':') {
+			*fvalue++ = '\0';
+			i = (int) strlen(fname) - 1;
+			while (i >= 0 && fname[i] == ' ') {
+			    fname[i--] = '\0';	/* trim trailing */
+			}
+			break;
+		    }
+		}
+		if (fvalue) {
+		    while (*fvalue == ' ') {
+			fvalue++;	/* trim leading spaces */
+		    }
+		}
+		if (*fname) {
+		    for (fld = CSOfields; fld; fld = fld->next) {
+			if (!strcmp(fld->name, fname)) {
+			    if (fld->description) {
+				fname = fld->description;
+			    }
+			    break;
+			}
+		    }
+		    if (fld && fld->url) {
+			HTSprintf0(&buf,
+				   "<DT><I>%s</I><DD><A HREF=\"%s\">%s</A>\n",
+				   fname, fvalue, fvalue);
+			(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		    } else {
+			HTSprintf0(&buf, "<DT><I>%s</I><DD>", fname);
+			(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+			buf[0] = '\0';
+			l = fvalue;
+			while (*l) {
+			    if (*l == '<') {
+				StrAllocCat(buf, "&lt;");
+				l++;
+			    } else if (*l == '>') {
+				StrAllocCat(buf, "&gt;");
+				l++;
+			    } else if (StrNCmp(l, STR_NEWS_URL, LEN_NEWS_URL) &&
+				       StrNCmp(l, "snews://", 8) &&
+				       StrNCmp(l, "nntp://", 7) &&
+				       StrNCmp(l, "snewspost:", 10) &&
+				       StrNCmp(l, "snewsreply:", 11) &&
+				       StrNCmp(l, "newspost:", 9) &&
+				       StrNCmp(l, "newsreply:", 10) &&
+				       StrNCmp(l, "ftp://", 6) &&
+				       StrNCmp(l, "file:/", 6) &&
+				       StrNCmp(l, "finger://", 9) &&
+				       StrNCmp(l, "http://", 7) &&
+				       StrNCmp(l, "https://", 8) &&
+				       StrNCmp(l, "wais://", 7) &&
+				       StrNCmp(l, STR_MAILTO_URL,
+					       LEN_MAILTO_URL) &&
+				       StrNCmp(l, "cso://", 6) &&
+				       StrNCmp(l, "gopher://", 9)) {
+				HTSprintf(&buf, "%c", *l++);
+			    } else {
+				StrAllocCat(buf, "<a href=\"");
+				StrAllocCopy(href, l);
+				StrAllocCat(buf, strtok(href, " \r\n\t,>)\""));
+				StrAllocCat(buf, "\">");
+				while (*l && !StrChr(" \r\n\t,>)\"", *l)) {
+				    HTSprintf(&buf, "%c", *l++);
+				}
+				StrAllocCat(buf, "</a>");
+				FREE(href);
+			    }
+			}
+			StrAllocCat(buf, "\n");
+			(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		    }
+		} else {
+		    HTSprintf0(&buf, "<DD>");
+		    (*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		    buf[0] = '\0';
+		    l = fvalue;
+		    while (*l) {
+			if (*l == '<') {
+			    StrAllocCat(buf, "&lt;");
+			    l++;
+			} else if (*l == '>') {
+			    StrAllocCat(buf, "&gt;");
+			    l++;
+			} else if (StrNCmp(l, STR_NEWS_URL, LEN_NEWS_URL) &&
+				   StrNCmp(l, "snews://", 8) &&
+				   StrNCmp(l, "nntp://", 7) &&
+				   StrNCmp(l, "snewspost:", 10) &&
+				   StrNCmp(l, "snewsreply:", 11) &&
+				   StrNCmp(l, "newspost:", 9) &&
+				   StrNCmp(l, "newsreply:", 10) &&
+				   StrNCmp(l, "ftp://", 6) &&
+				   StrNCmp(l, "file:/", 6) &&
+				   StrNCmp(l, "finger://", 9) &&
+				   StrNCmp(l, "http://", 7) &&
+				   StrNCmp(l, "https://", 8) &&
+				   StrNCmp(l, "wais://", 7) &&
+				   StrNCmp(l, STR_MAILTO_URL, LEN_MAILTO_URL) &&
+				   StrNCmp(l, "cso://", 6) &&
+				   StrNCmp(l, "gopher://", 9)) {
+			    HTSprintf(&buf, "%c", *l++);
+			} else {
+			    StrAllocCat(buf, "<a href=\"");
+			    StrAllocCopy(href, l);
+			    StrAllocCat(buf, strtok(href, " \r\n\t,>)\""));
+			    StrAllocCat(buf, "\">");
+			    while (*l && !StrChr(" \r\n\t,>)\"", *l)) {
+				HTSprintf(&buf, "%c", *l++);
+			    }
+			    StrAllocCat(buf, "</a>");
+			    FREE(href);
+			}
+		    }
+		    StrAllocCat(buf, "\n");
+		    (*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+		}
+	    } else {
+		HTSprintf0(&buf, "<DD>%s\n", fname);
+		(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+	    }
+	}
+    }
+  end_CSOreport:
+    if (prev_ndx != -100) {
+	HTSprintf0(&buf, "</DL></DL>\n");
+	(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+    }
+    FREE(buf);
+    return 0;
+}
+
+/*	CSO/PH form-based search gateway - FM			HTLoadCSO
+ *	=====================================
+ */
+static int HTLoadCSO(const char *arg,
+		     HTParentAnchor *anAnchor,
+		     HTFormat format_out,
+		     HTStream *sink)
+{
+    static const char end_form[] = "</BODY>\n</HTML>\n";
+    char *host, *cp, *data;
+    int port = CSO_PORT;
+    int status;			/* tcp return */
+    bstring *command = NULL;
+    bstring *content = NULL;
+    int len, i, j, start, finish, flen, ndx;
+    int return_type, has_indexed;
+    CSOfield_info *fld;
+    char buf[2048];
+    HTFormat format_in = WWW_HTML;
+    HTStream *Target = NULL;
+
+    if (!acceptable_inited)
+	init_acceptable();
+
+    if (!arg)
+	return -3;		/* Bad if no name specified     */
+    if (!*arg)
+	return -2;		/* Bad if name had zero length  */
+    CTRACE((tfp, "HTLoadCSO: Looking for %s\n", arg));
+
+    /*
+     * Set up a socket to the server for the data.
+     */
+    status = HTDoConnect(arg, "cso", CSO_PORT, &s);
+    if (status == HT_INTERRUPTED) {
+	/*
+	 * Interrupt cleanly.
+	 */
+	CTRACE((tfp,
+		"HTLoadCSO: Interrupted on connect; recovering cleanly.\n"));
+	_HTProgress(CONNECTION_INTERRUPTED);
+	return HT_NOT_LOADED;
+    }
+    if (status < 0) {
+	CTRACE((tfp, "HTLoadCSO: Unable to connect to remote host for `%s'.\n",
+		arg));
+	return HTInetStatus("connect");
+    }
+
+    HTInitInput(s);		/* Set up input buffering */
+
+    HTBprintf(&command, "fields%c%c", CR, LF);
+    if (TRACE) {
+	CTRACE((tfp, "HTLoadCSO: Connected, writing command `"));
+	trace_bstring(command);
+	CTRACE((tfp, "' to socket %d\n", s));
+    }
+    _HTProgress(GOPHER_SENDING_CSO_REQUEST);
+    status = (int) NETWRITE(s, BStrData(command), BStrLen(command));
+    BStrFree(command);
+    if (status < 0) {
+	CTRACE((tfp, "HTLoadCSO: Unable to send command.\n"));
+	return HTInetStatus("send");
+    }
+    _HTProgress(GOPHER_SENT_CSO_REQUEST);
+
+    /*
+     * Now read the data from the socket.
+     */
+    status = parse_cso_fields(buf, sizeof(buf));
+    if (status) {
+	NETCLOSE(s);
+	if (status == HT_INTERRUPTED) {
+	    _HTProgress(CONNECTION_INTERRUPTED);
+	} else if (buf[0] != '\0') {
+	    HTAlert(buf);
+	} else {
+	    HTAlert(FAILED_NO_RESPONSE);
+	}
+	return HT_NOT_LOADED;
+    }
+    Target = HTStreamStack(format_in,
+			   format_out,
+			   sink, anAnchor);
+    if (Target == NULL) {
+	char *temp = 0;
+
+	HTSprintf0(&temp, CANNOT_CONVERT_I_TO_O,
+		   HTAtom_name(format_in), HTAtom_name(format_out));
+	HTAlert(temp);
+	FREE(temp);
+	NETCLOSE(s);
+	return HT_NOT_LOADED;
+    }
+    host = HTParse(arg, "", PARSE_HOST);
+    if ((cp = HTParsePort(host, &port)) != NULL) {
+	if (port == CSO_PORT) {
+	    *cp = '\0';
+	}
+    }
+    anAnchor->safe = TRUE;
+    if (isBEmpty(anAnchor->post_data)) {
+	generate_cso_form(host, port, buf, sizeof(buf), Target);
+	(*Target->isa->_free) (Target);
+	FREE(host);
+	NETCLOSE(s);
+	free_CSOfields();
+	return HT_LOADED;
+    }
+
+    HTBprintf(&command,
+	      "<HTML>\n<HEAD>\n<TITLE>CSO/PH Results on %s</TITLE>\n</HEAD>\n<BODY>\n",
+	      host);
+    (*Target->isa->put_block) (Target, BStrData(command), BStrLen(command));
+    BStrFree(command);
+    FREE(host);
+
+    BStrCopy(content, anAnchor->post_data);
+    assert(content != NULL);
+
+    if (BStrData(content)[BStrLen(content) - 1] != '&')
+	BStrCat0(content, "&");
+
+    data = BStrData(content);
+    len = BStrLen(content);
+    for (i = 0; i < len; i++) {
+	if (data[i] == '+') {
+	    data[i] = ' ';
+	}
+    }
+
+    data = BStrData(content);
+    HTUnEscape(data);		/* FIXME: could it have embedded null? */
+    len = BStrLen(content);
+
+    return_type = 0;
+    has_indexed = 0;
+    start = 0;
+    for (i = 0; i < len; i++) {
+	if (!data[i] || data[i] == '&') {
+	    /*
+	     * Value parsed.  Unescape characters and look for first '=' to
+	     * delimit field name from value.
+	     */
+	    flen = i - start;
+	    finish = start + flen;
+	    data[finish] = '\0';
+	    for (j = start; j < finish; j++) {
+		if (data[j] == '=') {
+		    /*
+		     * data[start..j-1] is field name,
+		     * [j+1..finish-1] is value.
+		     */
+		    if ((data[start + 1] == '_') &&
+			((data[start] == 'r') || (data[start] == 'q'))) {
+			/*
+			 * Decode fields number and lookup field info.
+			 */
+			sscanf(&data[start + 2], "%d=", &ndx);
+			for (fld = CSOfields; fld; fld = fld->next) {
+			    if (ndx == fld->id) {
+				if ((j + 1) >= finish)
+				    break;	/* ignore nulls */
+				if (data[start] == 'q') {
+				    /*
+				     * Append field to query line.
+				     */
+				    if (fld->lookup) {
+					if (fld->indexed)
+					    has_indexed = 1;
+					if (isBEmpty(command)) {
+					    BStrCopy0(command, "query ");
+					} else {
+					    BStrCat0(command, " ");
+					}
+					HTBprintf(&command, "%s=\"%s\"",
+						  fld->name, &data[j + 1]);
+				    } else {
+					strcpy(buf,
+					       "Warning: non-lookup field ignored<BR>\n");
+					(*Target->isa->put_block) (Target,
+								   buf,
+								   (int)
+								   strlen(buf));
+				    }
+				} else if (data[start] == 'r') {
+				    fld->explicit_return = 1;
+				}
+				break;
+			    }
+			}
+		    } else if (!StrNCmp(&data[start], "return=", 7)) {
+			if (!strcmp(&data[start + 7], "all")) {
+			    return_type = 1;
+			} else if (!strcmp(&data[start + 7], "selected")) {
+			    return_type = 2;
+			}
+		    }
+		}
+	    }
+	    start = i + 1;
+	}
+    }
+    BStrFree(content);
+    if (isBEmpty(command) || !has_indexed) {
+	NETCLOSE(s);
+	strcpy(buf,
+	       "<EM>Error:</EM> At least one indexed field value must be specified!\n");
+	(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+	strcpy(buf, "</BODY>\n</HTML>\n");
+	(*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+	(*Target->isa->_free) (Target);
+	free_CSOfields();
+	BStrFree(command);
+	return HT_LOADED;
+    }
+    /*
+     * Append return fields.
+     */
+    if (return_type == 1) {
+	BStrCat0(command, " return all");
+    } else if (return_type == 2) {
+	BStrCat0(command, " return");
+	for (fld = CSOfields; fld; fld = fld->next) {
+	    if (fld->explicit_return) {
+		HTBprintf(&command, " %s", fld->name);
+	    }
+	}
+    }
+    HTBprintf(&command, "%c%c", CR, LF);
+    strcpy(buf, "<H2>\n<EM>CSO/PH command:</EM> ");
+    (*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+    (*Target->isa->put_block) (Target, BStrData(command), BStrLen(command));
+    strcpy(buf, "</H2>\n");
+    (*Target->isa->put_block) (Target, buf, (int) strlen(buf));
+    if (TRACE) {
+	CTRACE((tfp, "HTLoadCSO: Writing command `"));
+	trace_bstring(command);
+	CTRACE((tfp, "' to socket %d\n", s));
+    }
+    status = (int) NETWRITE(s, BStrData(command), BStrLen(command));
+    BStrFree(command);
+    if (status < 0) {
+	CTRACE((tfp, "HTLoadCSO: Unable to send command.\n"));
+	free_CSOfields();
+	return HTInetStatus("send");
+    }
+    generate_cso_report(Target);
+    NETCLOSE(s);
+    (*Target->isa->put_block) (Target, end_form, (int) sizeof(end_form) - 1);
+    (*Target->isa->_free) (Target);
+    FREE(host);
+    free_CSOfields();
+    return HT_LOADED;
+}
+
+static char *link_to_URL(const char *arg)
+{
+    char *result;
+    char *next;
+    char *temp = 0;
+
+    StrAllocCopy(temp, arg);
+    HTUnEscape(temp);
+    result = temp;
+
+    /* skip past method://host */
+    if ((next = strstr(result, "://")) != 0) {
+	result = next + 3;
+    }
+    if ((next = strchr(result, '/')) != 0) {
+	result = next + 1;
+    }
+    /* check if the selector is the special html one */
+    if (!strncmp(result, "hURL:", (size_t) 5)) {
+	result += 5;
+	next = result;
+	result = temp;
+	while ((*temp++ = *next++) != 0) ;
+    } else {
+	FREE(temp);
+	result = 0;
+    }
+    return result;
+}
+
+/*	Load by name.						HTLoadGopher
+ *	=============
+ *
+ */
+static int HTLoadGopher(const char *arg,
+			HTParentAnchor *anAnchor,
+			HTFormat format_out,
+			HTStream *sink)
+{
+    char *hURL;
+    char *command;		/* The whole command */
+    int status;			/* tcp return */
+    char gtype;			/* Gopher Node type */
+    char *selector;		/* Selector string */
+
+    if (!acceptable_inited)
+	init_acceptable();
+
+    if (!arg)
+	return -3;		/* Bad if no name specified     */
+    if (!*arg)
+	return -2;		/* Bad if name had zero length  */
+    CTRACE((tfp, "HTGopher: Looking for %s\n", arg));
+
+    /*
+     * If it's a port 105 GOPHER_CSO gtype with no ISINDEX token ('?'), use the
+     * form-based CSO gateway (otherwise, return an ISINDEX cover page or do
+     * the ISINDEX search).  - FM
+     */
+    {
+	size_t len;
+
+	if ((len = strlen(arg)) > 5) {
+	    if (0 == strcmp((const char *) &arg[len - 6], ":105/2")) {
+		/* Use CSO gateway. */
+		CTRACE((tfp, "HTGopher: Passing to CSO/PH gateway.\n"));
+		return HTLoadCSO(arg, anAnchor, format_out, sink);
+	    }
+	}
+    }
+
+    /*
+     * If it's a port 79/0[/...] URL, use the finger gateway.  - FM
+     */
+    if (strstr(arg, ":79/0") != NULL) {
+#ifndef DISABLE_FINGER
+	CTRACE((tfp, "HTGopher: Passing to finger gateway.\n"));
+	return HTLoadFinger(arg, anAnchor, format_out, sink);
+#else /* finger is disabled */
+	HTAlert(COULD_NOT_ACCESS_DOCUMENT);
+	return HT_NOT_LOADED;
+#endif /* DISABLE_FINGER */
+    }
+
+    /*
+     * Get entity type, and selector string.
+     */
+    {
+	char *p1 = HTParse(arg, "", PARSE_PATH | PARSE_PUNCTUATION);
+
+	gtype = '1';		/* Default = menu */
+	selector = p1;
+	if ((*selector++ == '/') && (*selector)) {	/* Skip first slash */
+	    gtype = *selector++;	/* Pick up gtype */
+	}
+	if (gtype == GOPHER_INDEX) {
+	    char *query;
+
+	    /*
+	     * Search is allowed.
+	     */
+	    HTAnchor_setIndex(anAnchor, anAnchor->address);
+	    query = StrChr(selector, '?');	/* Look for search string */
+	    if (!query || !query[1]) {	/* No search required */
+		target = HTML_new(anAnchor, format_out, sink);
+		targetClass = *target->isa;
+		display_index(arg, anAnchor);	/* Display "cover page" */
+		return HT_LOADED;	/* Local function only */
+	    }
+	    *query++ = '\0';	/* Skip '?'     */
+	    command =
+		(char *) malloc(strlen(selector) + 1 + strlen(query) + 2 + 1);
+	    if (command == NULL)
+		outofmem(__FILE__, "HTLoadGopher");
+
+	    de_escape(command, selector);	/* Bug fix TBL 921208 */
+
+	    strcat(command, "\t");
+
+	    {			/* Remove plus signs 921006 */
+		char *p;
+
+		for (p = query; *p; p++) {
+		    if (*p == '+')
+			*p = ' ';
+		}
+	    }
+
+	    de_escape(&command[strlen(command)], query);	/* bug fix LJM 940415 */
+	} else if (gtype == GOPHER_CSO) {
+	    char *query;
+
+	    /*
+	     * Search is allowed.
+	     */
+	    query = StrChr(selector, '?');	/* Look for search string */
+	    if (!query || !query[1]) {	/* No search required */
+		target = HTML_new(anAnchor, format_out, sink);
+		targetClass = *target->isa;
+		display_cso(arg, anAnchor);	/* Display "cover page" */
+		return HT_LOADED;	/* Local function only */
+	    }
+	    HTAnchor_setIndex(anAnchor, anAnchor->address);
+	    *query++ = '\0';	/* Skip '?'     */
+	    command = (char *) malloc(strlen("query") + 1 +
+				      strlen(query) + 2 + 1);
+	    if (command == NULL)
+		outofmem(__FILE__, "HTLoadGopher");
+
+	    de_escape(command, selector);	/* Bug fix TBL 921208 */
+
+	    strcpy(command, "query ");
+
+	    {			/* Remove plus signs 921006 */
+		char *p;
+
+		for (p = query; *p; p++) {
+		    if (*p == '+')
+			*p = ' ';
+		}
+	    }
+	    de_escape(&command[strlen(command)], query);	/* bug fix LJM 940415 */
+
+	} else {		/* Not index */
+	    command = (char *) malloc(strlen(selector) + 2 + 1);
+	    if (command == NULL)
+		outofmem(__FILE__, "HTLoadGopher");
+
+	    de_escape(command, selector);
+	}
+	FREE(p1);
+    }
+
+    {
+	char *p = command + strlen(command);
+
+	*p++ = CR;		/* Macros to be correct on Mac */
+	*p++ = LF;
+	*p = '\0';
+    }
+    /*
+     * Check for link to URL
+     */
+    if ((hURL = link_to_URL(arg)) != 0) {
+	CTRACE((tfp, "gopher found link to URL '%s'\n", hURL));
+	free(hURL);
+    }
+
+    /*
+     * Set up a socket to the server for the data.
+     */
+    status = HTDoConnect(arg, "gopher", GOPHER_PORT, &s);
+    if (status == HT_INTERRUPTED) {
+	/*
+	 * Interrupt cleanly.
+	 */
+	CTRACE((tfp, "HTGopher: Interrupted on connect; recovering cleanly.\n"));
+	_HTProgress(CONNECTION_INTERRUPTED);
+	FREE(command);
+	return HT_NOT_LOADED;
+    }
+    if (status < 0) {
+	CTRACE((tfp, "HTGopher: Unable to connect to remote host for `%s'.\n",
+		arg));
+	FREE(command);
+	return HTInetStatus("connect");
+    }
+
+    HTInitInput(s);		/* Set up input buffering */
+
+    CTRACE((tfp, "HTGopher: Connected, writing command `%s' to socket %d\n",
+	    command, s));
+
+#ifdef NOT_ASCII
+    {
+	char *p;
+
+	for (p = command; *p; p++) {
+	    *p = TOASCII(*p);
+	}
+    }
+#endif
+
+    _HTProgress(GOPHER_SENDING_REQUEST);
+
+    status = (int) NETWRITE(s, command, (int) strlen(command));
+    FREE(command);
+    if (status < 0) {
+	CTRACE((tfp, "HTGopher: Unable to send command.\n"));
+	return HTInetStatus("send");
+    }
+
+    _HTProgress(GOPHER_SENT_REQUEST);
+
+    /*
+     * Now read the data from the socket.
+     */
+    switch (gtype) {
+
+    case GOPHER_TEXT:
+	HTParseSocket(WWW_PLAINTEXT, format_out, anAnchor, s, sink);
+	break;
+
+    case GOPHER_HTML:
+    case GOPHER_CHTML:
+	HTParseSocket(WWW_HTML, format_out, anAnchor, s, sink);
+	break;
+
+    case GOPHER_GIF:
+    case GOPHER_IMAGE:
+    case GOPHER_PLUS_IMAGE:
+	HTParseSocket(HTAtom_for("image/gif"),
+		      format_out, anAnchor, s, sink);
+	break;
+
+    case GOPHER_MENU:
+    case GOPHER_INDEX:
+	target = HTML_new(anAnchor, format_out, sink);
+	targetClass = *target->isa;
+	parse_menu(arg, anAnchor);
+	break;
+
+    case GOPHER_CSO:
+	target = HTML_new(anAnchor, format_out, sink);
+	targetClass = *target->isa;
+	parse_cso(arg, anAnchor);
+	break;
+
+    case GOPHER_SOUND:
+    case GOPHER_PLUS_SOUND:
+	HTParseSocket(WWW_AUDIO, format_out, anAnchor, s, sink);
+	break;
+
+    case GOPHER_PLUS_MOVIE:
+	HTParseSocket(HTAtom_for("video/mpeg"), format_out, anAnchor, s, sink);
+	break;
+
+    case GOPHER_PLUS_PDF:
+	HTParseSocket(HTAtom_for("application/pdf"), format_out, anAnchor,
+		      s, sink);
+	break;
+
+    default:
+	{
+	    HTAtom *encoding = 0;
+	    const char *desc = 0;
+	    HTFormat format = HTFileFormat(arg, &encoding, &desc);
+
+	    /*
+	     * Ignore WWW_BINARY (since that is returned by HTFileFormat when
+	     * it does not have a representation), but otherwise use the
+	     * result.
+	     */
+	    if (format != WWW_BINARY) {
+		HTParseSocket(format, format_out, anAnchor, s, sink);
+		break;
+	    }
+	}
+	/* FALL-THRU */
+
+    case GOPHER_MACBINHEX:
+    case GOPHER_PCBINARY:
+    case GOPHER_UUENCODED:
+    case GOPHER_BINARY:
+	/*
+	 * Specifying WWW_UNKNOWN forces dump to local disk.
+	 */
+	HTParseSocket(WWW_UNKNOWN, format_out, anAnchor, s, sink);
+	break;
+
+    }				/* switch(gtype) */
+
+    NETCLOSE(s);
+    return HT_LOADED;
+}
+
+#ifdef GLOBALDEF_IS_MACRO
+#define _HTGOPHER_C_1_INIT { "gopher", HTLoadGopher, NULL }
+GLOBALDEF(HTProtocol, HTGopher, _HTGOPHER_C_1_INIT);
+#define _HTCSO_C_1_INIT { "cso", HTLoadCSO, NULL }
+GLOBALDEF(HTProtocol, HTCSO, _HTCSO_C_1_INIT);
+#else
+GLOBALDEF HTProtocol HTGopher =
+{"gopher", HTLoadGopher, NULL};
+GLOBALDEF HTProtocol HTCSO =
+{"cso", HTLoadCSO, NULL};
+#endif /* GLOBALDEF_IS_MACRO */
+
+#endif /* not DISABLE_GOPHER */
diff --git a/WWW/Library/Implementation/HTGopher.h b/WWW/Library/Implementation/HTGopher.h
new file mode 100644
index 0000000..667fc24
--- /dev/null
+++ b/WWW/Library/Implementation/HTGopher.h
@@ -0,0 +1,29 @@
+/*                                                          Gopher protocol module for libwww
+                                      GOPHER ACCESS
+                                             
+  HISTORY:
+  
+  8 Jan 92               Adapted from HTTP TBL
+                         
+ */
+
+#ifndef HTGOPHER_H
+#define HTGOPHER_H
+
+#include <HTAccess.h>
+#include <HTAnchor.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef GLOBALREF_IS_MACRO
+    extern GLOBALREF (HTProtocol, HTGopher);
+
+#else
+    GLOBALREF HTProtocol HTGopher;
+#endif				/* GLOBALREF_IS_MACRO */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTGOPHER_H */
diff --git a/WWW/Library/Implementation/HTGroup.c b/WWW/Library/Implementation/HTGroup.c
new file mode 100644
index 0000000..42d55dc
--- /dev/null
+++ b/WWW/Library/Implementation/HTGroup.c
@@ -0,0 +1,758 @@
+/* MODULE							HTGroup.c
+ *		GROUP FILE ROUTINES
+ *
+ *	Contains group file parser and routines to match IP
+ *	address templates and to find out group membership.
+ *
+ *
+ * AUTHORS:
+ *	AL	Ari Luotonen	luotonen@dxcern.cern.ch
+ *
+ * HISTORY:
+ *
+ *
+ * BUGS:
+ *
+ *
+ *
+ * GROUP DEFINITION GRAMMAR:
+ *
+ *	string = "sequence of alphanumeric characters"
+ *	user_name ::= string
+ *	group_name ::= string
+ *	group_ref ::= group_name
+ *	user_def ::= user_name | group_ref
+ *	user_def_list ::= user_def { ',' user_def }
+ *	user_part = user_def | '(' user_def_list ')'
+ *
+ *	templ = "sequence of alphanumeric characters and '*'s"
+ *	ip_number_mask ::= templ '.' templ '.' templ '.' templ
+ *	domain_name_mask ::= templ { '.' templ }
+ *	address ::= ip_number_mask | domain_name_mask
+ *	address_def ::= address
+ *	address_def_list ::= address_def { ',' address_def }
+ *	address_part = address_def | '(' address_def_list ')'
+ *
+ *	item ::= [user_part] ['@' address_part]
+ *	item_list ::= item { ',' item }
+ *	group_def ::= item_list
+ *	group_decl ::= group_name ':' group_def
+ *
+ */
+
+#include <HTUtils.h>
+
+#include <HTAAUtil.h>
+#include <HTLex.h>		/* Lexical analysor     */
+#include <HTGroup.h>		/* Implemented here     */
+
+#include <LYUtils.h>
+#include <LYLeaks.h>
+
+/*
+ * Group file parser
+ */
+
+typedef HTList UserDefList;
+typedef HTList AddressDefList;
+
+typedef struct {
+    UserDefList *user_def_list;
+    AddressDefList *address_def_list;
+} Item;
+
+typedef struct {
+    char *name;
+    GroupDef *translation;
+} Ref;
+
+static void syntax_error(FILE *fp, const char *msg,
+			 LexItem lex_item)
+{
+    char buffer[41];
+    int cnt = 0;
+    int ch;
+
+    while ((ch = getc(fp)) != EOF && ch != '\n')
+	if (cnt < 40)
+	    buffer[cnt++] = (char) ch;
+    buffer[cnt] = (char) 0;
+
+    CTRACE((tfp, "%s %d before: '%s'\nHTGroup.c: %s (got %s)\n",
+	    "HTGroup.c: Syntax error in rule file at line",
+	    HTlex_line, buffer, msg, lex_verbose(lex_item)));
+    HTlex_line++;
+}
+
+static AddressDefList *parse_address_part(FILE *fp)
+{
+    AddressDefList *address_def_list = NULL;
+    LexItem lex_item;
+    BOOL only_one = NO;
+
+    lex_item = lex(fp);
+    if (lex_item == LEX_ALPH_STR || lex_item == LEX_TMPL_STR)
+	only_one = YES;
+    else if (lex_item != LEX_OPEN_PAREN ||
+	     ((lex_item = lex(fp)) != LEX_ALPH_STR &&
+	      lex_item != LEX_TMPL_STR)) {
+	syntax_error(fp, "Expecting a single address or '(' beginning list",
+		     lex_item);
+	return NULL;
+    }
+    address_def_list = HTList_new();
+
+    for (;;) {
+	Ref *ref = typecalloc(Ref);
+
+	if (ref == NULL)
+	    outofmem(__FILE__, "parse_address_part");
+
+	ref->name = NULL;
+	ref->translation = NULL;
+	StrAllocCopy(ref->name, HTlex_buffer);
+
+	HTList_addObject(address_def_list, (void *) ref);
+
+	if (only_one || (lex_item = lex(fp)) != LEX_ITEM_SEP)
+	    break;
+	/*
+	 * Here lex_item == LEX_ITEM_SEP; after item separator it
+	 * is ok to have one or more newlines (LEX_REC_SEP) and
+	 * they are ignored (continuation line).
+	 */
+	do {
+	    lex_item = lex(fp);
+	} while (lex_item == LEX_REC_SEP);
+
+	if (lex_item != LEX_ALPH_STR && lex_item != LEX_TMPL_STR) {
+	    syntax_error(fp, "Expecting an address template", lex_item);
+	    HTList_delete(address_def_list);
+	    address_def_list = NULL;
+	    return NULL;
+	}
+    }
+
+    if (!only_one && lex_item != LEX_CLOSE_PAREN) {
+	HTList_delete(address_def_list);
+	address_def_list = NULL;
+	syntax_error(fp, "Expecting ')' closing address list", lex_item);
+	return NULL;
+    }
+    return address_def_list;
+}
+
+static UserDefList *parse_user_part(FILE *fp)
+{
+    UserDefList *user_def_list = NULL;
+    LexItem lex_item;
+    BOOL only_one = NO;
+
+    lex_item = lex(fp);
+    if (lex_item == LEX_ALPH_STR)
+	only_one = YES;
+    else if (lex_item != LEX_OPEN_PAREN ||
+	     (lex_item = lex(fp)) != LEX_ALPH_STR) {
+	syntax_error(fp, "Expecting a single name or '(' beginning list",
+		     lex_item);
+	return NULL;
+    }
+    user_def_list = HTList_new();
+
+    for (;;) {
+	Ref *ref = typecalloc(Ref);
+
+	if (ref == NULL)
+	    outofmem(__FILE__, "parse_user_part");
+
+	ref->name = NULL;
+	ref->translation = NULL;
+	StrAllocCopy(ref->name, HTlex_buffer);
+
+	HTList_addObject(user_def_list, (void *) ref);
+
+	if (only_one || (lex_item = lex(fp)) != LEX_ITEM_SEP)
+	    break;
+	/*
+	 * Here lex_item == LEX_ITEM_SEP; after item separator it
+	 * is ok to have one or more newlines (LEX_REC_SEP) and
+	 * they are ignored (continuation line).
+	 */
+	do {
+	    lex_item = lex(fp);
+	} while (lex_item == LEX_REC_SEP);
+
+	if (lex_item != LEX_ALPH_STR) {
+	    syntax_error(fp, "Expecting user or group name", lex_item);
+	    HTList_delete(user_def_list);
+	    user_def_list = NULL;
+	    return NULL;
+	}
+    }
+
+    if (!only_one && lex_item != LEX_CLOSE_PAREN) {
+	HTList_delete(user_def_list);
+	user_def_list = NULL;
+	syntax_error(fp, "Expecting ')' closing user/group list", lex_item);
+	return NULL;
+    }
+    return user_def_list;
+}
+
+static Item *parse_item(FILE *fp)
+{
+    Item *item = NULL;
+    UserDefList *user_def_list = NULL;
+    AddressDefList *address_def_list = NULL;
+    LexItem lex_item;
+
+    lex_item = lex(fp);
+    if (lex_item == LEX_ALPH_STR || lex_item == LEX_OPEN_PAREN) {
+	unlex(lex_item);
+	user_def_list = parse_user_part(fp);
+	lex_item = lex(fp);
+    }
+
+    if (lex_item == LEX_AT_SIGN) {
+	lex_item = lex(fp);
+	if (lex_item == LEX_ALPH_STR || lex_item == LEX_TMPL_STR ||
+	    lex_item == LEX_OPEN_PAREN) {
+	    unlex(lex_item);
+	    address_def_list = parse_address_part(fp);
+	} else {
+	    if (user_def_list) {
+		HTList_delete(user_def_list);	/* @@@@ */
+		user_def_list = NULL;
+	    }
+	    syntax_error(fp, "Expected address part (single address or list)",
+			 lex_item);
+	    return NULL;
+	}
+    } else
+	unlex(lex_item);
+
+    if (!user_def_list && !address_def_list) {
+	syntax_error(fp, "Empty item not allowed", lex_item);
+	return NULL;
+    }
+    item = typecalloc(Item);
+    if (item == NULL)
+	outofmem(__FILE__, "parse_item");
+
+    item->user_def_list = user_def_list;
+    item->address_def_list = address_def_list;
+    return item;
+}
+
+static ItemList *parse_item_list(FILE *fp)
+{
+    ItemList *item_list = HTList_new();
+    Item *item;
+    LexItem lex_item;
+
+    for (;;) {
+	if (!(item = parse_item(fp))) {
+	    HTList_delete(item_list);	/* @@@@ */
+	    item_list = NULL;
+	    return NULL;
+	}
+	HTList_addObject(item_list, (void *) item);
+	lex_item = lex(fp);
+	if (lex_item != LEX_ITEM_SEP) {
+	    unlex(lex_item);
+	    return item_list;
+	}
+	/*
+	 * Here lex_item == LEX_ITEM_SEP; after item separator it
+	 * is ok to have one or more newlines (LEX_REC_SEP) and
+	 * they are ignored (continuation line).
+	 */
+	do {
+	    lex_item = lex(fp);
+	} while (lex_item == LEX_REC_SEP);
+	unlex(lex_item);
+    }
+}
+
+GroupDef *HTAA_parseGroupDef(FILE *fp)
+{
+    ItemList *item_list = NULL;
+    GroupDef *group_def = NULL;
+    LexItem lex_item;
+
+    if (!(item_list = parse_item_list(fp))) {
+	return NULL;
+    }
+    group_def = typecalloc(GroupDef);
+    if (group_def == NULL)
+	outofmem(__FILE__, "HTAA_parseGroupDef");
+
+    group_def->group_name = NULL;
+    group_def->item_list = item_list;
+
+    if ((lex_item = lex(fp)) != LEX_REC_SEP) {
+	syntax_error(fp, "Garbage after group definition", lex_item);
+    }
+
+    return group_def;
+}
+
+#if 0
+static GroupDef *parse_group_decl(FILE *fp)
+{
+    char *group_name = NULL;
+    GroupDef *group_def = NULL;
+    LexItem lex_item;
+
+    do {
+	lex_item = lex(fp);
+    } while (lex_item == LEX_REC_SEP);	/* Ignore empty lines */
+
+    if (lex_item != LEX_ALPH_STR) {
+	if (lex_item != LEX_EOF)
+	    syntax_error(fp, "Expecting group name", lex_item);
+	return NULL;
+    }
+    StrAllocCopy(group_name, HTlex_buffer);
+
+    if (LEX_FIELD_SEP != (lex_item = lex(fp))) {
+	syntax_error(fp, "Expecting field separator", lex_item);
+	FREE(group_name);
+	return NULL;
+    }
+
+    if (!(group_def = HTAA_parseGroupDef(fp))) {
+	FREE(group_name);
+	return NULL;
+    }
+    group_def->group_name = group_name;
+
+    return group_def;
+}
+
+/*
+ * Group manipulation routines
+ */
+
+static GroupDef *find_group_def(GroupDefList *group_list,
+				const char *group_name)
+{
+    if (group_list && group_name) {
+	GroupDefList *cur = group_list;
+	GroupDef *group_def;
+
+	while (NULL != (group_def = (GroupDef *) HTList_nextObject(cur))) {
+	    if (!strcmp(group_name, group_def->group_name)) {
+		return group_def;
+	    }
+	}
+    }
+    return NULL;
+}
+
+void HTAA_resolveGroupReferences(GroupDef *group_def,
+				 GroupDefList *group_def_list)
+{
+    if (group_def && group_def->item_list && group_def_list) {
+	ItemList *cur1 = group_def->item_list;
+	Item *item;
+
+	while (NULL != (item = (Item *) HTList_nextObject(cur1))) {
+	    UserDefList *cur2 = item->user_def_list;
+	    Ref *ref;
+
+	    while (NULL != (ref = (Ref *) HTList_nextObject(cur2)))
+		ref->translation = find_group_def(group_def_list, ref->name);
+
+	    /* Does NOT translate address_def_list */
+	}
+    }
+}
+
+static void add_group_def(GroupDefList *group_def_list,
+			  GroupDef *group_def)
+{
+    HTAA_resolveGroupReferences(group_def, group_def_list);
+    HTList_addObject(group_def_list, (void *) group_def);
+}
+
+static GroupDefList *parse_group_file(FILE *fp)
+{
+    GroupDefList *group_def_list = HTList_new();
+    GroupDef *group_def;
+
+    while (NULL != (group_def = parse_group_decl(fp)))
+	add_group_def(group_def_list, group_def);
+
+    return group_def_list;
+}
+#endif
+
+/*
+ * Trace functions
+ */
+
+static void print_item(Item *item)
+{
+    if (!item)
+	fprintf(tfp, "\tNULL-ITEM\n");
+    else {
+	UserDefList *cur1 = item->user_def_list;
+	AddressDefList *cur2 = item->address_def_list;
+	Ref *user_ref = (Ref *) HTList_nextObject(cur1);
+	Ref *addr_ref = (Ref *) HTList_nextObject(cur2);
+
+	if (user_ref) {
+	    fprintf(tfp, "\t[%s%s", user_ref->name,
+		    (user_ref->translation ? "*REF*" : ""));
+	    while (NULL != (user_ref = (Ref *) HTList_nextObject(cur1)))
+		fprintf(tfp, "; %s%s", user_ref->name,
+			(user_ref->translation ? "*REF*" : ""));
+	    fprintf(tfp, "] ");
+	} else
+	    fprintf(tfp, "\tANYBODY ");
+
+	if (addr_ref) {
+	    fprintf(tfp, "@ [%s", addr_ref->name);
+	    while (NULL != (addr_ref = (Ref *) HTList_nextObject(cur2)))
+		fprintf(tfp, "; %s", addr_ref->name);
+	    fprintf(tfp, "]\n");
+	} else
+	    fprintf(tfp, "@ ANYADDRESS\n");
+    }
+}
+
+static void print_item_list(ItemList *item_list)
+{
+    ItemList *cur = item_list;
+    Item *item;
+
+    if (!item_list)
+	fprintf(tfp, "EMPTY");
+    else
+	while (NULL != (item = (Item *) HTList_nextObject(cur)))
+	    print_item(item);
+}
+
+void HTAA_printGroupDef(GroupDef *group_def)
+{
+    if (!group_def) {
+	fprintf(tfp, "\nNULL RECORD\n");
+	return;
+    }
+
+    fprintf(tfp, "\nGroup %s:\n",
+	    (group_def->group_name ? group_def->group_name : "NULL"));
+
+    print_item_list(group_def->item_list);
+    fprintf(tfp, "\n");
+}
+
+#if 0
+static void print_group_def_list(GroupDefList *group_list)
+{
+    GroupDefList *cur = group_list;
+    GroupDef *group_def;
+
+    while (NULL != (group_def = (GroupDef *) HTList_nextObject(cur)))
+	HTAA_printGroupDef(group_def);
+}
+
+/*
+ * IP address template matching
+ */
+
+/* static						part_match()
+ *		MATCH ONE PART OF INET ADDRESS AGAINST
+ *		A PART OF MASK (inet address has 4 parts)
+ * ON ENTRY:
+ *	tcur	pointer to the beginning of template part.
+ *	icur	pointer to the beginning of actual inet
+ *		number part.
+ *
+ * ON EXIT:
+ *	returns	YES, if match.
+ */
+static BOOL part_match(const char *tcur,
+		       const char *icur)
+{
+    char required[4];
+    char actual[4];
+    const char *cur;
+    int cnt;
+    BOOL status;
+
+    if (!tcur || !icur)
+	return NO;
+
+    cur = tcur;
+    cnt = 0;
+    while (cnt < 3 && *cur && *cur != '.')
+	required[cnt++] = *(cur++);
+    required[cnt] = (char) 0;
+
+    cur = icur;
+    cnt = 0;
+    while (cnt < 3 && *cur && *cur != '.')
+	actual[cnt++] = *(cur++);
+    actual[cnt] = (char) 0;
+
+    status = HTAA_templateMatch(required, actual);
+    CTRACE((tfp, "part_match: req: '%s' act: '%s' match: %s\n",
+	    required, actual, (status ? "yes" : "no")));
+
+    return status;
+}
+
+/* static						ip_number_match()
+ *		MATCH INET NUMBER AGAINST AN INET NUMBER MASK
+ * ON ENTRY:
+ *	template	mask to match against, e.g., 128.141.*.*
+ *	the_inet_addr	actual inet address, e.g., 128.141.201.74
+ *
+ * ON EXIT:
+ *	returns		YES, if match;  NO, if not.
+ */
+static BOOL ip_number_match(const char *ctemplate,
+			    const char *the_inet_addr)
+{
+    const char *tcur = ctemplate;
+    const char *icur = the_inet_addr;
+    int cnt;
+
+    for (cnt = 0; cnt < 4; cnt++) {
+	if (!tcur || !icur || !part_match(tcur, icur))
+	    return NO;
+	if (NULL != (tcur = StrChr(tcur, '.')))
+	    tcur++;
+	if (NULL != (icur = StrChr(icur, '.')))
+	    icur++;
+    }
+    return YES;
+}
+
+/* static						is_domain_mask()
+ *		DETERMINE IF A GIVEN MASK IS A
+ *		DOMAIN NAME MASK OR AN INET NUMBER MASK
+ * ON ENTRY:
+ *	mask	either a domain name mask,
+ *		e.g.
+ *			*.cern.ch
+ *
+ *		or an inet number mask,
+ *		e.g.
+ *			128.141.*.*
+ *
+ * ON EXIT:
+ *	returns	YES, if mask is a domain name mask.
+ *		NO, if it is an inet number mask.
+ */
+static BOOL is_domain_mask(const char *mask)
+{
+    const char *cur = mask;
+
+    if (!mask)
+	return NO;
+
+    while (*cur) {
+	if (*cur != '.' && *cur != '*' && (*cur < '0' || *cur > '9'))
+	    return YES;		/* Even one non-digit makes it a domain name mask */
+	cur++;
+    }
+    return NO;			/* All digits and dots, so it is an inet number mask */
+}
+
+/* static							ip_mask_match()
+ *		MATCH AN IP NUMBER MASK OR IP NAME MASK
+ *		AGAINST ACTUAL IP NUMBER OR IP NAME
+ *
+ * ON ENTRY:
+ *	mask		mask.  Mask may be either an inet number
+ *			mask or a domain name mask,
+ *			e.g.
+ *				128.141.*.*
+ *			or
+ *				*.cern.ch
+ *
+ *	ip_number	IP number of connecting host.
+ *	ip_name		IP name of the connecting host.
+ *
+ * ON EXIT:
+ *	returns		YES, if hostname/internet number
+ *			matches the mask.
+ *			NO, if no match (no fire).
+ */
+static BOOL ip_mask_match(const char *mask,
+			  const char *ip_number,
+			  const char *ip_name)
+{
+    if (mask && (ip_number || ip_name)) {
+	if (is_domain_mask(mask)) {
+	    if (HTAA_templateMatch(mask, ip_name))
+		return YES;
+	} else {
+	    if (ip_number_match(mask, ip_number))
+		return YES;
+	}
+    }
+    return NO;
+}
+
+static BOOL ip_in_def_list(AddressDefList *address_def_list,
+			   char *ip_number,
+			   char *ip_name)
+{
+    if (address_def_list && (ip_number || ip_name)) {
+	AddressDefList *cur = address_def_list;
+	Ref *ref;
+
+	while (NULL != (ref = (Ref *) HTList_nextObject(cur))) {
+	    /* Value of ref->translation is ignored, i.e., */
+	    /* no recursion for ip address tamplates.     */
+	    if (ip_mask_match(ref->name, ip_number, ip_name))
+		return YES;
+	}
+    }
+    return NO;
+}
+
+/*
+ * Group file cached reading
+ */
+
+typedef struct {
+    char *group_filename;
+    GroupDefList *group_list;
+} GroupCache;
+
+typedef HTList GroupCacheList;
+
+static GroupCacheList *group_cache_list = NULL;
+
+GroupDefList *HTAA_readGroupFile(const char *filename)
+{
+    FILE *fp;
+    GroupCache *group_cache;
+
+    if (isEmpty(filename))
+	return NULL;
+
+    if (!group_cache_list)
+	group_cache_list = HTList_new();
+    else {
+	GroupCacheList *cur = group_cache_list;
+
+	while (NULL != (group_cache = (GroupCache *) HTList_nextObject(cur))) {
+	    if (!strcmp(filename, group_cache->group_filename)) {
+		CTRACE((tfp, "%s '%s' %s\n",
+			"HTAA_readGroupFile: group file",
+			filename, "already found in cache"));
+		return group_cache->group_list;
+	    }			/* if cache match */
+	}			/* while cached files remain */
+    }				/* cache exists */
+
+    CTRACE((tfp, "HTAA_readGroupFile: reading group file `%s'\n",
+	    filename));
+
+    if (!(fp = fopen(filename, TXT_R))) {
+	CTRACE((tfp, "%s '%s'\n",
+		"HTAA_readGroupFile: unable to open group file",
+		filename));
+	return NULL;
+    }
+
+    if ((group_cache = typecalloc(GroupCache)) == 0)
+	outofmem(__FILE__, "HTAA_readGroupFile");
+
+    group_cache->group_filename = NULL;
+    StrAllocCopy(group_cache->group_filename, filename);
+    group_cache->group_list = parse_group_file(fp);
+    HTList_addObject(group_cache_list, (void *) group_cache);
+    fclose(fp);
+
+    CTRACE((tfp, "Read group file '%s', results follow:\n", filename));
+    if (TRACE)
+	print_group_def_list(group_cache->group_list);
+
+    return group_cache->group_list;
+}
+
+/* PUBLIC					HTAA_userAndInetInGroup()
+ *		CHECK IF USER BELONGS TO TO A GIVEN GROUP
+ *		AND THAT THE CONNECTION COMES FROM AN
+ *		ADDRESS THAT IS ALLOWED BY THAT GROUP
+ * ON ENTRY:
+ *	group		the group definition structure.
+ *	username	connecting user.
+ *	ip_number	browser host IP number, optional.
+ *	ip_name		browser host IP name, optional.
+ *			However, one of ip_number or ip_name
+ *			must be given.
+ * ON EXIT:
+ *	returns		HTAA_IP_MASK, if IP address mask was
+ *			reason for failing.
+ *			HTAA_NOT_MEMBER, if user does not belong
+ *			to the group.
+ *			HTAA_OK if both IP address and user are ok.
+ */
+HTAAFailReasonType HTAA_userAndInetInGroup(GroupDef *group,
+					   char *username,
+					   char *ip_number,
+					   char *ip_name)
+{
+    HTAAFailReasonType reason = HTAA_NOT_MEMBER;
+
+    if (group && username) {
+	ItemList *cur1 = group->item_list;
+	Item *item;
+
+	while (NULL != (item = (Item *) HTList_nextObject(cur1))) {
+	    if (!item->address_def_list ||	/* Any address allowed */
+		ip_in_def_list(item->address_def_list, ip_number, ip_name)) {
+
+		if (!item->user_def_list)	/* Any user allowed */
+		    return HTAA_OK;
+		else {
+		    UserDefList *cur2 = item->user_def_list;
+		    Ref *ref;
+
+		    while (NULL != (ref = (Ref *) HTList_nextObject(cur2))) {
+
+			if (ref->translation) {		/* Group, check recursively */
+			    reason = HTAA_userAndInetInGroup(ref->translation,
+							     username,
+							     ip_number, ip_name);
+			    if (reason == HTAA_OK)
+				return HTAA_OK;
+			} else {	/* Username, check directly */
+			    if (username && *username &&
+				0 == strcmp(ref->name, username))
+				return HTAA_OK;
+			}
+			/* Every user/group name in this group */
+		    }
+		    /* search for username */
+		}
+		/* IP address ok */
+	    } else {
+		reason = HTAA_IP_MASK;
+	    }
+	}			/* while items in group */
+    }
+    /* valid parameters */
+    return reason;		/* No match, or invalid parameters */
+}
+
+void GroupDef_delete(GroupDef *group_def)
+{
+    if (group_def) {
+	FREE(group_def->group_name);
+	if (group_def->item_list) {
+	    HTList_delete(group_def->item_list);	/* @@@@ */
+	    group_def->item_list = NULL;
+	}
+	FREE(group_def);
+    }
+}
+#endif
diff --git a/WWW/Library/Implementation/HTGroup.h b/WWW/Library/Implementation/HTGroup.h
new file mode 100644
index 0000000..7874565
--- /dev/null
+++ b/WWW/Library/Implementation/HTGroup.h
@@ -0,0 +1,182 @@
+/*                                    GROUP FILE ROUTINES
+
+ */
+
+#ifndef HTGROUP_H
+#define HTGROUP_H
+
+#include <HTList.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef HTList GroupDefList;
+    typedef HTList ItemList;
+
+    typedef struct {
+	char *group_name;
+	ItemList *item_list;
+    } GroupDef;
+
+/*
+ * Access Authorization failure reasons
+ */
+    typedef enum {
+	HTAA_OK,		/* 200 OK                               */
+	HTAA_OK_GATEWAY,	/* 200 OK, acting as a gateway          */
+	HTAA_NO_AUTH,		/* 401 Unauthorized, not authenticated  */
+	HTAA_NOT_MEMBER,	/* 401 Unauthorized, not authorized     */
+	HTAA_IP_MASK,		/* 403 Forbidden by IP mask             */
+	HTAA_BY_RULE,		/* 403 Forbidden by rule                */
+	HTAA_NO_ACL,		/* 403 Forbidden, ACL non-existent      */
+	HTAA_NO_ENTRY,		/* 403 Forbidden, no ACL entry          */
+	HTAA_SETUP_ERROR,	/* 403 Forbidden, server setup error    */
+	HTAA_DOTDOT,		/* 403 Forbidden, URL with /../ illegal */
+	HTAA_HTBIN,		/* 403 Forbidden, /htbin not enabled    */
+	HTAA_NOT_FOUND		/* 404 Not found, or read protected     */
+    } HTAAFailReasonType;
+
+/*
+
+Group definition grammar
+
+  string
+                         "sequence of alphanumeric characters"
+
+  user_name
+                         string
+
+  group_name
+                         string
+
+  group_ref
+                         group_name
+
+  user_def
+                         user_name | group_ref
+
+  user_def_list
+                           user_def { ',' user_def }
+
+  user_part
+                         user_def | '(' user_def_list ')'
+
+  templ
+
+                         "sequence of alphanumeric characters and '*'s"
+
+  ip_number_mask
+                         templ '.' templ '.' templ '.' templ
+
+  domain_name_mask
+                         templ { '.' templ }
+
+  address
+
+                         ip_number_mask | domain_name_mask
+
+  address_def
+
+                         address
+
+  address_def_list
+                         address_def { ',' address_def }
+
+  address_part
+                         address_def | '(' address_def_list ')'
+
+  item
+                         [user_part] ['@' address_part]
+
+  item_list
+                         item { ',' item }
+
+  group_def
+                         item_list
+
+  group_decl
+                         group_name ':' group_def
+
+  PARSE GROUP DEFINITION
+
+ */
+
+    extern GroupDef *HTAA_parseGroupDef(FILE *fp);
+
+/*
+
+Fill in Pointers to referenced Group Definitions in a Group Definition
+
+   References to groups (by their name) are resolved from group_def_list and pointers to
+   those structures are added to group_def.
+
+ */
+
+    extern void HTAA_resolveGroupReferences(GroupDef *group_def,
+					    GroupDefList *group_def_list);
+
+/*
+
+Read Group File (and do caching)
+
+   If group file is already in cache returns a pointer to previously read group definition
+   list.
+
+ */
+
+    extern GroupDefList *HTAA_readGroupFile(const char *filename);
+
+/*
+
+Delete Group Definition
+
+   Groups in cache should never be freed by this function.  This should only be used to
+   free group definitions read by HTAA_parseGroupDef.
+
+ */
+
+    extern void GroupDef_delete(GroupDef *group_def);
+
+/*
+
+Print Out Group Definition (for trace purposes)
+
+ */
+
+    extern void HTAA_printGroupDef(GroupDef *group_def);
+
+/*
+
+Does a User Belong to a Given Set of Groups
+
+   This function checks both the username and the internet address.
+
+ */
+
+/* PUBLIC                                       HTAA_userAndInetInGroup()
+ *              CHECK IF USER BELONGS TO TO A GIVEN GROUP
+ *              AND THAT THE CONNECTION COMES FROM AN
+ *              ADDRESS THAT IS ALLOWED BY THAT GROUP
+ * ON ENTRY:
+ *      group           the group definition structure.
+ *      username        connecting user.
+ *      ip_number       browser host IP number, optional.
+ *      ip_name         browser host IP name, optional.
+ *                      However, one of ip_number or ip_name
+ *                      must be given.
+ * ON EXIT:
+ *      returns         HTAA_IP_MASK, if IP address mask was
+ *                      reason for failing.
+ *                      HTAA_NOT_MEMBER, if user does not belong
+ *                      to the group.
+ *                      HTAA_OK if both IP address and user are ok.
+ */
+    extern HTAAFailReasonType HTAA_userAndInetInGroup(GroupDef *group,
+						      char *username,
+						      char *ip_number,
+						      char *ip_name);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* not HTGROUP_H */
diff --git a/WWW/Library/Implementation/HTInit.h b/WWW/Library/Implementation/HTInit.h
new file mode 100644
index 0000000..4fc7000
--- /dev/null
+++ b/WWW/Library/Implementation/HTInit.h
@@ -0,0 +1,34 @@
+/*                   /Net/dxcern/userd/timbl/hypertext/WWW/Library/Implementation/HTInit.html
+                                  INITIALISATION MODULE
+                                             
+   This module registers all the plug & play software modules which will be
+   used in the program.  This is for a browser.
+   
+   To override this, just copy it and link in your version before you link with
+   the library.
+   
+   Implemented by HTInit.c by default.
+   
+ */
+
+#ifndef HTINIT_H
+#define HTINIT_H 1
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern void HTFormatInit(void);
+    extern void HTPreparsedFormatInit(void);
+    extern void HTFileInit(void);
+    extern int LYTestMailcapCommand(const char *testcommand, const char *params);
+    extern BOOL LYMailcapUsesPctS(const char *controlstring);
+    extern char *LYMakeMailcapCommand(const char *command, const char *params, const char *filename);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTINIT_H */
diff --git a/WWW/Library/Implementation/HTLex.c b/WWW/Library/Implementation/HTLex.c
new file mode 100644
index 0000000..5a0df91
--- /dev/null
+++ b/WWW/Library/Implementation/HTLex.c
@@ -0,0 +1,142 @@
+
+/* MODULE							HTLex.c
+ *		LEXICAL ANALYSOR
+ *
+ * AUTHORS:
+ *	AL	Ari Luotonen	luotonen@dxcern.cern.ch
+ *
+ * HISTORY:
+ *
+ *
+ * BUGS:
+ *
+ *
+ */
+
+#include <HTUtils.h>
+
+#include <HTLex.h>		/* Implemented here */
+
+#include <LYLeaks.h>
+
+/*
+ * Global variables
+ */
+char HTlex_buffer[40];		/* Read lexical string          */
+int HTlex_line = 1;		/* Line number in source file   */
+
+/*
+ * Module-wide variables
+ */
+static int lex_cnt;
+static BOOL lex_template;
+static LexItem lex_pushed_back = LEX_NONE;
+static FILE *cache = NULL;
+
+void unlex(LexItem lex_item)
+{
+    lex_pushed_back = lex_item;
+}
+
+LexItem lex(FILE *fp)
+{
+    int ch = 0;
+
+    if (fp != cache) {		/* This cache doesn't work ok because the system  */
+	cache = fp;		/* often assign same FILE structure the next open */
+	HTlex_line = 1;		/* file.  So, if there are syntax errors in setup *
+				   files it may confuse things later on.      */
+    }
+    if (lex_pushed_back != LEX_NONE) {
+	LexItem ret = lex_pushed_back;
+
+	lex_pushed_back = LEX_NONE;
+	return ret;
+    }
+
+    lex_cnt = 0;
+    lex_template = NO;
+
+    for (;;) {
+	switch (ch = getc(fp)) {
+	case EOF:
+	case ' ':
+	case '\t':
+	case '\r':
+	case '\n':
+	case ':':
+	case ',':
+	case '(':
+	case ')':
+	case '@':
+	    if (lex_cnt > 0) {
+		if (ch != EOF)
+		    ungetc(ch, fp);
+		if (lex_template)
+		    return LEX_TMPL_STR;
+		else
+		    return LEX_ALPH_STR;
+	    } else
+		switch (ch) {
+		case EOF:
+		    return LEX_EOF;
+		case '\n':
+		    HTlex_line++;
+		    return LEX_REC_SEP;
+		case ':':
+		    return LEX_FIELD_SEP;
+		case ',':
+		    return LEX_ITEM_SEP;
+		case '(':
+		    return LEX_OPEN_PAREN;
+		case ')':
+		    return LEX_CLOSE_PAREN;
+		case '@':
+		    return LEX_AT_SIGN;
+		default:	/* Leading white space ignored (SP,TAB,CR) */
+		    break;
+		}
+	    break;
+	default:
+	    if (lex_cnt < (int) (sizeof(HTlex_buffer) - 1))
+		HTlex_buffer[lex_cnt++] = (char) ch;
+	    HTlex_buffer[lex_cnt] = '\0';
+	    if ('*' == ch)
+		lex_template = YES;
+	}			/* switch ch */
+    }				/* forever */
+}
+
+const char *lex_verbose(LexItem lex_item)
+{
+    static char msg[sizeof(HTlex_buffer) + 30];		/* @@@@@@@@ */
+
+    switch (lex_item) {
+    case LEX_NONE:		/* Internally used      */
+	return "NO-LEX-ITEM";
+    case LEX_EOF:		/* End of file          */
+	return "end-of-file";
+    case LEX_REC_SEP:		/* Record separator     */
+	return "record separator (newline)";
+    case LEX_FIELD_SEP:	/* Field separator      */
+	return "field separator ':'";
+    case LEX_ITEM_SEP:		/* List item separator  */
+	return "item separator ','";
+    case LEX_OPEN_PAREN:	/* Group start tag      */
+	return "'('";
+    case LEX_CLOSE_PAREN:	/* Group end tag        */
+	return "')'";
+    case LEX_AT_SIGN:		/* Address qualifier    */
+	return "address qualifier '@'";
+    case LEX_ALPH_STR:		/* Alphanumeric string  */
+	sprintf(msg, "alphanumeric string '%.*s'",
+		(int) sizeof(HTlex_buffer), HTlex_buffer);
+	return msg;
+    case LEX_TMPL_STR:		/* Template string      */
+	sprintf(msg, "template string '%.*s'",
+		(int) sizeof(HTlex_buffer), HTlex_buffer);
+	return msg;
+    default:
+	return "UNKNOWN-LEX-ITEM";
+    }
+}
diff --git a/WWW/Library/Implementation/HTLex.h b/WWW/Library/Implementation/HTLex.h
new file mode 100644
index 0000000..fde9034
--- /dev/null
+++ b/WWW/Library/Implementation/HTLex.h
@@ -0,0 +1,64 @@
+/*                         LEXICAL ANALYSOR (MAINLY FOR CONFIG FILES)
+
+ */
+
+#ifndef HTLEX_H
+#define HTLEX_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef enum {
+	LEX_NONE,		/* Internally used      */
+	LEX_EOF,		/* End of file          */
+	LEX_REC_SEP,		/* Record separator     */
+	LEX_FIELD_SEP,		/* Field separator      */
+	LEX_ITEM_SEP,		/* List item separator  */
+	LEX_OPEN_PAREN,		/* Group start tag      */
+	LEX_CLOSE_PAREN,	/* Group end tag        */
+	LEX_AT_SIGN,		/* Address qualifier    */
+	LEX_ALPH_STR,		/* Alphanumeric string  */
+	LEX_TMPL_STR		/* Template string      */
+    } LexItem;
+
+    extern char HTlex_buffer[];	/* Read lexical string          */
+    extern int HTlex_line;	/* Line number in source file   */
+
+/*
+
+Get Next Lexical Item
+
+   If returns LEX_ALPH_STR or LEX_TMPL_STR the string is in global buffer lex_buffer.
+
+ */
+
+    extern LexItem lex(FILE *fp);
+
+/*
+
+Push Back Latest Item
+
+ */
+
+    extern void unlex(LexItem lex_item);
+
+/*
+
+Get the Name for Lexical Item
+
+ */
+
+    extern const char *lex_verbose(LexItem lex_item);
+
+/*
+
+ */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* not HTLEX_H */
diff --git a/WWW/Library/Implementation/HTList.c b/WWW/Library/Implementation/HTList.c
new file mode 100644
index 0000000..d12cd38
--- /dev/null
+++ b/WWW/Library/Implementation/HTList.c
@@ -0,0 +1,402 @@
+/*
+ * $LynxId: HTList.c,v 1.20 2016/11/24 15:29:50 tom Exp $
+ *
+ *	A small List class					      HTList.c
+ *	==================
+ *
+ *	A list is represented as a sequence of linked nodes of type HTList.
+ *	The first node is a header which contains no object.
+ *	New nodes are inserted between the header and the rest of the list.
+ */
+
+#include <HTUtils.h>
+#include <HTList.h>
+
+#include <LYLeaks.h>
+
+/*	Create list.
+*/
+HTList *HTList_new(void)
+{
+    HTList *newList;
+
+    if ((newList = typeMalloc(HTList)) == NULL)
+	  outofmem(__FILE__, "HTList_new");
+
+    newList->object = NULL;
+    newList->next = NULL;
+
+    return newList;
+}
+
+/*	Delete list.
+*/
+void HTList_delete(HTList *me)
+{
+    HTList *current;
+
+    while ((current = me)) {
+	me = me->next;
+	FREE(current);
+    }
+
+    return;
+}
+
+/*	Reverse order of elements in list.
+ */
+HTList *HTList_reverse(HTList *start)
+{
+    HTList *cur, *succ;
+
+    if (!(start && start->next && (cur = start->next->next)))
+	return start;
+    start->next->next = NULL;
+    while (cur) {
+	succ = cur->next;
+	cur->next = start->next;
+	start->next = cur;
+	cur = succ;
+    }
+    return start;
+}
+
+/*	Append a list to another.
+ *
+ *	If successful, the second list will become empty but not freed.
+ */
+HTList *HTList_appendList(HTList *start,
+			  HTList *tail)
+{
+    HTList *temp = start;
+
+    if (!start) {
+	CTRACE((tfp,
+		"HTList: Trying to append list %p to a nonexisting list\n",
+		(void *) tail));
+	return NULL;
+    }
+    if (!(tail && tail->next))
+	return start;
+
+    while (temp->next)
+	temp = temp->next;
+
+    temp->next = tail->next;
+    tail->next = NULL;		/* tail is now an empty list */
+    return start;
+}
+
+/*	Link object to START of list (so it is pointed to by the head).
+ *
+ *	Unlike HTList_addObject(), it does not malloc memory for HTList entry,
+ *	it use already allocated memory which should not be free'd by any
+ *	list operations (optimization).
+ */
+void HTList_linkObject(HTList *me, void *newObject,
+		       HTList *newNode)
+{
+    if (me) {
+	if (newNode->object == NULL && newNode->next == NULL) {
+	    /*  It is safe: */
+	    newNode->object = newObject;
+	    newNode->next = me->next;
+	    me->next = newNode;
+
+	} else {
+	    /*
+	     * This node is already linked to some list (probably this one), so
+	     * refuse changing node pointers to keep the list valid!!!
+	     */
+	    CTRACE((tfp, "*** HTList: Refuse linking already linked obj "));
+	    CTRACE((tfp, "%p, node %p, list %p\n",
+		    (void *) newObject, (void *) newNode, (void *) me));
+	}
+
+    } else {
+	CTRACE((tfp,
+		"HTList: Trying to link object %p to a nonexisting list\n",
+		newObject));
+    }
+
+    return;
+}
+
+/*      Add object to START of list (so it is pointed to by the head).
+*/
+void HTList_addObject(HTList *me, void *newObject)
+{
+    HTList *newNode;
+
+    if (me) {
+	if ((newNode = typeMalloc(HTList)) == NULL)
+	      outofmem(__FILE__, "HTList_addObject");
+
+	newNode->object = newObject;
+	newNode->next = me->next;
+	me->next = newNode;
+
+    } else {
+	CTRACE((tfp, "HTList: Trying to add object %p to a nonexisting list\n",
+		newObject));
+    }
+
+    return;
+}
+
+/*      Append object to END of list (furthest from the head).
+*/
+void HTList_appendObject(HTList *me, void *newObject)
+{
+    HTList *temp = me;
+
+    if (temp && newObject) {
+	while (temp->next)
+	    temp = temp->next;
+	HTList_addObject(temp, newObject);
+    }
+
+    return;
+}
+
+/*	Insert an object into the list at a specified position.
+ *      If position is 0, this places the object at the head of the list
+ *      and is equivalent to HTList_addObject().
+ */
+void HTList_insertObjectAt(HTList *me, void *newObject,
+			   int pos)
+{
+    HTList *newNode;
+    HTList *temp = me;
+    HTList *prevNode;
+    int Pos = pos;
+
+    if (!temp) {
+	CTRACE((tfp, "HTList: Trying to add object %p to a nonexisting list\n",
+		newObject));
+	return;
+    }
+    if (Pos < 0) {
+	Pos = 0;
+	CTRACE((tfp, "HTList: Treating negative object position %d as %d.\n",
+		pos, Pos));
+    }
+
+    prevNode = temp;
+    while ((temp = temp->next)) {
+	if (Pos == 0) {
+	    if ((newNode = typeMalloc(HTList)) == NULL)
+		  outofmem(__FILE__, "HTList_addObjectAt");
+
+	    newNode->object = newObject;
+	    newNode->next = temp;
+	    if (prevNode)
+		prevNode->next = newNode;
+	    return;
+	}
+	prevNode = temp;
+	Pos--;
+    }
+    if (Pos >= 0)
+	HTList_addObject(prevNode, newObject);
+
+    return;
+}
+
+/*	Unlink specified object from list.
+ *	It does not free memory.
+ */
+BOOL HTList_unlinkObject(HTList *me, void *oldObject)
+{
+    HTList *temp = me;
+    HTList *prevNode;
+
+    if (temp && oldObject) {
+	while (temp->next) {
+	    prevNode = temp;
+	    temp = temp->next;
+	    if (temp->object == oldObject) {
+		prevNode->next = temp->next;
+		temp->next = NULL;
+		temp->object = NULL;
+		return YES;	/* Success */
+	    }
+	}
+    }
+    return NO;			/* object not found or NULL list */
+}
+
+/*	Remove specified object from list.
+*/
+BOOL HTList_removeObject(HTList *me, void *oldObject)
+{
+    HTList *temp = me;
+    HTList *prevNode;
+
+    if (temp && oldObject) {
+	while (temp->next) {
+	    prevNode = temp;
+	    temp = temp->next;
+	    if (temp->object == oldObject) {
+		prevNode->next = temp->next;
+		FREE(temp);
+		return YES;	/* Success */
+	    }
+	}
+    }
+    return NO;			/* object not found or NULL list */
+}
+
+/*	Remove object at a given position in the list, where 0 is the
+ *	object pointed to by the head (returns a pointer to the element
+ *	(->object) for the object, and NULL if the list is empty, or
+ *	if it doesn't exist - Yuk!).
+ */
+void *HTList_removeObjectAt(HTList *me, int position)
+{
+    HTList *temp = me;
+    HTList *prevNode;
+    int pos = position;
+    void *result = NULL;
+
+    if (temp != NULL && pos >= 0) {
+	prevNode = temp;
+	while ((temp = temp->next) != NULL) {
+	    if (pos == 0) {
+		prevNode->next = temp->next;
+		result = temp->object;
+		FREE(temp);
+		break;
+	    }
+	    prevNode = temp;
+	    pos--;
+	}
+    }
+
+    return result;
+}
+
+/*	Unlink object from START of list (the Last one inserted
+ *	via HTList_linkObject(), and pointed to by the head).
+ *	It does not free memory.
+ */
+void *HTList_unlinkLastObject(HTList *me)
+{
+    HTList *lastNode;
+    void *lastObject;
+
+    if (me && me->next) {
+	lastNode = me->next;
+	lastObject = lastNode->object;
+	me->next = lastNode->next;
+	lastNode->next = NULL;
+	lastNode->object = NULL;
+	return lastObject;
+
+    } else {			/* Empty list */
+	return NULL;
+    }
+}
+
+/*	Remove object from START of list (the Last one inserted
+ *	via HTList_addObject(), and pointed to by the head).
+ */
+void *HTList_removeLastObject(HTList *me)
+{
+    HTList *lastNode;
+    void *lastObject;
+
+    if (me && me->next) {
+	lastNode = me->next;
+	lastObject = lastNode->object;
+	me->next = lastNode->next;
+	FREE(lastNode);
+	return lastObject;
+
+    } else {			/* Empty list */
+	return NULL;
+    }
+}
+
+/*	Remove object from END of list (the First one inserted
+ *	via HTList_addObject(), and furthest from the head).
+ */
+void *HTList_removeFirstObject(HTList *me)
+{
+    HTList *temp = me;
+    HTList *prevNode;
+    void *firstObject;
+
+    if (!temp)
+	return NULL;
+
+    prevNode = temp;
+    if (temp->next) {
+	while (temp->next) {
+	    prevNode = temp;
+	    temp = temp->next;
+	}
+	firstObject = temp->object;
+	prevNode->next = NULL;
+	FREE(temp);
+	return firstObject;
+
+    } else {			/* Empty list */
+	return NULL;
+    }
+}
+
+/*	Determine total number of objects in the list,
+ *	not counting the head.
+ */
+int HTList_count(HTList *me)
+{
+    HTList *temp = me;
+    int count = 0;
+
+    if (temp)
+	while ((temp = temp->next))
+	    count++;
+
+    return count;
+}
+
+/*	Determine position of an object in the list (a value of 0
+ *	means it is pointed to by the head; returns -1 if not found).
+ */
+int HTList_indexOf(HTList *me, void *object)
+{
+    HTList *temp = me;
+    int position = 0;
+
+    if (temp) {
+	while ((temp = temp->next)) {
+	    if (temp->object == object)
+		return position;
+	    position++;
+	}
+    }
+
+    return -1;			/* Object not in the list */
+}
+
+/*	Return pointer to the object at a specified position in the list,
+ *	where 0 is the object pointed to by the head (returns NULL if
+ *	the list is empty, or if it doesn't exist - Yuk!).
+ */
+void *HTList_objectAt(HTList *me, int position)
+{
+    HTList *temp = me;
+    int pos = position;
+
+    if (!temp || pos < 0)
+	return NULL;
+
+    while ((temp = temp->next)) {
+	if (pos == 0)
+	    return temp->object;
+	pos--;
+    }
+
+    return NULL;		/* Reached the end of the list */
+}
diff --git a/WWW/Library/Implementation/HTList.h b/WWW/Library/Implementation/HTList.h
new file mode 100644
index 0000000..93f9147
--- /dev/null
+++ b/WWW/Library/Implementation/HTList.h
@@ -0,0 +1,142 @@
+
+/*              List object
+ *
+ *      The list object is a generic container for storing collections
+ *      of things in order.
+ */
+#ifndef HTLIST_H
+#define HTLIST_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef struct _HTList HTList;
+
+    struct _HTList {
+	void *object;
+	HTList *next;
+    };
+
+/*	Fast macro to traverse a list.  Call it first with copy of the list
+ *	header.  It returns the first object and increments the passed list
+ *	pointer.  Call it with the same variable until it returns NULL.
+ */
+#define HTList_nextObject(me) \
+	((me) && ((me) = (me)->next) ? (me)->object : NULL)
+
+/*	Macro to find object pointed to by the head (returns NULL
+ *	if list is empty, OR if it doesn't exist - Yuk!)
+ */
+#define HTList_lastObject(me) \
+	((me) && (me)->next ? (me)->next->object : NULL)
+
+/*	Macro to check if a list is empty (or doesn't exist - Yuk!)
+*/
+#define HTList_isEmpty(me) ((me) ? ((me)->next == NULL) : YES)
+
+/*	Create list.
+*/
+    extern HTList *HTList_new(void);
+
+/*	Delete list.
+*/
+    extern void HTList_delete(HTList *me);
+
+/*	Reverse a list.
+*/
+    extern HTList *HTList_reverse(HTList *start);
+
+/*	Append two lists, making second list empty.
+*/
+    extern HTList *HTList_appendList(HTList *start,
+				     HTList *tail);
+
+/*      Add object to START of list (so it is pointed to by the head).
+*/
+    extern void HTList_addObject(HTList *me,
+				 void *newObject);
+
+/*      Append object to END of list (furthest from the head).
+*/
+    extern void HTList_appendObject(HTList *me,
+				    void *newObject);
+
+/*	Insert an object into the list at a specified position.
+ *      If position is 0, this places the object at the head of the list
+ *      and is equivalent to HTList_addObject().
+ */
+    extern void HTList_insertObjectAt(HTList *me,
+				      void *newObject,
+				      int pos);
+
+/*	Remove specified object from list.
+*/
+    extern BOOL HTList_removeObject(HTList *me,
+				    void *oldObject);
+
+/*	Remove object at a given position in the list, where 0 is the
+ *	object pointed to by the head (returns a pointer to the element
+ *	(->object) for the object, and NULL if the list is empty, or
+ *	if it doesn't exist - Yuk!).
+ */
+    extern void *HTList_removeObjectAt(HTList *me,
+				       int position);
+
+/*	Remove object from START of list (the Last one inserted
+ *	via HTList_addObject(), and pointed to by the head).
+ */
+    extern void *HTList_removeLastObject(HTList *me);
+
+/*	Remove object from END of list (the First one inserted
+ *	via HTList_addObject(), and furthest from the head).
+ */
+    extern void *HTList_removeFirstObject(HTList *me);
+
+/*	Determine total number of objects in the list,
+ *	not counting the head.
+ */
+    extern int HTList_count(HTList *me);
+
+/*	Determine position of an object in the list (a value of 0
+ *	means it is pointed to by the head; returns -1 if not found).
+ */
+    extern int HTList_indexOf(HTList *me,
+			      void *object);
+
+/*	Return pointer to the object at a specified position in the list,
+ *	where 0 is the object pointed to by the head (returns NULL if
+ *	the list is empty, or if it doesn't exist - Yuk!).
+ */
+    extern void *HTList_objectAt(HTList *me,
+				 int position);
+
+/*      Link object to START of list (so it is pointed to by the head).
+ *
+ *      Unlike HTList_addObject(), it does not malloc memory for HTList entry,
+ *	it use already allocated memory which should not be free'd by any
+ *	list operations (optimization).
+ */
+    extern void HTList_linkObject(HTList *me,
+				  void *newObject,
+				  HTList *newNode);
+
+/*	Unlink object from START of list (the Last one inserted
+ *	via HTList_linkObject(), and pointed to by the head).
+ *	It does not free memory.
+ */
+    extern void *HTList_unlinkLastObject(HTList *me);
+
+/*	Unlink specified object from list.
+ *	It does not free memory.
+ */
+    extern BOOL HTList_unlinkObject(HTList *me,
+				    void *oldObject);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTLIST_H */
diff --git a/WWW/Library/Implementation/HTMIME.c b/WWW/Library/Implementation/HTMIME.c
new file mode 100644
index 0000000..fde89a6
--- /dev/null
+++ b/WWW/Library/Implementation/HTMIME.c
@@ -0,0 +1,2594 @@
+/*
+ * $LynxId: HTMIME.c,v 1.102 2022/03/12 14:47:02 tom Exp $
+ *
+ *			MIME Message Parse			HTMIME.c
+ *			==================
+ *
+ *	This is RFC 1341-specific code.
+ *	The input stream pushed into this parser is assumed to be
+ *	stripped on CRs, ie lines end with LF, not CR LF.
+ *	(It is easy to change this except for the body part where
+ *	conversion can be slow.)
+ *
+ * History:
+ *	   Feb 92	Written Tim Berners-Lee, CERN
+ *
+ */
+
+#define HTSTREAM_INTERNAL 1
+
+#include <HTUtils.h>
+#include <HTMIME.h>		/* Implemented here */
+#include <HTTP.h>		/* for redirecting_url */
+#include <HTAlert.h>
+#include <HTFile.h>
+#include <HTCJK.h>
+#include <UCMap.h>
+#include <UCDefs.h>
+#include <UCAux.h>
+
+#include <LYCookie.h>
+#include <LYCharSets.h>
+#include <LYCharUtils.h>
+#include <LYStrings.h>
+#include <LYUtils.h>
+#include <LYGlobalDefs.h>
+#include <LYLeaks.h>
+
+/*		MIME Object
+ *		-----------
+ */
+
+typedef enum {
+    MIME_TRANSPARENT,		/* put straight through to target ASAP! */
+    /* states for "Transfer-Encoding: chunked" */
+    MIME_CHUNKED,
+    mcCHUNKED_COUNT_DIGIT,
+    mcCHUNKED_COUNT_CR,
+    mcCHUNKED_COUNT_LF,
+    mcCHUNKED_EXTENSION,
+    mcCHUNKED_DATA,
+    mcCHUNKED_DATA_CR,
+    mcCHUNKED_DATA_LF,
+    /* character state-machine */
+    miBEGINNING_OF_LINE,	/* first character and not a continuation */
+    miA,
+    miACCEPT_RANGES,
+    miAGE,
+    miAL,
+    miALLOW,
+    miALTERNATES,
+    miC,
+    miCACHE_CONTROL,
+    miCO,
+    miCOOKIE,
+    miCON,
+    miCONNECTION,
+    miCONTENT_,
+    miCONTENT_BASE,
+    miCONTENT_DISPOSITION,
+    miCONTENT_ENCODING,
+    miCONTENT_FEATURES,
+    miCONTENT_L,
+    miCONTENT_LANGUAGE,
+    miCONTENT_LENGTH,
+    miCONTENT_LOCATION,
+    miCONTENT_MD5,
+    miCONTENT_RANGE,
+    miCONTENT_T,
+    miCONTENT_TRANSFER_ENCODING,
+    miCONTENT_TYPE,
+    miDATE,
+    miE,
+    miETAG,
+    miEXPIRES,
+    miKEEP_ALIVE,
+    miL,
+    miLAST_MODIFIED,
+    miLINK,
+    miLOCATION,
+    miP,
+    miPR,
+    miPRAGMA,
+    miPROXY_AUTHENTICATE,
+    miPUBLIC,
+    miR,
+    miRE,
+    miREFRESH,
+    miRETRY_AFTER,
+    miS,
+    miSAFE,
+    miSE,
+    miSERVER,
+    miSET_COOKIE,
+    miSET_COOKIE1,
+    miSET_COOKIE2,
+    miT,
+    miTITLE,
+    miTRANSFER_ENCODING,
+    miU,
+    miUPGRADE,
+    miURI,
+    miV,
+    miVARY,
+    miVIA,
+    miW,
+    miWARNING,
+    miWWW_AUTHENTICATE,
+    miSKIP_GET_VALUE,		/* Skip space then get value */
+    miGET_VALUE,		/* Get value till white space */
+    miJUNK_LINE,		/* Ignore the rest of this folded line */
+    miNEWLINE,			/* Just found a LF .. maybe continuation */
+    miCHECK,			/* check against check_pointer */
+    MIME_NET_ASCII,		/* Translate from net ascii */
+    MIME_IGNORE			/* Ignore entire file */
+    /* TRANSPARENT and IGNORE are defined as stg else in _WINDOWS */
+} MIME_state;
+
+#define VALUE_SIZE 5120		/* @@@@@@@ Arbitrary? */
+struct _HTStream {
+    const HTStreamClass *isa;
+
+    BOOL net_ascii;		/* Is input net ascii? */
+    MIME_state state;		/* current state */
+    MIME_state if_ok;		/* got this state if match */
+    MIME_state field;		/* remember which field */
+    MIME_state fold_state;	/* state on a fold */
+    BOOL head_only;		/* only parsing header */
+    BOOL pickup_redirection;	/* parsing for location */
+    BOOL no_streamstack;	/* use sink directly */
+    const char *check_pointer;	/* checking input */
+
+    char *value_pointer;	/* storing values */
+    char value[VALUE_SIZE];
+
+    HTParentAnchor *anchor;	/* Given on creation */
+    HTStream *sink;		/* Given on creation */
+
+    char *boundary;		/* For multipart */
+    char *set_cookie;		/* Set-Cookie */
+    char *set_cookie2;		/* Set-Cookie2 */
+    char *location;		/* Location */
+
+    char *refresh_url;		/* "Refresh:" URL */
+
+    HTFormat c_t_encoding;	/* Content-Transfer-Encoding */
+    char *compression_encoding;
+
+    BOOL chunked_encoding;	/* Transfer-Encoding: chunked */
+    long chunked_size;		/* ...counter for "chunked" */
+
+    HTFormat format;		/* Content-Type */
+    HTStream *target;		/* While writing out */
+    HTStreamClass targetClass;
+
+    HTAtom *targetRep;		/* Converting into? */
+};
+
+/*
+ *  This function is for trimming off any paired
+ *  open- and close-double quotes from header values.
+ *  It does not parse the string for embedded quotes,
+ *  and will not modify the string unless both the
+ *  first and last characters are double-quotes. - FM
+ */
+void HTMIME_TrimDoubleQuotes(char *value)
+{
+    size_t i;
+    char *cp = value;
+
+    if (isEmpty(cp) || *cp != '"')
+	return;
+
+    i = strlen(cp);
+    if (cp[(i - 1)] != '"')
+	return;
+    else
+	cp[(i - 1)] = '\0';
+
+    for (i = 0; value[i]; i++)
+	value[i] = cp[(i + 1)];
+}
+
+/*
+ * Check if the token from "Content-Encoding" corresponds to a compression
+ * type.
+ */
+static BOOL content_is_compressed(HTStream *me)
+{
+    char *encoding = me->anchor->content_encoding;
+    BOOL result = (BOOL) (HTEncodingToCompressType(encoding) != cftNone);
+
+    CTRACE((tfp, "content is%s compressed\n", result ? "" : " NOT"));
+    return result;
+}
+
+/*
+ * Strip quotes from a refresh-URL.
+ */
+static void dequote(char *url)
+{
+    size_t len;
+
+    len = strlen(url);
+    if (*url == '\'' && len > 1 && url[len - 1] == url[0]) {
+	url[len - 1] = '\0';
+	while ((url[0] = url[1]) != '\0') {
+	    ++url;
+	}
+    }
+}
+
+/*
+ * Strip off any compression-suffix from the address and check if the result
+ * looks like one of the presentable suffixes.  If so, return the corresponding
+ * MIME type.
+ */
+static const char *UncompressedContentType(HTStream *me, CompressFileType method)
+{
+    const char *result = 0;
+    char *address = me->anchor->address;
+    const char *expected = HTCompressTypeToSuffix(method);
+    const char *actual = strrchr(address, '.');
+
+    /*
+     * We have to ensure the suffix is consistent, to use HTFileFormat().
+     */
+    if (actual != 0 && !strcasecomp(actual, expected)) {
+	HTFormat format;
+	HTAtom *pencoding = 0;
+	const char *description = 0;
+
+	format = HTFileFormat(address, &pencoding, &description);
+	result = HTAtom_name(format);
+    }
+
+    return result;
+}
+
+static int pumpData(HTStream *me)
+{
+    CompressFileType method;
+    const char *new_encoding;
+    const char *new_content;
+
+    CTRACE((tfp, "Begin pumpData\n"));
+    /*
+     * If the content-type says it is compressed, and there is no
+     * content-encoding, check further and see if the address (omitting the
+     * suffix for a compressed type) looks like a type we can present.  If so,
+     * rearrange things so we'll present the StreamStack code with the
+     * presentable type, already marked as compressed.
+     */
+    CTRACE((tfp, "...address{%s}\n", me->anchor->address));
+    method = HTContentTypeToCompressType(me->anchor->content_type_params);
+    if (isEmpty(me->anchor->content_encoding))
+	me->anchor->no_content_encoding = TRUE;
+    if ((method != cftNone)
+	&& isEmpty(me->anchor->content_encoding)
+	&& (new_content = UncompressedContentType(me, method)) != 0) {
+
+	new_encoding = HTCompressTypeToEncoding(method);
+	CTRACE((tfp, "reinterpreting as content-type:%s, encoding:%s\n",
+		new_content, new_encoding));
+
+	StrAllocCopy(me->anchor->content_encoding, new_encoding);
+	FREE(me->compression_encoding);
+	StrAllocCopy(me->compression_encoding, new_encoding);
+
+	LYStrNCpy(me->value, new_content, VALUE_SIZE - 1);
+	StrAllocCopy(me->anchor->content_type_params, me->value);
+	me->format = HTAtom_for(me->value);
+    }
+
+    if (StrChr(HTAtom_name(me->format), ';') != NULL) {
+	char *cp = NULL, *cp1, *cp2, *cp3 = NULL, *cp4;
+
+	CTRACE((tfp, "HTMIME: Extended MIME Content-Type is %s\n",
+		HTAtom_name(me->format)));
+	StrAllocCopy(cp, HTAtom_name(me->format));
+	/*
+	 * Note that the Content-Type value was converted
+	 * to lower case when we loaded into me->format,
+	 * but there may have been a mixed or upper-case
+	 * atom, so we'll force lower-casing again.  We
+	 * also stripped spaces and double-quotes, but
+	 * we'll make sure they're still gone from any
+	 * charset parameter we check.  - FM
+	 */
+	LYLowerCase(cp);
+	if ((cp1 = StrChr(cp, ';')) != NULL) {
+	    BOOL chartrans_ok = NO;
+
+	    if ((cp2 = strstr(cp1, "charset")) != NULL) {
+		int chndl;
+
+		cp2 += 7;
+		while (*cp2 == ' ' || *cp2 == '=' || *cp2 == '"')
+		    cp2++;
+		StrAllocCopy(cp3, cp2);		/* copy to mutilate more */
+		for (cp4 = cp3; (*cp4 != '\0' && *cp4 != '"' &&
+				 *cp4 != ';' && *cp4 != ':' &&
+				 !WHITE(*cp4)); cp4++) ;	/* do nothing */
+		*cp4 = '\0';
+		cp4 = cp3;
+		chndl = UCGetLYhndl_byMIME(cp3);
+		if (UCCanTranslateFromTo(chndl,
+					 current_char_set)) {
+		    chartrans_ok = YES;
+		    *cp1 = '\0';
+		    me->format = HTAtom_for(cp);
+		    StrAllocCopy(me->anchor->charset, cp4);
+		    HTAnchor_setUCInfoStage(me->anchor, chndl,
+					    UCT_STAGE_MIME,
+					    UCT_SETBY_MIME);
+		} else if (chndl < 0) {		/* got something but we don't
+						   recognize it */
+		    chndl = UCLYhndl_for_unrec;
+		    if (chndl < 0)
+			/*
+			 * UCLYhndl_for_unrec not defined :-( fallback to
+			 * UCLYhndl_for_unspec which always valid.
+			 */
+			chndl = UCLYhndl_for_unspec;	/* always >= 0 */
+		    if (UCCanTranslateFromTo(chndl,
+					     current_char_set)) {
+			chartrans_ok = YES;
+			*cp1 = '\0';
+			me->format = HTAtom_for(cp);
+			HTAnchor_setUCInfoStage(me->anchor, chndl,
+						UCT_STAGE_MIME,
+						UCT_SETBY_DEFAULT);
+		    }
+		} else {
+		    /*
+		     * Something like 'big5' - we cannot translate it, but
+		     * the user may still be able to navigate the links.
+		     */
+		    *cp1 = '\0';
+		    me->format = HTAtom_for(cp);
+		    StrAllocCopy(me->anchor->charset, cp4);
+		    HTAnchor_setUCInfoStage(me->anchor, chndl,
+					    UCT_STAGE_MIME,
+					    UCT_SETBY_MIME);
+		}
+		if (chartrans_ok) {
+		    LYUCcharset *p_in =
+		    HTAnchor_getUCInfoStage(me->anchor,
+					    UCT_STAGE_MIME);
+		    LYUCcharset *p_out =
+		    HTAnchor_setUCInfoStage(me->anchor,
+					    current_char_set,
+					    UCT_STAGE_HTEXT,
+					    UCT_SETBY_DEFAULT);
+
+		    if (!p_out)
+			/*
+			 * Try again.
+			 */
+			p_out =
+			    HTAnchor_getUCInfoStage(me->anchor,
+						    UCT_STAGE_HTEXT);
+
+		    if (!strcmp(p_in->MIMEname,
+				"x-transparent")) {
+			HTPassEightBitRaw = TRUE;
+			HTAnchor_setUCInfoStage(me->anchor,
+						HTAnchor_getUCLYhndl(me->anchor,
+								     UCT_STAGE_HTEXT),
+						UCT_STAGE_MIME,
+						UCT_SETBY_DEFAULT);
+		    }
+		    if (!strcmp(p_out->MIMEname,
+				"x-transparent")) {
+			HTPassEightBitRaw = TRUE;
+			HTAnchor_setUCInfoStage(me->anchor,
+						HTAnchor_getUCLYhndl(me->anchor,
+								     UCT_STAGE_MIME),
+						UCT_STAGE_HTEXT,
+						UCT_SETBY_DEFAULT);
+		    }
+		    if ((p_in->enc != UCT_ENC_CJK)
+#ifdef USE_JAPANESEUTF8_SUPPORT
+			&& ((p_in->enc != UCT_ENC_UTF8)
+			    || (p_out->enc != UCT_ENC_CJK))
+#endif
+			) {
+			HTCJK = NOCJK;
+			if (!(p_in->codepoints &
+			      UCT_CP_SUBSETOF_LAT1) &&
+			    chndl == current_char_set) {
+			    HTPassEightBitRaw = TRUE;
+			}
+		    } else if (p_out->enc == UCT_ENC_CJK) {
+			Set_HTCJK(p_in->MIMEname, p_out->MIMEname);
+		    }
+		} else {
+		    /*
+		     * Cannot translate.  If according to some heuristic the
+		     * given charset and the current display character both are
+		     * likely to be like ISO-8859 in structure, pretend we have
+		     * some kind of match.
+		     */
+		    BOOL given_is_8859 =
+		    (BOOL) (!StrNCmp(cp4, "iso-8859-", 9) &&
+			    isdigit(UCH(cp4[9])));
+		    BOOL given_is_8859like =
+		    (BOOL) (given_is_8859 ||
+			    !StrNCmp(cp4, "windows-", 8) ||
+			    !StrNCmp(cp4, "cp12", 4) ||
+			    !StrNCmp(cp4, "cp-12", 5));
+		    BOOL given_and_display_8859like =
+		    (BOOL) (given_is_8859like &&
+			    (strstr(LYchar_set_names[current_char_set],
+				    "ISO-8859") ||
+			     strstr(LYchar_set_names[current_char_set],
+				    "windows-")));
+
+		    if (given_and_display_8859like) {
+			*cp1 = '\0';
+			me->format = HTAtom_for(cp);
+		    }
+		    if (given_is_8859) {
+			cp1 = &cp4[10];
+			while (*cp1 &&
+			       isdigit(UCH(*cp1)))
+			    cp1++;
+			*cp1 = '\0';
+		    }
+		    if (given_and_display_8859like) {
+			StrAllocCopy(me->anchor->charset, cp4);
+			HTPassEightBitRaw = TRUE;
+		    }
+		    HTAlert(*cp4 ? cp4 : me->anchor->charset);
+		}
+		FREE(cp3);
+	    } else {
+		/*
+		 * No charset parameter is present.  Ignore all other
+		 * parameters, as we do when charset is present.  - FM
+		 */
+		*cp1 = '\0';
+		me->format = HTAtom_for(cp);
+	    }
+	}
+	FREE(cp);
+    }
+    /*
+     * If we have an Expires header and haven't already set the no_cache
+     * element for the anchor, check if we should set it based on that header. 
+     * - FM
+     */
+    if (me->anchor->no_cache == FALSE &&
+	me->anchor->expires != NULL) {
+	if (!strcmp(me->anchor->expires, "0")) {
+	    /*
+	     * The value is zero, which we treat as an absolute no-cache
+	     * directive.  - FM
+	     */
+	    me->anchor->no_cache = TRUE;
+	} else if (me->anchor->date != NULL) {
+	    /*
+	     * We have a Date header, so check if the value is less than or
+	     * equal to that.  - FM
+	     */
+	    if (LYmktime(me->anchor->expires, TRUE) <=
+		LYmktime(me->anchor->date, TRUE)) {
+		me->anchor->no_cache = TRUE;
+	    }
+	} else if (LYmktime(me->anchor->expires, FALSE) == 0) {
+	    /*
+	     * We don't have a Date header, and the value is in past for us.  -
+	     * FM
+	     */
+	    me->anchor->no_cache = TRUE;
+	}
+    }
+    StrAllocCopy(me->anchor->content_type,
+		 HTAtom_name(me->format));
+
+    if (me->set_cookie != NULL || me->set_cookie2 != NULL) {
+	LYSetCookie(me->set_cookie,
+		    me->set_cookie2,
+		    me->anchor->address);
+	FREE(me->set_cookie);
+	FREE(me->set_cookie2);
+    }
+    if (me->pickup_redirection) {
+	if (me->location && *me->location) {
+	    redirecting_url = me->location;
+	    me->location = NULL;
+	    if (me->targetRep != WWW_DEBUG || me->sink)
+		me->head_only = YES;
+
+	} else {
+	    permanent_redirection = FALSE;
+	    if (me->location) {
+		CTRACE((tfp, "HTTP: 'Location:' is zero-length!\n"));
+		HTAlert(REDIRECTION_WITH_BAD_LOCATION);
+	    }
+	    CTRACE((tfp, "HTTP: Failed to pick up location.\n"));
+	    if (me->location) {
+		FREE(me->location);
+	    } else {
+		HTAlert(REDIRECTION_WITH_NO_LOCATION);
+	    }
+	}
+    }
+    CTRACE((tfp, "...pumpData finished reading header\n"));
+    if (me->head_only) {
+	/* We are done! - kw */
+	me->state = MIME_IGNORE;
+    } else {
+
+	if (me->no_streamstack) {
+	    me->target = me->sink;
+	} else {
+	    if (!me->compression_encoding) {
+		CTRACE((tfp,
+			"HTMIME: MIME Content-Type is '%s', converting to '%s'\n",
+			HTAtom_name(me->format), HTAtom_name(me->targetRep)));
+	    } else {
+		/*
+		 * Change the format to that for "www/compressed" and set up a
+		 * stream to deal with it.  - FM
+		 */
+		CTRACE((tfp, "HTMIME: MIME Content-Type is '%s',\n",
+			HTAtom_name(me->format)));
+		me->format = HTAtom_for("www/compressed");
+		CTRACE((tfp, "        Treating as '%s'.  Converting to '%s'\n",
+			HTAtom_name(me->format), HTAtom_name(me->targetRep)));
+		FREE(me->compression_encoding);
+	    }
+	    me->target = HTStreamStack(me->format, me->targetRep,
+				       me->sink, me->anchor);
+	    if (!me->target) {
+		CTRACE((tfp, "HTMIME: Can't translate! ** \n"));
+		me->target = me->sink;	/* Cheat */
+	    }
+	}
+	if (me->target) {
+	    me->targetClass = *me->target->isa;
+	    /*
+	     * Pump rest of data right through, according to the transfer encoding.
+	     */
+	    me->state = (me->chunked_encoding
+			 ? MIME_CHUNKED
+			 : MIME_TRANSPARENT);
+	} else {
+	    me->state = MIME_IGNORE;	/* What else to do? */
+	}
+	if (me->refresh_url != NULL && !content_is_compressed(me)) {
+	    char *url = NULL;
+	    char *num = NULL;
+	    char *txt = NULL;
+	    const char *base = "";	/* FIXME: refresh_url may be relative to doc */
+
+	    LYParseRefreshURL(me->refresh_url, &num, &url);
+	    if (url != NULL && me->format == WWW_HTML) {
+		CTRACE((tfp,
+			"Formatting refresh-url as first line of result\n"));
+		HTSprintf0(&txt, gettext("Refresh: "));
+		HTSprintf(&txt, gettext("%s seconds "), num);
+		dequote(url);
+		HTSprintf(&txt, "<a href=\"%s%s\">%s</a><br>", base, url, url);
+		CTRACE((tfp, "URL %s%s\n", base, url));
+		(me->isa->put_string) (me, txt);
+		free(txt);
+	    }
+	    FREE(num);
+	    FREE(url);
+	}
+    }
+    CTRACE((tfp, "...end of pumpData, copied %"
+	    PRI_off_t " vs %"
+	    PRI_off_t "\n",
+	    CAST_off_t (me->anchor->actual_length),
+	    CAST_off_t (me->anchor->content_length)));
+    me->anchor->actual_length = 0;
+    return HT_OK;
+}
+
+static int dispatchField(HTStream *me)
+{
+    int i, j;
+    char *cp;
+
+    *me->value_pointer = '\0';
+
+    cp = me->value_pointer;
+    while ((cp > me->value) && *(--cp) == ' ')	/* S/390 -- gil -- 0146 */
+	/*
+	 * Trim trailing spaces.
+	 */
+	*cp = '\0';
+
+    switch (me->field) {
+    case miACCEPT_RANGES:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Accept-Ranges: '%s'\n",
+		me->value));
+	break;
+    case miAGE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Age: '%s'\n",
+		me->value));
+	break;
+    case miALLOW:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Allow: '%s'\n",
+		me->value));
+	break;
+    case miALTERNATES:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Alternates: '%s'\n",
+		me->value));
+	break;
+    case miCACHE_CONTROL:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Cache-Control: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Convert to lowercase and indicate in anchor.  - FM
+	 */
+	LYLowerCase(me->value);
+	StrAllocCopy(me->anchor->cache_control, me->value);
+	/*
+	 * Check whether to set no_cache for the anchor.  - FM
+	 */
+	{
+	    char *cp1, *cp0 = me->value;
+
+	    while ((cp1 = strstr(cp0, "no-cache")) != NULL) {
+		cp1 += 8;
+		while (*cp1 != '\0' && WHITE(*cp1))
+		    cp1++;
+		if (*cp1 == '\0' || *cp1 == ';') {
+		    me->anchor->no_cache = TRUE;
+		    break;
+		}
+		cp0 = cp1;
+	    }
+	    if (me->anchor->no_cache == TRUE)
+		break;
+	    cp0 = me->value;
+	    while ((cp1 = strstr(cp0, "max-age")) != NULL) {
+		cp1 += 7;
+		while (*cp1 != '\0' && WHITE(*cp1))
+		    cp1++;
+		if (*cp1 == '=') {
+		    cp1++;
+		    while (*cp1 != '\0' && WHITE(*cp1))
+			cp1++;
+		    if (isdigit(UCH(*cp1))) {
+			cp0 = cp1;
+			while (isdigit(UCH(*cp1)))
+			    cp1++;
+			if (*cp0 == '0' && cp1 == (cp0 + 1)) {
+			    me->anchor->no_cache = TRUE;
+			    break;
+			}
+		    }
+		}
+		cp0 = cp1;
+	    }
+	}
+	break;
+    case miCOOKIE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Cookie: '%s'\n",
+		me->value));
+	break;
+    case miCONNECTION:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Connection: '%s'\n",
+		me->value));
+	break;
+    case miCONTENT_BASE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Base: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->content_base, me->value);
+	break;
+    case miCONTENT_DISPOSITION:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Disposition: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->content_disposition, me->value);
+	/*
+	 * It's not clear yet from existing RFCs and IDs whether we should be
+	 * looking for file;, attachment;, and/or inline; before the
+	 * filename=value, so we'll just search for "filename" followed by '='
+	 * and just hope we get the intended value.  It is purely a suggested
+	 * name, anyway.  - FM
+	 */
+	cp = me->anchor->content_disposition;
+	while (*cp != '\0' && strncasecomp(cp, "filename", 8))
+	    cp++;
+	if (*cp == '\0')
+	    break;
+	cp += 8;
+	while ((*cp != '\0') && (WHITE(*cp) || *cp == '='))
+	    cp++;
+	if (*cp == '\0')
+	    break;
+	while (*cp != '\0' && WHITE(*cp))
+	    cp++;
+	if (*cp == '\0')
+	    break;
+	StrAllocCopy(me->anchor->SugFname, cp);
+	if (*me->anchor->SugFname == '"') {
+	    if ((cp = StrChr((me->anchor->SugFname + 1),
+			     '"')) != NULL) {
+		*(cp + 1) = '\0';
+		HTMIME_TrimDoubleQuotes(me->anchor->SugFname);
+	    } else {
+		FREE(me->anchor->SugFname);
+		break;
+	    }
+	}
+	cp = me->anchor->SugFname;
+	while (*cp != '\0' && !WHITE(*cp))
+	    cp++;
+	*cp = '\0';
+	if (*me->anchor->SugFname == '\0')
+	    FREE(me->anchor->SugFname);
+	break;
+    case miCONTENT_ENCODING:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Encoding: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0' ||
+	    !strcasecomp(me->value, "identity"))
+	    break;
+	/*
+	 * Convert to lowercase and indicate in anchor.  - FM
+	 */
+	LYLowerCase(me->value);
+	StrAllocCopy(me->anchor->content_encoding, me->value);
+	FREE(me->compression_encoding);
+	if (content_is_compressed(me)) {
+	    /*
+	     * Save it to use as a flag for setting up a "www/compressed"
+	     * target.  - FM
+	     */
+	    StrAllocCopy(me->compression_encoding, me->value);
+	} else {
+	    /*
+	     * Some server indicated "8bit", "7bit" or "binary"
+	     * inappropriately.  We'll ignore it.  - FM
+	     */
+	    CTRACE((tfp, "                Ignoring it!\n"));
+	}
+	break;
+    case miCONTENT_FEATURES:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Features: '%s'\n",
+		me->value));
+	break;
+    case miCONTENT_LANGUAGE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Language: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Convert to lowercase and indicate in anchor.  - FM
+	 */
+	LYLowerCase(me->value);
+	StrAllocCopy(me->anchor->content_language, me->value);
+	break;
+    case miCONTENT_LENGTH:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Length: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Convert to integer and indicate in anchor.  - FM
+	 */
+	me->anchor->content_length = LYatoll(me->value);
+	if (me->anchor->content_length < 0)
+	    me->anchor->content_length = 0;
+	CTRACE((tfp, "        Converted to integer: '%" PRI_off_t "'\n",
+		CAST_off_t (me->anchor->content_length)));
+	break;
+    case miCONTENT_LOCATION:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Location: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->content_location, me->value);
+	break;
+    case miCONTENT_MD5:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-MD5: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->content_md5, me->value);
+	break;
+    case miCONTENT_RANGE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Range: '%s'\n",
+		me->value));
+	break;
+    case miCONTENT_TRANSFER_ENCODING:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Transfer-Encoding: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Force the Content-Transfer-Encoding value to all lower case.  - FM
+	 */
+	LYLowerCase(me->value);
+	me->c_t_encoding = HTAtom_for(me->value);
+	break;
+    case miCONTENT_TYPE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Content-Type: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Force the Content-Type value to all lower case and strip spaces and
+	 * double-quotes.  - FM
+	 */
+	for (i = 0, j = 0; me->value[i]; i++) {
+	    if (me->value[i] != ' ' && me->value[i] != '"') {
+		me->value[j++] = (char) TOLOWER(me->value[i]);
+	    }
+	}
+	me->value[j] = '\0';
+	me->format = HTAtom_for(me->value);
+	StrAllocCopy(me->anchor->content_type_params, me->value);
+	break;
+    case miDATE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Date: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->date, me->value);
+	break;
+    case miETAG:
+	/* Do not trim double quotes:  an entity tag consists of an opaque
+	 * quoted string, possibly prefixed by a weakness indicator.
+	 */
+	CTRACE((tfp, "HTMIME: PICKED UP ETag: %s\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->ETag, me->value);
+	break;
+    case miEXPIRES:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Expires: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->expires, me->value);
+	break;
+    case miKEEP_ALIVE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Keep-Alive: '%s'\n",
+		me->value));
+	break;
+    case miLAST_MODIFIED:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Last-Modified: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->last_modified, me->value);
+	break;
+    case miLINK:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Link: '%s'\n",
+		me->value));
+	break;
+    case miLOCATION:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Location: '%s'\n",
+		me->value));
+	if (me->pickup_redirection && !me->location) {
+	    StrAllocCopy(me->location, me->value);
+	} else {
+	    CTRACE((tfp, "HTMIME: *** Ignoring Location!\n"));
+	}
+	break;
+    case miPRAGMA:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Pragma: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Check whether to set no_cache for the anchor.  - FM
+	 */
+	if (!strcmp(me->value, "no-cache"))
+	    me->anchor->no_cache = TRUE;
+	break;
+    case miPROXY_AUTHENTICATE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Proxy-Authenticate: '%s'\n",
+		me->value));
+	break;
+    case miPUBLIC:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Public: '%s'\n",
+		me->value));
+	break;
+    case miREFRESH:		/* nonstandard: Netscape */
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Refresh: '%s'\n",
+		me->value));
+	StrAllocCopy(me->refresh_url, me->value);
+	break;
+    case miRETRY_AFTER:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Retry-After: '%s'\n",
+		me->value));
+	break;
+    case miSAFE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Safe: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor if "YES" or "TRUE".  - FM
+	 */
+	if (!strcasecomp(me->value, "YES") ||
+	    !strcasecomp(me->value, "TRUE")) {
+	    me->anchor->safe = TRUE;
+	} else if (!strcasecomp(me->value, "NO") ||
+		   !strcasecomp(me->value, "FALSE")) {
+	    /*
+	     * If server explicitly tells us that it has changed its mind,
+	     * reset flag in anchor.  - kw
+	     */
+	    me->anchor->safe = FALSE;
+	}
+	break;
+    case miSERVER:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Server: '%s'\n",
+		me->value));
+	if (me->value[0] == '\0')
+	    break;
+	/*
+	 * Indicate in anchor.  - FM
+	 */
+	StrAllocCopy(me->anchor->server, me->value);
+	break;
+    case miSET_COOKIE1:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Set-Cookie: '%s'\n",
+		me->value));
+	if (me->set_cookie == NULL) {
+	    StrAllocCopy(me->set_cookie, me->value);
+	} else {
+	    StrAllocCat(me->set_cookie, ", ");
+	    StrAllocCat(me->set_cookie, me->value);
+	}
+	break;
+    case miSET_COOKIE2:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Set-Cookie2: '%s'\n",
+		me->value));
+	if (me->set_cookie2 == NULL) {
+	    StrAllocCopy(me->set_cookie2, me->value);
+	} else {
+	    StrAllocCat(me->set_cookie2, ", ");
+	    StrAllocCat(me->set_cookie2, me->value);
+	}
+	break;
+    case miTITLE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Title: '%s'\n",
+		me->value));
+	break;
+    case miTRANSFER_ENCODING:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Transfer-Encoding: '%s'\n",
+		me->value));
+	if (!strcmp(me->value, "chunked"))
+	    me->chunked_encoding = YES;
+	break;
+    case miUPGRADE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Upgrade: '%s'\n",
+		me->value));
+	break;
+    case miURI:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP URI: '%s'\n",
+		me->value));
+	break;
+    case miVARY:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Vary: '%s'\n",
+		me->value));
+	break;
+    case miVIA:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Via: '%s'\n",
+		me->value));
+	break;
+    case miWARNING:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP Warning: '%s'\n",
+		me->value));
+	break;
+    case miWWW_AUTHENTICATE:
+	HTMIME_TrimDoubleQuotes(me->value);
+	CTRACE((tfp, "HTMIME: PICKED UP WWW-Authenticate: '%s'\n",
+		me->value));
+	break;
+    default:			/* Should never get here */
+	return HT_ERROR;
+    }
+    return HT_OK;
+}
+
+/*_________________________________________________________________________
+ *
+ *			A C T I O N	R O U T I N E S
+ */
+
+/*	Character handling
+ *	------------------
+ *
+ *	This is a FSM parser. It ignores field names it does not understand.
+ *	Folded header fields are recognized.  Lines without a fieldname at
+ *	the beginning (that are not folded continuation lines) are ignored
+ *	as unknown field names.  Fields with empty values are not picked up.
+ */
+static void HTMIME_put_character(HTStream *me, int c)
+{
+    if (me->anchor->inHEAD) {
+	me->anchor->header_length++;
+    }
+    switch (me->state) {
+      begin_transparent:
+    case MIME_TRANSPARENT:
+	me->anchor->actual_length += 1;
+	(me->targetClass.put_character) (me->target, c);
+	return;
+
+	/* RFC-2616 describes chunked transfer coding */
+    case mcCHUNKED_DATA:
+	(*me->targetClass.put_character) (me->target, c);
+	me->chunked_size--;
+	if (me->chunked_size <= 0)
+	    me->state = mcCHUNKED_DATA_CR;
+	return;
+
+    case mcCHUNKED_DATA_CR:
+	me->state = mcCHUNKED_DATA_LF;
+	if (c == CR) {
+	    return;
+	}
+	/* FALLTHRU */
+
+    case mcCHUNKED_DATA_LF:
+	me->state = MIME_CHUNKED;
+	if (c == LF) {
+	    return;
+	}
+
+	CTRACE((tfp, "HTIME_put_character expected LF in chunked data\n"));
+	me->state = MIME_TRANSPARENT;
+	goto begin_transparent;
+
+	/* FALLTHRU */
+      begin_chunked:
+    case MIME_CHUNKED:
+	me->chunked_size = 0;
+	me->state = mcCHUNKED_COUNT_DIGIT;
+
+	/* FALLTHRU */
+    case mcCHUNKED_COUNT_DIGIT:
+	if (isxdigit(UCH(c))) {
+	    me->chunked_size <<= 4;
+	    if (isdigit(UCH(c)))
+		me->chunked_size += UCH(c) - '0';
+	    else
+		me->chunked_size += TOUPPER(UCH(c)) - 'A' + 10;
+	    return;
+	}
+	if (c == ';')
+	    me->state = mcCHUNKED_EXTENSION;
+
+	/* FALLTHRU */
+    case mcCHUNKED_EXTENSION:
+	if (c != CR && c != LF) {
+	    return;
+	}
+	me->state = mcCHUNKED_COUNT_CR;
+
+	/* FALLTHRU */
+    case mcCHUNKED_COUNT_CR:
+	me->state = mcCHUNKED_COUNT_LF;
+	if (c == CR) {
+	    return;
+	}
+
+	/* FALLTHRU */
+    case mcCHUNKED_COUNT_LF:
+	me->state = ((me->chunked_size != 0)
+		     ? mcCHUNKED_DATA
+		     : MIME_CHUNKED);
+	if (c == LF) {
+	    return;
+	}
+	goto begin_chunked;
+
+    default:
+	break;
+    }
+
+    /*
+     * This slightly simple conversion just strips CR and turns LF to newline. 
+     * On unix LF is \n but on Mac \n is CR for example.  See NetToText for an
+     * implementation which preserves single CR or LF.
+     */
+    if (me->net_ascii) {
+	/*
+	 * <sigh> This is evidence that at one time, this code supported
+	 * local character sets other than ASCII.  But there is so much
+	 * code in HTTP.c that depends on line_buffer's having been
+	 * translated to local character set that I needed to put the
+	 * FROMASCII translation there, leaving this translation purely
+	 * destructive.  -- gil
+	 */
+	/* S/390 -- gil -- 0118 */
+#ifndef   NOT_ASCII
+	c = FROMASCII(c);
+#endif /* NOT_ASCII */
+	if (c == CR)
+	    return;
+	else if (c == LF)
+	    c = '\n';
+    }
+
+    switch (me->state) {
+
+    case MIME_IGNORE:
+	return;
+
+    case MIME_TRANSPARENT:	/* Not reached see above */
+    case MIME_CHUNKED:
+    case mcCHUNKED_COUNT_DIGIT:
+    case mcCHUNKED_COUNT_CR:
+    case mcCHUNKED_COUNT_LF:
+    case mcCHUNKED_EXTENSION:
+    case mcCHUNKED_DATA:
+    case mcCHUNKED_DATA_CR:
+    case mcCHUNKED_DATA_LF:
+	return;
+
+    case MIME_NET_ASCII:
+	(*me->targetClass.put_character) (me->target, c);	/* MUST BE FAST */
+	return;
+
+    case miNEWLINE:
+	if (c != '\n' && WHITE(c)) {	/* Folded line */
+	    me->state = me->fold_state;		/* pop state before newline */
+	    if (me->state == miGET_VALUE &&
+		me->value_pointer && me->value_pointer != me->value &&
+		!WHITE(*(me->value_pointer - 1))) {
+		c = ' ';
+		goto GET_VALUE;	/* will add space to value if it fits - kw */
+	    }
+	    break;
+	} else if (me->fold_state == miGET_VALUE) {
+	    /* Got a field, and now we know it's complete - so
+	     * act on it. - kw */
+	    dispatchField(me);
+	}
+	/* FALLTHRU */
+
+    case miBEGINNING_OF_LINE:
+	me->net_ascii = YES;
+	switch (c) {
+	case 'a':
+	case 'A':
+	    me->state = miA;
+	    CTRACE((tfp, "HTMIME: Got 'A' at beginning of line, state now A\n"));
+	    break;
+
+	case 'c':
+	case 'C':
+	    me->state = miC;
+	    CTRACE((tfp, "HTMIME: Got 'C' at beginning of line, state now C\n"));
+	    break;
+
+	case 'd':
+	case 'D':
+	    me->check_pointer = "ate:";
+	    me->if_ok = miDATE;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Got 'D' at beginning of line, checking for 'ate:'\n"));
+	    break;
+
+	case 'e':
+	case 'E':
+	    me->state = miE;
+	    CTRACE((tfp, "HTMIME: Got 'E' at beginning of line, state now E\n"));
+	    break;
+
+	case 'k':
+	case 'K':
+	    me->check_pointer = "eep-alive:";
+	    me->if_ok = miKEEP_ALIVE;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Got 'K' at beginning of line, checking for 'eep-alive:'\n"));
+	    break;
+
+	case 'l':
+	case 'L':
+	    me->state = miL;
+	    CTRACE((tfp, "HTMIME: Got 'L' at beginning of line, state now L\n"));
+	    break;
+
+	case 'p':
+	case 'P':
+	    me->state = miP;
+	    CTRACE((tfp, "HTMIME: Got 'P' at beginning of line, state now P\n"));
+	    break;
+
+	case 'r':
+	case 'R':
+	    me->state = miR;
+	    CTRACE((tfp, "HTMIME: Got 'R' at beginning of line, state now R\n"));
+	    break;
+
+	case 's':
+	case 'S':
+	    me->state = miS;
+	    CTRACE((tfp, "HTMIME: Got 'S' at beginning of line, state now S\n"));
+	    break;
+
+	case 't':
+	case 'T':
+	    me->state = miT;
+	    CTRACE((tfp, "HTMIME: Got 'T' at beginning of line, state now T\n"));
+	    break;
+
+	case 'u':
+	case 'U':
+	    me->state = miU;
+	    CTRACE((tfp, "HTMIME: Got 'U' at beginning of line, state now U\n"));
+	    break;
+
+	case 'v':
+	case 'V':
+	    me->state = miV;
+	    CTRACE((tfp, "HTMIME: Got 'V' at beginning of line, state now V\n"));
+	    break;
+
+	case 'w':
+	case 'W':
+	    me->state = miW;
+	    CTRACE((tfp, "HTMIME: Got 'W' at beginning of line, state now W\n"));
+	    break;
+
+	case '\n':		/* Blank line: End of Header! */
+	    {
+		me->anchor->inHEAD = FALSE;
+		CTRACE((tfp, "HTMIME length %" PRI_off_t "\n",
+			CAST_off_t (me->anchor->header_length)));
+		me->net_ascii = NO;
+		pumpData(me);
+	    }
+	    break;
+
+	default:
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miA:			/* Check for 'c','g' or 'l' */
+	switch (c) {
+	case 'c':
+	case 'C':
+	    me->check_pointer = "cept-ranges:";
+	    me->if_ok = miACCEPT_RANGES;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was A, found C, checking for 'cept-ranges:'\n"));
+	    break;
+
+	case 'g':
+	case 'G':
+	    me->check_pointer = "e:";
+	    me->if_ok = miAGE;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was A, found G, checking for 'e:'\n"));
+	    break;
+
+	case 'l':
+	case 'L':
+	    me->state = miAL;
+	    CTRACE((tfp, "HTMIME: Was A, found L, state now AL'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'g' or 'l'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miAL:			/* Check for 'l' or 't' */
+	switch (c) {
+	case 'l':
+	case 'L':
+	    me->check_pointer = "ow:";
+	    me->if_ok = miALLOW;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was AL, found L, checking for 'ow:'\n"));
+	    break;
+
+	case 't':
+	case 'T':
+	    me->check_pointer = "ernates:";
+	    me->if_ok = miALTERNATES;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was AL, found T, checking for 'ernates:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'l' or 't'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miC:			/* Check for 'a' or 'o' */
+	switch (c) {
+	case 'a':
+	case 'A':
+	    me->check_pointer = "che-control:";
+	    me->if_ok = miCACHE_CONTROL;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was C, found A, checking for 'che-control:'\n"));
+	    break;
+
+	case 'o':
+	case 'O':
+	    me->state = miCO;
+	    CTRACE((tfp, "HTMIME: Was C, found O, state now CO'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'a' or 'o'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miCO:			/* Check for 'n' or 'o' */
+	switch (c) {
+	case 'n':
+	case 'N':
+	    me->state = miCON;
+	    CTRACE((tfp, "HTMIME: Was CO, found N, state now CON\n"));
+	    break;
+
+	case 'o':
+	case 'O':
+	    me->check_pointer = "kie:";
+	    me->if_ok = miCOOKIE;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was CO, found O, checking for 'kie:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'n' or 'o'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miCON:		/* Check for 'n' or 't' */
+	switch (c) {
+	case 'n':
+	case 'N':
+	    me->check_pointer = "ection:";
+	    me->if_ok = miCONNECTION;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was CON, found N, checking for 'ection:'\n"));
+	    break;
+
+	case 't':
+	case 'T':
+	    me->check_pointer = "ent-";
+	    me->if_ok = miCONTENT_;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was CON, found T, checking for 'ent-'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'n' or 't'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miE:			/* Check for 't' or 'x' */
+	switch (c) {
+	case 't':
+	case 'T':
+	    me->check_pointer = "ag:";
+	    me->if_ok = miETAG;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was E, found T, checking for 'ag:'\n"));
+	    break;
+
+	case 'x':
+	case 'X':
+	    me->check_pointer = "pires:";
+	    me->if_ok = miEXPIRES;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was E, found X, checking for 'pires:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'t' or 'x'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miL:			/* Check for 'a', 'i' or 'o' */
+	switch (c) {
+	case 'a':
+	case 'A':
+	    me->check_pointer = "st-modified:";
+	    me->if_ok = miLAST_MODIFIED;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was L, found A, checking for 'st-modified:'\n"));
+	    break;
+
+	case 'i':
+	case 'I':
+	    me->check_pointer = "nk:";
+	    me->if_ok = miLINK;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was L, found I, checking for 'nk:'\n"));
+	    break;
+
+	case 'o':
+	case 'O':
+	    me->check_pointer = "cation:";
+	    me->if_ok = miLOCATION;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was L, found O, checking for 'cation:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'a', 'i' or 'o'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miP:			/* Check for 'r' or 'u' */
+	switch (c) {
+	case 'r':
+	case 'R':
+	    me->state = miPR;
+	    CTRACE((tfp, "HTMIME: Was P, found R, state now PR'\n"));
+	    break;
+
+	case 'u':
+	case 'U':
+	    me->check_pointer = "blic:";
+	    me->if_ok = miPUBLIC;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was P, found U, checking for 'blic:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'r' or 'u'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miPR:			/* Check for 'a' or 'o' */
+	switch (c) {
+	case 'a':
+	case 'A':
+	    me->check_pointer = "gma:";
+	    me->if_ok = miPRAGMA;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was PR, found A, checking for 'gma'\n"));
+	    break;
+
+	case 'o':
+	case 'O':
+	    me->check_pointer = "xy-authenticate:";
+	    me->if_ok = miPROXY_AUTHENTICATE;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was PR, found O, checking for 'xy-authenticate'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'a' or 'o'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miR:			/* Check for 'e' */
+	switch (c) {
+	case 'e':
+	case 'E':
+	    me->state = miRE;
+	    CTRACE((tfp, "HTMIME: Was R, found E\n"));
+	    break;
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'e'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miRE:			/* Check for 'a' or 'o' */
+	switch (c) {
+	case 'f':
+	case 'F':		/* nonstandard: Netscape */
+	    me->check_pointer = "resh:";
+	    me->if_ok = miREFRESH;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was RE, found F, checking for '%s'\n", me->check_pointer));
+	    break;
+
+	case 't':
+	case 'T':
+	    me->check_pointer = "ry-after:";
+	    me->if_ok = miRETRY_AFTER;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was RE, found T, checking for '%s'\n", me->check_pointer));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'f' or 't'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miS:			/* Check for 'a' or 'e' */
+	switch (c) {
+	case 'a':
+	case 'A':
+	    me->check_pointer = "fe:";
+	    me->if_ok = miSAFE;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was S, found A, checking for 'fe:'\n"));
+	    break;
+
+	case 'e':
+	case 'E':
+	    me->state = miSE;
+	    CTRACE((tfp, "HTMIME: Was S, found E, state now SE'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'a' or 'e'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miSE:			/* Check for 'r' or 't' */
+	switch (c) {
+	case 'r':
+	case 'R':
+	    me->check_pointer = "ver:";
+	    me->if_ok = miSERVER;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was SE, found R, checking for 'ver'\n"));
+	    break;
+
+	case 't':
+	case 'T':
+	    me->check_pointer = "-cookie";
+	    me->if_ok = miSET_COOKIE;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was SE, found T, checking for '-cookie'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'r' or 't'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miSET_COOKIE:		/* Check for ':' or '2' */
+	switch (c) {
+	case ':':
+	    me->field = miSET_COOKIE1;	/* remember it */
+	    me->state = miSKIP_GET_VALUE;
+	    CTRACE((tfp, "HTMIME: Was SET_COOKIE, found :, processing\n"));
+	    break;
+
+	case '2':
+	    me->check_pointer = ":";
+	    me->if_ok = miSET_COOKIE2;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was SET_COOKIE, found 2, checking for ':'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "':' or '2'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miT:			/* Check for 'i' or 'r' */
+	switch (c) {
+	case 'i':
+	case 'I':
+	    me->check_pointer = "tle:";
+	    me->if_ok = miTITLE;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was T, found I, checking for 'tle:'\n"));
+	    break;
+
+	case 'r':
+	case 'R':
+	    me->check_pointer = "ansfer-encoding:";
+	    me->if_ok = miTRANSFER_ENCODING;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was T, found R, checking for 'ansfer-encoding'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'i' or 'r'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miU:			/* Check for 'p' or 'r' */
+	switch (c) {
+	case 'p':
+	case 'P':
+	    me->check_pointer = "grade:";
+	    me->if_ok = miUPGRADE;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was U, found P, checking for 'grade:'\n"));
+	    break;
+
+	case 'r':
+	case 'R':
+	    me->check_pointer = "i:";
+	    me->if_ok = miURI;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was U, found R, checking for 'i:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'p' or 'r'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miV:			/* Check for 'a' or 'i' */
+	switch (c) {
+	case 'a':
+	case 'A':
+	    me->check_pointer = "ry:";
+	    me->if_ok = miVARY;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was V, found A, checking for 'ry:'\n"));
+	    break;
+
+	case 'i':
+	case 'I':
+	    me->check_pointer = "a:";
+	    me->if_ok = miVIA;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was V, found I, checking for 'a:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'a' or 'i'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miW:			/* Check for 'a' or 'w' */
+	switch (c) {
+	case 'a':
+	case 'A':
+	    me->check_pointer = "rning:";
+	    me->if_ok = miWARNING;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was W, found A, checking for 'rning:'\n"));
+	    break;
+
+	case 'w':
+	case 'W':
+	    me->check_pointer = "w-authenticate:";
+	    me->if_ok = miWWW_AUTHENTICATE;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was W, found W, checking for 'w-authenticate:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, "'a' or 'w'"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miCHECK:		/* Check against string */
+	if (TOLOWER(c) == *(me->check_pointer)++) {
+	    if (!*me->check_pointer)
+		me->state = me->if_ok;
+	} else {		/* Error */
+	    CTRACE((tfp,
+		    "HTMIME: Bad character `%c' found where `%s' expected\n",
+		    c, me->check_pointer - 1));
+	    goto bad_field_name;
+	}
+	break;
+
+    case miCONTENT_:
+	CTRACE((tfp, "HTMIME: in case CONTENT_\n"));
+
+	switch (c) {
+	case 'b':
+	case 'B':
+	    me->check_pointer = "ase:";
+	    me->if_ok = miCONTENT_BASE;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_, found B, checking for 'ase:'\n"));
+	    break;
+
+	case 'd':
+	case 'D':
+	    me->check_pointer = "isposition:";
+	    me->if_ok = miCONTENT_DISPOSITION;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_, found D, checking for 'isposition:'\n"));
+	    break;
+
+	case 'e':
+	case 'E':
+	    me->check_pointer = "ncoding:";
+	    me->if_ok = miCONTENT_ENCODING;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_, found E, checking for 'ncoding:'\n"));
+	    break;
+
+	case 'f':
+	case 'F':
+	    me->check_pointer = "eatures:";
+	    me->if_ok = miCONTENT_FEATURES;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_, found F, checking for 'eatures:'\n"));
+	    break;
+
+	case 'l':
+	case 'L':
+	    me->state = miCONTENT_L;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_, found L, state now CONTENT_L\n"));
+	    break;
+
+	case 'm':
+	case 'M':
+	    me->check_pointer = "d5:";
+	    me->if_ok = miCONTENT_MD5;
+	    me->state = miCHECK;
+	    CTRACE((tfp, "HTMIME: Was CONTENT_, found M, checking for 'd5:'\n"));
+	    break;
+
+	case 'r':
+	case 'R':
+	    me->check_pointer = "ange:";
+	    me->if_ok = miCONTENT_RANGE;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_, found R, checking for 'ange:'\n"));
+	    break;
+
+	case 't':
+	case 'T':
+	    me->state = miCONTENT_T;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_, found T, state now CONTENT_T\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp, "HTMIME: Was CONTENT_, found nothing; bleah\n"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miCONTENT_L:
+	CTRACE((tfp, "HTMIME: in case CONTENT_L\n"));
+
+	switch (c) {
+	case 'a':
+	case 'A':
+	    me->check_pointer = "nguage:";
+	    me->if_ok = miCONTENT_LANGUAGE;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_L, found A, checking for 'nguage:'\n"));
+	    break;
+
+	case 'e':
+	case 'E':
+	    me->check_pointer = "ngth:";
+	    me->if_ok = miCONTENT_LENGTH;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_L, found E, checking for 'ngth:'\n"));
+	    break;
+
+	case 'o':
+	case 'O':
+	    me->check_pointer = "cation:";
+	    me->if_ok = miCONTENT_LOCATION;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_L, found O, checking for 'cation:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp, "HTMIME: Was CONTENT_L, found nothing; bleah\n"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miCONTENT_T:
+	CTRACE((tfp, "HTMIME: in case CONTENT_T\n"));
+
+	switch (c) {
+	case 'r':
+	case 'R':
+	    me->check_pointer = "ansfer-encoding:";
+	    me->if_ok = miCONTENT_TRANSFER_ENCODING;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_T, found R, checking for 'ansfer-encoding:'\n"));
+	    break;
+
+	case 'y':
+	case 'Y':
+	    me->check_pointer = "pe:";
+	    me->if_ok = miCONTENT_TYPE;
+	    me->state = miCHECK;
+	    CTRACE((tfp,
+		    "HTMIME: Was CONTENT_T, found Y, checking for 'pe:'\n"));
+	    break;
+
+	default:
+	    CTRACE((tfp, "HTMIME: Was CONTENT_T, found nothing; bleah\n"));
+	    goto bad_field_name;
+
+	}			/* switch on character */
+	break;
+
+    case miACCEPT_RANGES:
+    case miAGE:
+    case miALLOW:
+    case miALTERNATES:
+    case miCACHE_CONTROL:
+    case miCOOKIE:
+    case miCONNECTION:
+    case miCONTENT_BASE:
+    case miCONTENT_DISPOSITION:
+    case miCONTENT_ENCODING:
+    case miCONTENT_FEATURES:
+    case miCONTENT_LANGUAGE:
+    case miCONTENT_LENGTH:
+    case miCONTENT_LOCATION:
+    case miCONTENT_MD5:
+    case miCONTENT_RANGE:
+    case miCONTENT_TRANSFER_ENCODING:
+    case miCONTENT_TYPE:
+    case miDATE:
+    case miETAG:
+    case miEXPIRES:
+    case miKEEP_ALIVE:
+    case miLAST_MODIFIED:
+    case miLINK:
+    case miLOCATION:
+    case miPRAGMA:
+    case miPROXY_AUTHENTICATE:
+    case miPUBLIC:
+    case miREFRESH:
+    case miRETRY_AFTER:
+    case miSAFE:
+    case miSERVER:
+    case miSET_COOKIE1:
+    case miSET_COOKIE2:
+    case miTITLE:
+    case miTRANSFER_ENCODING:
+    case miUPGRADE:
+    case miURI:
+    case miVARY:
+    case miVIA:
+    case miWARNING:
+    case miWWW_AUTHENTICATE:
+	me->field = me->state;	/* remember it */
+	me->state = miSKIP_GET_VALUE;
+	/* FALLTHRU */
+
+    case miSKIP_GET_VALUE:
+	if (c == '\n') {
+	    me->fold_state = me->state;
+	    me->state = miNEWLINE;
+	    break;
+	}
+	if (WHITE(c))
+	    /*
+	     * Skip white space.
+	     */
+	    break;
+
+	me->value_pointer = me->value;
+	me->state = miGET_VALUE;
+	/* Fall through to store first character */
+	/* FALLTHRU */
+
+    case miGET_VALUE:
+      GET_VALUE:
+	if (c != '\n') {	/* Not end of line */
+	    if (me->value_pointer < me->value + VALUE_SIZE - 1) {
+		*me->value_pointer++ = (char) c;
+		break;
+	    } else {
+		goto value_too_long;
+	    }
+	}
+	/* Fall through (if end of line) */
+	/* FALLTHRU */
+
+    case miJUNK_LINE:
+	if (c == '\n') {
+	    me->fold_state = me->state;
+	    me->state = miNEWLINE;
+	}
+	break;
+
+    }				/* switch on state */
+
+    HTChunkPutc(&me->anchor->http_headers, UCH(c));
+    if (me->state == MIME_TRANSPARENT) {
+	HTChunkTerminate(&me->anchor->http_headers);
+	CTRACE((tfp, "Server Headers (%d bytes):\n%.*s\n",
+		me->anchor->http_headers.size,
+		me->anchor->http_headers.size,
+		me->anchor->http_headers.data));
+	CTRACE((tfp, "Server Content-Type:%s\n",
+		me->anchor->content_type_params));
+    }
+    return;
+
+  value_too_long:
+    CTRACE((tfp, "HTMIME: *** Syntax error. (string too long)\n"));
+
+  bad_field_name:		/* Ignore it */
+    me->state = miJUNK_LINE;
+
+    HTChunkPutc(&me->anchor->http_headers, UCH(c));
+
+    return;
+}
+
+/*	String handling
+ *	---------------
+ *
+ *	Strings must be smaller than this buffer size.
+ */
+static void HTMIME_put_string(HTStream *me,
+			      const char *s)
+{
+    const char *p;
+
+    if (me->state == MIME_TRANSPARENT) {	/* Optimisation */
+	(*me->targetClass.put_string) (me->target, s);
+
+    } else if (me->state != MIME_IGNORE) {
+	CTRACE((tfp, "HTMIME:  %s\n", s));
+
+	for (p = s; *p; p++)
+	    HTMIME_put_character(me, *p);
+    }
+}
+
+/*	Buffer write.  Buffers can (and should!) be big.
+ *	------------
+ */
+static void HTMIME_write(HTStream *me,
+			 const char *s,
+			 int l)
+{
+    const char *p;
+
+    if (me->state == MIME_TRANSPARENT) {	/* Optimisation */
+	(*me->targetClass.put_block) (me->target, s, l);
+
+    } else {
+	CTRACE((tfp, "HTMIME:  %.*s\n", l, s));
+
+	for (p = s; p < s + l; p++)
+	    HTMIME_put_character(me, *p);
+    }
+}
+
+/*	Free an HTML object
+ *	-------------------
+ *
+ */
+static void HTMIME_free(HTStream *me)
+{
+    if (me) {
+	FREE(me->location);
+	FREE(me->compression_encoding);
+	if (me->target)
+	    (*me->targetClass._free) (me->target);
+	FREE(me);
+    }
+}
+
+/*	End writing
+*/
+static void HTMIME_abort(HTStream *me,
+			 HTError e)
+{
+    if (me) {
+	FREE(me->location);
+	FREE(me->compression_encoding);
+	if (me->target)
+	    (*me->targetClass._abort) (me->target, e);
+	FREE(me);
+    }
+}
+
+/*	Structured Object Class
+ *	-----------------------
+ */
+static const HTStreamClass HTMIME =
+{
+    "MIMEParser",
+    HTMIME_free,
+    HTMIME_abort,
+    HTMIME_put_character,
+    HTMIME_put_string,
+    HTMIME_write
+};
+
+/*	Subclass-specific Methods
+ *	-------------------------
+ */
+HTStream *HTMIMEConvert(HTPresentation *pres,
+			HTParentAnchor *anchor,
+			HTStream *sink)
+{
+    HTStream *me;
+
+    CTRACE((tfp, "HTMIMEConvert\n"));
+    me = typecalloc(HTStream);
+
+    if (me == NULL)
+	outofmem(__FILE__, "HTMIMEConvert");
+
+    me->isa = &HTMIME;
+    me->sink = sink;
+    me->anchor = anchor;
+    me->anchor->safe = FALSE;
+    me->anchor->no_cache = FALSE;
+
+    FREE(me->anchor->cache_control);
+    FREE(me->anchor->SugFname);
+    FREE(me->anchor->charset);
+
+    HTChunkClear(&me->anchor->http_headers);
+    HTChunkInit(&me->anchor->http_headers, 128);
+
+    FREE(me->anchor->content_type_params);
+    FREE(me->anchor->content_language);
+    FREE(me->anchor->content_encoding);
+    FREE(me->anchor->content_base);
+    FREE(me->anchor->content_disposition);
+    FREE(me->anchor->content_location);
+    FREE(me->anchor->content_md5);
+
+    me->anchor->inHEAD = TRUE;
+    me->anchor->header_length = 0;
+    me->anchor->content_length = 0;
+
+    FREE(me->anchor->date);
+    FREE(me->anchor->expires);
+    FREE(me->anchor->last_modified);
+    FREE(me->anchor->ETag);
+    FREE(me->anchor->server);
+
+    me->target = NULL;
+    me->state = miBEGINNING_OF_LINE;
+    me->format = HTAtom_for(ContentTypes[LYContentType]);
+
+    CTRACE((tfp, "default Content-Type is %s\n", HTAtom_name(me->format)));
+    me->targetRep = pres->rep_out;
+    me->boundary = NULL;	/* Not set yet */
+    me->set_cookie = NULL;	/* Not set yet */
+    me->set_cookie2 = NULL;	/* Not set yet */
+    me->refresh_url = NULL;	/* Not set yet */
+    me->c_t_encoding = 0;	/* Not set yet */
+    me->compression_encoding = NULL;	/* Not set yet */
+    me->net_ascii = NO;		/* Local character set */
+
+    HTAnchor_setUCInfoStage(me->anchor, current_char_set,
+			    UCT_STAGE_STRUCTURED,
+			    UCT_SETBY_DEFAULT);
+    HTAnchor_setUCInfoStage(me->anchor, current_char_set,
+			    UCT_STAGE_HTEXT,
+			    UCT_SETBY_DEFAULT);
+    return me;
+}
+
+HTStream *HTNetMIME(HTPresentation *pres,
+		    HTParentAnchor *anchor,
+		    HTStream *sink)
+{
+    HTStream *me = HTMIMEConvert(pres, anchor, sink);
+
+    if (!me)
+	return NULL;
+
+    me->net_ascii = YES;
+    return me;
+}
+
+HTStream *HTMIMERedirect(HTPresentation *pres,
+			 HTParentAnchor *anchor,
+			 HTStream *sink)
+{
+    HTStream *me = HTMIMEConvert(pres, anchor, sink);
+
+    if (!me)
+	return NULL;
+
+    me->pickup_redirection = YES;
+    if (me->targetRep == WWW_DEBUG && sink)
+	me->no_streamstack = YES;
+    return me;
+}
+
+/*		Japanese header handling functions
+ *		==================================
+ *
+ *	K&Rized and added 07-Jun-96 by FM, based on:
+ *
+////////////////////////////////////////////////////////////////////////
+ *
+ *	ISO-2022-JP handling routines
+ *			&
+ *	MIME decode routines (quick hack just for ISO-2022-JP)
+ *
+ *		Thu Jan 25 10:11:42 JST 1996
+ *
+ *  Copyright (C) 1994, 1995, 1996
+ *  Shuichi Ichikawa (ichikawa@nuee.nagoya-u.ac.jp)
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either versions 2, or (at your option)
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with SKK, see the file COPYING.  If not, write to the Free
+ *  Software Foundation Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ *  MIME decoding routines
+ *
+ *	Written by S. Ichikawa,
+ *	partially inspired by encdec.c of <jh@efd.lth.se>.
+ *	Caller's buffers decode to no longer than the input strings.
+ */
+#include <LYCharVals.h>		/* S/390 -- gil -- 0163 */
+
+static char HTmm64[] =
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+static char HTmmquote[] = "0123456789ABCDEF";
+static int HTmmcont = 0;
+
+static void HTmmdec_base64(char **t,
+			   char *s)
+{
+    int d, count, j, val;
+    char *buf, *bp, nw[4], *p;
+
+    if ((buf = typeMallocn(char, strlen(s) * 3 + 1)) == 0)
+	  outofmem(__FILE__, "HTmmdec_base64");
+
+    for (bp = buf; *s; s += 4) {
+	val = 0;
+	if (s[2] == '=')
+	    count = 1;
+	else if (s[3] == '=')
+	    count = 2;
+	else
+	    count = 3;
+
+	for (j = 0; j <= count; j++) {
+	    if (!(p = StrChr(HTmm64, s[j]))) {
+		FREE(buf);
+		return;
+	    }
+	    d = (int) (p - HTmm64);
+	    d <<= (3 - j) * 6;
+	    val += d;
+	}
+	for (j = 2; j >= 0; j--) {
+	    nw[j] = (char) (val & 255);
+	    val >>= 8;
+	}
+	if (count--)
+	    *bp++ = nw[0];
+	if (count--)
+	    *bp++ = nw[1];
+	if (count)
+	    *bp++ = nw[2];
+    }
+    *bp = '\0';
+    StrAllocCopy(*t, buf);
+    FREE(buf);
+}
+
+static void HTmmdec_quote(char **t,
+			  char *s)
+{
+    char *buf, cval, *bp, *p;
+
+    if ((buf = typeMallocn(char, strlen(s) + 1)) == 0)
+	  outofmem(__FILE__, "HTmmdec_quote");
+
+    for (bp = buf; *s;) {
+	if (*s == '=') {
+	    cval = 0;
+	    if (s[1] && (p = StrChr(HTmmquote, s[1]))) {
+		cval = (char) (cval + (char) (p - HTmmquote));
+	    } else {
+		*bp++ = *s++;
+		continue;
+	    }
+	    if (s[2] && (p = StrChr(HTmmquote, s[2]))) {
+		cval = (char) (cval << 4);
+		cval = (char) (cval + (p - HTmmquote));
+		*bp++ = cval;
+		s += 3;
+	    } else {
+		*bp++ = *s++;
+	    }
+	} else if (*s == '_') {
+	    *bp++ = 0x20;
+	    s++;
+	} else {
+	    *bp++ = *s++;
+	}
+    }
+    *bp = '\0';
+    StrAllocCopy(*t, buf);
+    FREE(buf);
+}
+
+/*
+ *	HTmmdecode for ISO-2022-JP - FM
+ */
+void HTmmdecode(char **target,
+		char *source)
+{
+    char *buf;
+    char *mmbuf = NULL;
+    char *m2buf = NULL;
+    char *s, *t, *u;
+    int base64, quote;
+
+    if ((buf = typeMallocn(char, strlen(source) + 1)) == 0)
+	  outofmem(__FILE__, "HTmmdecode");
+
+    for (s = source, *(u = buf) = '\0'; *s;) {
+	if (!strncasecomp(s, "=?ISO-2022-JP?B?", 16)) {
+	    base64 = 1;
+	} else {
+	    base64 = 0;
+	}
+	if (!strncasecomp(s, "=?ISO-2022-JP?Q?", 16)) {
+	    quote = 1;
+	} else {
+	    quote = 0;
+	}
+	if (base64 || quote) {
+	    if (HTmmcont) {
+		for (t = s - 1;
+		     t >= source && (*t == ' ' || *t == '\t'); t--) {
+		    u--;
+		}
+	    }
+	    if (mmbuf == 0)	/* allocate buffer big enough for source */
+		StrAllocCopy(mmbuf, source);
+	    for (s += 16, t = mmbuf; *s;) {
+		if (s[0] == '?' && s[1] == '=') {
+		    break;
+		} else {
+		    *t++ = *s++;
+		    *t = '\0';
+		}
+	    }
+	    if (s[0] != '?' || s[1] != '=') {
+		goto end;
+	    } else {
+		s += 2;
+		*t = '\0';
+	    }
+	    if (base64)
+		HTmmdec_base64(&m2buf, mmbuf);
+	    else
+		HTmmdec_quote(&m2buf, mmbuf);
+	    for (t = m2buf; non_empty(t);)
+		*u++ = *t++;
+	    HTmmcont = 1;
+	} else {
+	    if (*s != ' ' && *s != '\t')
+		HTmmcont = 0;
+	    *u++ = *s++;
+	}
+    }
+    *u = '\0';
+  end:
+    StrAllocCopy(*target, buf);
+    FREE(m2buf);
+    FREE(mmbuf);
+    FREE(buf);
+}
+
+/*
+ *  Insert ESC where it seems lost.
+ *  (The author of this function "rjis" is S. Ichikawa.)
+ */
+int HTrjis(char **t,
+	   char *s)
+{
+    char *p;
+    char *buf = NULL;
+    int kanji = 0;
+
+    if (StrChr(s, CH_ESC) || !StrChr(s, '$')) {
+	if (s != *t)
+	    StrAllocCopy(*t, s);
+	return 1;
+    }
+
+    if ((buf = typeMallocn(char, strlen(s) * 2 + 1)) == 0)
+	  outofmem(__FILE__, "HTrjis");
+
+    for (p = buf; *s;) {
+	if (!kanji && s[0] == '$' && (s[1] == '@' || s[1] == 'B')) {
+	    if (HTmaybekanji((int) s[2], (int) s[3])) {
+		kanji = 1;
+		*p++ = CH_ESC;
+		*p++ = *s++;
+		*p++ = *s++;
+		*p++ = *s++;
+		*p++ = *s++;
+		continue;
+	    }
+	    *p++ = *s++;
+	    continue;
+	}
+	if (kanji && s[0] == '(' && (s[1] == 'J' || s[1] == 'B')) {
+	    kanji = 0;
+	    *p++ = CH_ESC;
+	    *p++ = *s++;
+	    *p++ = *s++;
+	    continue;
+	}
+	*p++ = *s++;
+    }
+    *p = *s;			/* terminate string */
+
+    StrAllocCopy(*t, buf);
+    FREE(buf);
+    return 0;
+}
+
+/*
+ *  The following function "maybekanji" is derived from
+ *  RJIS-1.0 by Mr. Hironobu Takahashi.
+ *  Maybekanji() is included here under the courtesy of the author.
+ *  The original comment of rjis.c is also included here.
+ */
+/*
+ * RJIS ( Recover JIS code from broken file )
+ * Copyright (C) 1992 1994
+ * Hironobu Takahashi (takahasi@tiny.or.jp)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either versions 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with SKK, see the file COPYING.  If not, write to the Free
+ * Software Foundation Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+int HTmaybekanji(int c1,
+		 int c2)
+{
+
+    if ((c2 < 33) || (c2 > 126))
+	return 0;
+    if ((c1 < 33) || ((40 < c1) && (c1 < 48)) || (116 < c1))
+	return 0;
+    c2 -= 32;
+    switch (c1 - 32) {
+    case 2:
+	if ((14 < c2) && (c2 < 26))
+	    return 0;
+	if ((33 < c2) && (c2 < 42))
+	    return 0;
+	if ((48 < c2) && (c2 < 60))
+	    return 0;
+	if ((74 < c2) && (c2 < 82))
+	    return 0;
+	if ((89 < c2) && (c2 < 94))
+	    return 0;
+	break;
+    case 3:
+	if (c2 < 16)
+	    return 0;
+	if ((25 < c2) && (c2 < 33))
+	    return 0;
+	if ((58 < c2) && (c2 < 65))
+	    return 0;
+	if (90 < c2)
+	    return 0;
+	break;
+    case 4:
+	if (83 < c2)
+	    return 0;
+	break;
+    case 5:
+	if (86 < c2)
+	    return 0;
+	break;
+    case 6:
+	if ((24 < c2) && (c2 < 33))
+	    return 0;
+	if (56 < c2)
+	    return 0;
+	break;
+    case 7:
+	if ((33 < c2) && (c2 < 49))
+	    return 0;
+	if (81 < c2)
+	    return 0;
+	break;
+    case 8:
+	if (32 < c2)
+	    return 0;
+	break;
+    case 47:
+	if (51 < c2)
+	    return 0;
+	break;
+    case 84:
+	if (6 < c2)
+	    return 0;
+	break;
+    }
+    return 1;
+}
diff --git a/WWW/Library/Implementation/HTMIME.h b/WWW/Library/Implementation/HTMIME.h
new file mode 100644
index 0000000..6410c15
--- /dev/null
+++ b/WWW/Library/Implementation/HTMIME.h
@@ -0,0 +1,84 @@
+/*                   /Net/dxcern/userd/timbl/hypertext/WWW/Library/Implementation/HTMIME.html
+                                       MIME PARSER
+
+   The MIME parser stream presents a MIME document.  It recursively invokes the
+   format manager to handle embedded formats.
+
+   As well as stripping off and parsing the headers, the MIME parser has to
+   parse any weirld MIME encodings it may meet within the body parts of
+   messages, and must deal with multipart messages.
+
+   This module is implemented to the level necessary for operation with WWW,
+   but is not currently complete for any arbitrary MIME message.
+
+   Check the source for latest additions to functionality.
+
+   The MIME parser is complicated by the fact that WWW allows real binary to be
+   sent, not ASCII encoded.  Therefore the netascii decoding is included in
+   this module.  One cannot layer it by converting first from Net to local
+   text, then decoding it.  Of course, for local files, the net ascii decoding
+   is not needed.  There are therefore two creation routines.
+
+ */
+#ifndef HTMIME_H
+#define HTMIME_H
+
+#include <HTStream.h>
+#include <HTAnchor.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ *  This function is for trimming off any paired
+ *  open- and close-double quotes from header values.
+ *  It does not parse the string for embedded quotes,
+ *  and will not modify the string unless both the
+ *  first and last characters are double-quotes. - FM
+ */ extern void HTMIME_TrimDoubleQuotes(char *value);
+
+/*
+
+  INPUT: LOCAL TEXT
+
+ */
+    extern HTStream *HTMIMEConvert(HTPresentation *pres,
+				   HTParentAnchor *anchor,
+				   HTStream *sink);
+
+/*
+
+  INPUT: NET ASCII
+
+ */
+    extern HTStream *HTNetMIME(HTPresentation *pres,
+			       HTParentAnchor *anchor,
+			       HTStream *sink);
+
+/*
+
+  INPUT: Redirection message, parse headers only for Location if present
+
+ */
+    extern HTStream *HTMIMERedirect(HTPresentation *pres,
+				    HTParentAnchor *anchor,
+				    HTStream *sink);
+
+/*
+
+  For handling Japanese headers.
+
+*/
+    extern void HTmmdecode(char **target,
+			   char *source);
+
+    extern int HTrjis(char **target,
+		      char *source);
+
+    extern int HTmaybekanji(int c1,
+			    int c2);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* !HTMIME_H */
diff --git a/WWW/Library/Implementation/HTMLDTD.c b/WWW/Library/Implementation/HTMLDTD.c
new file mode 100644
index 0000000..382c141
--- /dev/null
+++ b/WWW/Library/Implementation/HTMLDTD.c
@@ -0,0 +1,334 @@
+/*
+ * $LynxId: HTMLDTD.c,v 1.58 2021/07/23 00:00:03 tom Exp $
+ *
+ *		Our Static DTD for HTML
+ *		-----------------------
+ */
+
+/* Implements:
+*/
+
+#include <HTUtils.h>
+#include <HTMLDTD.h>
+#include <LYLeaks.h>
+#include <LYJustify.h>
+
+/*
+ * Character entities like &nbsp now excluded from our DTD tables, they are
+ * mapped to Unicode and handled by chartrans code directly the similar way the
+ * numeric entities like &#123 does.  See src/chrtrans/entities.h for real
+ * mapping.
+ */
+
+/*	Entity Names
+ *	------------
+ *
+ *	This table must be matched exactly with ALL the translation tables
+ *		(this is an obsolete translation mechanism, probably unused,
+ *		currently replaced with Unicode chartrans in most cases...)
+ */
+static const char *entities[] =
+{
+    "AElig",			/* capital AE diphthong (ligature) */
+    "Aacute",			/* capital A, acute accent */
+    "Acirc",			/* capital A, circumflex accent */
+    "Agrave",			/* capital A, grave accent */
+    "Aring",			/* capital A, ring */
+    "Atilde",			/* capital A, tilde */
+    "Auml",			/* capital A, dieresis or umlaut mark */
+    "Ccedil",			/* capital C, cedilla */
+    "Dstrok",			/* capital Eth, Icelandic */
+    "ETH",			/* capital Eth, Icelandic */
+    "Eacute",			/* capital E, acute accent */
+    "Ecirc",			/* capital E, circumflex accent */
+    "Egrave",			/* capital E, grave accent */
+    "Euml",			/* capital E, dieresis or umlaut mark */
+    "Iacute",			/* capital I, acute accent */
+    "Icirc",			/* capital I, circumflex accent */
+    "Igrave",			/* capital I, grave accent */
+    "Iuml",			/* capital I, dieresis or umlaut mark */
+    "Ntilde",			/* capital N, tilde */
+    "Oacute",			/* capital O, acute accent */
+    "Ocirc",			/* capital O, circumflex accent */
+    "Ograve",			/* capital O, grave accent */
+    "Oslash",			/* capital O, slash */
+    "Otilde",			/* capital O, tilde */
+    "Ouml",			/* capital O, dieresis or umlaut mark */
+    "THORN",			/* capital THORN, Icelandic */
+    "Uacute",			/* capital U, acute accent */
+    "Ucirc",			/* capital U, circumflex accent */
+    "Ugrave",			/* capital U, grave accent */
+    "Uuml",			/* capital U, dieresis or umlaut mark */
+    "Yacute",			/* capital Y, acute accent */
+    "aacute",			/* small a, acute accent */
+    "acirc",			/* small a, circumflex accent */
+    "acute",			/* spacing acute */
+    "aelig",			/* small ae diphthong (ligature) */
+    "agrave",			/* small a, grave accent */
+    "amp",			/* ampersand */
+    "aring",			/* small a, ring */
+    "atilde",			/* small a, tilde */
+    "auml",			/* small a, dieresis or umlaut mark */
+    "brkbar",			/* broken vertical bar */
+    "brvbar",			/* broken vertical bar */
+    "ccedil",			/* small c, cedilla */
+    "cedil",			/* spacing cedilla */
+    "cent",			/* cent sign */
+    "copy",			/* copyright sign */
+    "curren",			/* currency sign */
+    "deg",			/* degree sign */
+    "die",			/* spacing dieresis */
+    "divide",			/* division sign */
+    "eacute",			/* small e, acute accent */
+    "ecirc",			/* small e, circumflex accent */
+    "egrave",			/* small e, grave accent */
+    "emdash",			/* dash the width of emsp */
+    "emsp",			/* em space - not collapsed */
+    "endash",			/* dash the width of ensp */
+    "ensp",			/* en space - not collapsed */
+    "eth",			/* small eth, Icelandic */
+    "euml",			/* small e, dieresis or umlaut mark */
+    "frac12",			/* fraction 1/2 */
+    "frac14",			/* fraction 1/4 */
+    "frac34",			/* fraction 3/4 */
+    "gt",			/* greater than */
+    "hibar",			/* spacing macron */
+    "iacute",			/* small i, acute accent */
+    "icirc",			/* small i, circumflex accent */
+    "iexcl",			/* inverted exclamation mark */
+    "igrave",			/* small i, grave accent */
+    "iquest",			/* inverted question mark */
+    "iuml",			/* small i, dieresis or umlaut mark */
+    "laquo",			/* angle quotation mark, left */
+    "lt",			/* less than */
+    "macr",			/* spacing macron */
+    "mdash",			/* dash the width of emsp */
+    "micro",			/* micro sign */
+    "middot",			/* middle dot */
+    "nbsp",			/* non breaking space */
+    "ndash",			/* dash the width of ensp */
+    "not",			/* negation sign */
+    "ntilde",			/* small n, tilde */
+    "oacute",			/* small o, acute accent */
+    "ocirc",			/* small o, circumflex accent */
+    "ograve",			/* small o, grave accent */
+    "ordf",			/* feminine ordinal indicator */
+    "ordm",			/* masculine ordinal indicator */
+    "oslash",			/* small o, slash */
+    "otilde",			/* small o, tilde */
+    "ouml",			/* small o, dieresis or umlaut mark */
+    "para",			/* paragraph sign */
+    "plusmn",			/* plus-or-minus sign */
+    "pound",			/* pound sign */
+    "quot",			/* quote '"' */
+    "raquo",			/* angle quotation mark, right */
+    "reg",			/* circled R registered sign */
+    "sect",			/* section sign */
+    "shy",			/* soft hyphen */
+    "sup1",			/* superscript 1 */
+    "sup2",			/* superscript 2 */
+    "sup3",			/* superscript 3 */
+    "szlig",			/* small sharp s, German (sz ligature) */
+    "thinsp",			/* thin space (not collapsed) */
+    "thorn",			/* small thorn, Icelandic */
+    "times",			/* multiplication sign */
+    "trade",			/* trade mark sign (U+2122) */
+    "uacute",			/* small u, acute accent */
+    "ucirc",			/* small u, circumflex accent */
+    "ugrave",			/* small u, grave accent */
+    "uml",			/* spacing dieresis */
+    "uuml",			/* small u, dieresis or umlaut mark */
+    "yacute",			/* small y, acute accent */
+    "yen",			/* yen sign */
+    "yuml",			/* small y, dieresis or umlaut mark */
+};
+
+/*		Attribute Lists
+ *		---------------
+ *
+ *	Lists must be in alphabetical order by attribute name
+ *	The tag elements contain the number of attributes
+ */
+
+/* From Peter Flynn's intro to the HTML Pro DTD:
+
+   %structure;
+
+   DIV, CENTER, H1 to H6, P, UL, OL, DL, DIR, MENU, PRE, XMP, LISTING, BLOCKQUOTE, BQ,
+   2	1	2     2   1  8	 8   8	 8    8     8	 8    8        4	   4
+   MULTICOL,?NOBR, FORM, TABLE, ADDRESS, FIG, BDO, NOTE, and FN; plus?WBR, LI, and LH
+   8 n	    ?1 n   8	 8	2	 2    2    2	     2	    ?1 nE  4	   4
+
+   %insertions;
+
+   Elements which usually contain special-purpose material, or no text material at all.
+
+   BASEFONT, APPLET, OBJECT, EMBED, SCRIPT, MAP, MARQUEE, HR, ISINDEX, BGSOUND, TAB,?IMG,
+   1 e?      2	     2 l     1 e    2 l     8	 4	  4 E 1? E     1 E	! E ?1 E
+   IMAGE, BR, plus NOEMBED, SERVER, SPACER, AUDIOSCOPE, and SIDEBAR; ?area
+   1 n	  1 E	     n	      n	      n	      n		      n	      8 E
+
+   %text;
+
+   Elements within the %structure; which directly contain running text.
+
+   Descriptive or analytic markup: EM, STRONG, DFN, CODE, SAMP, KBD, VAR, CITE, Q, LANG, AU,
+				   2   2       2    2	  2	2    2	  2	2  2 n	 2
+   AUTHOR, PERSON, ACRONYM, ABBR, INS, DEL, and SPAN
+   2	   2 n	   2	    2	    2	 2	  2
+   Visual markup:S, STRIKE, I, B, TT, U,?NOBR,?WBR, BR, BIG, SMALL, FONT, STYLE, BLINK, TAB,
+		 1  1	    1  1  1   1  ?1 n ?1nE? 1 E  1   1	    1	  1 l	 1	1 E?
+   BLACKFACE, LIMITTEXT, NOSMARTQUOTES, and SHADOW
+   1 n	      1 n	 1 n		    1 n
+   Hypertext and graphics: A and?IMG
+			   8	?8 E
+   Mathematical: SUB, SUP, and MATH
+		 4    4        4 l
+   Documentary: COMMENT, ENTITY, ELEMENT, and ATTRIB
+		4	 4 n	 4 n	      4 n
+   %formula;
+ */
+
+/*	Elements
+ *	--------
+ *
+ *	Must match definitions in HTMLDTD.html!
+ *	Must be in alphabetical order.
+ *
+ *  The T_* extra info is listed here, even though most fields are not used
+ *  in SGML.c if Old_DTD is set (with the exception of some Tgf_* flags).
+ *  This simplifies comparison of the tags_table0[] table (otherwise unchanged
+ *  from original Lynx treatment) with the tags_table1[] table below. - kw
+ *
+ *    Name*,	Attributes,	No. of attributes,     content,   extra info...
+ */
+
+#include <src0_HTMLDTD.h>
+#include <src1_HTMLDTD.h>
+
+/* Dummy space, will be filled with the contents of either tags_table1
+   or tags_table0 on calling HTSwitchDTD - kw */
+
+static HTTag tags[HTML_ALL_ELEMENTS];
+
+const SGML_dtd HTML_dtd =
+{
+    tags,
+    HTML_ELEMENTS,
+    entities,			/* probably unused */
+    TABLESIZE(entities),
+};
+
+/* This function fills the "tags" part of the HTML_dtd structure with
+   what we want to use, either tags_table0 or tags_table1.  Note that it
+   has to be called at least once before HTML_dtd is used, otherwise
+   the HTML_dtd contents will be invalid!  This could be coded in a way
+   that would make an initialisation call unnecessary, but my C knowledge
+   is limited and I didn't want to list the whole tags_table1 table
+   twice... - kw */
+void HTSwitchDTD(int new_flag)
+{
+    if (TRACE)
+	CTRACE((tfp,
+		"HTMLDTD: Copying %s DTD element info of size %d, %d * %d\n",
+		new_flag ? "strict" : "tagsoup",
+		(int) (new_flag ? sizeof(tags_table1) : sizeof(tags_table0)),
+		HTML_ALL_ELEMENTS,
+		(int) sizeof(HTTag)));
+    if (new_flag)
+	MemCpy(tags, tags_table1, HTML_ALL_ELEMENTS * sizeof(HTTag));
+    else
+	MemCpy(tags, tags_table0, HTML_ALL_ELEMENTS * sizeof(HTTag));
+}
+
+HTTag HTTag_unrecognized =
+
+{NULL_HTTag, NULL, 0, 0, SGML_EMPTY, T__UNREC_, 0, 0};
+
+/*
+ *	Utility Routine:  Useful for people building HTML objects.
+ */
+
+/*	Start anchor element
+ *	--------------------
+ *
+ *	It is kinda convenient to have a particulr routine for
+ *	starting an anchor element, as everything else for HTML is
+ *	simple anyway.
+ */
+struct _HTStructured {
+    HTStructuredClass *isa;
+    /* ... */
+};
+
+void HTStartAnchor(HTStructured * obj, const char *name,
+		   const char *href)
+{
+    BOOL present[HTML_A_ATTRIBUTES];
+    const char *value[HTML_A_ATTRIBUTES];
+    int i;
+
+    for (i = 0; i < HTML_A_ATTRIBUTES; i++)
+	present[i] = NO;
+
+    if (name && *name) {
+	present[HTML_A_NAME] = YES;
+	value[HTML_A_NAME] = (const char *) name;
+    }
+    if (href) {
+	present[HTML_A_HREF] = YES;
+	value[HTML_A_HREF] = (const char *) href;
+    }
+
+    (*obj->isa->start_element) (obj, HTML_A, present, value, -1, 0);
+}
+
+void HTStartAnchor5(HTStructured * obj, const char *name,
+		    const char *href,
+		    const char *linktype,
+		    int tag_charset)
+{
+    BOOL present[HTML_A_ATTRIBUTES];
+    const char *value[HTML_A_ATTRIBUTES];
+    int i;
+
+    for (i = 0; i < HTML_A_ATTRIBUTES; i++)
+	present[i] = NO;
+
+    if (name && *name) {
+	present[HTML_A_NAME] = YES;
+	value[HTML_A_NAME] = name;
+    }
+    if (href && *href) {
+	present[HTML_A_HREF] = YES;
+	value[HTML_A_HREF] = href;
+    }
+    if (linktype && *linktype) {
+	present[HTML_A_TYPE] = YES;
+	value[HTML_A_TYPE] = linktype;
+    }
+
+    (*obj->isa->start_element) (obj, HTML_A, present, value, tag_charset, 0);
+}
+
+void HTStartIsIndex(HTStructured * obj, const char *prompt,
+		    const char *href)
+{
+    BOOL present[HTML_ISINDEX_ATTRIBUTES];
+    const char *value[HTML_ISINDEX_ATTRIBUTES];
+    int i;
+
+    for (i = 0; i < HTML_ISINDEX_ATTRIBUTES; i++)
+	present[i] = NO;
+
+    if (prompt && *prompt) {
+	present[HTML_ISINDEX_PROMPT] = YES;
+	value[HTML_ISINDEX_PROMPT] = (const char *) prompt;
+    }
+    if (href) {
+	present[HTML_ISINDEX_HREF] = YES;
+	value[HTML_ISINDEX_HREF] = (const char *) href;
+    }
+
+    (*obj->isa->start_element) (obj, HTML_ISINDEX, present, value, -1, 0);
+}
diff --git a/WWW/Library/Implementation/HTMLDTD.h b/WWW/Library/Implementation/HTMLDTD.h
new file mode 100644
index 0000000..10b0308
--- /dev/null
+++ b/WWW/Library/Implementation/HTMLDTD.h
@@ -0,0 +1,97 @@
+/*
+ * $LynxId: HTMLDTD.h,v 1.32 2008/07/06 17:38:13 tom Exp $
+ *
+			      The HTML DTD -- software interface in libwww
+			      HTML DTD - SOFTWARE INTERFACE
+
+   SGML purists should excuse the use of the term "DTD" in this file to
+   represent DTD-related information which is not exactly a DTD itself.
+
+   The C modular structure doesn't work very well here, as the dtd is
+   partly in the .h and partly in the .c which are not very independent.
+   Tant pis.
+
+ */
+#ifndef HTMLDTD_H
+#define HTMLDTD_H
+
+#include <SGML.h>
+#include <HTFont.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ *  Valid name chars for tag parsing.
+ */
+#define IsNmStart(c) (isalpha(UCH(c)))
+#define IsNmChar(c) (isalnum(UCH(c)) || \
+		      c == '_' || c=='-' || c == '.' || c==':')
+#define ReallyEmptyTagNum(e) ((HTML_dtd.tags[e].contents == SGML_EMPTY) && \
+			      !(HTML_dtd.tags[e].flags & Tgf_nreie))
+#define ReallyEmptyTag(t) ((t->contents == SGML_EMPTY) && \
+			   !(t->flags & Tgf_nreie))
+
+#include <hdr_HTMLDTD.h>
+
+#ifdef USE_PRETTYSRC
+/* values of HTML attributes' types */
+#define HTMLA_NORMAL 0		/* nothing specific */
+#define HTMLA_ANAME  1		/* anchor name - 'id' or a's 'name' */
+#define HTMLA_HREF   2		/* href */
+#define HTMLA_CLASS  4		/* class name.  */
+#define HTMLA_AUXCLASS 8	/* attribute, the value of which also designates
+				   a class name */
+#endif
+    extern const SGML_dtd HTML_dtd;
+
+    extern void HTSwitchDTD(int new_flag);
+
+    extern HTTag HTTag_unrecognized;
+    extern HTTag HTTag_mixedObject;
+
+/*
+
+Start anchor element
+
+   It is kinda convenient to have a particular routine for starting an anchor
+   element, as everything else for HTML is simple anyway.
+
+  ON ENTRY
+
+   targetstream points to a structured stream object.
+
+   name and href point to attribute strings or are NULL if the attribute is
+   to be omitted.
+
+ */
+    extern void HTStartAnchor(HTStructured * targetstream, const char *name,
+			      const char *href);
+
+    extern void HTStartAnchor5(HTStructured * targetstream, const char *name,
+			       const char *href,
+			       const char *linktype,
+			       int tag_charset);
+
+/*
+
+Start IsIndex element - FM
+
+   It is kinda convenient to have a particular routine for starting an IsIndex
+   element with the prompt and/or href (action) attributes specified.
+
+  ON ENTRY
+
+   targetstream points to a structured stream object.
+
+   prompt and href point to attribute strings or are NULL if the attribute is
+   to be omitted.
+
+ */
+    extern void HTStartIsIndex(HTStructured * targetstream, const char *prompt,
+			       const char *href);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTMLDTD_H */
diff --git a/WWW/Library/Implementation/HTMLGen.c b/WWW/Library/Implementation/HTMLGen.c
new file mode 100644
index 0000000..c63723c
--- /dev/null
+++ b/WWW/Library/Implementation/HTMLGen.c
@@ -0,0 +1,738 @@
+/*
+ * $LynxId: HTMLGen.c,v 1.46 2020/01/21 22:02:35 tom Exp $
+ *
+ *		HTML Generator
+ *		==============
+ *
+ *	This version of the HTML object sends HTML markup to the output stream.
+ *
+ * Bugs:	Line wrapping is not done at all.
+ *		All data handled as PCDATA.
+ *		Should convert old XMP, LISTING and PLAINTEXT to PRE.
+ *
+ *	It is not obvious to me right now whether the HEAD should be generated
+ *	from the incoming data or the anchor.	Currently it is from the former
+ *	which is cleanest.
+ */
+
+#define HTSTREAM_INTERNAL 1
+
+#include <HTUtils.h>
+
+#define BUFFER_SIZE    200	/* Line buffer attempts to make neat breaks */
+#define MAX_CLEANNESS	20
+
+/* Implements:
+*/
+#include <HTMLGen.h>
+
+#include <HTMLDTD.h>
+#include <HTStream.h>
+#include <SGML.h>
+#include <HTFormat.h>
+
+#ifdef USE_COLOR_STYLE
+#include <LYCharUtils.h>
+#include <AttrList.h>
+#include <LYHash.h>
+#include <LYStyle.h>
+#endif
+
+#include <LYGlobalDefs.h>
+#include <LYCurses.h>
+#include <LYLeaks.h>
+
+#ifdef USE_COLOR_STYLE
+char class_string[TEMPSTRINGSIZE + 1];
+
+static char *Style_className = NULL;
+static int hcode;
+#endif
+
+/*		HTML Object
+ *		-----------
+ */
+struct _HTStream {
+    const HTStreamClass *isa;
+    HTStream *target;
+    HTStreamClass targetClass;	/* COPY for speed */
+};
+
+struct _HTStructured {
+    const HTStructuredClass *isa;
+    HTStream *target;
+    HTStreamClass targetClass;	/* COPY for speed */
+
+    char buffer[BUFFER_SIZE + 1];	/* 1for NL */
+    int buffer_maxchars;
+    char *write_pointer;
+    char *line_break[MAX_CLEANNESS + 1];
+    int cleanness;
+    BOOL overflowed;
+    BOOL delete_line_break_char[MAX_CLEANNESS + 1];
+    BOOL preformatted;
+    BOOL escape_specials;
+    BOOL in_attrval;
+#ifdef USE_COLOR_STYLE
+    HText *text;
+#endif
+};
+
+/*	Flush Buffer
+ *	------------
+ */
+
+static void flush_breaks(HTStructured * me)
+{
+    int i;
+
+    for (i = 0; i <= MAX_CLEANNESS; i++) {
+	me->line_break[i] = NULL;
+    }
+}
+
+static void HTMLGen_flush(HTStructured * me)
+{
+    (*me->targetClass.put_block) (me->target,
+				  me->buffer,
+				  (int) (me->write_pointer - me->buffer));
+    me->write_pointer = me->buffer;
+    flush_breaks(me);
+    me->cleanness = 0;
+    me->delete_line_break_char[0] = NO;
+}
+
+#ifdef USE_COLOR_STYLE
+/*
+ * We need to flush our buffer each time before we effect a color style change,
+ * this also relies on the subsequent stage not doing any buffering - this is
+ * currently true, in cases where it matters the target stream should be the
+ * HTPlain converter.  The flushing currently prevents reasonable line breaking
+ * in lines with tags.  Since color styles help visual scanning of displayed
+ * source lines, and long lines are wrapped in GridText anyway, this is
+ * probably acceptable (or even A Good Thing - more to see in one screenful). 
+ * The pointer to the HText structure is initialized here before we effect the
+ * first style change.  Getting it from the global HTMainText variable isn't
+ * very clean, since it relies on the fact that HText_new() has already been
+ * called for the current stream stack's document by the time we start
+ * processing the first element; we rely on HTMLGenerator's callers
+ * (HTMLParsedPresent in particular) to guarantee this when it matters. 
+ * Normally the target stream will have been setup by HTPlainPresent, which
+ * does what we need in this respect.  (A check whether we have the right
+ * output stream could be done by checking that targetClass.name is
+ * "PlainPresenter" or similar.)
+ *
+ * All special color style handling is only done if LYPreparsedSource is set. 
+ * We could always do it for displaying source generated by an internal
+ * gateway, but this makes the rule more simple for the user:  color styles are
+ * applied to html source only with the -preparsed flag.  - kw
+ */
+static void do_cstyle_flush(HTStructured * me)
+{
+    if (!me->text && LYPreparsedSource) {
+	me->text = HTMainText;
+    }
+    if (me->text) {
+	HTMLGen_flush(me);
+    }
+}
+#endif /* COLOR_STYLE */
+
+/*	Weighted optional line break
+ *
+ *	We keep track of all the breaks for when we chop the line
+ */
+
+static void allow_break(HTStructured * me, int new_cleanness, int dlbc)
+{
+    if (dlbc && me->write_pointer == me->buffer)
+	dlbc = NO;
+    me->line_break[new_cleanness] =
+	dlbc ? me->write_pointer - 1	/* Point to space */
+	: me->write_pointer;	/* point to gap */
+    me->delete_line_break_char[new_cleanness] = (BOOLEAN) dlbc;
+    if (new_cleanness >= me->cleanness &&
+	(me->overflowed || me->line_break[new_cleanness] > me->buffer))
+	me->cleanness = new_cleanness;
+}
+
+/*	Character handling
+ *	------------------
+ *
+ *	The tricky bits are the line break handling.  This attempts
+ *	to synchrononise line breaks on sentence or phrase ends.  This
+ *	is important if one stores SGML files in a line-oriented code
+ *	repository, so that if a small change is made, line ends don't
+ *	shift in a ripple-through to apparently change a large part of the
+ *	file.  We give extra "cleanness" to spaces appearing directly
+ *	after periods (full stops), [semi]colons and commas.
+ *	   This should make the source files easier to read and modify
+ *	by hand, too, though this is not a primary design consideration. TBL
+ */
+static void HTMLGen_put_character(HTStructured * me, int c)
+{
+    if (me->escape_specials && UCH(c) < 32) {
+	if (c == HT_NON_BREAK_SPACE || c == HT_EN_SPACE ||
+	    c == LY_SOFT_HYPHEN) {	/* recursion... */
+	    HTMLGen_put_character(me, '&');
+	    HTMLGen_put_character(me, '#');
+	    HTMLGen_put_character(me, 'x');
+	    switch (c) {
+	    case HT_NON_BREAK_SPACE:	/* &#xA0; */
+		HTMLGen_put_character(me, 'A');
+		HTMLGen_put_character(me, '0');
+		break;
+	    case HT_EN_SPACE:	/* &#x2002; */
+		HTMLGen_put_character(me, '2');
+		HTMLGen_put_character(me, '0');
+		HTMLGen_put_character(me, '0');
+		HTMLGen_put_character(me, '2');
+		break;
+	    case LY_SOFT_HYPHEN:	/* &#xAD; */
+		HTMLGen_put_character(me, 'A');
+		HTMLGen_put_character(me, 'D');
+		break;
+	    }
+	    c = ';';
+	}
+    }
+
+    *me->write_pointer++ = (char) c;
+
+    if (c == '\n') {
+	HTMLGen_flush(me);
+	return;
+    }
+
+    /* Figure our whether we can break at this point
+     */
+    if ((!me->preformatted && (c == ' ' || c == '\t'))) {
+	int new_cleanness = 3;
+
+	if (me->write_pointer > (me->buffer + 1)) {
+	    char delims[5];
+	    char *p;
+
+	    strcpy(delims, ",;:.");	/* @@ english bias */
+	    p = StrChr(delims, me->write_pointer[-2]);
+	    if (p)
+		new_cleanness = (int) (p - delims + 6);
+	    if (!me->in_attrval)
+		new_cleanness += 10;
+	}
+	allow_break(me, new_cleanness, YES);
+    }
+
+    /*
+     * Flush buffer out when full, or whenever the line is over the nominal
+     * maximum and we can break at all
+     */
+    if (me->write_pointer >= me->buffer + me->buffer_maxchars ||
+	(me->overflowed && me->cleanness)) {
+	if (me->cleanness) {
+	    char line_break_char = me->line_break[me->cleanness][0];
+	    char *saved = me->line_break[me->cleanness];
+
+	    if (me->delete_line_break_char[me->cleanness])
+		saved++;
+	    me->line_break[me->cleanness][0] = '\n';
+	    (*me->targetClass.put_block) (me->target,
+					  me->buffer,
+					  (int) (me->line_break[me->cleanness] -
+						 me->buffer + 1));
+	    me->line_break[me->cleanness][0] = line_break_char;
+	    {			/* move next line in */
+		char *p = saved;
+		char *q;
+
+		for (q = me->buffer; p < me->write_pointer;)
+		    *q++ = *p++;
+	    }
+	    me->cleanness = 0;
+	    /* Now we have to check whether there are any perfectly good breaks
+	     * which weren't good enough for the last line but may be good
+	     * enough for the next
+	     */
+	    {
+		int i;
+
+		for (i = 0; i <= MAX_CLEANNESS; i++) {
+		    if (me->line_break[i] != NULL &&
+			me->line_break[i] > saved) {
+			me->line_break[i] = me->line_break[i] -
+			    (saved - me->buffer);
+			me->cleanness = i;
+		    } else {
+			me->line_break[i] = NULL;
+		    }
+		}
+	    }
+
+	    me->delete_line_break_char[0] = 0;
+	    me->write_pointer = me->write_pointer - (saved - me->buffer);
+	    me->overflowed = NO;
+
+	} else {
+	    (*me->targetClass.put_block) (me->target,
+					  me->buffer,
+					  me->buffer_maxchars);
+	    me->write_pointer = me->buffer;
+	    flush_breaks(me);
+	    me->overflowed = YES;
+	}
+    }
+}
+
+/*	String handling
+ *	---------------
+ */
+static void HTMLGen_put_string(HTStructured * me, const char *s)
+{
+    const char *p;
+
+    for (p = s; *p; p++)
+	HTMLGen_put_character(me, *p);
+}
+
+static void HTMLGen_write(HTStructured * me, const char *s,
+			  int l)
+{
+    const char *p;
+
+    for (p = s; p < (s + l); p++)
+	HTMLGen_put_character(me, *p);
+}
+
+/*	Start Element
+ *	-------------
+ *
+ * Within the opening tag, there may be spaces and the line may be broken at
+ * these spaces.
+ */
+static int HTMLGen_start_element(HTStructured * me, int element_number,
+				 const BOOL *present,
+				 STRING2PTR value,
+				 int charset GCC_UNUSED,
+				 char **insert GCC_UNUSED)
+{
+    int i;
+    BOOL was_preformatted = me->preformatted;
+    HTTag *tag = &HTML_dtd.tags[element_number];
+
+#if defined(USE_COLOR_STYLE)
+    char *title = NULL;
+    char *title_tmp = NULL;
+    const char *name;
+
+    if (LYPreparsedSource && (name = tag->name) != 0) {
+	char *myHash = NULL;
+
+	/*
+	 * Same logic as in HTML_start_element, copied from there.  - kw
+	 */
+	HTSprintf(&Style_className, ";%s", name);
+	StrAllocCopy(myHash, name);
+	if (class_string[0]) {
+	    StrAllocCat(myHash, ".");
+	    StrAllocCat(myHash, class_string);
+	    HTSprintf(&Style_className, ".%s", class_string);
+	}
+	class_string[0] = '\0';
+	strtolower(myHash);
+	hcode = color_style_1(myHash);
+	strtolower(Style_className);
+
+	if (TRACE_STYLE) {
+	    fprintf(tfp, "CSSTRIM:%s -> %d", myHash, hcode);
+	    if (!hashStyles[hcode].used) {
+		char *rp = strrchr(myHash, '.');
+
+		fprintf(tfp, " (undefined) %s\n", myHash);
+		if (rp) {
+		    int hcd;
+
+		    *rp = '\0';	/* trim the class */
+		    hcd = color_style_1(myHash);
+		    fprintf(tfp, "CSS:%s -> %d", myHash, hcd);
+		    if (!hashStyles[hcd].used)
+			fprintf(tfp, " (undefined) %s\n", myHash);
+		    else
+			fprintf(tfp, " ca=%d\n", hashStyles[hcd].color);
+		}
+	    } else
+		fprintf(tfp, " ca=%d\n", hashStyles[hcode].color);
+	}
+
+	if (displayStyles[element_number + STARTAT].color > -2) {
+	    CTRACE2(TRACE_STYLE,
+		    (tfp, "CSSTRIM: start_element: top <%s>\n",
+		     tag->name));
+	    do_cstyle_flush(me);
+	    HText_characterStyle(me->text, hcode, 1);
+	}
+	FREE(myHash);
+    }
+#endif /* USE_COLOR_STYLE */
+    me->preformatted = YES;	/* free text within tags */
+    HTMLGen_put_character(me, '<');
+    HTMLGen_put_string(me, tag->name);
+    if (present) {
+	BOOL had_attr = NO;
+
+	for (i = 0; i < tag->number_of_attributes; i++) {
+	    if (present[i]) {
+		had_attr = YES;
+		HTMLGen_put_character(me, ' ');
+		allow_break(me, 11, YES);
+#ifdef USE_COLOR_STYLE
+		/*
+		 * Try to mimic HTML_start_element's special handling for
+		 * HTML_LINK.  If applicable, color the displayed attribute /
+		 * value pairs differently.  - kw
+		 */
+		if (LYPreparsedSource &&
+		    element_number == HTML_LINK && !title &&
+		    present[HTML_LINK_CLASS] && *value[HTML_LINK_CLASS] &&
+		    !present[HTML_LINK_REV] &&
+		    (present[HTML_LINK_REL] || present[HTML_LINK_HREF])) {
+		    if (present[HTML_LINK_TITLE] && *value[HTML_LINK_TITLE]) {
+			StrAllocCopy(title, value[HTML_LINK_TITLE]);
+			LYTrimHead(title);
+			LYTrimTail(title);
+		    }
+		    if ((!title || *title == '\0') && present[HTML_LINK_REL]) {
+			StrAllocCopy(title, value[HTML_LINK_REL]);
+		    }
+		    if (title && *title) {
+			HTSprintf0(&title_tmp, "link.%s.%s",
+				   value[HTML_LINK_CLASS], title);
+			CTRACE2(TRACE_STYLE,
+				(tfp, "CSSTRIM:link=%s\n", title_tmp));
+
+			do_cstyle_flush(me);
+			HText_characterStyle(me->text,
+					     color_style_1(title_tmp), 1);
+		    }
+		}
+#endif
+		HTMLGen_put_string(me, tag->attributes[i].name);
+		if (value[i]) {
+		    me->preformatted = was_preformatted;
+		    me->in_attrval = YES;
+		    if (StrChr(value[i], '"') == NULL) {
+			HTMLGen_put_string(me, "=\"");
+			HTMLGen_put_string(me, value[i]);
+			HTMLGen_put_character(me, '"');
+		    } else if (StrChr(value[i], '\'') == NULL) {
+			HTMLGen_put_string(me, "='");
+			HTMLGen_put_string(me, value[i]);
+			HTMLGen_put_character(me, '\'');
+		    } else {	/* attribute value has both kinds of quotes */
+			const char *p;
+
+			HTMLGen_put_string(me, "=\"");
+			for (p = value[i]; *p; p++) {
+			    if (*p != '"') {
+				HTMLGen_put_character(me, *p);
+			    } else {
+				HTMLGen_put_string(me, "&#34;");
+			    }
+			}
+			HTMLGen_put_character(me, '"');
+		    }
+		    me->preformatted = YES;
+		    me->in_attrval = NO;
+		}
+	    }
+	}
+#ifdef USE_COLOR_STYLE
+	if (had_attr && LYPreparsedSource && element_number == HTML_LINK) {
+	    /*
+	     * Clean up after special HTML_LINK handling - kw
+	     */
+	    if (title && *title) {
+		do_cstyle_flush(me);
+		HText_characterStyle(me->text, color_style_1(title_tmp), 0);
+		FREE(title_tmp);
+	    }
+	    FREE(title);
+	}
+#endif
+	if (had_attr)
+	    allow_break(me, 12, NO);
+    }
+    HTMLGen_put_string(me, ">");	/* got rid of \n LJM */
+
+    /*
+     * Make very specific HTML assumption that PRE can't be nested!
+     */
+    me->preformatted = (BOOL) ((element_number == HTML_PRE)
+			       ? YES
+			       : was_preformatted);
+
+    /*
+     * Can break after element start.
+     */
+    if (!me->preformatted && tag->contents != SGML_EMPTY) {
+	if (tag->contents == SGML_ELEMENT)
+	    allow_break(me, 15, NO);
+	else
+	    allow_break(me, 2, NO);
+    }
+#if defined(USE_COLOR_STYLE)
+    /*
+     * Same logic as in HTML_start_element, copied from there.  - kw
+     */
+
+    /* end really empty tags straight away */
+    if (LYPreparsedSource && ReallyEmptyTagNum(element_number)) {
+	CTRACE2(TRACE_STYLE,
+		(tfp, "STYLE:begin_element:ending EMPTY element style\n"));
+	do_cstyle_flush(me);
+	HText_characterStyle(me->text, hcode, STACK_OFF);
+	TrimColorClass(tag->name, Style_className, &hcode);
+    }
+#endif /* USE_COLOR_STYLE */
+    if (element_number == HTML_OBJECT && tag->contents == SGML_LITTERAL) {
+	/*
+	 * These conditions only approximate the ones used in HTML.c.  Let our
+	 * SGML parser know that further content is to be parsed normally not
+	 * literally.  - kw
+	 */
+	if (!present) {
+	    return HT_PARSER_OTHER_CONTENT;
+	} else if (!present[HTML_OBJECT_DECLARE] &&
+		   !(present[HTML_OBJECT_NAME] &&
+		     value[HTML_OBJECT_NAME] && *value[HTML_OBJECT_NAME])) {
+	    if (present[HTML_OBJECT_SHAPES] ||
+		!(present[HTML_OBJECT_USEMAP] &&
+		  value[HTML_OBJECT_USEMAP] && *value[HTML_OBJECT_USEMAP]))
+		return HT_PARSER_OTHER_CONTENT;
+	}
+    }
+    return HT_OK;
+}
+
+/*		End Element
+ *		-----------
+ *
+ * When we end an element, the style must be returned to that in effect before
+ * that element.  Note that anchors (etc?) don't have an associated style, so
+ * that we must scan down the stack for an element with a defined style.  (In
+ * fact, the styles should be linked to the whole stack not just the top one.)
+ * TBL 921119
+ */
+static int HTMLGen_end_element(HTStructured * me, int element_number,
+			       char **insert GCC_UNUSED)
+{
+    if (!me->preformatted &&
+	HTML_dtd.tags[element_number].contents != SGML_EMPTY) {
+	/*
+	 * Can break before element end.
+	 */
+	if (HTML_dtd.tags[element_number].contents == SGML_ELEMENT)
+	    allow_break(me, 14, NO);
+	else
+	    allow_break(me, 1, NO);
+    }
+    HTMLGen_put_string(me, "</");
+    HTMLGen_put_string(me, HTML_dtd.tags[element_number].name);
+    HTMLGen_put_character(me, '>');
+    if (element_number == HTML_PRE) {
+	me->preformatted = NO;
+    }
+#ifdef USE_COLOR_STYLE
+    /*
+     * Same logic as in HTML_end_element, copied from there.  - kw
+     */
+    TrimColorClass(HTML_dtd.tags[element_number].name,
+		   Style_className, &hcode);
+
+    if (LYPreparsedSource && !ReallyEmptyTagNum(element_number)) {
+	CTRACE2(TRACE_STYLE,
+		(tfp, "STYLE:end_element: ending non-EMPTY style\n"));
+	do_cstyle_flush(me);
+	HText_characterStyle(me->text, hcode, STACK_OFF);
+    }
+#endif /* USE_COLOR_STYLE */
+    return HT_OK;
+}
+
+/*		Expanding entities
+ *		------------------
+ *
+ */
+static int HTMLGen_put_entity(HTStructured * me, int entity_number)
+{
+    int nent = (int) HTML_dtd.number_of_entities;
+
+    HTMLGen_put_character(me, '&');
+    if (entity_number < nent) {
+	HTMLGen_put_string(me, HTML_dtd.entity_names[entity_number]);
+    }
+    HTMLGen_put_character(me, ';');
+    return HT_OK;
+}
+
+/*	Free an HTML object
+ *	-------------------
+ *
+ */
+static void HTMLGen_free(HTStructured * me)
+{
+    (*me->targetClass.put_character) (me->target, '\n');
+    HTMLGen_flush(me);
+    (*me->targetClass._free) (me->target);	/* ripple through */
+#ifdef USE_COLOR_STYLE
+    FREE(Style_className);
+#endif
+    FREE(me);
+}
+
+static void PlainToHTML_free(HTStructured * me)
+{
+    HTMLGen_end_element(me, HTML_PRE, 0);
+    HTMLGen_free(me);
+}
+
+static void HTMLGen_abort(HTStructured * me, HTError e GCC_UNUSED)
+{
+    HTMLGen_free(me);
+#ifdef USE_COLOR_STYLE
+    FREE(Style_className);
+#endif
+}
+
+static void PlainToHTML_abort(HTStructured * me, HTError e GCC_UNUSED)
+{
+    PlainToHTML_free(me);
+}
+
+/*	Structured Object Class
+ *	-----------------------
+ */
+static const HTStructuredClass HTMLGeneration =		/* As opposed to print etc */
+{
+    "HTMLGen",
+    HTMLGen_free,
+    HTMLGen_abort,
+    HTMLGen_put_character, HTMLGen_put_string, HTMLGen_write,
+    HTMLGen_start_element, HTMLGen_end_element,
+    HTMLGen_put_entity
+};
+
+/*	Subclass-specific Methods
+ *	-------------------------
+ */
+HTStructured *HTMLGenerator(HTStream *output)
+{
+    HTStructured *me = (HTStructured *) malloc(sizeof(*me));
+
+    if (me == NULL)
+	outofmem(__FILE__, "HTMLGenerator");
+
+    me->isa = &HTMLGeneration;
+
+    me->target = output;
+    me->targetClass = *me->target->isa;		/* Copy pointers to routines for speed */
+
+    me->write_pointer = me->buffer;
+    flush_breaks(me);
+    me->line_break[0] = me->buffer;
+    me->cleanness = 0;
+    me->overflowed = NO;
+    me->delete_line_break_char[0] = NO;
+    me->preformatted = NO;
+    me->in_attrval = NO;
+
+    /*
+     * For what line length should we attempt to wrap ?  - kw
+     */
+    if (!LYPreparsedSource) {
+	me->buffer_maxchars = 80;	/* work as before - kw */
+    } else if (dump_output_width > 1) {
+	me->buffer_maxchars = dump_output_width;	/* try to honor -width - kw */
+    } else if (dump_output_immediately) {
+	me->buffer_maxchars = 80;	/* try to honor -width - kw */
+    } else {
+	me->buffer_maxchars = (LYcolLimit - 1);
+	if (me->buffer_maxchars < 38)	/* too narrow, let GridText deal */
+	    me->buffer_maxchars = 40;
+    }
+    if (me->buffer_maxchars > 900)	/* likely not true - kw */
+	me->buffer_maxchars = 78;
+    if (me->buffer_maxchars > BUFFER_SIZE)	/* must not be larger! */
+	me->buffer_maxchars = BUFFER_SIZE - 2;
+
+    /*
+     * If dump_output_immediately is set, there likely isn't anything after
+     * this stream to interpret the Lynx special chars.  Also if they get
+     * displayed via HTPlain, that will probably make non-breaking space chars
+     * etc.  invisible.  So let's translate them to numerical character
+     * references.  For debugging purposes we'll use the new hex format.
+     */
+    me->escape_specials = LYPreparsedSource;
+
+#ifdef USE_COLOR_STYLE
+    me->text = NULL;		/* Will be initialized when first needed. - kw */
+    FREE(Style_className);
+    class_string[0] = '\0';
+#endif /* COLOR_STYLE */
+
+    return me;
+}
+
+/*	Stream Object Class
+ *	-------------------
+ *
+ *	This object just converts a plain text stream into HTML
+ *	It is officially a structured stream but only the stream bits exist.
+ *	This is just the easiest way of typecasting all the routines.
+ */
+static const HTStructuredClass PlainToHTMLConversion =
+{
+    "plaintexttoHTML",
+    HTMLGen_free,
+    PlainToHTML_abort,
+    HTMLGen_put_character,
+    HTMLGen_put_string,
+    HTMLGen_write,
+    NULL,			/* Structured stuff */
+    NULL,
+    NULL
+};
+
+/*	HTConverter from plain text to HTML Stream
+ *	------------------------------------------
+ */
+HTStream *HTPlainToHTML(HTPresentation *pres GCC_UNUSED,
+			HTParentAnchor *anchor GCC_UNUSED,
+			HTStream *sink)
+{
+    HTStructured *me = (HTStructured *) malloc(sizeof(*me));
+
+    if (me == NULL)
+	outofmem(__FILE__, "PlainToHTML");
+
+    me->isa = (const HTStructuredClass *) &PlainToHTMLConversion;
+
+    /*
+     * Copy pointers to routines for speed.
+     */
+    me->target = sink;
+    me->targetClass = *me->target->isa;
+    me->write_pointer = me->buffer;
+    flush_breaks(me);
+    me->cleanness = 0;
+    me->overflowed = NO;
+    me->delete_line_break_char[0] = NO;
+    /* try to honor -width - kw */
+    me->buffer_maxchars = (dump_output_width > 1 ?
+			   dump_output_width : 80);
+
+    HTMLGen_put_string(me, "<HTML>\n<BODY>\n<PRE>\n");
+    me->preformatted = YES;
+    me->escape_specials = NO;
+    me->in_attrval = NO;
+    return (HTStream *) me;
+}
diff --git a/WWW/Library/Implementation/HTMLGen.h b/WWW/Library/Implementation/HTMLGen.h
new file mode 100644
index 0000000..f2db3d4
--- /dev/null
+++ b/WWW/Library/Implementation/HTMLGen.h
@@ -0,0 +1,26 @@
+/*                  /Net/dxcern/userd/timbl/hypertext/WWW/Library/Implementation/HTMLGen.html
+                                      HTML GENERATOR
+                                             
+   This module converts structed stream into stream.  That is, given a stream
+   to write to, it will give you a structured stream to
+   
+ */
+#ifndef HTMLGEN_H
+#define HTMLGEN_H
+
+#include <HTML.h>
+#include <HTStream.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern HTStructured *HTMLGenerator(HTStream *output);
+
+    extern HTStream *HTPlainToHTML(HTPresentation *pres,
+				   HTParentAnchor *anchor,
+				   HTStream *sink);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTMLGEN_H */
diff --git a/WWW/Library/Implementation/HTNews.c b/WWW/Library/Implementation/HTNews.c
new file mode 100644
index 0000000..a1b94dc
--- /dev/null
+++ b/WWW/Library/Implementation/HTNews.c
@@ -0,0 +1,3147 @@
+/*
+ * $LynxId: HTNews.c,v 1.81 2022/04/01 00:18:22 tom Exp $
+ *
+ *			NEWS ACCESS				HTNews.c
+ *			===========
+ *
+ * History:
+ *	26 Sep 90	Written TBL
+ *	29 Nov 91	Downgraded to C, for portable implementation.
+ */
+
+#include <HTUtils.h>		/* Coding convention macros */
+
+#ifndef DISABLE_NEWS
+
+/* Implements:
+*/
+#include <HTNews.h>
+
+#include <HTCJK.h>
+#include <HTMIME.h>
+#include <HTFont.h>
+#include <HTFormat.h>
+#include <HTTCP.h>
+#include <LYUtils.h>
+#include <LYStrings.h>
+
+#define NEWS_PORT 119		/* See rfc977 */
+#define SNEWS_PORT 563		/* See Lou Montulli */
+#define APPEND			/* Use append methods */
+int HTNewsChunkSize = 30;	/* Number of articles for quick display */
+int HTNewsMaxChunk = 40;	/* Largest number of articles in one window */
+
+#ifndef DEFAULT_NEWS_HOST
+#define DEFAULT_NEWS_HOST "news"
+#endif /* DEFAULT_NEWS_HOST */
+
+#ifndef NEWS_SERVER_FILE
+#define NEWS_SERVER_FILE "/usr/local/lib/rn/server"
+#endif /* NEWS_SERVER_FILE */
+
+#ifndef NEWS_AUTH_FILE
+#define NEWS_AUTH_FILE ".newsauth"
+#endif /* NEWS_AUTH_FILE */
+
+#ifdef USE_SSL
+
+#if defined(LIBRESSL_VERSION_NUMBER)
+/* OpenSSL and LibreSSL version numbers do not correspond */
+#elif (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+#undef  SSL_load_error_strings
+#define SSL_load_error_strings()	/* nothing */
+#endif
+
+static SSL *Handle = NULL;
+static int channel_s = 1;
+
+#define NEWS_NETWRITE(sock, buff, size) \
+	((Handle != NULL) \
+	 ? SSL_write(Handle, buff, size) \
+	 : NETWRITE(sock, buff, size))
+#define NEWS_NETCLOSE(sock) \
+	{ \
+	    if ((int)(sock) >= 0) { \
+	        (void)NETCLOSE(sock); \
+	    } \
+	    if (Handle != NULL) { \
+	        SSL_free(Handle); \
+	        Handle = NULL; \
+	    } \
+	}
+static int HTNewsGetCharacter(void);
+
+#define NEXT_CHAR HTNewsGetCharacter()
+#else
+#define NEWS_NETWRITE  NETWRITE
+#define NEWS_NETCLOSE  NETCLOSE
+#define NEXT_CHAR HTGetCharacter()
+#endif /* USE_SSL */
+
+#include <HTML.h>
+#include <HTAccess.h>
+#include <HTParse.h>
+#include <HTFormat.h>
+#include <HTAlert.h>
+
+#include <LYNews.h>
+#include <LYGlobalDefs.h>
+#include <LYLeaks.h>
+
+#define SnipIn(d,fmt,len,s)      sprintf(d, fmt,      (int)sizeof(d)-len, s)
+#define SnipIn2(d,fmt,tag,len,s) sprintf(d, fmt, tag, (int)sizeof(d)-len, s)
+
+struct _HTStructured {
+    const HTStructuredClass *isa;
+    /* ... */
+};
+
+#define LINE_LENGTH 512		/* Maximum length of line of ARTICLE etc */
+#define GROUP_NAME_LENGTH	256	/* Maximum length of group name */
+
+/*
+ *  Module-wide variables.
+ */
+char *HTNewsHost = NULL;	/* Default host */
+static char *NewsHost = NULL;	/* Current host */
+static char *NewsHREF = NULL;	/* Current HREF prefix */
+static int s;			/* Socket for NewsHost */
+static int HTCanPost = FALSE;	/* Current POST permission */
+static char response_text[LINE_LENGTH + 1];	/* Last response */
+
+static HTStructured *target;	/* The output sink */
+static HTStructuredClass targetClass;	/* Copy of fn addresses */
+static HTStream *rawtarget = NULL;	/* The output sink for rawtext */
+static HTStreamClass rawtargetClass;	/* Copy of fn addresses */
+static int diagnostic;		/* level: 0=none 2=source */
+static BOOL rawtext = NO;	/* Flag: HEAD or -mime_headers */
+static HTList *NNTP_AuthInfo = NULL;	/* AUTHINFO database */
+static char *name = NULL;
+static char *address = NULL;
+static char *dbuf = NULL;	/* dynamic buffer for long messages etc. */
+
+#define PUTC(c) (*targetClass.put_character)(target, c)
+#define PUTS(s) (*targetClass.put_string)(target, s)
+#define RAW_PUTS(s) (*rawtargetClass.put_string)(rawtarget, s)
+#define START(e) (*targetClass.start_element)(target, e, 0, 0, -1, 0)
+#define END(e) (*targetClass.end_element)(target, e, 0)
+#define MAYBE_END(e) if (HTML_dtd.tags[e].contents != SGML_EMPTY) \
+			(*targetClass.end_element)(target, e, 0)
+#define FREE_TARGET if (rawtext) (*rawtargetClass._free)(rawtarget); \
+			else (*targetClass._free)(target)
+#define ABORT_TARGET if (rawtext) (*rawtargetClass._abort)(rawtarget, NULL); \
+			else (*targetClass._abort)(target, NULL)
+
+typedef struct _NNTPAuth {
+    char *host;
+    char *user;
+    char *pass;
+} NNTPAuth;
+
+#ifdef LY_FIND_LEAKS
+static void free_news_globals(void)
+{
+    if (s >= 0) {
+	NEWS_NETCLOSE(s);
+	s = -1;
+    }
+    FREE(HTNewsHost);
+    FREE(NewsHost);
+    FREE(NewsHREF);
+    FREE(name);
+    FREE(address);
+    FREE(dbuf);
+}
+#endif /* LY_FIND_LEAKS */
+
+static void free_NNTP_AuthInfo(void)
+{
+    HTList *cur = NNTP_AuthInfo;
+    NNTPAuth *auth = NULL;
+
+    if (!cur)
+	return;
+
+    while (NULL != (auth = (NNTPAuth *) HTList_nextObject(cur))) {
+	FREE(auth->host);
+	FREE(auth->user);
+	FREE(auth->pass);
+	FREE(auth);
+    }
+    HTList_delete(NNTP_AuthInfo);
+    NNTP_AuthInfo = NULL;
+    return;
+}
+
+/*
+ * Initialize the authentication list by loading the user's $HOME/.newsauth
+ * file.  That file is part of tin's configuration and is used by a few other
+ * programs.
+ */
+static void load_NNTP_AuthInfo(void)
+{
+    FILE *fp;
+    char fname[LY_MAXPATH];
+    char buffer[LINE_LENGTH + 1];
+
+    LYAddPathToHome(fname, sizeof(fname), NEWS_AUTH_FILE);
+
+    if ((fp = fopen(fname, "r")) != 0) {
+	while (fgets(buffer, (int) sizeof(buffer), fp) != 0) {
+	    char the_host[LINE_LENGTH + 1];
+	    char the_pass[LINE_LENGTH + 1];
+	    char the_user[LINE_LENGTH + 1];
+
+	    if (sscanf(buffer, "%s%s%s", the_host, the_pass, the_user) == 3
+		&& strlen(the_host) != 0
+		&& strlen(the_pass) != 0
+		&& strlen(the_user) != 0) {
+		NNTPAuth *auth = typecalloc(NNTPAuth);
+
+		if (auth == NULL)
+		    break;
+		StrAllocCopy(auth->host, the_host);
+		StrAllocCopy(auth->pass, the_pass);
+		StrAllocCopy(auth->user, the_user);
+
+		HTList_appendObject(NNTP_AuthInfo, auth);
+	    }
+	}
+	fclose(fp);
+    }
+}
+
+const char *HTGetNewsHost(void)
+{
+    return HTNewsHost;
+}
+
+void HTSetNewsHost(const char *value)
+{
+    StrAllocCopy(HTNewsHost, value);
+}
+
+/*	Initialisation for this module
+ *	------------------------------
+ *
+ *	Except on the NeXT, we pick up the NewsHost name from
+ *
+ *	1.	Environment variable NNTPSERVER
+ *	2.	File NEWS_SERVER_FILE
+ *	3.	Compilation time macro DEFAULT_NEWS_HOST
+ *	4.	Default to "news"
+ *
+ *	On the NeXT, we pick up the NewsHost name from, in order:
+ *
+ *	1.	WorldWideWeb default "NewsHost"
+ *	2.	Global default "NewsHost"
+ *	3.	News default "NewsHost"
+ *	4.	Compilation time macro DEFAULT_NEWS_HOST
+ *	5.	Default to "news"
+ */
+static BOOL initialized = NO;
+static BOOL initialize(void)
+{
+#ifdef NeXTStep
+    char *cp = NULL;
+#endif
+
+    /*
+     * Get name of Host.
+     */
+#ifdef NeXTStep
+    if ((cp = NXGetDefaultValue("WorldWideWeb", "NewsHost")) == 0) {
+	if ((cp = NXGetDefaultValue("News", "NewsHost")) == 0) {
+	    StrAllocCopy(HTNewsHost, DEFAULT_NEWS_HOST);
+	}
+    }
+    if (cp) {
+	StrAllocCopy(HTNewsHost, cp);
+	cp = NULL;
+    }
+#else
+    if (LYGetEnv("NNTPSERVER")) {
+	StrAllocCopy(HTNewsHost, LYGetEnv("NNTPSERVER"));
+	CTRACE((tfp, "HTNews: NNTPSERVER defined as `%s'\n",
+		HTNewsHost));
+    } else {
+	FILE *fp = fopen(NEWS_SERVER_FILE, TXT_R);
+
+	if (fp) {
+	    char server_name[MAXHOSTNAMELEN + 1];
+
+	    if (fgets(server_name, (int) sizeof server_name, fp) != NULL) {
+		char *p = StrChr(server_name, '\n');
+
+		if (p != NULL)
+		    *p = '\0';
+		StrAllocCopy(HTNewsHost, server_name);
+		CTRACE((tfp, "HTNews: File %s defines news host as `%s'\n",
+			NEWS_SERVER_FILE, HTNewsHost));
+	    }
+	    fclose(fp);
+	}
+    }
+    if (!HTNewsHost)
+	StrAllocCopy(HTNewsHost, DEFAULT_NEWS_HOST);
+#endif /* NeXTStep */
+
+    s = -1;			/* Disconnected */
+#ifdef LY_FIND_LEAKS
+    atexit(free_news_globals);
+#endif
+    return YES;
+}
+
+/*	Send NNTP Command line to remote host & Check Response
+ *	------------------------------------------------------
+ *
+ * On entry,
+ *	command points to the command to be sent, including CRLF, or is null
+ *		pointer if no command to be sent.
+ * On exit,
+ *	Negative status indicates transmission error, socket closed.
+ *	Positive status is an NNTP status.
+ */
+static int response(char *command)
+{
+    int result;
+    char *p = response_text;
+    int ich;
+
+    if (command) {
+	int status;
+	int length = (int) strlen(command);
+
+	CTRACE((tfp, "NNTP command to be sent: %s", command));
+#ifdef NOT_ASCII
+	{
+	    const char *p2;
+	    char *q;
+	    char ascii[LINE_LENGTH + 1];
+
+	    for (p2 = command, q = ascii; *p2; p2++, q++) {
+		*q = TOASCII(*p2);
+	    }
+	    status = NEWS_NETWRITE(s, ascii, length);
+	}
+#else
+	status = (int) NEWS_NETWRITE(s, (char *) command, length);
+#endif /* NOT_ASCII */
+	if (status < 0) {
+	    CTRACE((tfp, "HTNews: Unable to send command. Disconnecting.\n"));
+	    NEWS_NETCLOSE(s);
+	    s = -1;
+	    return status;
+	}			/* if bad status */
+    }
+    /* if command to be sent */
+    for (;;) {
+	ich = NEXT_CHAR;
+	if (((*p++ = (char) ich) == LF) ||
+	    (p == &response_text[LINE_LENGTH])) {
+	    *--p = '\0';	/* Terminate the string */
+	    CTRACE((tfp, "NNTP Response: %s\n", response_text));
+	    sscanf(response_text, "%d", &result);
+	    return result;
+	}
+	/* if end of line */
+	if (ich == EOF) {
+	    *(p - 1) = '\0';
+	    if (interrupted_in_htgetcharacter) {
+		CTRACE((tfp,
+			"HTNews: Interrupted on read, closing socket %d\n",
+			s));
+	    } else {
+		CTRACE((tfp, "HTNews: EOF on read, closing socket %d\n",
+			s));
+	    }
+	    NEWS_NETCLOSE(s);	/* End of file, close socket */
+	    s = -1;
+	    if (interrupted_in_htgetcharacter) {
+		interrupted_in_htgetcharacter = 0;
+		return (HT_INTERRUPTED);
+	    }
+	    return ((int) EOF);	/* End of file on response */
+	}
+    }				/* Loop over characters */
+}
+
+/*	Case insensitive string comparisons
+ *	-----------------------------------
+ *
+ * On entry,
+ *	template must be already in upper case.
+ *	unknown may be in upper or lower or mixed case to match.
+ */
+static BOOL match(const char *unknown, const char *ctemplate)
+{
+    const char *u = unknown;
+    const char *t = ctemplate;
+
+    for (; *u && *t && (TOUPPER(*u) == *t); u++, t++) ;		/* Find mismatch or end */
+    return (BOOL) (*t == 0);	/* OK if end of template */
+}
+
+typedef enum {
+    NNTPAUTH_ERROR = 0,		/* general failure */
+    NNTPAUTH_OK = 281,		/* authenticated successfully */
+    NNTPAUTH_CLOSE = 502	/* server probably closed connection */
+} NNTPAuthResult;
+
+/*
+ *  This function handles nntp authentication. - FM
+ */
+static NNTPAuthResult HTHandleAuthInfo(char *host)
+{
+    HTList *cur = NULL;
+    NNTPAuth *auth = NULL;
+    char *UserName = NULL;
+    char *PassWord = NULL;
+    char *msg = NULL;
+    char buffer[512];
+    int status, tries;
+
+    /*
+     * Make sure we have a host.  - FM
+     */
+    if (isEmpty(host))
+	return NNTPAUTH_ERROR;
+
+    /*
+     * Check for an existing authorization entry.  - FM
+     */
+    if (NNTP_AuthInfo == NULL) {
+	NNTP_AuthInfo = HTList_new();
+	load_NNTP_AuthInfo();
+#ifdef LY_FIND_LEAKS
+	atexit(free_NNTP_AuthInfo);
+#endif
+    }
+
+    cur = NNTP_AuthInfo;
+    while (NULL != (auth = (NNTPAuth *) HTList_nextObject(cur))) {
+	if (!strcmp(auth->host, host)) {
+	    UserName = auth->user;
+	    PassWord = auth->pass;
+	    break;
+	}
+    }
+
+    /*
+     * Handle the username.  - FM
+     */
+    buffer[sizeof(buffer) - 1] = '\0';
+    tries = 3;
+
+    while (tries) {
+	if (UserName == NULL) {
+	    HTSprintf0(&msg, gettext("Username for news host '%s':"), host);
+	    UserName = HTPrompt(msg, NULL);
+	    FREE(msg);
+	    if (!(UserName && *UserName)) {
+		FREE(UserName);
+		return NNTPAUTH_ERROR;
+	    }
+	}
+	sprintf(buffer, "AUTHINFO USER %.*s%c%c",
+		(int) sizeof(buffer) - 17, UserName, CR, LF);
+	if ((status = response(buffer)) < 0) {
+	    if (status == HT_INTERRUPTED)
+		_HTProgress(CONNECTION_INTERRUPTED);
+	    else
+		HTAlert(FAILED_CONNECTION_CLOSED);
+	    if (auth) {
+		if (auth->user != UserName) {
+		    FREE(auth->user);
+		    auth->user = UserName;
+		}
+	    } else {
+		FREE(UserName);
+	    }
+	    return NNTPAUTH_CLOSE;
+	}
+	if (status == 281) {
+	    /*
+	     * Username is accepted and no password is required.  - FM
+	     */
+	    if (auth) {
+		if (auth->user != UserName) {
+		    FREE(auth->user);
+		    auth->user = UserName;
+		}
+	    } else {
+		/*
+		 * Store the accepted username and no password.  - FM
+		 */
+		if ((auth = typecalloc(NNTPAuth)) != NULL) {
+		    StrAllocCopy(auth->host, host);
+		    auth->user = UserName;
+		    HTList_appendObject(NNTP_AuthInfo, auth);
+		}
+	    }
+	    return NNTPAUTH_OK;
+	}
+	if (status != 381) {
+	    /*
+	     * Not success, nor a request for the password, so it must be an
+	     * error.  - FM
+	     */
+	    HTAlert(response_text);
+	    tries--;
+	    if ((tries > 0) && HTConfirm(gettext("Change username?"))) {
+		if (!auth || auth->user != UserName) {
+		    FREE(UserName);
+		}
+		if ((UserName = HTPrompt(gettext("Username:"), UserName))
+		    != NULL &&
+		    *UserName) {
+		    continue;
+		}
+	    }
+	    if (auth) {
+		if (auth->user != UserName) {
+		    FREE(auth->user);
+		}
+		FREE(auth->pass);
+	    }
+	    FREE(UserName);
+	    return NNTPAUTH_ERROR;
+	}
+	break;
+    }
+
+    if (status == 381) {
+	/*
+	 * Handle the password.  - FM
+	 */
+	tries = 3;
+	while (tries) {
+	    if (PassWord == NULL) {
+		HTSprintf0(&msg, gettext("Password for news host '%s':"), host);
+		PassWord = HTPromptPassword(msg, NULL);
+		FREE(msg);
+		if (!(PassWord && *PassWord)) {
+		    FREE(PassWord);
+		    return NNTPAUTH_ERROR;
+		}
+	    }
+	    sprintf(buffer, "AUTHINFO PASS %.*s%c%c",
+		    (int) sizeof(buffer) - 17, PassWord, CR, LF);
+	    if ((status = response(buffer)) < 0) {
+		if (status == HT_INTERRUPTED) {
+		    _HTProgress(CONNECTION_INTERRUPTED);
+		} else {
+		    HTAlert(FAILED_CONNECTION_CLOSED);
+		}
+		if (auth) {
+		    if (auth->user != UserName) {
+			FREE(auth->user);
+			auth->user = UserName;
+		    }
+		    if (auth->pass != PassWord) {
+			FREE(auth->pass);
+			auth->pass = PassWord;
+		    }
+		} else {
+		    FREE(UserName);
+		    FREE(PassWord);
+		}
+		return NNTPAUTH_CLOSE;
+	    }
+	    if (status == 502) {
+		/*
+		 * That's what INN's nnrpd returns.  It closes the connection
+		 * after this.  - kw
+		 */
+		HTAlert(response_text);
+		if (auth) {
+		    if (auth->user == UserName)
+			UserName = NULL;
+		    FREE(auth->user);
+		    if (auth->pass == PassWord)
+			PassWord = NULL;
+		    FREE(auth->pass);
+		}
+		FREE(UserName);
+		FREE(PassWord);
+		return NNTPAUTH_CLOSE;
+	    }
+	    if (status == 281) {
+		/*
+		 * Password also is accepted, and everything has been stored. 
+		 * - FM
+		 */
+		if (auth) {
+		    if (auth->user != UserName) {
+			FREE(auth->user);
+			auth->user = UserName;
+		    }
+		    if (auth->pass != PassWord) {
+			FREE(auth->pass);
+			auth->pass = PassWord;
+		    }
+		} else {
+		    if ((auth = typecalloc(NNTPAuth)) != NULL) {
+			StrAllocCopy(auth->host, host);
+			auth->user = UserName;
+			auth->pass = PassWord;
+			HTList_appendObject(NNTP_AuthInfo, auth);
+		    }
+		}
+		return NNTPAUTH_OK;
+	    }
+	    /*
+	     * Not success, so it must be an error.  - FM
+	     */
+	    HTAlert(response_text);
+	    if (!auth || auth->pass != PassWord) {
+		FREE(PassWord);
+	    } else {
+		PassWord = NULL;
+	    }
+	    tries--;
+	    if ((tries > 0) && HTConfirm(gettext("Change password?"))) {
+		continue;
+	    }
+	    if (auth) {
+		if (auth->user == UserName)
+		    UserName = NULL;
+		FREE(auth->user);
+		FREE(auth->pass);
+	    }
+	    FREE(UserName);
+	    break;
+	}
+    }
+
+    return NNTPAUTH_ERROR;
+}
+
+/*	Find Author's name in mail address
+ *	----------------------------------
+ *
+ * On exit,
+ *	Returns allocated string which cannot be freed by the
+ *	calling function, and is reallocated on subsequent calls
+ *	to this function.
+ *
+ * For example, returns "Tim Berners-Lee" if given any of
+ *	" Tim Berners-Lee <tim@online.cern.ch> "
+ *  or	" tim@online.cern.ch ( Tim Berners-Lee ) "
+ */
+static char *author_name(char *email)
+{
+    char *p, *e;
+
+    StrAllocCopy(name, email);
+    CTRACE((tfp, "Trying to find name in: %s\n", name));
+
+    if ((p = strrchr(name, '(')) && (e = strrchr(name, ')'))) {
+	if (e > p) {
+	    *e = '\0';		/* Chop off everything after the ')'  */
+	    return HTStrip(p + 1);	/* Remove leading and trailing spaces */
+	}
+    }
+
+    if ((p = strrchr(name, '<')) && (e = strrchr(name, '>'))) {
+	if (e++ > p) {
+	    while ((*p++ = *e++) != 0)	/* Remove <...> */
+		;
+	    return HTStrip(name);	/* Remove leading and trailing spaces */
+	}
+    }
+
+    return HTStrip(name);	/* Default to the whole thing */
+}
+
+/*	Find Author's mail address
+ *	--------------------------
+ *
+ * On exit,
+ *	Returns allocated string which cannot be freed by the
+ *	calling function, and is reallocated on subsequent calls
+ *	to this function.
+ *
+ * For example, returns "montulli@spaced.out.galaxy.net" if given any of
+ *	" Lou Montulli <montulli@spaced.out.galaxy.net> "
+ *  or	" montulli@spaced.out.galaxy.net ( Lou "The Stud" Montulli ) "
+ */
+static char *author_address(char *email)
+{
+    char *p, *at, *e;
+
+    StrAllocCopy(address, email);
+    CTRACE((tfp, "Trying to find address in: %s\n", address));
+
+    if ((p = strrchr(address, '<'))) {
+	if ((e = strrchr(p, '>')) && (at = strrchr(p, '@'))) {
+	    if (at < e) {
+		*e = '\0';	/* Remove > */
+		return HTStrip(p + 1);	/* Remove leading and trailing spaces */
+	    }
+	}
+    }
+
+    if ((p = strrchr(address, '(')) &&
+	(e = strrchr(address, ')')) && (at = StrChr(address, '@'))) {
+	if (e > p && at < e) {
+	    *p = '\0';		/* Chop off everything after the ')'  */
+	    return HTStrip(address);	/* Remove leading and trailing spaces */
+	}
+    }
+
+    if ((at = strrchr(address, '@')) && at > address) {
+	p = (at - 1);
+	e = (at + 1);
+	while (p > address && !isspace(UCH(*p)))
+	    p--;
+	while (*e && !isspace(UCH(*e)))
+	    e++;
+	*e = 0;
+	return HTStrip(p);
+    }
+
+    /*
+     * Default to the first word.
+     */
+    p = address;
+    while (isspace(UCH(*p)))
+	p++;			/* find first non-space */
+    e = p;
+    while (!isspace(UCH(*e)) && *e != '\0')
+	e++;			/* find next space or end */
+    *e = '\0';			/* terminate space */
+
+    return (p);
+}
+
+/*	Start anchor element
+ *	--------------------
+ */
+static void start_anchor(const char *href)
+{
+    BOOL present[HTML_A_ATTRIBUTES];
+    const char *value[HTML_A_ATTRIBUTES];
+    int i;
+
+    for (i = 0; i < HTML_A_ATTRIBUTES; i++)
+	present[i] = (BOOL) (i == HTML_A_HREF);
+    value[HTML_A_HREF] = href;
+    (*targetClass.start_element) (target, HTML_A, present, value, -1, 0);
+}
+
+/*	Start link element
+ *	------------------
+ */
+static void start_link(const char *href, const char *rev)
+{
+    BOOL present[HTML_LINK_ATTRIBUTES];
+    const char *value[HTML_LINK_ATTRIBUTES];
+    int i;
+
+    for (i = 0; i < HTML_LINK_ATTRIBUTES; i++)
+	present[i] = (BOOL) (i == HTML_LINK_HREF || i == HTML_LINK_REV);
+    value[HTML_LINK_HREF] = href;
+    value[HTML_LINK_REV] = rev;
+    (*targetClass.start_element) (target, HTML_LINK, present, value, -1, 0);
+}
+
+/*	Start list element
+ *	------------------
+ */
+static void start_list(int seqnum)
+{
+    BOOL present[HTML_OL_ATTRIBUTES];
+    const char *value[HTML_OL_ATTRIBUTES];
+    char SeqNum[20];
+    int i;
+
+    for (i = 0; i < HTML_OL_ATTRIBUTES; i++)
+	present[i] = (BOOL) (i == HTML_OL_SEQNUM || i == HTML_OL_START);
+    sprintf(SeqNum, "%d", seqnum);
+    value[HTML_OL_SEQNUM] = SeqNum;
+    value[HTML_OL_START] = SeqNum;
+    (*targetClass.start_element) (target, HTML_OL, present, value, -1, 0);
+}
+
+/*	Paste in an Anchor
+ *	------------------
+ *
+ *
+ * On entry,
+ *	HT	has a selection of zero length at the end.
+ *	text	points to the text to be put into the file, 0 terminated.
+ *	addr	points to the hypertext reference address,
+ *		terminated by white space, comma, NULL or '>'
+ */
+static void write_anchor(const char *text, const char *addr)
+{
+    char href[LINE_LENGTH + 1];
+    const char *p;
+    char *q;
+
+    for (p = addr; *p && (*p != '>') && !WHITE(*p) && (*p != ','); p++) {
+	;
+    }
+    if (strlen(NewsHREF) + (size_t) (p - addr) + 1 < sizeof(href)) {
+	q = href;
+	strcpy(q, NewsHREF);
+	/* Make complete hypertext reference */
+	StrNCat(q, addr, (size_t) (p - addr));
+    } else {
+	q = NULL;
+	HTSprintf0(&q, "%s%.*s", NewsHREF, (int) (p - addr), addr);
+    }
+
+    start_anchor(q);
+    PUTS(text);
+    END(HTML_A);
+
+    if (q != href)
+	FREE(q);
+}
+
+/*	Write list of anchors
+ *	---------------------
+ *
+ *	We take a pointer to a list of objects, and write out each,
+ *	generating an anchor for each.
+ *
+ * On entry,
+ *	HT	has a selection of zero length at the end.
+ *	text	points to a comma or space separated list of addresses.
+ * On exit,
+ *	*text	is NOT any more chopped up into substrings.
+ */
+static void write_anchors(char *text)
+{
+    char *start = text;
+    char *end;
+    char c;
+
+    for (;;) {
+	for (; *start && (WHITE(*start)); start++) ;	/* Find start */
+	if (!*start)
+	    return;		/* (Done) */
+	for (end = start;
+	     *end && (*end != ' ') && (*end != ','); end++) ;	/* Find end */
+	if (*end)
+	    end++;		/* Include comma or space but not NULL */
+	c = *end;
+	*end = '\0';
+	if (*start == '<')
+	    write_anchor(start, start + 1);
+	else
+	    write_anchor(start, start);
+	START(HTML_BR);
+	*end = c;
+	start = end;		/* Point to next one */
+    }
+}
+
+/*	Abort the connection					abort_socket
+ *	--------------------
+ */
+static void abort_socket(void)
+{
+    CTRACE((tfp, "HTNews: EOF on read, closing socket %d\n", s));
+    NEWS_NETCLOSE(s);		/* End of file, close socket */
+    if (rawtext) {
+	RAW_PUTS("Network Error: connection lost\n");
+    } else {
+	PUTS("Network Error: connection lost");
+	PUTC('\n');
+    }
+    s = -1;			/* End of file on response */
+}
+
+/*
+ *  Determine if a line is a valid header line.			valid_header
+ *  -------------------------------------------
+ */
+static BOOLEAN valid_header(char *line)
+{
+    char *colon, *space;
+
+    /*
+     * Blank or tab in first position implies this is a continuation header.
+     */
+    if (line[0] == ' ' || line[0] == '\t')
+	return (TRUE);
+
+    /*
+     * Just check for initial letter, colon, and space to make sure we discard
+     * only invalid headers.
+     */
+    colon = StrChr(line, ':');
+    space = StrChr(line, ' ');
+    if (isalpha(UCH(line[0])) && colon && space == colon + 1)
+	return (TRUE);
+
+    /*
+     * Anything else is a bad header -- it should be ignored.
+     */
+    return (FALSE);
+}
+
+/*	post in an Article					post_article
+ *	------------------
+ *			(added by FM, modeled on Lynx's previous mini inews)
+ *
+ *	Note the termination condition of a single dot on a line by itself.
+ *
+ *  On entry,
+ *	s		Global socket number is OK
+ *	postfile	file with header and article to post.
+ */
+static void post_article(char *postfile)
+{
+    char line[512];
+    char buf[512];
+    char crlf[3];
+    char *cp;
+    int status;
+    FILE *fd;
+    int in_header = 1, seen_header = 0, seen_fromline = 0;
+    int blen = 0, llen = 0;
+
+    /*
+     * Open the temporary file with the nntp headers and message body.  - FM
+     */
+    if ((fd = fopen(NonNull(postfile), TXT_R)) == NULL) {
+	HTAlert(FAILED_CANNOT_OPEN_POST);
+	return;
+    }
+
+    /*
+     * Read the temporary file and post in maximum 512 byte chunks.  - FM
+     */
+    buf[0] = '\0';
+    sprintf(crlf, "%c%c", CR, LF);
+    while (fgets(line, (int) sizeof(line) - 2, fd) != NULL) {
+	if ((cp = StrChr(line, '\n')) != NULL)
+	    *cp = '\0';
+	if (line[0] == '.') {
+	    /*
+	     * A single '.' means end of transmission for nntp.  Lead dots on
+	     * lines normally are trimmed and the EOF is not registered if the
+	     * dot was not followed by CRLF.  We prepend an extra dot for any
+	     * line beginning with one, to retain the one intended, as well as
+	     * avoid a false EOF signal.  We know we have room for it in the
+	     * buffer, because we normally send when it would exceed 510.  - FM
+	     */
+	    strcat(buf, ".");
+	    blen++;
+	}
+	llen = (int) strlen(line);
+	if (in_header && !strncasecomp(line, "From:", 5)) {
+	    seen_header = 1;
+	    seen_fromline = 1;
+	}
+	if (in_header && line[0] == '\0') {
+	    if (seen_header) {
+		in_header = 0;
+		if (!seen_fromline) {
+		    if (blen >= (int) sizeof(buf) - 35) {
+			IGNORE_RC(NEWS_NETWRITE(s, buf, blen));
+			buf[blen = 0] = 0;
+		    }
+		    strcat(buf, "From: anonymous@nowhere.you.know");
+		    strcat(buf, crlf);
+		    blen += 34;
+		}
+	    } else {
+		continue;
+	    }
+	} else if (in_header) {
+	    if (valid_header(line)) {
+		seen_header = 1;
+	    } else {
+		continue;
+	    }
+	}
+	strcat(line, crlf);
+	llen += 2;
+	if ((blen + llen) >= (int) sizeof(buf) - 1) {
+	    IGNORE_RC(NEWS_NETWRITE(s, buf, blen));
+	    buf[blen = 0] = 0;
+	}
+	strcat(buf, line);
+	blen += llen;
+    }
+    fclose(fd);
+    HTSYS_remove(postfile);
+
+    /*
+     * Send the nntp EOF and get the server's response.  - FM
+     */
+    if (blen >= (int) sizeof(buf) - 4) {
+	IGNORE_RC(NEWS_NETWRITE(s, buf, blen));
+	buf[blen = 0] = 0;
+    }
+    strcat(buf, ".");
+    strcat(buf, crlf);
+    blen += 3;
+    IGNORE_RC(NEWS_NETWRITE(s, buf, blen));
+
+    status = response(NULL);
+    if (status == 240) {
+	/*
+	 * Successful post.  - FM
+	 */
+	HTProgress(response_text);
+    } else {
+	/*
+	 * Shucks, something went wrong.  - FM
+	 */
+	HTAlert(response_text);
+    }
+}
+
+#ifdef NEWS_DEBUG
+/* for DEBUG 1997/11/07 (Fri) 17:20:16 */
+void debug_print(unsigned char *p)
+{
+    while (*p) {
+	if (*p == '\0')
+	    break;
+	if (*p == 0x1b)
+	    printf("[ESC]");
+	else if (*p == '\n')
+	    printf("[NL]");
+	else if (*p < ' ' || *p >= 0x80)
+	    printf("(%02x)", *p);
+	else
+	    putchar(*p);
+	p++;
+    }
+    printf("]\n");
+}
+#endif
+
+static char *decode_mime(char **str)
+{
+    static char empty[] = "";
+
+#ifdef SH_EX
+    if (HTCJK != JAPANESE)
+	return *str;
+#endif
+    HTmmdecode(str, *str);
+    return HTrjis(str, *str) ? *str : empty;
+}
+
+/*	Read in an Article					read_article
+ *	------------------
+ *
+ *	Note the termination condition of a single dot on a line by itself.
+ *	RFC 977 specifies that the line "folding" of RFC850 is not used, so we
+ *	do not handle it here.
+ *
+ * On entry,
+ *	s	Global socket number is OK
+ *	HT	Global hypertext object is ready for appending text
+ */
+static int read_article(HTParentAnchor *thisanchor)
+{
+    char line[LINE_LENGTH + 1];
+    char *full_line = NULL;
+    char *subject = NULL;	/* Subject string           */
+    char *from = NULL;		/* From string              */
+    char *replyto = NULL;	/* Reply-to string          */
+    char *date = NULL;		/* Date string              */
+    char *organization = NULL;	/* Organization string      */
+    char *references = NULL;	/* Hrefs for other articles */
+    char *newsgroups = NULL;	/* Newsgroups list          */
+    char *followupto = NULL;	/* Followup list            */
+    char *href = NULL;
+    char *p = line;
+    char *cp;
+    const char *ccp;
+    BOOL done = NO;
+
+    /*
+     * Read in the HEADer of the article.
+     *
+     * The header fields are either ignored, or formatted and put into the
+     * text.
+     */
+    if (!diagnostic && !rawtext) {
+	while (!done) {
+	    int ich = NEXT_CHAR;
+
+	    *p++ = (char) ich;
+	    if (ich == EOF) {
+		if (interrupted_in_htgetcharacter) {
+		    interrupted_in_htgetcharacter = 0;
+		    CTRACE((tfp,
+			    "HTNews: Interrupted on read, closing socket %d\n",
+			    s));
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		    return (HT_INTERRUPTED);
+		}
+		abort_socket();	/* End of file, close socket */
+		return (HT_LOADED);	/* End of file on response */
+	    }
+	    if (((char) ich == LF) || (p == &line[LINE_LENGTH])) {
+		*--p = '\0';	/* Terminate the string */
+		CTRACE((tfp, "H %s\n", line));
+
+		if (line[0] == '\t' || line[0] == ' ') {
+		    int i = 0;
+
+		    while (line[i]) {
+			if (line[i] == '\t')
+			    line[i] = ' ';
+			i++;
+		    }
+		    if (full_line == NULL) {
+			StrAllocCopy(full_line, line);
+		    } else {
+			StrAllocCat(full_line, line);
+		    }
+		} else {
+		    StrAllocCopy(full_line, line);
+		}
+
+		if (full_line[0] == '.') {
+		    /*
+		     * End of article?
+		     */
+		    if (UCH(full_line[1]) < ' ') {
+			done = YES;
+			break;
+		    }
+		} else if (UCH(full_line[0]) < ' ') {
+		    break;	/* End of Header? */
+
+		} else if (match(full_line, "SUBJECT:")) {
+		    StrAllocCopy(subject, HTStrip(StrChr(full_line, ':') + 1));
+		    decode_mime(&subject);
+		} else if (match(full_line, "DATE:")) {
+		    StrAllocCopy(date, HTStrip(StrChr(full_line, ':') + 1));
+
+		} else if (match(full_line, "ORGANIZATION:")) {
+		    StrAllocCopy(organization,
+				 HTStrip(StrChr(full_line, ':') + 1));
+		    decode_mime(&organization);
+
+		} else if (match(full_line, "FROM:")) {
+		    StrAllocCopy(from, HTStrip(StrChr(full_line, ':') + 1));
+		    decode_mime(&from);
+
+		} else if (match(full_line, "REPLY-TO:")) {
+		    StrAllocCopy(replyto, HTStrip(StrChr(full_line, ':') + 1));
+		    decode_mime(&replyto);
+
+		} else if (match(full_line, "NEWSGROUPS:")) {
+		    StrAllocCopy(newsgroups, HTStrip(StrChr(full_line, ':') + 1));
+
+		} else if (match(full_line, "REFERENCES:")) {
+		    StrAllocCopy(references, HTStrip(StrChr(full_line, ':') + 1));
+
+		} else if (match(full_line, "FOLLOWUP-TO:")) {
+		    StrAllocCopy(followupto, HTStrip(StrChr(full_line, ':') + 1));
+
+		} else if (match(full_line, "MESSAGE-ID:")) {
+		    char *msgid = HTStrip(full_line + 11);
+
+		    if (msgid[0] == '<' && msgid[strlen(msgid) - 1] == '>') {
+			msgid[strlen(msgid) - 1] = '\0';	/* Chop > */
+			msgid++;	/* Chop < */
+			HTAnchor_setMessageID(thisanchor, msgid);
+		    }
+
+		}		/* end if match */
+		p = line;	/* Restart at beginning */
+	    }			/* if end of line */
+	}			/* Loop over characters */
+	FREE(full_line);
+
+	START(HTML_HEAD);
+	PUTC('\n');
+	START(HTML_TITLE);
+	if (subject && *subject != '\0')
+	    PUTS(subject);
+	else
+	    PUTS("No Subject");
+	END(HTML_TITLE);
+	PUTC('\n');
+	/*
+	 * Put in the owner as a link rel.
+	 */
+	if (from || replyto) {
+	    char *temp = NULL;
+
+	    StrAllocCopy(temp, author_address(replyto ? replyto : from));
+	    StrAllocCopy(href, STR_MAILTO_URL);
+	    if (StrChr(temp, '%') || StrChr(temp, '?')) {
+		cp = HTEscape(temp, URL_XPALPHAS);
+		StrAllocCat(href, cp);
+		FREE(cp);
+	    } else {
+		StrAllocCat(href, temp);
+	    }
+	    start_link(href, "made");
+	    PUTC('\n');
+	    FREE(temp);
+	}
+	END(HTML_HEAD);
+	PUTC('\n');
+
+	START(HTML_H1);
+	if (subject && *subject != '\0')
+	    PUTS(subject);
+	else
+	    PUTS("No Subject");
+	END(HTML_H1);
+	PUTC('\n');
+
+	if (subject)
+	    FREE(subject);
+
+	START(HTML_DLC);
+	PUTC('\n');
+
+	if (from || replyto) {
+	    START(HTML_DT);
+	    START(HTML_B);
+	    PUTS("From:");
+	    END(HTML_B);
+	    PUTC(' ');
+	    if (from)
+		PUTS(from);
+	    else
+		PUTS(replyto);
+	    MAYBE_END(HTML_DT);
+	    PUTC('\n');
+
+	    if (!replyto)
+		StrAllocCopy(replyto, from);
+	    START(HTML_DT);
+	    START(HTML_B);
+	    PUTS("Reply to:");
+	    END(HTML_B);
+	    PUTC(' ');
+	    start_anchor(href);
+	    if (*replyto != '<')
+		PUTS(author_name(replyto));
+	    else
+		PUTS(author_address(replyto));
+	    END(HTML_A);
+	    START(HTML_BR);
+	    MAYBE_END(HTML_DT);
+	    PUTC('\n');
+
+	    FREE(from);
+	    FREE(replyto);
+	}
+
+	if (date) {
+	    START(HTML_DT);
+	    START(HTML_B);
+	    PUTS("Date:");
+	    END(HTML_B);
+	    PUTC(' ');
+	    PUTS(date);
+	    MAYBE_END(HTML_DT);
+	    PUTC('\n');
+	    FREE(date);
+	}
+
+	if (organization) {
+	    START(HTML_DT);
+	    START(HTML_B);
+	    PUTS("Organization:");
+	    END(HTML_B);
+	    PUTC(' ');
+	    PUTS(organization);
+	    MAYBE_END(HTML_DT);
+	    PUTC('\n');
+	    FREE(organization);
+	}
+
+	/* sanitize some headers - kw */
+	if (newsgroups &&
+	    ((cp = StrChr(newsgroups, '/')) ||
+	     (cp = StrChr(newsgroups, '(')))) {
+	    *cp = '\0';
+	}
+	if (newsgroups && !*newsgroups) {
+	    FREE(newsgroups);
+	}
+	if (followupto &&
+	    ((cp = StrChr(followupto, '/')) ||
+	     (cp = StrChr(followupto, '(')))) {
+	    *cp = '\0';
+	}
+	if (followupto && !*followupto) {
+	    FREE(followupto);
+	}
+
+	if (newsgroups && HTCanPost) {
+	    START(HTML_DT);
+	    START(HTML_B);
+	    PUTS("Newsgroups:");
+	    END(HTML_B);
+	    PUTC('\n');
+	    MAYBE_END(HTML_DT);
+	    START(HTML_DD);
+	    write_anchors(newsgroups);
+	    MAYBE_END(HTML_DD);
+	    PUTC('\n');
+	}
+
+	if (followupto && !strcasecomp(followupto, "poster")) {
+	    /*
+	     * "Followup-To:  poster" has special meaning.  Don't use it to
+	     * construct a newsreply link.  -kw
+	     */
+	    START(HTML_DT);
+	    START(HTML_B);
+	    PUTS("Followup to:");
+	    END(HTML_B);
+	    PUTC(' ');
+	    if (href) {
+		start_anchor(href);
+		PUTS("poster");
+		END(HTML_A);
+	    } else {
+		PUTS("poster");
+	    }
+	    MAYBE_END(HTML_DT);
+	    PUTC('\n');
+	    FREE(followupto);
+	}
+
+	if (newsgroups && HTCanPost) {
+	    /*
+	     * We have permission to POST to this host, so add a link for
+	     * posting followups for this article.  - FM
+	     */
+	    if (!strncasecomp(NewsHREF, STR_SNEWS_URL, 6))
+		StrAllocCopy(href, "snewsreply://");
+	    else
+		StrAllocCopy(href, "newsreply://");
+	    StrAllocCat(href, NewsHost);
+	    StrAllocCat(href, "/");
+	    StrAllocCat(href, (followupto ? followupto : newsgroups));
+	    if (*href == 'n' &&
+		(ccp = HTAnchor_messageID(thisanchor)) && *ccp) {
+		StrAllocCat(href, ";ref=");
+		if (StrChr(ccp, '<') || StrChr(ccp, '&') ||
+		    StrChr(ccp, ' ') || StrChr(ccp, ':') ||
+		    StrChr(ccp, '/') || StrChr(ccp, '%') ||
+		    StrChr(ccp, ';')) {
+		    char *cp1 = HTEscape(ccp, URL_XPALPHAS);
+
+		    StrAllocCat(href, cp1);
+		    FREE(cp1);
+		} else {
+		    StrAllocCat(href, ccp);
+		}
+	    }
+
+	    START(HTML_DT);
+	    START(HTML_B);
+	    PUTS("Followup to:");
+	    END(HTML_B);
+	    PUTC(' ');
+	    start_anchor(href);
+	    if (StrChr((followupto ? followupto : newsgroups), ',')) {
+		PUTS("newsgroups");
+	    } else {
+		PUTS("newsgroup");
+	    }
+	    END(HTML_A);
+	    MAYBE_END(HTML_DT);
+	    PUTC('\n');
+	}
+	FREE(newsgroups);
+	FREE(followupto);
+
+	if (references) {
+	    START(HTML_DT);
+	    START(HTML_B);
+	    PUTS("References:");
+	    END(HTML_B);
+	    MAYBE_END(HTML_DT);
+	    PUTC('\n');
+	    START(HTML_DD);
+	    write_anchors(references);
+	    MAYBE_END(HTML_DD);
+	    PUTC('\n');
+	    FREE(references);
+	}
+
+	END(HTML_DLC);
+	PUTC('\n');
+	FREE(href);
+    }
+
+    if (rawtext) {
+	/*
+	 * No tags, and never do a PUTC.  - kw
+	 */
+	;
+    } else if (diagnostic) {
+	/*
+	 * Read in the HEAD and BODY of the Article as XMP formatted text.  -
+	 * FM
+	 */
+	START(HTML_XMP);
+	PUTC('\n');
+    } else {
+	/*
+	 * Read in the BODY of the Article as PRE formatted text.  - FM
+	 */
+	START(HTML_PRE);
+	PUTC('\n');
+    }
+
+    p = line;
+    while (!done) {
+	int ich = NEXT_CHAR;
+
+	*p++ = (char) ich;
+	if (ich == EOF) {
+	    if (interrupted_in_htgetcharacter) {
+		interrupted_in_htgetcharacter = 0;
+		CTRACE((tfp,
+			"HTNews: Interrupted on read, closing socket %d\n",
+			s));
+		NEWS_NETCLOSE(s);
+		s = -1;
+		return (HT_INTERRUPTED);
+	    }
+	    abort_socket();	/* End of file, close socket */
+	    return (HT_LOADED);	/* End of file on response */
+	}
+	if (((char) ich == LF) || (p == &line[LINE_LENGTH])) {
+	    *p = '\0';		/* Terminate the string */
+	    CTRACE((tfp, "B %s", line));
+#ifdef NEWS_DEBUG		/* 1997/11/09 (Sun) 15:56:11 */
+	    debug_print(line);	/* @@@ */
+#endif
+	    if (line[0] == '.') {
+		/*
+		 * End of article?
+		 */
+		if (UCH(line[1]) < ' ') {
+		    break;
+		} else {	/* Line starts with dot */
+		    if (rawtext) {
+			RAW_PUTS(&line[1]);
+		    } else {
+			PUTS(&line[1]);		/* Ignore first dot */
+		    }
+		}
+	    } else {
+		if (rawtext) {
+		    RAW_PUTS(line);
+		} else if (diagnostic || !scan_for_buried_news_references) {
+		    /*
+		     * All lines are passed as unmodified source.  - FM
+		     */
+		    PUTS(line);
+		} else {
+		    /*
+		     * Normal lines are scanned for buried references to other
+		     * articles.  Unfortunately, it could pick up mail
+		     * addresses as well!  It also can corrupt uuencoded
+		     * messages!  So we don't do this when fetching articles as
+		     * WWW_SOURCE or when downloading (diagnostic is TRUE) or
+		     * if the client has set scan_for_buried_news_references to
+		     * FALSE.  Otherwise, we convert all "<...@...>" strings
+		     * preceded by "rticle " to "news:...@..." links, and any
+		     * strings that look like URLs to links.  - FM
+		     */
+		    char *l = line;
+		    char *p2;
+
+		    while ((p2 = strstr(l, "rticle <")) != NULL) {
+			char *q = strrchr(p2, '>');
+			char *at = strrchr(p2, '@');
+
+			if (q && at && at < q) {
+			    char c = q[1];
+
+			    q[1] = 0;	/* chop up */
+			    p2 += 7;
+			    *p2 = 0;
+			    while (*l) {
+				if (StrNCmp(l, STR_NEWS_URL, LEN_NEWS_URL) &&
+				    StrNCmp(l, "snews://", 8) &&
+				    StrNCmp(l, "nntp://", 7) &&
+				    StrNCmp(l, "snewspost:", 10) &&
+				    StrNCmp(l, "snewsreply:", 11) &&
+				    StrNCmp(l, "newspost:", 9) &&
+				    StrNCmp(l, "newsreply:", 10) &&
+				    StrNCmp(l, "ftp://", 6) &&
+				    StrNCmp(l, "file:/", 6) &&
+				    StrNCmp(l, "finger://", 9) &&
+				    StrNCmp(l, "http://", 7) &&
+				    StrNCmp(l, "https://", 8) &&
+				    StrNCmp(l, "wais://", 7) &&
+				    StrNCmp(l, STR_MAILTO_URL, LEN_MAILTO_URL) &&
+				    StrNCmp(l, "cso://", 6) &&
+				    StrNCmp(l, "gopher://", 9)) {
+				    PUTC(*l++);
+				} else {
+				    StrAllocCopy(href, l);
+				    start_anchor(strtok(href, " \r\n\t,>)\""));
+				    while (*l && !StrChr(" \r\n\t,>)\"", *l))
+					PUTC(*l++);
+				    END(HTML_A);
+				    FREE(href);
+				}
+			    }
+			    *p2 = '<';	/* again */
+			    *q = 0;
+			    start_anchor(p2 + 1);
+			    *q = '>';	/* again */
+			    PUTS(p2);
+			    END(HTML_A);
+			    q[1] = c;	/* again */
+			    l = q + 1;
+			} else {
+			    break;	/* line has unmatched <> */
+			}
+		    }
+		    while (*l) {	/* Last bit of the line */
+			if (StrNCmp(l, STR_NEWS_URL, LEN_NEWS_URL) &&
+			    StrNCmp(l, "snews://", 8) &&
+			    StrNCmp(l, "nntp://", 7) &&
+			    StrNCmp(l, "snewspost:", 10) &&
+			    StrNCmp(l, "snewsreply:", 11) &&
+			    StrNCmp(l, "newspost:", 9) &&
+			    StrNCmp(l, "newsreply:", 10) &&
+			    StrNCmp(l, "ftp://", 6) &&
+			    StrNCmp(l, "file:/", 6) &&
+			    StrNCmp(l, "finger://", 9) &&
+			    StrNCmp(l, "http://", 7) &&
+			    StrNCmp(l, "https://", 8) &&
+			    StrNCmp(l, "wais://", 7) &&
+			    StrNCmp(l, STR_MAILTO_URL, LEN_MAILTO_URL) &&
+			    StrNCmp(l, "cso://", 6) &&
+			    StrNCmp(l, "gopher://", 9))
+			    PUTC(*l++);
+			else {
+			    StrAllocCopy(href, l);
+			    start_anchor(strtok(href, " \r\n\t,>)\""));
+			    while (*l && !StrChr(" \r\n\t,>)\"", *l))
+				PUTC(*l++);
+			    END(HTML_A);
+			    FREE(href);
+			}
+		    }
+		}		/* if diagnostic or not scan_for_buried_news_references */
+	    }			/* if not dot */
+	    p = line;		/* Restart at beginning */
+	}			/* if end of line */
+    }				/* Loop over characters */
+
+    if (rawtext)
+	return (HT_LOADED);
+
+    if (diagnostic)
+	END(HTML_XMP);
+    else
+	END(HTML_PRE);
+    PUTC('\n');
+    return (HT_LOADED);
+}
+
+/*	Read in a List of Newsgroups
+ *	----------------------------
+ *
+ *  Note the termination condition of a single dot on a line by itself.
+ *  RFC 977 specifies that the line "folding" of RFC850 is not used,
+ *  so we do not handle it here.
+ */
+static int read_list(char *arg)
+{
+    char line[LINE_LENGTH + 1];
+    char *p;
+    BOOL done = NO;
+    BOOL head = NO;
+    BOOL tail = NO;
+    BOOL skip_this_line = NO;
+    BOOL skip_rest_of_line = NO;
+    int listing = 0;
+    char *pattern = NULL;
+    int len = 0;
+
+    /*
+     * Support head or tail matches for groups to list.  - FM
+     */
+    if (arg && strlen(arg) > 1) {
+	if (*arg == '*') {
+	    tail = YES;
+	    StrAllocCopy(pattern, (arg + 1));
+	} else if (arg[strlen(arg) - 1] == '*') {
+	    head = YES;
+	    StrAllocCopy(pattern, arg);
+	    pattern[strlen(pattern) - 1] = '\0';
+	}
+	if (tail || head) {
+	    len = (int) strlen(pattern);
+	}
+
+    }
+
+    /*
+     * Read the server's reply.
+     *
+     * The lines are scanned for newsgroup names and descriptions.
+     */
+    START(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_TITLE);
+    PUTS("Newsgroups");
+    END(HTML_TITLE);
+    PUTC('\n');
+    END(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_H1);
+    PUTS("Newsgroups");
+    END(HTML_H1);
+    PUTC('\n');
+    *(p = line) = '\0';
+    START(HTML_DLC);
+    PUTC('\n');
+    while (!done) {
+	int ich = NEXT_CHAR;
+	char ch = (char) ich;
+
+	if (ich == EOF) {
+	    if (interrupted_in_htgetcharacter) {
+		interrupted_in_htgetcharacter = 0;
+		CTRACE((tfp,
+			"HTNews: Interrupted on read, closing socket %d\n",
+			s));
+		NEWS_NETCLOSE(s);
+		s = -1;
+		return (HT_INTERRUPTED);
+	    }
+	    abort_socket();	/* End of file, close socket */
+	    FREE(pattern);
+	    return (HT_LOADED);	/* End of file on response */
+	} else if (skip_this_line) {
+	    if (ch == LF) {
+		skip_this_line = skip_rest_of_line = NO;
+		p = line;
+	    }
+	    continue;
+	} else if (skip_rest_of_line) {
+	    if (ch != LF) {
+		continue;
+	    }
+	} else if (p == &line[LINE_LENGTH]) {
+	    CTRACE((tfp, "b %.*s%c[...]\n", (LINE_LENGTH), line, ch));
+	    *p = '\0';
+	    if (ch == LF) {
+		;		/* Will be dealt with below */
+	    } else if (WHITE(ch)) {
+		ch = LF;	/* May treat as line without description */
+		skip_this_line = YES;	/* ...and ignore until LF */
+	    } else if (StrChr(line, ' ') == NULL &&
+		       StrChr(line, '\t') == NULL) {
+		/* No separator found */
+		CTRACE((tfp, "HTNews..... group name too long, discarding.\n"));
+		skip_this_line = YES;	/* ignore whole line */
+		continue;
+	    } else {
+		skip_rest_of_line = YES;	/* skip until ch == LF found */
+	    }
+	} else {
+	    *p++ = ch;
+	}
+	if (ch == LF) {
+	    skip_rest_of_line = NO;	/* done, reset flag */
+	    *p = '\0';		/* Terminate the string */
+	    CTRACE((tfp, "B %s", line));
+	    if (line[0] == '.') {
+		/*
+		 * End of article?
+		 */
+		if (UCH(line[1]) < ' ') {
+		    break;
+		} else {	/* Line starts with dot */
+		    START(HTML_DT);
+		    PUTS(&line[1]);
+		    MAYBE_END(HTML_DT);
+		}
+	    } else if (line[0] == '#') {	/* Comment? */
+		p = line;	/* Restart at beginning */
+		continue;
+	    } else {
+		/*
+		 * Normal lines are scanned for references to newsgroups.
+		 */
+		int i = 0;
+
+		/* find whitespace if it exits */
+		for (; line[i] != '\0' && !WHITE(line[i]); i++) ;	/* null body */
+
+		if (line[i] != '\0') {
+		    line[i] = '\0';
+		    if ((head && strncasecomp(line, pattern, len)) ||
+			(tail && (i < len ||
+				  strcasecomp((line + (i - len)), pattern)))) {
+			p = line;	/* Restart at beginning */
+			continue;
+		    }
+		    START(HTML_DT);
+		    write_anchor(line, line);
+		    listing++;
+		    MAYBE_END(HTML_DT);
+		    PUTC('\n');
+		    START(HTML_DD);
+		    PUTS(&line[i + 1]);		/* put description */
+		    MAYBE_END(HTML_DD);
+		} else {
+		    if ((head && strncasecomp(line, pattern, len)) ||
+			(tail && (i < len ||
+				  strcasecomp((line + (i - len)), pattern)))) {
+			p = line;	/* Restart at beginning */
+			continue;
+		    }
+		    START(HTML_DT);
+		    write_anchor(line, line);
+		    MAYBE_END(HTML_DT);
+		    listing++;
+		}
+	    }			/* if not dot */
+	    p = line;		/* Restart at beginning */
+	}			/* if end of line */
+    }				/* Loop over characters */
+    if (!listing) {
+	char *msg = NULL;
+
+	START(HTML_DT);
+	HTSprintf0(&msg, gettext("No matches for: %s"), arg);
+	PUTS(msg);
+	MAYBE_END(HTML_DT);
+	FREE(msg);
+    }
+    END(HTML_DLC);
+    PUTC('\n');
+    FREE(pattern);
+    return (HT_LOADED);
+}
+
+/*	Read in a Newsgroup
+ *	-------------------
+ *
+ *  Unfortunately, we have to ask for each article one by one if we
+ *  want more than one field.
+ *
+ */
+static int read_group(const char *groupName,
+		      int first_required,
+		      int last_required)
+{
+    char line[LINE_LENGTH + 1];
+    char *author = NULL;
+    char *subject = NULL;
+    char *date = NULL;
+    int i;
+    char *p;
+    BOOL done;
+
+    char buffer[LINE_LENGTH + 1];
+    char *temp = NULL;
+    char *reference = NULL;	/* Href for article */
+    int art;			/* Article number WITHIN GROUP */
+    int status, count, first, last;	/* Response fields */
+
+    START(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_TITLE);
+    PUTS("Newsgroup ");
+    PUTS(groupName);
+    END(HTML_TITLE);
+    PUTC('\n');
+    END(HTML_HEAD);
+    PUTC('\n');
+
+    sscanf(response_text, " %d %d %d %d", &status, &count, &first, &last);
+    CTRACE((tfp, "Newsgroup status=%d, count=%d, (%d-%d) required:(%d-%d)\n",
+	    status, count, first, last, first_required, last_required));
+    if (last == 0) {
+	PUTS(gettext("\nNo articles in this group.\n"));
+	goto add_post;
+    }
+#define FAST_THRESHOLD 100	/* Above this, read IDs fast */
+#define CHOP_THRESHOLD 50	/* Above this, chop off the rest */
+
+    if (first_required < first)
+	first_required = first;	/* clip */
+    if ((last_required == 0) || (last_required > last))
+	last_required = last;
+
+    if (last_required < first_required) {
+	PUTS(gettext("\nNo articles in this range.\n"));
+	goto add_post;
+    }
+
+    if (last_required - first_required + 1 > HTNewsMaxChunk) {	/* Trim this block */
+	first_required = last_required - HTNewsChunkSize + 1;
+    }
+    CTRACE((tfp, "    Chunk will be (%d-%d)\n",
+	    first_required, last_required));
+
+    /*
+     * Set window title.
+     */
+    HTSprintf0(&temp, gettext("%s,  Articles %d-%d"),
+	       groupName, first_required, last_required);
+    START(HTML_H1);
+    PUTS(temp);
+    FREE(temp);
+    END(HTML_H1);
+    PUTC('\n');
+
+    /*
+     * Link to earlier articles.
+     */
+    if (first_required > first) {
+	int before;		/* Start of one before */
+
+	if (first_required - HTNewsMaxChunk <= first)
+	    before = first;
+	else
+	    before = first_required - HTNewsChunkSize;
+	HTSprintf0(&dbuf, "%s%s/%d-%d", NewsHREF, groupName,
+		   before, first_required - 1);
+	CTRACE((tfp, "    Block before is %s\n", dbuf));
+	PUTC('(');
+	start_anchor(dbuf);
+	PUTS(gettext("Earlier articles"));
+	END(HTML_A);
+	PUTS("...)\n");
+	START(HTML_P);
+	PUTC('\n');
+    }
+
+    done = NO;
+
+/*#define USE_XHDR*/
+#ifdef USE_XHDR
+    if (count > FAST_THRESHOLD) {
+	HTSprintf0(&temp,
+		   gettext("\nThere are about %d articles currently available in %s, IDs as follows:\n\n"),
+		   count, groupName);
+	PUTS(temp);
+	FREE(temp);
+	sprintf(buffer, "XHDR Message-ID %d-%d%c%c", first, last, CR, LF);
+	status = response(buffer);
+	if (status == 221) {
+	    p = line;
+	    while (!done) {
+		int ich = NEXT_CHAR;
+
+		*p++ = ich;
+		if (ich == EOF) {
+		    if (interrupted_in_htgetcharacter) {
+			interrupted_in_htgetcharacter = 0;
+			CTRACE((tfp,
+				"HTNews: Interrupted on read, closing socket %d\n",
+				s));
+			NEWS_NETCLOSE(s);
+			s = -1;
+			return (HT_INTERRUPTED);
+		    }
+		    abort_socket();	/* End of file, close socket */
+		    return (HT_LOADED);		/* End of file on response */
+		}
+		if (((char) ich == '\n') || (p == &line[LINE_LENGTH])) {
+		    *p = '\0';	/* Terminate the string */
+		    CTRACE((tfp, "X %s", line));
+		    if (line[0] == '.') {
+			/*
+			 * End of article?
+			 */
+			if (UCH(line[1]) < ' ') {
+			    done = YES;
+			    break;
+			} else {	/* Line starts with dot */
+			    /* Ignore strange line */
+			}
+		    } else {
+			/*
+			 * Normal lines are scanned for references to articles.
+			 */
+			char *space = StrChr(line, ' ');
+
+			if (space++)
+			    write_anchor(space, space);
+		    }		/* if not dot */
+		    p = line;	/* Restart at beginning */
+		}		/* if end of line */
+	    }			/* Loop over characters */
+
+	    /* leaving loop with "done" set */
+	}			/* Good status */
+    }
+#endif /* USE_XHDR */
+
+    /*
+     * Read newsgroup using individual fields.
+     */
+    if (!done) {
+	START(HTML_B);
+	if (first == first_required && last == last_required)
+	    PUTS(gettext("All available articles in "));
+	else
+	    PUTS("Articles in ");
+	PUTS(groupName);
+	END(HTML_B);
+	PUTC('\n');
+	if (LYListNewsNumbers)
+	    start_list(first_required);
+	else
+	    START(HTML_UL);
+	for (art = first_required; art <= last_required; art++) {
+/*#define OVERLAP*/
+#ifdef OVERLAP
+	    /*
+	     * With this code we try to keep the server running flat out by
+	     * queuing just one extra command ahead of time.  We assume (1)
+	     * that the server won't abort if it gets input during output, and
+	     * (2) that TCP buffering is enough for the two commands.  Both
+	     * these assumptions seem very reasonable.  However, we HAVE had a
+	     * hangup with a loaded server.
+	     */
+	    if (art == first_required) {
+		if (art == last_required) {	/* Only one */
+		    sprintf(buffer, "HEAD %d%c%c",
+			    art, CR, LF);
+		    status = response(buffer);
+		} else {	/* First of many */
+		    sprintf(buffer, "HEAD %d%c%cHEAD %d%c%c",
+			    art, CR, LF, art + 1, CR, LF);
+		    status = response(buffer);
+		}
+	    } else if (art == last_required) {	/* Last of many */
+		status = response(NULL);
+	    } else {		/* Middle of many */
+		sprintf(buffer, "HEAD %d%c%c", art + 1, CR, LF);
+		status = response(buffer);
+	    }
+#else /* Not OVERLAP: */
+	    sprintf(buffer, "HEAD %d%c%c", art, CR, LF);
+	    status = response(buffer);
+#endif /* OVERLAP */
+	    /*
+	     * Check for a good response (221) for the HEAD request, and if so,
+	     * parse it.  Otherwise, indicate the error so that the number of
+	     * listings corresponds to what's claimed for the range, and if we
+	     * are listing numbers via an ordered list, they stay in synchrony
+	     * with the article numbers.  - FM
+	     */
+	    if (status == 221) {	/* Head follows - parse it: */
+		p = line;	/* Write pointer */
+		done = NO;
+		while (!done) {
+		    int ich = NEXT_CHAR;
+
+		    *p++ = (char) ich;
+		    if (ich == EOF) {
+			if (interrupted_in_htgetcharacter) {
+			    interrupted_in_htgetcharacter = 0;
+			    CTRACE((tfp,
+				    "HTNews: Interrupted on read, closing socket %d\n",
+				    s));
+			    NEWS_NETCLOSE(s);
+			    s = -1;
+			    return (HT_INTERRUPTED);
+			}
+			abort_socket();		/* End of file, close socket */
+			return (HT_LOADED);	/* End of file on response */
+		    }
+		    if (((char) ich == LF) ||
+			(p == &line[LINE_LENGTH])) {
+
+			*--p = '\0';	/* Terminate  & chop LF */
+			p = line;	/* Restart at beginning */
+			CTRACE((tfp, "G %s\n", line));
+			switch (line[0]) {
+
+			case '.':
+			    /*
+			     * End of article?
+			     */
+			    done = (BOOL) (UCH(line[1]) < ' ');
+			    break;
+
+			case 'S':
+			case 's':
+			    if (match(line, "SUBJECT:")) {
+				StrAllocCopy(subject, line + 9);
+				decode_mime(&subject);
+			    }
+			    break;
+
+			case 'M':
+			case 'm':
+			    if (match(line, "MESSAGE-ID:")) {
+				char *addr = HTStrip(line + 11) + 1;	/* Chop < */
+
+				addr[strlen(addr) - 1] = '\0';	/* Chop > */
+				StrAllocCopy(reference, addr);
+			    }
+			    break;
+
+			case 'f':
+			case 'F':
+			    if (match(line, "FROM:")) {
+				char *p2;
+
+				StrAllocCopy(author, StrChr(line, ':') + 1);
+				decode_mime(&author);
+				p2 = author + strlen(author) - 1;
+				if (*p2 == LF)
+				    *p2 = '\0';		/* Chop off newline */
+			    }
+			    break;
+
+			case 'd':
+			case 'D':
+			    if (LYListNewsDates && match(line, "DATE:")) {
+				StrAllocCopy(date,
+					     HTStrip(StrChr(line, ':') + 1));
+			    }
+			    break;
+
+			}	/* end switch on first character */
+		    }		/* if end of line */
+		}		/* Loop over characters */
+
+		PUTC('\n');
+		START(HTML_LI);
+		p = decode_mime(&subject);
+		HTSprintf0(&temp, "\"%s\"", NonNull(p));
+		if (reference) {
+		    write_anchor(temp, reference);
+		    FREE(reference);
+		} else {
+		    PUTS(temp);
+		}
+		FREE(temp);
+
+		if (author != NULL) {
+		    PUTS(" - ");
+		    if (LYListNewsDates)
+			START(HTML_I);
+		    PUTS(decode_mime(&author));
+		    if (LYListNewsDates)
+			END(HTML_I);
+		    FREE(author);
+		}
+		if (date) {
+		    if (!diagnostic) {
+			for (i = 0; date[i]; i++) {
+			    if (date[i] == ' ') {
+				date[i] = HT_NON_BREAK_SPACE;
+			    }
+			}
+		    }
+		    sprintf(buffer, " [%.*s]", (int) (sizeof(buffer) - 4), date);
+		    PUTS(buffer);
+		    FREE(date);
+		}
+		MAYBE_END(HTML_LI);
+		/*
+		 * Indicate progress!  @@@@@@
+		 */
+	    } else if (status == HT_INTERRUPTED) {
+		interrupted_in_htgetcharacter = 0;
+		CTRACE((tfp,
+			"HTNews: Interrupted on read, closing socket %d\n",
+			s));
+		NEWS_NETCLOSE(s);
+		s = -1;
+		return (HT_INTERRUPTED);
+	    } else {
+		/*
+		 * Use the response text on error.  - FM
+		 */
+		PUTC('\n');
+		START(HTML_LI);
+		START(HTML_I);
+		if (LYListNewsNumbers)
+		    LYStrNCpy(buffer, "Status:", sizeof(buffer) - 1);
+		else
+		    sprintf(buffer, "Status (ARTICLE %d):", art);
+		PUTS(buffer);
+		END(HTML_I);
+		PUTC(' ');
+		PUTS(response_text);
+		MAYBE_END(HTML_LI);
+	    }			/* Handle response to HEAD request */
+	}			/* Loop over article */
+	FREE(author);
+	FREE(subject);
+    }				/* If read headers */
+    PUTC('\n');
+    if (LYListNewsNumbers)
+	END(HTML_OL);
+    else
+	END(HTML_UL);
+    PUTC('\n');
+
+    /*
+     * Link to later articles.
+     */
+    if (last_required < last) {
+	int after;		/* End of article after */
+
+	after = last_required + HTNewsChunkSize;
+	if (after == last)
+	    HTSprintf0(&dbuf, "%s%s", NewsHREF, groupName);	/* original group */
+	else
+	    HTSprintf0(&dbuf, "%s%s/%d-%d", NewsHREF, groupName,
+		       last_required + 1, after);
+	CTRACE((tfp, "    Block after is %s\n", dbuf));
+	PUTC('(');
+	start_anchor(dbuf);
+	PUTS(gettext("Later articles"));
+	END(HTML_A);
+	PUTS("...)\n");
+    }
+
+  add_post:
+    if (HTCanPost) {
+	/*
+	 * We have permission to POST to this host, so add a link for posting
+	 * messages to this newsgroup.  - FM
+	 */
+	char *href = NULL;
+
+	START(HTML_HR);
+	PUTC('\n');
+	if (!strncasecomp(NewsHREF, STR_SNEWS_URL, 6))
+	    StrAllocCopy(href, "snewspost://");
+	else
+	    StrAllocCopy(href, "newspost://");
+	StrAllocCat(href, NewsHost);
+	StrAllocCat(href, "/");
+	StrAllocCat(href, groupName);
+	start_anchor(href);
+	PUTS(gettext("Post to "));
+	PUTS(groupName);
+	END(HTML_A);
+	FREE(href);
+    } else {
+	START(HTML_HR);
+    }
+    PUTC('\n');
+    return (HT_LOADED);
+}
+
+/*	Load by name.						HTLoadNews
+ *	=============
+ */
+static int HTLoadNews(const char *arg,
+		      HTParentAnchor *anAnchor,
+		      HTFormat format_out,
+		      HTStream *stream)
+{
+    char command[262];		/* The whole command */
+    char proxycmd[260];		/* The proxy command */
+    char groupName[GROUP_NAME_LENGTH];	/* Just the group name */
+    int status;			/* tcp return */
+    int retries;		/* A count of how hard we have tried */
+    BOOL normal_url;		/* Flag: "news:" or "nntp:" (physical) URL */
+    BOOL group_wanted;		/* Flag: group was asked for, not article */
+    BOOL list_wanted;		/* Flag: list was asked for, not article */
+    BOOL post_wanted;		/* Flag: new post to group was asked for */
+    BOOL reply_wanted;		/* Flag: followup post was asked for */
+    BOOL spost_wanted;		/* Flag: new SSL post to group was asked for */
+    BOOL sreply_wanted;		/* Flag: followup SSL post was asked for */
+    BOOL head_wanted = NO;	/* Flag: want HEAD of single article */
+    int first, last;		/* First and last articles asked for */
+    char *cp = 0;
+    char *ListArg = NULL;
+    char *ProxyHost = NULL;
+    char *ProxyHREF = NULL;
+    char *postfile = NULL;
+
+#ifdef USE_SSL
+    char SSLprogress[256];
+#endif /* USE_SSL */
+
+    diagnostic = (format_out == WWW_SOURCE ||	/* set global flag */
+		  format_out == WWW_DOWNLOAD ||
+		  format_out == WWW_DUMP);
+    rawtext = NO;
+
+    CTRACE((tfp, "HTNews: Looking for %s\n", arg));
+
+    if (!initialized)
+	initialized = initialize();
+    if (!initialized)
+	return -1;		/* FAIL */
+
+    FREE(NewsHREF);
+    command[0] = '\0';
+    command[sizeof(command) - 1] = '\0';
+    proxycmd[0] = '\0';
+    proxycmd[sizeof(proxycmd) - 1] = '\0';
+
+    {
+	const char *p1;
+
+	/*
+	 * We will ask for the document, omitting the host name & anchor.
+	 *
+	 * Syntax of address is
+	 * xxx@yyy                 Article
+	 * <xxx@yyy>               Same article
+	 * xxxxx                   News group (no "@")
+	 * group/n1-n2             Articles n1 to n2 in group
+	 */
+	normal_url = (BOOL) (!StrNCmp(arg, STR_NEWS_URL, LEN_NEWS_URL) ||
+			     !StrNCmp(arg, "nntp:", 5));
+	spost_wanted = (BOOL) (!normal_url && strstr(arg, "snewspost:") != NULL);
+	sreply_wanted = (BOOL) (!(normal_url || spost_wanted) &&
+				strstr(arg, "snewsreply:") != NULL);
+	post_wanted = (BOOL) (!(normal_url || spost_wanted || sreply_wanted) &&
+			      strstr(arg, "newspost:") != NULL);
+	reply_wanted = (BOOL) (!(normal_url || spost_wanted || sreply_wanted ||
+				 post_wanted) &&
+			       strstr(arg, "newsreply:") != NULL);
+	group_wanted = (BOOL) ((!(spost_wanted || sreply_wanted ||
+				  post_wanted || reply_wanted) &&
+				StrChr(arg, '@') == NULL) &&
+			       (StrChr(arg, '*') == NULL));
+	list_wanted = (BOOL) ((!(spost_wanted || sreply_wanted ||
+				 post_wanted || reply_wanted ||
+				 group_wanted) &&
+			       StrChr(arg, '@') == NULL) &&
+			      (StrChr(arg, '*') != NULL));
+
+#ifndef USE_SSL
+	if (!strncasecomp(arg, "snewspost:", 10) ||
+	    !strncasecomp(arg, "snewsreply:", 11)) {
+	    HTAlert(FAILED_CANNOT_POST_SSL);
+	    return HT_NOT_LOADED;
+	}
+#endif /* !USE_SSL */
+	if (post_wanted || reply_wanted || spost_wanted || sreply_wanted) {
+	    /*
+	     * Make sure we have a non-zero path for the newsgroup(s).  - FM
+	     */
+	    if ((p1 = strrchr(arg, '/')) != NULL) {
+		p1++;
+	    } else if ((p1 = strrchr(arg, ':')) != NULL) {
+		p1++;
+	    }
+	    if (!(p1 && *p1)) {
+		HTAlert(WWW_ILLEGAL_URL_MESSAGE);
+		return (HT_NO_DATA);
+	    }
+	    if (!(cp = HTParse(arg, "", PARSE_HOST)) || *cp == '\0') {
+		if (s >= 0 && NewsHost && strcasecomp(NewsHost, HTNewsHost)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		StrAllocCopy(NewsHost, HTNewsHost);
+	    } else {
+		if (s >= 0 && NewsHost && strcasecomp(NewsHost, cp)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		StrAllocCopy(NewsHost, cp);
+	    }
+	    FREE(cp);
+	    HTSprintf0(&NewsHREF, "%s://%.*s/",
+		       (post_wanted ?
+			"newspost" :
+			(reply_wanted ?
+			 "newreply" :
+			 (spost_wanted ?
+			  "snewspost" : "snewsreply"))),
+		       (int) sizeof(command) - 15, NewsHost);
+
+	    /*
+	     * If the SSL daemon is being used as a proxy, reset p1 to the
+	     * start of the proxied URL rather than to the start of the
+	     * newsgroup(s).  - FM
+	     */
+	    if (spost_wanted && strncasecomp(arg, "snewspost:", 10))
+		p1 = strstr(arg, "snewspost:");
+	    if (sreply_wanted && strncasecomp(arg, "snewsreply:", 11))
+		p1 = strstr(arg, "snewsreply:");
+
+	    /* p1 = HTParse(arg, "", PARSE_PATH | PARSE_PUNCTUATION); */
+	    /*
+	     * Don't use HTParse because news:  access doesn't follow
+	     * traditional rules.  For instance, if the article reference
+	     * contains a '#', the rest of it is lost -- JFG 10/7/92, from a
+	     * bug report
+	     */
+	} else if (isNNTP_URL(arg)) {
+	    if (((*(arg + 5) == '\0') ||
+		 (!strcmp((arg + 5), "/") ||
+		  !strcmp((arg + 5), "//") ||
+		  !strcmp((arg + 5), "///"))) ||
+		((!StrNCmp((arg + 5), "//", 2)) &&
+		 (!(cp = StrChr((arg + 7), '/')) || *(cp + 1) == '\0'))) {
+		p1 = "*";
+		group_wanted = FALSE;
+		list_wanted = TRUE;
+	    } else if (*(arg + 5) != '/') {
+		p1 = (arg + 5);
+	    } else if (*(arg + 5) == '/' && *(arg + 6) != '/') {
+		p1 = (arg + 6);
+	    } else {
+		p1 = (cp ? (cp + 1) : (arg + 6));
+	    }
+	    if (!(cp = HTParse(arg, "", PARSE_HOST)) || *cp == '\0') {
+		if (s >= 0 && NewsHost && strcasecomp(NewsHost, HTNewsHost)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		StrAllocCopy(NewsHost, HTNewsHost);
+	    } else {
+		if (s >= 0 && NewsHost && strcasecomp(NewsHost, cp)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		StrAllocCopy(NewsHost, cp);
+	    }
+	    FREE(cp);
+	    SnipIn2(command, "%s//%.*s/", STR_NNTP_URL, 9, NewsHost);
+	    StrAllocCopy(NewsHREF, command);
+	} else if (!strncasecomp(arg, STR_SNEWS_URL, 6)) {
+#ifdef USE_SSL
+	    if (((*(arg + 6) == '\0') ||
+		 (!strcmp((arg + 6), "/") ||
+		  !strcmp((arg + 6), "//") ||
+		  !strcmp((arg + 6), "///"))) ||
+		((!StrNCmp((arg + 6), "//", 2)) &&
+		 (!(cp = StrChr((arg + 8), '/')) || *(cp + 1) == '\0'))) {
+		p1 = "*";
+		group_wanted = FALSE;
+		list_wanted = TRUE;
+	    } else if (*(arg + 6) != '/') {
+		p1 = (arg + 6);
+	    } else if (*(arg + 6) == '/' && *(arg + 7) != '/') {
+		p1 = (arg + 7);
+	    } else {
+		p1 = (cp ? (cp + 1) : (arg + 7));
+	    }
+	    if (!(cp = HTParse(arg, "", PARSE_HOST)) || *cp == '\0') {
+		if (s >= 0 && NewsHost && strcasecomp(NewsHost, HTNewsHost)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		StrAllocCopy(NewsHost, HTNewsHost);
+	    } else {
+		if (s >= 0 && NewsHost && strcasecomp(NewsHost, cp)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		StrAllocCopy(NewsHost, cp);
+	    }
+	    FREE(cp);
+	    sprintf(command, "%s//%.250s/", STR_SNEWS_URL, NewsHost);
+	    StrAllocCopy(NewsHREF, command);
+#else
+	    HTAlert(gettext("This client does not contain support for SNEWS URLs."));
+	    return HT_NOT_LOADED;
+#endif /* USE_SSL */
+	} else if (!strncasecomp(arg, "news:/", 6)) {
+	    if (((*(arg + 6) == '\0') ||
+		 !strcmp((arg + 6), "/") ||
+		 !strcmp((arg + 6), "//")) ||
+		((*(arg + 6) == '/') &&
+		 (!(cp = StrChr((arg + 7), '/')) || *(cp + 1) == '\0'))) {
+		p1 = "*";
+		group_wanted = FALSE;
+		list_wanted = TRUE;
+	    } else if (*(arg + 6) != '/') {
+		p1 = (arg + 6);
+	    } else {
+		p1 = (cp ? (cp + 1) : (arg + 6));
+	    }
+	    if (!(cp = HTParse(arg, "", PARSE_HOST)) || *cp == '\0') {
+		if (s >= 0 && NewsHost && strcasecomp(NewsHost, HTNewsHost)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		StrAllocCopy(NewsHost, HTNewsHost);
+	    } else {
+		if (s >= 0 && NewsHost && strcasecomp(NewsHost, cp)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		StrAllocCopy(NewsHost, cp);
+	    }
+	    FREE(cp);
+	    SnipIn(command, "news://%.*s/", 9, NewsHost);
+	    StrAllocCopy(NewsHREF, command);
+	} else {
+	    p1 = (arg + 5);	/* Skip "news:" prefix */
+	    if (*p1 == '\0') {
+		p1 = "*";
+		group_wanted = FALSE;
+		list_wanted = TRUE;
+	    }
+	    if (s >= 0 && NewsHost && strcasecomp(NewsHost, HTNewsHost)) {
+		NEWS_NETCLOSE(s);
+		s = -1;
+	    }
+	    StrAllocCopy(NewsHost, HTNewsHost);
+	    StrAllocCopy(NewsHREF, STR_NEWS_URL);
+	}
+
+	/*
+	 * Set up any proxy for snews URLs that returns NNTP responses for Lynx
+	 * to convert to HTML, instead of doing the conversion itself, and for
+	 * handling posts or followups.  - TZ & FM
+	 */
+	if (!strncasecomp(p1, STR_SNEWS_URL, 6) ||
+	    !strncasecomp(p1, "snewspost:", 10) ||
+	    !strncasecomp(p1, "snewsreply:", 11)) {
+	    StrAllocCopy(ProxyHost, NewsHost);
+	    if ((cp = HTParse(p1, "", PARSE_HOST)) != NULL && *cp != '\0') {
+		SnipIn2(command, "%s//%.*s", STR_SNEWS_URL, 10, cp);
+		StrAllocCopy(NewsHost, cp);
+	    } else {
+		SnipIn2(command, "%s//%.*s", STR_SNEWS_URL, 10, NewsHost);
+	    }
+	    command[sizeof(command) - 2] = '\0';
+	    FREE(cp);
+	    sprintf(proxycmd, "GET %.*s%c%c%c%c",
+		    (int) sizeof(proxycmd) - 9, command,
+		    CR, LF, CR, LF);
+	    CTRACE((tfp, "HTNews: Proxy command is '%.*s'\n",
+		    (int) (strlen(proxycmd) - 4), proxycmd));
+	    strcat(command, "/");
+	    StrAllocCopy(ProxyHREF, NewsHREF);
+	    StrAllocCopy(NewsHREF, command);
+	    if (spost_wanted || sreply_wanted) {
+		/*
+		 * Reset p1 so that it points to the newsgroup(s).
+		 */
+		if ((p1 = strrchr(arg, '/')) != NULL) {
+		    p1++;
+		} else {
+		    p1 = (strrchr(arg, ':') + 1);
+		}
+	    } else {
+		char *cp2;
+
+		/*
+		 * Reset p1 so that it points to the newsgroup (or a wildcard),
+		 * or the article.
+		 */
+		if (!(cp2 = strrchr((p1 + 6), '/')) || *(cp2 + 1) == '\0') {
+		    p1 = "*";
+		    group_wanted = FALSE;
+		    list_wanted = TRUE;
+		} else {
+		    p1 = (cp2 + 1);
+		}
+	    }
+	}
+
+	/*
+	 * Set up command for a post, listing, or article request.  - FM
+	 */
+	if (post_wanted || reply_wanted || spost_wanted || sreply_wanted) {
+	    strcpy(command, "POST");
+	} else if (list_wanted) {
+	    if (strlen(p1) > 249) {
+		FREE(ProxyHost);
+		FREE(ProxyHREF);
+		HTAlert(URL_TOO_LONG);
+		return -400;
+	    }
+	    SnipIn(command, "XGTITLE %.*s", 11, p1);
+	} else if (group_wanted) {
+	    char *slash = StrChr(p1, '/');
+
+	    first = 0;
+	    last = 0;
+	    if (slash) {
+		*slash = '\0';
+		if (strlen(p1) >= sizeof(groupName)) {
+		    FREE(ProxyHost);
+		    FREE(ProxyHREF);
+		    HTAlert(URL_TOO_LONG);
+		    return -400;
+		}
+		LYStrNCpy(groupName, p1, sizeof(groupName) - 1);
+		*slash = '/';
+		(void) sscanf(slash + 1, "%d-%d", &first, &last);
+		if ((first > 0) && (isdigit(UCH(*(slash + 1)))) &&
+		    (StrChr(slash + 1, '-') == NULL || first == last)) {
+		    /*
+		     * We got a number greater than 0, which will be loaded as
+		     * first, and either no range or the range computes to
+		     * zero, so make last negative, as a flag to select the
+		     * group and then fetch an article by number (first)
+		     * instead of by messageID.  - FM
+		     */
+		    last = -1;
+		}
+	    } else {
+		if (strlen(p1) >= sizeof(groupName)) {
+		    FREE(ProxyHost);
+		    FREE(ProxyHREF);
+		    HTAlert(URL_TOO_LONG);
+		    return -400;
+		}
+		LYStrNCpy(groupName, p1, sizeof(groupName) - 1);
+	    }
+	    SnipIn(command, "GROUP %.*s", 9, groupName);
+	} else {
+	    size_t add_open = (size_t) (StrChr(p1, '<') == 0);
+	    size_t add_close = (size_t) (StrChr(p1, '>') == 0);
+
+	    if (strlen(p1) + add_open + add_close >= 252) {
+		FREE(ProxyHost);
+		FREE(ProxyHREF);
+		HTAlert(URL_TOO_LONG);
+		return -400;
+	    }
+	    sprintf(command, "ARTICLE %s%.*s%s",
+		    add_open ? "<" : "",
+		    (int) (sizeof(command) - (11 + add_open + add_close)),
+		    p1,
+		    add_close ? ">" : "");
+	}
+
+	{
+	    char *p = command + strlen(command);
+
+	    /*
+	     * Terminate command with CRLF, as in RFC 977.
+	     */
+	    *p++ = CR;		/* Macros to be correct on Mac */
+	    *p++ = LF;
+	    *p = 0;
+	}
+	StrAllocCopy(ListArg, p1);
+    }				/* scope of p1 */
+
+    if (!*arg) {
+	FREE(NewsHREF);
+	FREE(ProxyHost);
+	FREE(ProxyHREF);
+	FREE(ListArg);
+	return NO;		/* Ignore if no name */
+    }
+
+    if (!(post_wanted || reply_wanted || spost_wanted || sreply_wanted ||
+	  (group_wanted && last != -1) || list_wanted)) {
+	head_wanted = anAnchor->isHEAD;
+	if (head_wanted && !StrNCmp(command, "ARTICLE ", 8)) {
+	    /* overwrite "ARTICLE" - hack... */
+	    strcpy(command, "HEAD ");
+	    for (cp = command + 5;; cp++)
+		if ((*cp = *(cp + 3)) == '\0')
+		    break;
+	}
+	rawtext = (BOOL) (head_wanted || keep_mime_headers);
+    }
+    if (rawtext) {
+	rawtarget = HTStreamStack(WWW_PLAINTEXT,
+				  format_out,
+				  stream, anAnchor);
+	if (!rawtarget) {
+	    FREE(NewsHost);
+	    FREE(NewsHREF);
+	    FREE(ProxyHost);
+	    FREE(ProxyHREF);
+	    FREE(ListArg);
+	    HTAlert(gettext("No target for raw text!"));
+	    return (HT_NOT_LOADED);
+	}			/* Copy routine entry points */
+	rawtargetClass = *rawtarget->isa;
+    } else
+	/*
+	 * Make a hypertext object with an anchor list.
+	 */
+    if (!(post_wanted || reply_wanted || spost_wanted || sreply_wanted)) {
+	target = HTML_new(anAnchor, format_out, stream);
+	targetClass = *target->isa;	/* Copy routine entry points */
+    }
+
+    /*
+     * Now, let's get a stream setup up from the NewsHost.
+     */
+    for (retries = 0; retries < 2; retries++) {
+	if (s < 0) {
+	    /* CONNECTING to news host */
+	    char url[260];
+
+	    if (!strcmp(NewsHREF, STR_NEWS_URL)) {
+		SnipIn(url, "lose://%.*s/", 9, NewsHost);
+	    } else if (ProxyHREF) {
+		SnipIn(url, "%.*s", 1, ProxyHREF);
+	    } else {
+		SnipIn(url, "%.*s", 1, NewsHREF);
+	    }
+	    CTRACE((tfp, "News: doing HTDoConnect on '%s'\n", url));
+
+	    _HTProgress(gettext("Connecting to NewsHost ..."));
+
+#ifdef USE_SSL
+	    if (!using_proxy &&
+		(!StrNCmp(arg, STR_SNEWS_URL, 6) ||
+		 !StrNCmp(arg, "snewspost:", 10) ||
+		 !StrNCmp(arg, "snewsreply:", 11)))
+		status = HTDoConnect(url, "NNTPS", SNEWS_PORT, &s);
+	    else
+		status = HTDoConnect(url, "NNTP", NEWS_PORT, &s);
+#else
+	    status = HTDoConnect(url, "NNTP", NEWS_PORT, &s);
+#endif /* USE_SSL */
+
+	    if (status == HT_INTERRUPTED) {
+		/*
+		 * Interrupt cleanly.
+		 */
+		CTRACE((tfp,
+			"HTNews: Interrupted on connect; recovering cleanly.\n"));
+		_HTProgress(CONNECTION_INTERRUPTED);
+		if (!(post_wanted || reply_wanted ||
+		      spost_wanted || sreply_wanted)) {
+		    ABORT_TARGET;
+		}
+		FREE(NewsHost);
+		FREE(NewsHREF);
+		FREE(ProxyHost);
+		FREE(ProxyHREF);
+		FREE(ListArg);
+#ifdef USE_SSL
+		if (Handle) {
+		    SSL_free(Handle);
+		    Handle = NULL;
+		}
+#endif /* USE_SSL */
+		if (postfile) {
+		    HTSYS_remove(postfile);
+		    FREE(postfile);
+		}
+		return HT_NOT_LOADED;
+	    }
+	    if (status < 0) {
+		NEWS_NETCLOSE(s);
+		s = -1;
+		CTRACE((tfp, "HTNews: Unable to connect to news host.\n"));
+		if (retries < 1)
+		    continue;
+		if (!(post_wanted || reply_wanted ||
+		      spost_wanted || sreply_wanted)) {
+		    ABORT_TARGET;
+		}
+		HTSprintf0(&dbuf, gettext("Could not access %s."), NewsHost);
+		FREE(NewsHost);
+		FREE(NewsHREF);
+		FREE(ProxyHost);
+		FREE(ProxyHREF);
+		FREE(ListArg);
+		if (postfile) {
+		    HTSYS_remove(postfile);
+		    FREE(postfile);
+		}
+		return HTLoadError(stream, 500, dbuf);
+	    } else {
+		CTRACE((tfp, "HTNews: Connected to news host %s.\n",
+			NewsHost));
+#ifdef USE_SSL
+		/*
+		 * If this is an snews url, then do the SSL stuff here
+		 */
+		if (!using_proxy &&
+		    (!StrNCmp(url, "snews", 5) ||
+		     !StrNCmp(url, "snewspost:", 10) ||
+		     !StrNCmp(url, "snewsreply:", 11))) {
+		    Handle = HTGetSSLHandle();
+		    SSL_set_fd(Handle, s);
+		    HTSSLInitPRNG();
+		    status = SSL_connect(Handle);
+
+		    if (status <= 0) {
+			unsigned long SSLerror;
+
+			CTRACE((tfp,
+				"HTNews: Unable to complete SSL handshake for '%s', SSL_connect=%d, SSL error stack dump follows\n",
+				url, status));
+			SSL_load_error_strings();
+			while ((SSLerror = ERR_get_error()) != 0) {
+			    CTRACE((tfp, "HTNews: SSL: %s\n",
+				    ERR_error_string(SSLerror, NULL)));
+			}
+			HTAlert("Unable to make secure connection to remote host.");
+			NEWS_NETCLOSE(s);
+			s = -1;
+			if (!(post_wanted || reply_wanted ||
+			      spost_wanted || sreply_wanted))
+			    (*targetClass._abort) (target, NULL);
+			FREE(NewsHost);
+			FREE(NewsHREF);
+			FREE(ProxyHost);
+			FREE(ProxyHREF);
+			FREE(ListArg);
+			if (postfile) {
+#ifdef VMS
+			    while (remove(postfile) == 0) ;	/* loop through all versions */
+#else
+			    remove(postfile);
+#endif /* VMS */
+			    FREE(postfile);
+			}
+			return HT_NOT_LOADED;
+		    }
+		    sprintf(SSLprogress,
+			    "Secure %d-bit %s (%s) NNTP connection",
+			    SSL_get_cipher_bits(Handle, NULL),
+			    SSL_get_cipher_version(Handle),
+			    SSL_get_cipher(Handle));
+		    _HTProgress(SSLprogress);
+		}
+#endif /* USE_SSL */
+		HTInitInput(s);	/* set up buffering */
+		if (proxycmd[0]) {
+		    status = (int) NEWS_NETWRITE(s, proxycmd, (int) strlen(proxycmd));
+		    CTRACE((tfp,
+			    "HTNews: Proxy command returned status '%d'.\n",
+			    status));
+		}
+		if (((status = response(NULL)) / 100) != 2) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		    if (status == HT_INTERRUPTED) {
+			_HTProgress(CONNECTION_INTERRUPTED);
+			if (!(post_wanted || reply_wanted ||
+			      spost_wanted || sreply_wanted)) {
+			    ABORT_TARGET;
+			}
+			FREE(NewsHost);
+			FREE(NewsHREF);
+			FREE(ProxyHost);
+			FREE(ProxyHREF);
+			FREE(ListArg);
+			if (postfile) {
+			    HTSYS_remove(postfile);
+			    FREE(postfile);
+			}
+			return (HT_NOT_LOADED);
+		    }
+		    if (retries < 1)
+			continue;
+		    FREE(ProxyHost);
+		    FREE(ProxyHREF);
+		    FREE(ListArg);
+		    FREE(postfile);
+		    if (!(post_wanted || reply_wanted ||
+			  spost_wanted || sreply_wanted)) {
+			ABORT_TARGET;
+		    }
+		    if (response_text[0]) {
+			HTSprintf0(&dbuf,
+				   gettext("Can't read news info.  News host %.20s responded: %.200s"),
+				   NewsHost, response_text);
+		    } else {
+			HTSprintf0(&dbuf,
+				   gettext("Can't read news info, empty response from host %s"),
+				   NewsHost);
+		    }
+		    return HTLoadError(stream, 500, dbuf);
+		}
+		if (status == 200) {
+		    HTCanPost = TRUE;
+		} else {
+		    HTCanPost = FALSE;
+		    if (post_wanted || reply_wanted ||
+			spost_wanted || sreply_wanted) {
+			HTAlert(CANNOT_POST);
+			FREE(NewsHREF);
+			if (ProxyHREF) {
+			    StrAllocCopy(NewsHost, ProxyHost);
+			    FREE(ProxyHost);
+			    FREE(ProxyHREF);
+			}
+			FREE(ListArg);
+			if (postfile) {
+			    HTSYS_remove(postfile);
+			    FREE(postfile);
+			}
+			return (HT_NOT_LOADED);
+		    }
+		}
+	    }
+	}
+	/* If needed opening */
+	if (post_wanted || reply_wanted ||
+	    spost_wanted || sreply_wanted) {
+	    if (!HTCanPost) {
+		HTAlert(CANNOT_POST);
+		FREE(NewsHREF);
+		if (ProxyHREF) {
+		    StrAllocCopy(NewsHost, ProxyHost);
+		    FREE(ProxyHost);
+		    FREE(ProxyHREF);
+		}
+		FREE(ListArg);
+		if (postfile) {
+		    HTSYS_remove(postfile);
+		    FREE(postfile);
+		}
+		return (HT_NOT_LOADED);
+	    }
+	    if (postfile == NULL) {
+		postfile = LYNewsPost(ListArg,
+				      (reply_wanted || sreply_wanted));
+	    }
+	    if (postfile == NULL) {
+		HTProgress(CANCELLED);
+		FREE(NewsHREF);
+		if (ProxyHREF) {
+		    StrAllocCopy(NewsHost, ProxyHost);
+		    FREE(ProxyHost);
+		    FREE(ProxyHREF);
+		}
+		FREE(ListArg);
+		return (HT_NOT_LOADED);
+	    }
+	} else {
+	    /*
+	     * Ensure reader mode, but don't bother checking the status for
+	     * anything but HT_INTERRUPTED or a 480 Authorization request,
+	     * because if the reader mode command is not needed, the server
+	     * probably returned a 500, which is irrelevant at this point.  -
+	     * FM
+	     */
+	    char buffer[20];
+
+	    sprintf(buffer, "mode reader%c%c", CR, LF);
+	    if ((status = response(buffer)) == HT_INTERRUPTED) {
+		_HTProgress(CONNECTION_INTERRUPTED);
+		break;
+	    }
+	    if (status == 480) {
+		NNTPAuthResult auth_result = HTHandleAuthInfo(NewsHost);
+
+		if (auth_result == NNTPAUTH_CLOSE) {
+		    if (s != -1 && !(ProxyHost || ProxyHREF)) {
+			NEWS_NETCLOSE(s);
+			s = -1;
+		    }
+		}
+		if (auth_result != NNTPAUTH_OK) {
+		    break;
+		}
+		if (response(buffer) == HT_INTERRUPTED) {
+		    _HTProgress(CONNECTION_INTERRUPTED);
+		    break;
+		}
+	    }
+	}
+
+      Send_NNTP_command:
+#ifdef NEWS_DEB
+	if (postfile)
+	    printf("postfile = %s, command = %s", postfile, command);
+	else
+	    printf("command = %s", command);
+#endif
+	if ((status = response(command)) == HT_INTERRUPTED) {
+	    _HTProgress(CONNECTION_INTERRUPTED);
+	    break;
+	}
+	if (status < 0) {
+	    if (retries < 1) {
+		continue;
+	    } else {
+		break;
+	    }
+	}
+	/*
+	 * For some well known error responses which are expected to occur in
+	 * normal use, break from the loop without retrying and without closing
+	 * the connection.  It is unlikely that these are leftovers from a
+	 * timed-out connection (but we do some checks to see whether the
+	 * response corresponds to the last command), or that they will give
+	 * anything else when automatically retried.  - kw
+	 */
+	if (status == 411 && group_wanted &&
+	    !StrNCmp(command, "GROUP ", 6) &&
+	    !strncasecomp(response_text + 3, " No such group ", 15) &&
+	    !strcmp(response_text + 18, groupName)) {
+
+	    HTAlert(response_text);
+	    break;
+	} else if (status == 430 && !group_wanted && !list_wanted &&
+		   !StrNCmp(command, "ARTICLE <", 9) &&
+		   !strcasecomp(response_text + 3, " No such article")) {
+
+	    HTAlert(response_text);
+	    break;
+	}
+	if ((status / 100) != 2 &&
+	    status != 340 &&
+	    status != 480) {
+	    if (retries) {
+		if (list_wanted && !StrNCmp(command, "XGTITLE", 7)) {
+		    sprintf(command, "LIST NEWSGROUPS%c%c", CR, LF);
+		    goto Send_NNTP_command;
+		}
+		HTAlert(response_text);
+	    } else {
+		_HTProgress(response_text);
+	    }
+	    NEWS_NETCLOSE(s);
+	    s = -1;
+	    /*
+	     * Message might be a leftover "Timeout-disconnected", so try again
+	     * if the retries maximum has not been reached.
+	     */
+	    continue;
+	}
+
+	/*
+	 * Post or load a group, article, etc
+	 */
+	if (status == 480) {
+	    NNTPAuthResult auth_result;
+
+	    /*
+	     * Some servers return 480 for a failed XGTITLE.  - FM
+	     */
+	    if (list_wanted && !StrNCmp(command, "XGTITLE", 7) &&
+		strstr(response_text, "uthenticat") == NULL &&
+		strstr(response_text, "uthor") == NULL) {
+		sprintf(command, "LIST NEWSGROUPS%c%c", CR, LF);
+		goto Send_NNTP_command;
+	    }
+	    /*
+	     * Handle Authorization.  - FM
+	     */
+	    if ((auth_result = HTHandleAuthInfo(NewsHost)) == NNTPAUTH_OK) {
+		goto Send_NNTP_command;
+	    } else if (auth_result == NNTPAUTH_CLOSE) {
+		if (s != -1 && !(ProxyHost || ProxyHREF)) {
+		    NEWS_NETCLOSE(s);
+		    s = -1;
+		}
+		if (retries < 1)
+		    continue;
+	    }
+	    status = HT_NOT_LOADED;
+	} else if (post_wanted || reply_wanted ||
+		   spost_wanted || sreply_wanted) {
+	    /*
+	     * Handle posting of an article.  - FM
+	     */
+	    if (status != 340) {
+		HTAlert(CANNOT_POST);
+		if (postfile) {
+		    HTSYS_remove(postfile);
+		}
+	    } else {
+		post_article(postfile);
+	    }
+	    FREE(postfile);
+	    status = HT_NOT_LOADED;
+	} else if (list_wanted) {
+	    /*
+	     * List available newsgroups.  - FM
+	     */
+	    _HTProgress(gettext("Reading list of available newsgroups."));
+	    status = read_list(ListArg);
+	} else if (group_wanted) {
+	    /*
+	     * List articles in a news group.  - FM
+	     */
+	    if (last < 0) {
+		/*
+		 * We got one article number rather than a range following the
+		 * slash which followed the group name, or the range was zero,
+		 * so now that we have selected that group, load ARTICLE and
+		 * the the number (first) as the command and go back to send it
+		 * and check the response.  - FM
+		 */
+		sprintf(command, "%s %d%c%c",
+			head_wanted ? "HEAD" : "ARTICLE",
+			first, CR, LF);
+		group_wanted = FALSE;
+		retries = 2;
+		goto Send_NNTP_command;
+	    }
+	    _HTProgress(gettext("Reading list of articles in newsgroup."));
+	    status = read_group(groupName, first, last);
+	} else {
+	    /*
+	     * Get an article from a news group.  - FM
+	     */
+	    _HTProgress(gettext("Reading news article."));
+	    status = read_article(anAnchor);
+	}
+	if (status == HT_INTERRUPTED) {
+	    _HTProgress(CONNECTION_INTERRUPTED);
+	    status = HT_LOADED;
+	}
+	if (!(post_wanted || reply_wanted ||
+	      spost_wanted || sreply_wanted)) {
+	    if (status == HT_NOT_LOADED) {
+		ABORT_TARGET;
+	    } else {
+		FREE_TARGET;
+	    }
+	}
+	FREE(NewsHREF);
+	if (ProxyHREF) {
+	    StrAllocCopy(NewsHost, ProxyHost);
+	    FREE(ProxyHost);
+	    FREE(ProxyHREF);
+	}
+	FREE(ListArg);
+	if (postfile) {
+	    HTSYS_remove(postfile);
+	    FREE(postfile);
+	}
+	return status;
+    }				/* Retry loop */
+
+#if 0
+    HTAlert(gettext("Sorry, could not load requested news."));
+    NXRunAlertPanel(NULL, "Sorry, could not load `%s'.", NULL, NULL, NULL, arg);
+    /* No -- message earlier will have covered it */
+#endif
+
+    if (!(post_wanted || reply_wanted ||
+	  spost_wanted || sreply_wanted)) {
+	ABORT_TARGET;
+    }
+    FREE(NewsHREF);
+    if (ProxyHREF) {
+	StrAllocCopy(NewsHost, ProxyHost);
+	FREE(ProxyHost);
+	FREE(ProxyHREF);
+    }
+    FREE(ListArg);
+    if (postfile) {
+	HTSYS_remove(postfile);
+	FREE(postfile);
+    }
+    return HT_NOT_LOADED;
+}
+
+/*
+ *  This function clears all authorization information by
+ *  invoking the free_NNTP_AuthInfo() function, which normally
+ *  is invoked at exit.  It allows a browser command to do
+ *  this at any time, for example, if the user is leaving
+ *  the terminal for a period of time, but does not want
+ *  to end the current session.  - FM
+ */
+void HTClearNNTPAuthInfo(void)
+{
+    /*
+     * Need code to check cached documents and do something to ensure that any
+     * protected documents no longer can be accessed without a new retrieval. 
+     * - FM
+     */
+
+    /*
+     * Now free all of the authorization info.  - FM
+     */
+    free_NNTP_AuthInfo();
+}
+
+#ifdef USE_SSL
+static int HTNewsGetCharacter(void)
+{
+    if (!Handle)
+	return HTGetCharacter();
+    else
+	return HTGetSSLCharacter((void *) Handle);
+}
+
+int HTNewsProxyConnect(int sock,
+		       const char *url,
+		       HTParentAnchor *anAnchor,
+		       HTFormat format_out,
+		       HTStream *sink)
+{
+    int status;
+    const char *arg = url;
+    char SSLprogress[256];
+
+    s = channel_s = sock;
+    Handle = HTGetSSLHandle();
+    SSL_set_fd(Handle, s);
+    HTSSLInitPRNG();
+    status = SSL_connect(Handle);
+
+    if (status <= 0) {
+	unsigned long SSLerror;
+
+	channel_s = -1;
+	CTRACE((tfp,
+		"HTNews: Unable to complete SSL handshake for '%s', SSL_connect=%d, SSL error stack dump follows\n",
+		url, status));
+	SSL_load_error_strings();
+	while ((SSLerror = ERR_get_error()) != 0) {
+	    CTRACE((tfp, "HTNews: SSL: %s\n", ERR_error_string(SSLerror, NULL)));
+	}
+	HTAlert("Unable to make secure connection to remote host.");
+	NEWS_NETCLOSE(s);
+	s = -1;
+	return HT_NOT_LOADED;
+    }
+    sprintf(SSLprogress, "Secure %d-bit %s (%s) NNTP connection",
+	    SSL_get_cipher_bits(Handle, NULL),
+	    SSL_get_cipher_version(Handle),
+	    SSL_get_cipher(Handle));
+    _HTProgress(SSLprogress);
+    status = HTLoadNews(arg, anAnchor, format_out, sink);
+    channel_s = -1;
+    return status;
+}
+#endif /* USE_SSL */
+
+#ifdef GLOBALDEF_IS_MACRO
+#define _HTNEWS_C_1_INIT { "news", HTLoadNews, NULL }
+GLOBALDEF(HTProtocol, HTNews, _HTNEWS_C_1_INIT);
+#define _HTNEWS_C_2_INIT { "nntp", HTLoadNews, NULL }
+GLOBALDEF(HTProtocol, HTNNTP, _HTNEWS_C_2_INIT);
+#define _HTNEWS_C_3_INIT { "newspost", HTLoadNews, NULL }
+GLOBALDEF(HTProtocol, HTNewsPost, _HTNEWS_C_3_INIT);
+#define _HTNEWS_C_4_INIT { "newsreply", HTLoadNews, NULL }
+GLOBALDEF(HTProtocol, HTNewsReply, _HTNEWS_C_4_INIT);
+#define _HTNEWS_C_5_INIT { "snews", HTLoadNews, NULL }
+GLOBALDEF(HTProtocol, HTSNews, _HTNEWS_C_5_INIT);
+#define _HTNEWS_C_6_INIT { "snewspost", HTLoadNews, NULL }
+GLOBALDEF(HTProtocol, HTSNewsPost, _HTNEWS_C_6_INIT);
+#define _HTNEWS_C_7_INIT { "snewsreply", HTLoadNews, NULL }
+GLOBALDEF(HTProtocol, HTSNewsReply, _HTNEWS_C_7_INIT);
+#else
+GLOBALDEF HTProtocol HTNews =
+{"news", HTLoadNews, NULL};
+GLOBALDEF HTProtocol HTNNTP =
+{"nntp", HTLoadNews, NULL};
+GLOBALDEF HTProtocol HTNewsPost =
+{"newspost", HTLoadNews, NULL};
+GLOBALDEF HTProtocol HTNewsReply =
+{"newsreply", HTLoadNews, NULL};
+GLOBALDEF HTProtocol HTSNews =
+{"snews", HTLoadNews, NULL};
+GLOBALDEF HTProtocol HTSNewsPost =
+{"snewspost", HTLoadNews, NULL};
+GLOBALDEF HTProtocol HTSNewsReply =
+{"snewsreply", HTLoadNews, NULL};
+#endif /* GLOBALDEF_IS_MACRO */
+
+#endif /* not DISABLE_NEWS */
diff --git a/WWW/Library/Implementation/HTNews.h b/WWW/Library/Implementation/HTNews.h
new file mode 100644
index 0000000..ef9a6e4
--- /dev/null
+++ b/WWW/Library/Implementation/HTNews.h
@@ -0,0 +1,60 @@
+/*                                  Network News Transfer protocol module for the WWW library
+                                          HTNEWS
+                                             
+ */
+/* History:
+ *      26 Sep 90       Written TBL in Objective-C
+ *      29 Nov 91       Downgraded to C, for portable implementation.
+ */
+
+#ifndef HTNEWS_H
+#define HTNEWS_H
+
+#include <HTAccess.h>
+#include <HTAnchor.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern int HTNewsChunkSize;
+    extern int HTNewsMaxChunk;
+
+#ifdef GLOBALREF_IS_MACRO
+    extern GLOBALREF (HTProtocol, HTNews);
+    extern GLOBALREF (HTProtocol, HTNNTP);
+    extern GLOBALREF (HTProtocol, HTNewsPost);
+    extern GLOBALREF (HTProtocol, HTNewsReply);
+    extern GLOBALREF (HTProtocol, HTSNews);
+    extern GLOBALREF (HTProtocol, HTSNewsPost);
+    extern GLOBALREF (HTProtocol, HTSNewsReply);
+
+#else
+    GLOBALREF HTProtocol HTNews;
+    GLOBALREF HTProtocol HTNNTP;
+    GLOBALREF HTProtocol HTNewsPost;
+    GLOBALREF HTProtocol HTNewsReply;
+    GLOBALREF HTProtocol HTSNews;
+    GLOBALREF HTProtocol HTSNewsPost;
+    GLOBALREF HTProtocol HTSNewsReply;
+#endif				/* GLOBALREF_IS_MACRO */
+
+    extern void HTSetNewsHost(const char *value);
+    extern const char *HTGetNewsHost(void);
+    extern char *HTNewsHost;
+
+    extern void HTClearNNTPAuthInfo(void);
+
+#ifdef USE_SSL
+    extern SSL_CTX *ssl_ctx;
+
+    extern int HTNewsProxyConnect(int sock,
+				  const char *url,
+				  HTParentAnchor *anAnchor,
+				  HTFormat format_out,
+				  HTStream *sink);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTNEWS_H */
diff --git a/WWW/Library/Implementation/HTParse.c b/WWW/Library/Implementation/HTParse.c
new file mode 100644
index 0000000..2e45441
--- /dev/null
+++ b/WWW/Library/Implementation/HTParse.c
@@ -0,0 +1,1383 @@
+/*
+ * $LynxId: HTParse.c,v 1.98 2021/07/27 21:29:49 tom Exp $
+ *
+ *		Parse HyperText Document Address		HTParse.c
+ *		================================
+ */
+
+#include <HTUtils.h>
+#include <HTParse.h>
+
+#include <LYUtils.h>
+#include <LYLeaks.h>
+#include <LYStrings.h>
+#include <LYCharUtils.h>
+#include <LYGlobalDefs.h>
+
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#else
+#ifdef __MINGW32__
+#include <malloc.h>
+#endif /* __MINGW32__ */
+#endif
+
+#ifdef USE_IDN2
+#include <idn2.h>
+#define FreeIdna(out)             idn2_free(out)
+#elif defined(USE_IDNA)
+#include <idna.h>
+#include <idn-free.h>
+#define FreeIdna(out)             idn_free(out)
+#define IDN2_OK                   IDNA_SUCCESS
+#endif
+
+#define HEX_ESCAPE '%'
+
+struct struct_parts {
+    char *access;
+    char *host;
+    char *absolute;
+    char *relative;
+    char *search;		/* treated normally as part of path */
+    char *anchor;
+};
+
+#if 0				/* for debugging */
+static void show_parts(const char *name, struct struct_parts *parts, int line)
+{
+    if (TRACE) {
+	CTRACE((tfp, "struct_parts(%s) %s@%d\n", name, __FILE__, line));
+	CTRACE((tfp, "   access   '%s'\n", NONNULL(parts->access)));
+	CTRACE((tfp, "   host     '%s'\n", NONNULL(parts->host)));
+	CTRACE((tfp, "   absolute '%s'\n", NONNULL(parts->absolute)));
+	CTRACE((tfp, "   relative '%s'\n", NONNULL(parts->relative)));
+	CTRACE((tfp, "   search   '%s'\n", NONNULL(parts->search)));
+	CTRACE((tfp, "   anchor   '%s'\n", NONNULL(parts->anchor)));
+    }
+}
+#define SHOW_PARTS(name) show_parts(#name, &name, __LINE__)
+#else
+#define SHOW_PARTS(name)	/* nothing */
+#endif
+
+/*	Strip white space off a string.				HTStrip()
+ *	-------------------------------
+ *
+ * On exit,
+ *	Return value points to first non-white character, or to 0 if none.
+ *	All trailing white space is OVERWRITTEN with zero.
+ */
+char *HTStrip(char *s)
+{
+#define SPACE(c) ((c == ' ') || (c == '\t') || (c == '\n'))
+    char *p;
+
+    for (p = s; *p; p++) {	/* Find end of string */
+	;
+    }
+    for (p--; p >= s; p--) {
+	if (SPACE(*p))
+	    *p = '\0';		/* Zap trailing blanks */
+	else
+	    break;
+    }
+    while (SPACE(*s))
+	s++;			/* Strip leading blanks */
+    return s;
+}
+
+/*	Scan a filename for its constituents.			scan()
+ *	-------------------------------------
+ *
+ * On entry,
+ *	name	points to a document name which may be incomplete.
+ * On exit,
+ *	absolute or relative may be nonzero (but not both).
+ *	host, anchor and access may be nonzero if they were specified.
+ *	Any which are nonzero point to zero terminated strings.
+ */
+static void scan(char *name,
+		 struct struct_parts *parts)
+{
+    char *after_access;
+    char *p;
+
+    parts->access = NULL;
+    parts->host = NULL;
+    parts->absolute = NULL;
+    parts->relative = NULL;
+    parts->search = NULL;	/* normally not used - kw */
+    parts->anchor = NULL;
+
+    /*
+     * Scan left-to-right for a scheme (access).
+     */
+    after_access = name;
+    for (p = name; *p; p++) {
+	if (*p == ':') {
+	    *p = '\0';
+	    parts->access = name;	/* Access name has been specified */
+	    after_access = (p + 1);
+	    break;
+	}
+	if (*p == '/' || *p == '#' || *p == ';' || *p == '?')
+	    break;
+    }
+
+    /*
+     * Scan left-to-right for a fragment (anchor).
+     */
+    for (p = after_access; *p; p++) {
+	if (*p == '#') {
+	    parts->anchor = (p + 1);
+	    *p = '\0';		/* terminate the rest */
+	    break;		/* leave things after first # alone - kw */
+	}
+    }
+
+    /*
+     * Scan left-to-right for a host or absolute path.
+     */
+    p = after_access;
+    if (*p == '/') {
+	if (p[1] == '/') {
+	    parts->host = (p + 2);	/* host has been specified    */
+	    *p = '\0';		/* Terminate access           */
+	    p = StrChr(parts->host, '/');	/* look for end of host name if any */
+	    if (p != NULL) {
+		*p = '\0';	/* Terminate host */
+		parts->absolute = (p + 1);	/* Root has been found */
+	    } else {
+		p = StrChr(parts->host, '?');
+		if (p != NULL) {
+		    *p = '\0';	/* Terminate host */
+		    parts->search = (p + 1);
+		}
+	    }
+	} else {
+	    parts->absolute = (p + 1);	/* Root found but no host */
+	}
+    } else {
+	parts->relative = (*after_access) ?
+	    after_access : NULL;	/* NULL for "" */
+    }
+
+    /*
+     * Check schemes that commonly have unescaped hashes.
+     */
+    if (parts->access && parts->anchor &&
+    /* optimize */ StrChr("lnsdLNSD", *parts->access) != NULL) {
+	if ((!parts->host && strcasecomp(parts->access, "lynxcgi")) ||
+	    !strcasecomp(parts->access, "nntp") ||
+	    !strcasecomp(parts->access, "snews") ||
+	    !strcasecomp(parts->access, "news") ||
+	    !strcasecomp(parts->access, "data")) {
+	    /*
+	     * Access specified but no host and not a lynxcgi URL, so the
+	     * anchor may not really be one, e.g., news:j462#36487@foo.bar, or
+	     * it's an nntp or snews URL, or news URL with a host.  Restore the
+	     * '#' in the address.
+	     */
+	    /* but only if we have found a path component of which this will
+	     * become part. - kw  */
+	    if (parts->relative || parts->absolute) {
+		*(parts->anchor - 1) = '#';
+		parts->anchor = NULL;
+	    }
+	}
+    }
+}				/*scan */
+
+#if defined(HAVE_ALLOCA) && !defined(LY_FIND_LEAKS)
+#define LYalloca(x)        alloca((size_t)(x))
+#define LYalloca_free(x)   {}
+#else
+#define LYalloca(x)        malloc((size_t)(x))
+#define LYalloca_free(x)   free((void *)(x))
+#endif
+
+static char *strchr_or_end(char *string, int ch)
+{
+    char *result = StrChr(string, ch);
+
+    if (result == 0) {
+	result = string + strlen(string);
+    }
+    return result;
+}
+
+/*
+ * Given a host specification that may end with a port number, e.g.,
+ *	foobar:123
+ * point to the ':' which begins the ":port" to make it simple to handle the
+ * substring.
+ *
+ * If no port is found (or a syntax error), return null.
+ */
+char *HTParsePort(char *host, int *portp)
+{
+    int brackets = 0;
+    char *result = NULL;
+
+    *portp = 0;
+    if (host != NULL) {
+	while (*host != '\0' && result == 0) {
+	    switch (*host++) {
+	    case ':':
+		if (brackets == 0 && isdigit(UCH(*host))) {
+		    char *next = NULL;
+
+		    *portp = (int) strtol(host, &next, 10);
+		    if (next != 0 && next != host && *next == '\0') {
+			result = (host - 1);
+			CTRACE((tfp, "HTParsePort %d\n", *portp));
+		    }
+		}
+		break;
+	    case '[':		/* for ipv6 */
+		++brackets;
+		break;
+	    case ']':		/* for ipv6 */
+		--brackets;
+		break;
+	    }
+	}
+    }
+    return result;
+}
+
+#if defined(USE_IDNA) || defined(USE_IDN2)
+static int hex_decode(int ch)
+{
+    int result = -1;
+
+    if (ch >= '0' && ch <= '9')
+	result = (ch - '0');
+    else if (ch >= 'a' && ch <= 'f')
+	result = (ch - 'a') + 10;
+    else if (ch >= 'A' && ch <= 'F')
+	result = (ch - 'A') + 10;
+    return result;
+}
+
+/*
+ * Convert in-place the given hostname to IDNA form.  That requires up to 64
+ * characters, and we've allowed for that, with MIN_PARSE.
+ */
+static void convert_to_idna(char *host)
+{
+    size_t length = strlen(host);
+    char *endhost = host + length;
+    char *buffer = malloc(length + 1);
+    char *params = malloc(length + 1);
+    char *output = NULL;
+    char *src, *dst;
+    int code;
+    int hi, lo;
+
+    if (buffer != NULL && params != NULL) {
+	code = TRUE;
+	*params = '\0';
+	for (dst = buffer, src = host; src < endhost; ++dst) {
+	    int ch = *src++;
+
+	    if (RFC_3986_GEN_DELIMS(ch)) {
+		strcpy(params, src - 1);
+		*dst = '\0';
+		break;
+	    } else if (ch == HEX_ESCAPE) {
+		if ((src + 1) < endhost
+		    && (hi = hex_decode(src[0])) >= 0
+		    && (lo = hex_decode(src[1])) >= 0) {
+
+		    *dst = (char) ((hi << 4) | lo);
+		    src += 2;
+		} else {
+		    CTRACE((tfp, "convert_to_idna: `%s' is malformed\n", host));
+		    code = FALSE;
+		    break;
+		}
+	    } else {
+		*dst = (char) ch;
+	    }
+	}
+	if (code) {
+	    *dst = '\0';
+#ifdef USE_IDN2
+#if (!defined(IDN2_VERSION_NUMBER) || IDN2_VERSION_NUMBER < 0x02000003)
+	    /*
+	     * Older libidn2 mishandles STD3, stripping underscores.
+	     */
+	    if (strchr(buffer, '_') != NULL) {
+		code = -1;
+	    } else
+#endif
+		switch (LYidnaMode) {
+		case LYidna2003:
+		    code = idn2_to_ascii_8z(buffer, &output, IDN2_TRANSITIONAL);
+		    break;
+		case LYidna2008:
+		    /* IDNA2008 rules without the TR46 amendments */
+		    code = idn2_to_ascii_8z(buffer, &output, 0);
+		    break;
+		case LYidnaTR46:
+		    code = idn2_to_ascii_8z(buffer, &output, IDN2_NONTRANSITIONAL
+					    | IDN2_NFC_INPUT);
+		    break;
+		case LYidnaCompat:
+		    /* IDNA2008 */
+		    code = idn2_to_ascii_8z(buffer, &output, IDN2_NONTRANSITIONAL
+					    | IDN2_NFC_INPUT);
+		    if (code == IDN2_DISALLOWED) {
+			/* IDNA2003 - compatible */
+			code = idn2_to_ascii_8z(buffer, &output, IDN2_TRANSITIONAL);
+		    }
+		    break;
+		}
+#else
+	    code = idna_to_ascii_8z(buffer, &output, IDNA_USE_STD3_ASCII_RULES);
+#endif
+	    if (code == IDN2_OK) {
+		CTRACE((tfp, "convert_to_idna: `%s' -> `%s': OK\n", buffer, output));
+		strcpy(host, output);
+		strcat(host, params);
+	    } else {
+		CTRACE((tfp, "convert_to_idna: `%s': %s\n",
+			buffer,
+			idna_strerror((Idna_rc) code)));
+	    }
+	    if (output)
+		FreeIdna(output);
+	}
+    }
+    free(buffer);
+    free(params);
+}
+#define MIN_PARSE 80
+#else
+#define MIN_PARSE 8
+#endif
+
+/*	Parse a Name relative to another name.			HTParse()
+ *	--------------------------------------
+ *
+ *	This returns those parts of a name which are given (and requested)
+ *	substituting bits from the related name where necessary.
+ *
+ *	Originally based on RFC 1808, some details in RFC 3986 are used.
+ *
+ * On entry,
+ *	aName		A filename given
+ *	relatedName	A name relative to which aName is to be parsed
+ *	wanted		A mask for the bits which are wanted.
+ *
+ * On exit,
+ *     returns         A pointer to a malloc'd string which MUST BE FREED
+ */
+char *HTParse(const char *aName,
+	      const char *relatedName,
+	      int wanted)
+{
+    char *result = NULL;
+    char *tail = NULL;		/* a pointer to the end of the 'result' string */
+    char *return_value = NULL;
+    size_t len, len1, len2;
+    size_t need;
+    char *name = NULL;
+    char *rel = NULL;
+    char *p, *q;
+    char *acc_method;
+    struct struct_parts given, related;
+
+    CTRACE((tfp, "HTParse: aName:`%s'\n", aName));
+    CTRACE((tfp, "   relatedName:`%s'\n", relatedName));
+
+    if (wanted & (PARSE_STRICTPATH | PARSE_QUERY)) {	/* if detail wanted... */
+	if ((wanted & (PARSE_STRICTPATH | PARSE_QUERY))
+	    == (PARSE_STRICTPATH | PARSE_QUERY))	/* if strictpath AND query */
+	    wanted |= PARSE_PATH;	/* then treat as if PARSE_PATH wanted */
+	if (wanted & PARSE_PATH)	/* if PARSE_PATH wanted */
+	    wanted &= ~(PARSE_STRICTPATH | PARSE_QUERY);	/* ignore details */
+    }
+/* *INDENT-OFF* */
+    CTRACE((tfp, "   want:%s%s%s%s%s%s%s\n",
+	    wanted & PARSE_PUNCTUATION ? " punc"   : "",
+	    wanted & PARSE_ANCHOR      ? " anchor" : "",
+	    wanted & PARSE_PATH        ? " path"   : "",
+	    wanted & PARSE_HOST        ? " host"   : "",
+	    wanted & PARSE_ACCESS      ? " access" : "",
+	    wanted & PARSE_STRICTPATH  ? " PATH"   : "",
+	    wanted & PARSE_QUERY       ? " QUERY"  : ""));
+/* *INDENT-ON* */
+
+    /*
+     * Allocate the temporary string. Optimized.
+     */
+    len1 = strlen(aName) + 1;
+    len2 = strlen(relatedName) + 1;
+    len = len1 + len2 + MIN_PARSE;	/* Lots of space: more than enough */
+
+    need = (len * 2 + len1 + len2);
+    if (need > (size_t) max_uri_size ||
+	(int) need < (int) len1 ||
+	(int) need < (int) len2)
+	return StrAllocCopy(return_value, "");
+
+    result = tail = (char *) LYalloca(need);
+    if (result == NULL) {
+	outofmem(__FILE__, "HTParse");
+    }
+    *result = '\0';
+    name = result + len;
+    rel = name + len1;
+
+    /*
+     * Make working copy of the input string to cut up.
+     */
+    MemCpy(name, aName, len1);
+
+    /*
+     * Cut up the string into URL fields.
+     */
+    scan(name, &given);
+    SHOW_PARTS(given);
+
+    /*
+     * Now related string.
+     */
+    if ((given.access && given.host && given.absolute) || !*relatedName) {
+	/*
+	 * Inherit nothing!
+	 */
+	related.access = NULL;
+	related.host = NULL;
+	related.absolute = NULL;
+	related.relative = NULL;
+	related.search = NULL;
+	related.anchor = NULL;
+    } else {
+	MemCpy(rel, relatedName, len2);
+	scan(rel, &related);
+    }
+    SHOW_PARTS(related);
+
+    /*
+     * Handle the scheme (access) field.
+     */
+    if (given.access && given.host && !given.relative && !given.absolute) {
+	if (!strcmp(given.access, "http") ||
+	    !strcmp(given.access, "https") ||
+	    !strcmp(given.access, "ftp")) {
+
+	    /*
+	     * Assume root.
+	     */
+	    given.absolute = empty_string;
+	}
+    }
+    acc_method = given.access ? given.access : related.access;
+    if (wanted & PARSE_ACCESS) {
+	if (acc_method) {
+	    strcpy(tail, acc_method);
+	    tail += strlen(tail);
+	    if (wanted & PARSE_PUNCTUATION) {
+		*tail++ = ':';
+		*tail = '\0';
+	    }
+	}
+    }
+
+    /*
+     * If different schemes, inherit nothing.
+     *
+     * We'll try complying with RFC 1808 and the Fielding draft, and inherit
+     * nothing if both schemes are given, rather than only when they differ,
+     * except for file URLs - FM
+     *
+     * After trying it for a while, it's still premature, IHMO, to go along
+     * with it, so this is back to inheriting for identical schemes whether or
+     * not they are "file".  If you want to try it again yourself, uncomment
+     * the strcasecomp() below.  - FM
+     */
+    if ((given.access && related.access) &&
+	(			/* strcasecomp(given.access, "file") || */
+	    strcmp(given.access, related.access))) {
+	related.host = NULL;
+	related.absolute = NULL;
+	related.relative = NULL;
+	related.search = NULL;
+	related.anchor = NULL;
+    }
+
+    /*
+     * Handle the host field.
+     */
+    if (wanted & PARSE_HOST) {
+	if (given.host || related.host) {
+	    if (wanted & PARSE_PUNCTUATION) {
+		*tail++ = '/';
+		*tail++ = '/';
+	    }
+	    strcpy(tail, given.host ? given.host : related.host);
+	    /*
+	     * Ignore default port numbers, and trailing dots on FQDNs, which
+	     * will only cause identical addresses to look different.  (related
+	     * is already a clean url).
+	     */
+	    {
+		char *p2, *h;
+		int portnumber;
+		int gen_delims = 0;
+
+		if ((p2 = HTSkipToAt(result, &gen_delims)) != NULL
+		    && gen_delims == 0) {
+		    tail = (p2 + 1);
+		}
+		p2 = HTParsePort(result, &portnumber);
+		if (p2 != NULL && acc_method != NULL) {
+		    /*
+		     * Port specified.
+		     */
+#define ACC_METHOD(a,b) (!strcmp(acc_method, a) && (portnumber == b))
+		    if (ACC_METHOD("http", 80) ||
+			ACC_METHOD("https", 443) ||
+			ACC_METHOD("gopher", 70) ||
+			ACC_METHOD("ftp", 21) ||
+			ACC_METHOD("wais", 210) ||
+			ACC_METHOD("nntp", 119) ||
+			ACC_METHOD("news", 119) ||
+			ACC_METHOD("newspost", 119) ||
+			ACC_METHOD("newsreply", 119) ||
+			ACC_METHOD("snews", 563) ||
+			ACC_METHOD("snewspost", 563) ||
+			ACC_METHOD("snewsreply", 563) ||
+			ACC_METHOD("finger", 79) ||
+			ACC_METHOD("telnet", 23) ||
+			ACC_METHOD("tn3270", 23) ||
+			ACC_METHOD("rlogin", 513) ||
+			ACC_METHOD("cso", 105))
+			*p2 = '\0';	/* It is the default: ignore it */
+		}
+		if (p2 == NULL) {
+		    int len3 = (int) strlen(tail);
+
+		    if (len3 > 0) {
+			h = tail + len3 - 1;	/* last char of hostname */
+			if (*h == '.')
+			    *h = '\0';	/* chop final . */
+		    }
+		} else if (p2 != result) {
+		    h = p2;
+		    h--;	/* End of hostname */
+		    if (*h == '.') {
+			/*
+			 * Slide p2 over h.
+			 */
+			while (*p2 != '\0')
+			    *h++ = *p2++;
+			*h = '\0';	/* terminate */
+		    }
+		}
+	    }
+#if defined(USE_IDNA) || defined(USE_IDN2)
+	    /*
+	     * Depending on locale-support, we could have a literal UTF-8
+	     * string as a host name, or a URL-encoded form of that.
+	     */
+	    convert_to_idna(tail);
+#endif
+	}
+    }
+
+    /*
+     * Trim any blanks from the result so far - there's no excuse for blanks
+     * in a hostname.  Also update the tail here.
+     */
+    tail = LYRemoveBlanks(result);
+
+    /*
+     * If host in given or related was ended directly with a '?' (no slash),
+     * fake the search part into absolute.  This is the only case search is
+     * returned from scan.  A host must have been present.  this restores the
+     * '?' at which the host part had been truncated in scan, we have to do
+     * this after host part handling is done.  - kw
+     */
+    if (given.search && *(given.search - 1) == '\0') {
+	given.absolute = given.search - 1;
+	given.absolute[0] = '?';
+    } else if (related.search && !related.absolute &&
+	       *(related.search - 1) == '\0') {
+	related.absolute = related.search - 1;
+	related.absolute[0] = '?';
+    }
+
+    /*
+     * If different hosts, inherit no path.
+     */
+    if (given.host && related.host)
+	if (strcmp(given.host, related.host) != 0) {
+	    related.absolute = NULL;
+	    related.relative = NULL;
+	    related.anchor = NULL;
+	}
+
+    /*
+     * Handle the path.
+     */
+    if (wanted & (PARSE_PATH | PARSE_STRICTPATH | PARSE_QUERY)) {
+	int want_detail = (wanted & (PARSE_STRICTPATH | PARSE_QUERY));
+
+	if (acc_method && !given.absolute && given.relative) {
+	    /*
+	     * Treat all given nntp or snews paths, or given paths for news
+	     * URLs with a host, as absolute.
+	     */
+	    switch (*acc_method) {
+	    case 'N':
+	    case 'n':
+		if (!strcasecomp(acc_method, "nntp") ||
+		    (!strcasecomp(acc_method, "news") &&
+		     !strncasecomp(result, "news://", 7))) {
+		    given.absolute = given.relative;
+		    given.relative = NULL;
+		}
+		break;
+	    case 'S':
+	    case 's':
+		if (!strcasecomp(acc_method, "snews")) {
+		    given.absolute = given.relative;
+		    given.relative = NULL;
+		}
+		break;
+	    }
+	}
+
+	if (given.absolute) {	/* All is given */
+	    char *base = tail;
+
+	    if (wanted & PARSE_PUNCTUATION)
+		*tail++ = '/';
+	    strcpy(tail, given.absolute);
+	    HTSimplify(base, TRUE);
+	    CTRACE((tfp, "HTParse: (ABS)\n"));
+	} else if (related.absolute) {	/* Adopt path not name */
+	    char *base = tail;
+
+	    *tail++ = '/';
+	    strcpy(tail, related.absolute);
+	    if (given.relative) {
+		/* RFC 1808 part 4 step 5 (if URL path is empty) */
+		/* a) if given has params, add/replace that */
+		if (given.relative[0] == ';') {
+		    strcpy(strchr_or_end(tail, ';'), given.relative);
+		}
+		/* b) if given has query, add/replace that */
+		else if (given.relative[0] == '?') {
+		    strcpy(strchr_or_end(tail, '?'), given.relative);
+		}
+		/* otherwise fall through to RFC 1808 part 4 step 6 */
+		else {
+		    p = StrChr(tail, '?');	/* Search part? */
+		    if (p == NULL)
+			p = (tail + strlen(tail) - 1);
+		    for (; *p != '/'; p--) ;	/* last / */
+		    p[1] = '\0';	/* Remove filename */
+		    strcat(p, given.relative);	/* Add given one */
+		}
+		HTSimplify(base, FALSE);
+		if (*base == '\0')
+		    strcpy(base, "/");
+	    } else {
+		HTSimplify(base, TRUE);
+	    }
+	    if (base[0] == '/' && base[1] == '/') {
+		char *pz;
+
+		for (pz = base; (pz[0] = pz[1]) != '\0'; ++pz) ;
+	    }
+	    CTRACE((tfp, "HTParse: (Related-ABS)\n"));
+	} else if (given.relative) {
+	    strcpy(tail, given.relative);	/* what we've got */
+	    HTSimplify(tail, FALSE);
+	    CTRACE((tfp, "HTParse: (REL)\n"));
+	} else if (related.relative) {
+	    strcpy(tail, related.relative);
+	    HTSimplify(tail, FALSE);
+	    CTRACE((tfp, "HTParse: (Related-REL)\n"));
+	} else {		/* No inheritance */
+	    if (!isLYNXCGI(aName) &&
+		!isLYNXEXEC(aName) &&
+		!isLYNXPROG(aName)) {
+		*tail++ = '/';
+		*tail = '\0';
+	    } else {
+		HTSimplify(tail, FALSE);
+	    }
+	    if (!strcmp(result, "news:/"))
+		result[5] = '*';
+	    CTRACE((tfp, "HTParse: (No inheritance)\n"));
+	}
+	if (want_detail) {
+	    p = StrChr(tail, '?');	/* Search part? */
+	    if (p) {
+		if (PARSE_STRICTPATH) {
+		    *p = '\0';
+		} else {
+		    if (!(wanted & PARSE_PUNCTUATION))
+			p++;
+		    do {
+			*tail++ = *p;
+		    } while (*p++);
+		}
+	    } else {
+		if (wanted & PARSE_QUERY)
+		    *tail = '\0';
+	    }
+	}
+    }
+
+    /*
+     * Handle the fragment (anchor).  Never inherit.
+     */
+    if (wanted & PARSE_ANCHOR) {
+	if (given.anchor && *given.anchor) {
+	    tail += strlen(tail);
+	    if (wanted & PARSE_PUNCTUATION)
+		*tail++ = '#';
+	    strcpy(tail, given.anchor);
+	}
+    }
+
+    /*
+     * If there are any blanks remaining in the string, escape them as needed.
+     * See the discussion in LYLegitimizeHREF() for example.
+     */
+    if ((p = StrChr(result, ' ')) != 0) {
+	switch (is_url(result)) {
+	case UNKNOWN_URL_TYPE:
+	    CTRACE((tfp, "HTParse:      ignore:`%s'\n", result));
+	    break;
+	case LYNXEXEC_URL_TYPE:
+	case LYNXPROG_URL_TYPE:
+	case LYNXCGI_URL_TYPE:
+	case LYNXPRINT_URL_TYPE:
+	case LYNXHIST_URL_TYPE:
+	case LYNXDOWNLOAD_URL_TYPE:
+	case LYNXKEYMAP_URL_TYPE:
+	case LYNXIMGMAP_URL_TYPE:
+	case LYNXCOOKIE_URL_TYPE:
+	case LYNXCACHE_URL_TYPE:
+	case LYNXDIRED_URL_TYPE:
+	case LYNXOPTIONS_URL_TYPE:
+	case LYNXCFG_URL_TYPE:
+	case LYNXCOMPILE_OPTS_URL_TYPE:
+	case LYNXMESSAGES_URL_TYPE:
+	    CTRACE((tfp, "HTParse:      spaces:`%s'\n", result));
+	    break;
+	case NOT_A_URL_TYPE:
+	default:
+	    CTRACE((tfp, "HTParse:      encode:`%s'\n", result));
+	    do {
+		q = p + strlen(p) + 2;
+
+		while (q != p + 1) {
+		    q[0] = q[-2];
+		    --q;
+		}
+		p[0] = HEX_ESCAPE;
+		p[1] = '2';
+		p[2] = '0';
+	    } while ((p = StrChr(result, ' ')) != 0);
+	    break;
+	}
+    }
+    CTRACE((tfp, "HTParse:      result:`%s'\n", result));
+
+    StrAllocCopy(return_value, result);
+    LYalloca_free(result);
+
+    /* FIXME: could be optimized using HTParse() internals */
+    if (*relatedName &&
+	((wanted & PARSE_ALL_WITHOUT_ANCHOR) == PARSE_ALL_WITHOUT_ANCHOR)) {
+	/*
+	 * Check whether to fill in localhost.  - FM
+	 */
+	LYFillLocalFileURL(&return_value, relatedName);
+	CTRACE((tfp, "pass LYFillLocalFile:`%s'\n", return_value));
+    }
+
+    return return_value;	/* exactly the right length */
+}
+
+/*	HTParseAnchor(), fast HTParse() specialization
+ *	----------------------------------------------
+ *
+ * On exit,
+ *	returns		A pointer within input string (probably to its end '\0')
+ */
+const char *HTParseAnchor(const char *aName)
+{
+    const char *p = aName;
+
+    for (; *p && *p != '#'; p++) {
+	;
+    }
+    if (*p == '#') {
+	/* the safe way based on HTParse() -
+	 * keeping in mind scan() peculiarities on schemes:
+	 */
+	struct struct_parts given;
+	size_t need = ((unsigned) ((p - aName) + (int) strlen(p) + 1));
+	char *name;
+
+	if (need > (size_t) max_uri_size) {
+	    p += strlen(p);
+	} else {
+	    name = (char *) LYalloca(need);
+
+	    if (name == NULL) {
+		outofmem(__FILE__, "HTParseAnchor");
+	    }
+	    strcpy(name, aName);
+	    scan(name, &given);
+	    LYalloca_free(name);
+
+	    p++;		/*next to '#' */
+	    if (given.anchor == NULL) {
+		for (; *p; p++)	/*scroll to end '\0' */
+		    ;
+	    }
+	}
+    }
+    return p;
+}
+
+/*	Simplify a filename.				HTSimplify()
+ *	--------------------
+ *
+ *  A unix-style file is allowed to contain the sequence xxx/../ which may
+ *  be replaced by "" , and the sequence "/./" which may be replaced by "/".
+ *  Simplification helps us recognize duplicate filenames.
+ *
+ *  RFC 3986 section 5.2.4 says to do this whether or not the path was relative.
+ */
+void HTSimplify(char *filename, BOOL absolute)
+{
+#define MY_FMT "HTParse HTSimplify\t(%s)"
+#ifdef NO_LYNX_TRACE
+#define debug_at(at)		/* nothing */
+#define atln		"?"
+#else
+    const char *atln;
+
+#define debug_at(at)	atln = at
+#endif
+    char *mark;
+    char *p;
+    size_t limit;
+
+    CTRACE2(TRACE_HTPARSE,
+	    (tfp, MY_FMT " %s\n",
+	     filename,
+	     absolute ? "ABS" : "REL"));
+
+    if (LYIsPathSep(*filename) && !absolute)
+	++filename;
+    mark = filename;
+    limit = strlen(filename);
+
+    for (p = filename; *p; ++p) {
+	if (*p == '?' || *p == '#') {
+	    limit = (size_t) (p - filename);
+	    break;
+	}
+    }
+    while ((limit != 0) && (*filename != '\0')) {
+	size_t trim = 0;
+	size_t skip = 0;
+	size_t last = 0;
+
+	debug_at("?");
+	p = filename;
+	if (limit >= 2 && !memcmp(p, "./", 2)) {	/* 2A */
+	    debug_at("2A");
+	    trim = 2;
+	} else if (limit >= 3 && !memcmp(p, "../", 3)) {
+	    debug_at("2A2");
+	    trim = 3;
+	} else if (limit >= 3 && !memcmp(p, "/./", 3)) {	/* 2B */
+	    debug_at("2B");
+	    trim = 2;
+	    skip = 1;
+	} else if (limit == 2 && !memcmp(p, "/.", 2)) {
+	    debug_at("2B2");
+	    trim = 1;
+	    skip = 1;
+	} else if (limit >= 4 && !memcmp(p, "/../", 4)) {	/* 2C */
+	    debug_at("2C");
+	    trim = 3;
+	    skip = 1;
+	    last = 1;
+	} else if (limit == 3 && !memcmp(p, "/..", 3)) {
+	    debug_at("2C2");
+	    trim = 2;
+	    skip = 1;
+	    last = 1;
+	} else if (limit == 2 && !memcmp(p, "..", 2)) {		/* 2D */
+	    debug_at("2D");
+	    trim = 2;
+	} else if (limit == 1 && !memcmp(p, ".", 1)) {
+	    debug_at("2D2");
+	    trim = 1;
+	}
+	if (trim) {
+	    CTRACE2(TRACE_HTPARSE,
+		    (tfp, MY_FMT " trim %lu/%lu (%.*s) '%.*s' @%s\n",
+		     mark, (unsigned long) trim, (unsigned long) limit,
+		     (int) trim, p + skip, (int) limit, p, atln));
+	}
+	if (last) {
+	    char *prior = filename;
+
+	    if (prior != mark) {
+		--prior;
+		while (prior != mark && *prior != '/') {
+		    --prior;
+		}
+	    }
+	    if (prior != filename) {
+		trim += (size_t) (filename - prior);
+		limit += (size_t) (filename - prior);
+		filename = prior;
+		CTRACE2(TRACE_HTPARSE,
+			(tfp, MY_FMT " TRIM %lu/%lu (%.*s)\n",
+			 mark, (unsigned long) trim, (unsigned long) limit,
+			 (int) trim, filename + skip));
+	    }
+	}
+	if (trim) {
+	    limit -= trim;
+	    for (p = filename;; ++p) {
+		if ((p[0] = p[trim]) == '\0') {
+		    break;
+		}
+		if (skip) {
+		    p[0] = '/';
+		    skip = 0;
+		}
+	    }
+	    CTRACE2(TRACE_HTPARSE,
+		    (tfp, MY_FMT " loop %lu\n", mark, (unsigned long) limit));
+	} else {
+	    if (*filename == '/') {
+		++filename;
+		--limit;
+	    }
+	    while ((limit != 0) && (*filename != '/')) {
+		++filename;
+		--limit;
+	    }
+	}
+    }
+    CTRACE2(TRACE_HTPARSE, (tfp, MY_FMT " done\n", mark));
+#undef MY_FMT
+}
+
+/*	Make Relative Name.					HTRelative()
+ *	-------------------
+ *
+ * This function creates and returns a string which gives an expression of
+ * one address as related to another.  Where there is no relation, an absolute
+ * address is returned.
+ *
+ *  On entry,
+ *	Both names must be absolute, fully qualified names of nodes
+ *	(no anchor bits)
+ *
+ *  On exit,
+ *	The return result points to a newly allocated name which, if
+ *	parsed by HTParse relative to relatedName, will yield aName.
+ *	The caller is responsible for freeing the resulting name later.
+ *
+ */
+char *HTRelative(const char *aName,
+		 const char *relatedName)
+{
+    char *result = NULL;
+    const char *p = aName;
+    const char *q = relatedName;
+    const char *after_access = NULL;
+    const char *path = NULL;
+    const char *last_slash = NULL;
+    int slashes = 0;
+
+    for (; *p; p++, q++) {	/* Find extent of match */
+	if (*p != *q)
+	    break;
+	if (*p == ':')
+	    after_access = p + 1;
+	if (*p == '/') {
+	    last_slash = p;
+	    slashes++;
+	    if (slashes == 3)
+		path = p;
+	}
+    }
+
+    /* q, p point to the first non-matching character or zero */
+
+    if (!after_access) {	/* Different access */
+	StrAllocCopy(result, aName);
+    } else if (slashes < 3) {	/* Different nodes */
+	StrAllocCopy(result, after_access);
+    } else if (slashes == 3) {	/* Same node, different path */
+	StrAllocCopy(result, path);
+    } else {			/* Some path in common */
+	unsigned levels = 0;
+
+	for (; *q && (*q != '#'); q++)
+	    if (*q == '/')
+		levels++;
+	result = typecallocn(char, 3 * levels + strlen(last_slash) + 1);
+
+	if (result == NULL)
+	    outofmem(__FILE__, "HTRelative");
+
+	result[0] = '\0';
+	for (; levels; levels--)
+	    strcat(result, "../");
+	strcat(result, last_slash + 1);
+    }
+    CTRACE((tfp,
+	    "HTparse: `%s' expressed relative to\n   `%s' is\n   `%s'.\n",
+	    aName, relatedName, result));
+    return result;
+}
+
+#define AlloCopy(next,base,extra) \
+	typecallocn(char, ((next - base) + ((int) extra)))
+
+/*	Escape undesirable characters using %			HTEscape()
+ *	-------------------------------------
+ *
+ *	This function takes a pointer to a string in which
+ *	some characters may be unacceptable unescaped.
+ *	It returns a string which has these characters
+ *	represented by a '%' character followed by two hex digits.
+ *
+ *	Unlike HTUnEscape(), this routine returns a calloc'd string.
+ */
+/* *INDENT-OFF* */
+static const unsigned char isAcceptable[96] =
+
+/*	Bit 0		xalpha		-- see HTFile.h
+ *	Bit 1		xpalpha		-- as xalpha but with plus.
+ *	Bit 2 ...	path		-- as xpalphas but with /
+ */
+    /*	 0 1 2 3 4 5 6 7 8 9 A B C D E F */
+    {	 0,0,0,0,0,0,0,0,0,0,7,6,0,7,7,4,	/* 2x	!"#$%&'()*+,-./  */
+	 7,7,7,7,7,7,7,7,7,7,0,0,0,0,0,0,	/* 3x  0123456789:;<=>?  */
+	 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,	/* 4x  @ABCDEFGHIJKLMNO  */
+	 7,7,7,7,7,7,7,7,7,7,7,0,0,0,0,7,	/* 5X  PQRSTUVWXYZ[\]^_  */
+	 0,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,	/* 6x  `abcdefghijklmno  */
+	 7,7,7,7,7,7,7,7,7,7,7,0,0,0,0,0 };	/* 7X  pqrstuvwxyz{|}~	DEL */
+/* *INDENT-ON* */
+
+static const char *hex = "0123456789ABCDEF";
+
+#define ACCEPTABLE(a)	( a>=32 && a<128 && ((isAcceptable[a-32]) & mask))
+
+char *HTEscape(const char *str,
+	       unsigned mask)
+{
+    const char *p;
+    char *q;
+    char *result;
+    size_t unacceptable = 0;
+
+    for (p = str; *p; p++)
+	if (!ACCEPTABLE(UCH(TOASCII(*p))))
+	    unacceptable++;
+    result = AlloCopy(p, str, (unacceptable * 2) + 1);
+
+    if (result == NULL)
+	outofmem(__FILE__, "HTEscape");
+
+    for (q = result, p = str; *p; p++) {
+	unsigned char a = UCH(TOASCII(*p));
+
+	if (!ACCEPTABLE(a)) {
+	    *q++ = HEX_ESCAPE;	/* Means hex coming */
+	    *q++ = hex[a >> 4];
+	    *q++ = hex[a & 15];
+	} else
+	    *q++ = *p;
+    }
+    *q = '\0';			/* Terminate */
+    return result;
+}
+
+/*	Escape unsafe characters using %			HTEscapeUnsafe()
+ *	--------------------------------
+ *
+ *	This function takes a pointer to a string in which
+ *	some characters may be that may be unsafe are unescaped.
+ *	It returns a string which has these characters
+ *	represented by a '%' character followed by two hex digits.
+ *
+ *	Unlike HTUnEscape(), this routine returns a malloc'd string.
+ */
+#define UNSAFE(ch) (((ch) <= 32) || ((ch) >= 127))
+
+char *HTEscapeUnsafe(const char *str)
+{
+    const char *p;
+    char *q;
+    char *result;
+    size_t unacceptable = 0;
+
+    for (p = str; *p; p++)
+	if (UNSAFE(UCH(TOASCII(*p))))
+	    unacceptable++;
+    result = AlloCopy(p, str, (unacceptable * 2) + 1);
+
+    if (result == NULL)
+	outofmem(__FILE__, "HTEscapeUnsafe");
+
+    for (q = result, p = str; *p; p++) {
+	unsigned char a = UCH(TOASCII(*p));
+
+	if (UNSAFE(a)) {
+	    *q++ = HEX_ESCAPE;	/* Means hex coming */
+	    *q++ = hex[a >> 4];
+	    *q++ = hex[a & 15];
+	} else
+	    *q++ = *p;
+    }
+    *q = '\0';			/* Terminate */
+    return result;
+}
+
+/*	Escape undesirable characters using % but space to +.	HTEscapeSP()
+ *	-----------------------------------------------------
+ *
+ *	This function takes a pointer to a string in which
+ *	some characters may be unacceptable unescaped.
+ *	It returns a string which has these characters
+ *	represented by a '%' character followed by two hex digits,
+ *	except that spaces are converted to '+' instead of %2B.
+ *
+ *	Unlike HTUnEscape(), this routine returns a calloced string.
+ */
+char *HTEscapeSP(const char *str,
+		 unsigned mask)
+{
+    const char *p;
+    char *q;
+    char *result;
+    size_t unacceptable = 0;
+
+    for (p = str; *p; p++)
+	if (!(*p == ' ' || ACCEPTABLE(UCH(TOASCII(*p)))))
+	    unacceptable++;
+    result = AlloCopy(p, str, (unacceptable * 2) + 1);
+
+    if (result == NULL)
+	outofmem(__FILE__, "HTEscape");
+
+    for (q = result, p = str; *p; p++) {
+	unsigned char a = UCH(TOASCII(*p));
+
+	if (a == 32) {
+	    *q++ = '+';
+	} else if (!ACCEPTABLE(a)) {
+	    *q++ = HEX_ESCAPE;	/* Means hex coming */
+	    *q++ = hex[a >> 4];
+	    *q++ = hex[a & 15];
+	} else {
+	    *q++ = *p;
+	}
+    }
+    *q = '\0';			/* Terminate */
+    return result;
+}
+
+/*	Decode %xx escaped characters.				HTUnEscape()
+ *	------------------------------
+ *
+ *	This function takes a pointer to a string in which some
+ *	characters may have been encoded in %xy form, where xy is
+ *	the ASCII hex code for character 16x+y.
+ *	The string is converted in place, as it will never grow.
+ */
+static char from_hex(int c)
+{
+    return (char) (c >= '0' && c <= '9' ? c - '0'
+		   : c >= 'A' && c <= 'F' ? c - 'A' + 10
+		   : c - 'a' + 10);	/* accept small letters just in case */
+}
+
+char *HTUnEscape(char *str)
+{
+    char *p = str;
+    char *q = str;
+
+    if (!(p && *p))
+	return str;
+
+    while (*p != '\0') {
+	if (*p == HEX_ESCAPE &&
+	/*
+	 * Tests shouldn't be needed, but better safe than sorry.
+	 */
+	    p[1] && p[2] &&
+	    isxdigit(UCH(p[1])) &&
+	    isxdigit(UCH(p[2]))) {
+	    p++;
+	    if (*p)
+		*q = (char) (from_hex(*p++) * 16);
+	    if (*p) {
+		/*
+		 * Careful! FROMASCII() may evaluate its arg more than once!
+		 */
+		/* S/390 -- gil -- 0221 */
+		*q = (char) (*q + from_hex(*p++));
+	    }
+	    *q = FROMASCII(*q);
+	    q++;
+	} else {
+	    *q++ = *p++;
+	}
+    }
+
+    *q = '\0';
+    return str;
+
+}				/* HTUnEscape */
+
+/*	Decode some %xx escaped characters.		      HTUnEscapeSome()
+ *	-----------------------------------			Klaus Weide
+ *							    (kweide@tezcat.com)
+ *	This function takes a pointer to a string in which some
+ *	characters may have been encoded in %xy form, where xy is
+ *	the ASCII hex code for character 16x+y, and a pointer to
+ *	a second string containing one or more characters which
+ *	should be unescaped if escaped in the first string.
+ *	The first string is converted in place, as it will never grow.
+ */
+char *HTUnEscapeSome(char *str,
+		     const char *do_trans)
+{
+    char *p = str;
+    char *q = str;
+    char testcode;
+
+    if (p == NULL || *p == '\0' || do_trans == NULL || *do_trans == '\0')
+	return str;
+
+    while (*p != '\0') {
+	if (*p == HEX_ESCAPE &&
+	    p[1] && p[2] &&	/* tests shouldn't be needed, but.. */
+	    isxdigit(UCH(p[1])) &&
+	    isxdigit(UCH(p[2])) &&
+	    (testcode = (char) FROMASCII(from_hex(p[1]) * 16 +
+					 from_hex(p[2]))) &&	/* %00 no good */
+	    StrChr(do_trans, testcode)) {	/* it's one of the ones we want */
+	    *q++ = testcode;
+	    p += 3;
+	} else {
+	    *q++ = *p++;
+	}
+    }
+
+    *q = '\0';
+    return str;
+
+}				/* HTUnEscapeSome */
+/* *INDENT-OFF* */
+static const unsigned char crfc[96] =
+
+/*	Bit 0		xalpha		-- need "quoting"
+ *	Bit 1		xpalpha		-- need \escape if quoted
+ */
+    /*	 0 1 2 3 4 5 6 7 8 9 A B C D E F */
+    {	 1,0,3,0,0,0,0,0,1,1,0,0,1,0,1,0,	/* 2x	!"#$%&'()*+,-./  */
+	 0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,	/* 3x  0123456789:;<=>?  */
+	 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/* 4x  @ABCDEFGHIJKLMNO  */
+	 0,0,0,0,0,0,0,0,0,0,0,1,2,1,0,0,	/* 5X  PQRSTUVWXYZ[\]^_  */
+	 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/* 6x  `abcdefghijklmno  */
+	 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3 };	/* 7X  pqrstuvwxyz{|}~	DEL */
+/* *INDENT-ON* */
+
+#define ASCII_TAB '\011'
+#define ASCII_LF  '\012'
+#define ASCII_CR  '\015'
+#define ASCII_SPC '\040'
+#define ASCII_BAK '\134'
+
+/*
+ *  Turn a string which is not a RFC 822 token into a quoted-string. - KW
+ *  The "quoted" parameter tells whether we need the beginning/ending quote
+ *  marks.  If not, the caller will provide them -TD
+ */
+void HTMake822Word(char **str,
+		   int quoted)
+{
+    const char *p;
+    char *q;
+    char *result;
+    unsigned char a;
+    unsigned added = 0;
+
+    if (isEmpty(*str)) {
+	StrAllocCopy(*str, quoted ? "\"\"" : "");
+	return;
+    }
+    for (p = *str; *p; p++) {
+	a = UCH(TOASCII(*p));	/* S/390 -- gil -- 0240 */
+	if (a < 32 || a >= 128 ||
+	    ((crfc[a - 32]) & 1)) {
+	    if (!added)
+		added = 2;
+	    if (a >= 160 || a == '\t')
+		continue;
+	    if (a == '\r' || a == '\n')
+		added += 2;
+	    else if ((a & 127) < 32 || ((crfc[a - 32]) & 2))
+		added++;
+	}
+    }
+    if (!added)
+	return;
+    result = AlloCopy(p, *str, added + 1);
+    if (result == NULL)
+	outofmem(__FILE__, "HTMake822Word");
+
+    q = result;
+    if (quoted)
+	*q++ = '"';
+    /*
+     * Having converted the character to ASCII, we can't use symbolic
+     * escape codes, since they're in the host character set, which
+     * is not necessarily ASCII.  Thus we use octal escape codes instead.
+     * -- gil (Paul Gilmartin) <pg@sweng.stortek.com>
+     */
+    /* S/390 -- gil -- 0268 */
+    for (p = *str; *p; p++) {
+	a = UCH(TOASCII(*p));
+	if ((a != ASCII_TAB) &&
+	    ((a & 127) < ASCII_SPC ||
+	     (a < 128 && ((crfc[a - 32]) & 2))))
+	    *q++ = ASCII_BAK;
+	*q++ = *p;
+	if (a == ASCII_LF ||
+	    (a == ASCII_CR && (TOASCII(*(p + 1)) != ASCII_LF)))
+	    *q++ = ' ';
+    }
+    if (quoted)
+	*q++ = '"';
+    *q = '\0';			/* Terminate */
+    FREE(*str);
+    *str = result;
+}
diff --git a/WWW/Library/Implementation/HTParse.h b/WWW/Library/Implementation/HTParse.h
new file mode 100644
index 0000000..49b40b3
--- /dev/null
+++ b/WWW/Library/Implementation/HTParse.h
@@ -0,0 +1,212 @@
+/*
+ * $LynxId: HTParse.h,v 1.26 2021/07/05 20:56:50 tom Exp $
+ *				HTParse:  URL parsing in the WWW Library
+ *				HTPARSE
+ *
+ *  This module of the WWW library contains code to parse URLs and various
+ *  related things.
+ *  Implemented by HTParse.c .
+ */
+#ifndef HTPARSE_H
+#define HTPARSE_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define RFC_3986_UNRESERVED(c) (isalnum(UCH(c)) || strchr("-._~", UCH(c)) != 0)
+#define RFC_3986_GEN_DELIMS(c) ((c) != 0 && strchr(":/?#[]@", UCH(c)) != 0)
+#define RFC_3986_SUB_DELIMS(c) ((c) != 0 && strchr("!$&'()*+,;=", UCH(c)) != 0)
+
+/*
+ *  The following are flag bits which may be ORed together to form
+ *  a number to give the 'wanted' argument to HTParse.
+ */
+#define PARSE_ACCESS            16
+#define PARSE_HOST               8
+#define PARSE_PATH               4
+#define PARSE_ANCHOR             2
+#define PARSE_PUNCTUATION        1
+#define PARSE_ALL               31
+#define PARSE_ALL_WITHOUT_ANCHOR  (PARSE_ALL ^ PARSE_ANCHOR)
+/*
+ *  Additional flag bits for more details on components already
+ *  covered by the above.  The PARSE_PATH above doesn't really
+ *  strictly refer to the path component in the sense of the URI
+ *  specs only, but rather to that combined with a possible query
+ *  component. - kw
+ */
+#define PARSE_STRICTPATH        32
+#define PARSE_QUERY             64
+/*
+ *  The following are valid mask values.  The terms are the BNF names
+ *  in the URL document.
+ */
+#define URL_XALPHAS     UCH(1)
+#define URL_XPALPHAS    UCH(2)
+#define URL_PATH        UCH(4)
+
+#ifdef USE_IDN2
+    typedef enum {
+	LYidna2003 = 1,
+	LYidna2008,
+	LYidnaTR46,
+	LYidnaCompat
+    } HTIdnaModes;
+
+    extern int LYidnaMode;
+#endif
+
+/*	Strip white space off a string.				HTStrip()
+ *	-------------------------------
+ *
+ * On exit,
+ *	Return value points to first non-white character, or to 0 if none.
+ *	All trailing white space is OVERWRITTEN with zero.
+ */
+    extern char *HTStrip(char *s);
+
+/*
+ *	Parse a port number
+ *	-------------------
+ *
+ * On entry,
+ *	host            A pointer to hostname possibly followed by port
+ *
+ * On exit,
+ *	returns         A pointer to the ":" before the port
+ *	sets            the port number via the pointer portp.
+ */
+    extern char *HTParsePort(char *host, int *portp);
+
+/*	Parse a Name relative to another name.			HTParse()
+ *	--------------------------------------
+ *
+ *	This returns those parts of a name which are given (and requested)
+ *	substituting bits from the related name where necessary.
+ *
+ * On entry,
+ *	aName		A filename given
+ *      relatedName     A name relative to which aName is to be parsed
+ *      wanted          A mask for the bits which are wanted.
+ *
+ * On exit,
+ *	returns		A pointer to a malloc'd string which MUST BE FREED
+ */
+    extern char *HTParse(const char *aName,
+			 const char *relatedName,
+			 int wanted);
+
+/*	HTParseAnchor(), fast HTParse() specialization
+ *	----------------------------------------------
+ *
+ * On exit,
+ *	returns		A pointer within input string (probably to its end '\0')
+ */
+    extern const char *HTParseAnchor(const char *aName);
+
+/*	Simplify a filename.				HTSimplify()
+ *	--------------------
+ *
+ *  A unix-style file is allowed to contain the sequence xxx/../ which may
+ *  be replaced by "" , and the sequence "/./" which may be replaced by "/".
+ *  Simplification helps us recognize duplicate filenames.
+ */
+    extern void HTSimplify(char *filename, BOOL absolute);
+
+/*	Make Relative Name.					HTRelative()
+ *	-------------------
+ *
+ * This function creates and returns a string which gives an expression of
+ * one address as related to another.  Where there is no relation, an absolute
+ * address is returned.
+ *
+ *  On entry,
+ *	Both names must be absolute, fully qualified names of nodes
+ *	(no anchor bits)
+ *
+ *  On exit,
+ *	The return result points to a newly allocated name which, if
+ *	parsed by HTParse relative to relatedName, will yield aName.
+ *	The caller is responsible for freeing the resulting name later.
+ *
+ */
+    extern char *HTRelative(const char *aName,
+			    const char *relatedName);
+
+/*		Escape undesirable characters using %		HTEscape()
+ *		-------------------------------------
+ *
+ *	This function takes a pointer to a string in which
+ *	some characters may be unacceptable are unescaped.
+ *	It returns a string which has these characters
+ *	represented by a '%' character followed by two hex digits.
+ *
+ *	Unlike HTUnEscape(), this routine returns a malloc'd string.
+ */
+    extern char *HTEscape(const char *str,
+			  unsigned mask);
+
+/*		Escape unsafe characters using %		HTEscapeUnsafe()
+ *		--------------------------------
+ *
+ *	This function takes a pointer to a string in which
+ *	some characters may be that may be unsafe are unescaped.
+ *	It returns a string which has these characters
+ *	represented by a '%' character followed by two hex digits.
+ *
+ *	Unlike HTUnEscape(), this routine returns a malloc'd string.
+ */
+    extern char *HTEscapeUnsafe(const char *str);
+
+/*	Escape undesirable characters using % but space to +.	HTEscapeSP()
+ *	-----------------------------------------------------
+ *
+ *	This function takes a pointer to a string in which
+ *	some characters may be unacceptable are unescaped.
+ *	It returns a string which has these characters
+ *	represented by a '%' character followed by two hex digits,
+ *	except that spaces are converted to '+' instead of %2B.
+ *
+ *	Unlike HTUnEscape(), this routine returns a malloc'd string.
+ */
+    extern char *HTEscapeSP(const char *str,
+			    unsigned mask);
+
+/*	Decode %xx escaped characters.				HTUnEscape()
+ *	------------------------------
+ *
+ *	This function takes a pointer to a string in which some
+ *	characters may have been encoded in %xy form, where xy is
+ *	the acsii hex code for character 16x+y.
+ *	The string is converted in place, as it will never grow.
+ */
+    extern char *HTUnEscape(char *str);
+
+/*	Decode some %xx escaped characters.		      HTUnEscapeSome()
+ *	-----------------------------------			Klaus Weide
+ *							    (kweide@tezcat.com)
+ *	This function takes a pointer to a string in which some
+ *	characters may have been encoded in %xy form, where xy is
+ *	the acsii hex code for character 16x+y, and a pointer to
+ *	a second string containing one or more characters which
+ *	should be unescaped if escaped in the first string.
+ *	The first string is converted in place, as it will never grow.
+ */
+    extern char *HTUnEscapeSome(char *str,
+				const char *do_trans);
+
+/*
+ *  Turn a string which is not a RFC 822 token into a quoted-string. - KW
+ */
+    extern void HTMake822Word(char **str,
+			      int quoted);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTPARSE_H */
diff --git a/WWW/Library/Implementation/HTPlain.c b/WWW/Library/Implementation/HTPlain.c
new file mode 100644
index 0000000..ff52731
--- /dev/null
+++ b/WWW/Library/Implementation/HTPlain.c
@@ -0,0 +1,601 @@
+/*
+ * $LynxId: HTPlain.c,v 1.61 2020/01/21 22:05:46 tom Exp $
+ *
+ *		Plain text object		HTWrite.c
+ *		=================
+ *
+ *	This version of the stream object just writes to a socket.
+ *	The socket is assumed open and left open.
+ *
+ *	Bugs:
+ *		strings written must be less than buffer size.
+ */
+
+#define HTSTREAM_INTERNAL 1
+
+#include <HTUtils.h>
+#include <LYCharVals.h>		/* S/390 -- gil -- 0288 */
+
+#include <HTPlain.h>
+
+#include <HTChunk.h>
+#include <HText.h>
+#include <HTStyle.h>
+#define Lynx_HTML_Handler
+#include <HTML.h>		/* styles[] */
+
+#define BUFFER_SIZE 4096;	/* Tradeoff */
+
+#include <HTMLDTD.h>
+#include <HTCJK.h>
+#include <UCMap.h>
+#include <UCDefs.h>
+#include <UCAux.h>
+
+#include <LYCharSets.h>
+#include <LYStrings.h>
+#include <LYLeaks.h>
+
+static int HTPlain_lastraw = -1;
+static int HTPlain_bs_pending = 0;	/* 1:bs 2:underline 3:underline+bs - kw */
+
+/*		HTML Object
+ *		-----------
+ */
+struct _HTStream {
+    const HTStreamClass *isa;
+    HText *text;
+    /*
+     * The node_anchor UCInfo and handle for the input (PARSER) stage.  - FM
+     */
+    LYUCcharset *inUCI;
+    int inUCLYhndl;
+    /*
+     * The node_anchor UCInfo and handle for the output (HTEXT) stage.  - FM
+     */
+    LYUCcharset *outUCI;
+    int outUCLYhndl;
+
+    UTFDecodeState U;
+    UCTransParams T;
+};
+
+static char replace_buf[64];	/* buffer for replacement strings */
+
+static void HTPlain_getChartransInfo(HTStream *me, HTParentAnchor *anchor)
+{
+    if (me->inUCLYhndl < 0) {
+	HTAnchor_copyUCInfoStage(anchor, UCT_STAGE_PARSER, UCT_STAGE_MIME,
+				 UCT_SETBY_PARSER);
+	me->inUCLYhndl = HTAnchor_getUCLYhndl(anchor, UCT_STAGE_PARSER);
+    }
+    if (me->outUCLYhndl < 0) {
+	int chndl = HTAnchor_getUCLYhndl(anchor, UCT_STAGE_HTEXT);
+
+	if (chndl < 0) {
+	    chndl = current_char_set;
+	    HTAnchor_setUCInfoStage(anchor, chndl,
+				    UCT_STAGE_HTEXT, UCT_SETBY_DEFAULT);
+	}
+	HTAnchor_setUCInfoStage(anchor, chndl,
+				UCT_STAGE_HTEXT, UCT_SETBY_DEFAULT);
+	me->outUCLYhndl = HTAnchor_getUCLYhndl(anchor, UCT_STAGE_HTEXT);
+    }
+    me->inUCI = HTAnchor_getUCInfoStage(anchor, UCT_STAGE_PARSER);
+    me->outUCI = HTAnchor_getUCInfoStage(anchor, UCT_STAGE_HTEXT);
+}
+
+/*	Write the buffer out to the socket
+ *	----------------------------------
+ */
+
+/*_________________________________________________________________________
+ *
+ *			A C T I O N	R O U T I N E S
+ */
+
+static void HTPlain_write(HTStream *me, const char *s,
+			  int l);
+
+/*	Character handling
+ *	------------------
+ */
+static void HTPlain_put_character(HTStream *me, int c)
+{
+#ifdef REMOVE_CR_ONLY
+    /*
+     * Throw away \r's.
+     */
+    if (c != '\r') {
+	HText_appendCharacter(me->text, c);
+    }
+#else
+    /*
+     * See HTPlain_write() for explanations of the following code (we've been
+     * called via HTPlain_put_string() to do for each character of a terminated
+     * string what HTPlain_write() does via a while loop for each character in
+     * a stream of given length).  - FM
+     */
+    if ((HTPlain_lastraw == '\r') && c == '\n') {
+	HTPlain_lastraw = -1;
+	return;
+    }
+    if (c == '\b' || c == '_' || HTPlain_bs_pending) {
+	char temp[1];
+
+	temp[0] = (char) c;
+	HTPlain_write(me, temp, 1);
+	return;
+    }
+    HTPlain_lastraw = UCH(c);
+    if (c == '\r') {
+	HText_appendCharacter(me->text, '\n');
+    } else if (TOASCII(UCH(c)) >= 127) {	/* S/390 -- gil -- 0305 */
+	char temp[1];
+
+	temp[0] = (char) c;
+	/*
+	 * For now, don't repeat everything here that has been done below - KW
+	 */
+	HTPlain_write(me, temp, 1);
+    } else if (IS_CJK_TTY) {
+	HText_appendCharacter(me->text, c);
+    } else if (TOASCII(UCH(c)) >= 127 && TOASCII(UCH(c)) < 161 &&
+	       HTPassHighCtrlRaw) {
+	HText_appendCharacter(me->text, c);
+#if CH_NBSP < 127
+    } else if (UCH(c) == CH_NBSP) {	/* S/390 -- gil -- 0341 */
+	HText_appendCharacter(me->text, ' ');
+#endif
+#if CH_SHY < 127
+    } else if (UCH(c) == CH_SHY) {
+	return;
+#endif
+    } else if ((UCH(c) >= ' ' && TOASCII(UCH(c)) < 127) ||
+	       c == '\n' || c == '\t') {
+	HText_appendCharacter(me->text, c);
+    }
+#endif /* REMOVE_CR_ONLY */
+}
+
+/*	String handling
+ *	---------------
+ *
+ */
+static void HTPlain_put_string(HTStream *me, const char *s)
+{
+#ifdef REMOVE_CR_ONLY
+    HText_appendText(me->text, s);
+#else
+    const char *p;
+
+    if (s == NULL)
+	return;
+    for (p = s; *p; p++) {
+	HTPlain_put_character(me, *p);
+    }
+#endif /* REMOVE_CR_ONLY */
+}
+
+/*
+ *	Entry function for displayed text/plain and WWW_SOURCE strings. - FM
+ *	---------------------------------------------------------------
+ */
+static void HTPlain_write(HTStream *me, const char *s, int l)
+{
+    const char *p;
+    const char *e = s + l;
+    int c;
+    unsigned c_unsign;
+    BOOL chk;
+    UCode_t code, uck = -1;
+    int saved_char_in = '\0';
+
+    for (p = s; p < e; p++) {
+#ifdef REMOVE_CR_ONLY
+	/*
+	 * Append the whole string, but remove any \r's.  - FM
+	 */
+	if (*p != '\r') {
+	    HText_appendCharacter(me->text, *p);
+	}
+#else
+	if (*p == '\b') {
+	    if (HTPlain_lastraw >= UCH(' ') &&
+		HTPlain_lastraw != '\r' && HTPlain_lastraw != '\n') {
+		if (!HTPlain_bs_pending) {
+		    HTPlain_bs_pending = 1;
+		    continue;
+		} else if (HTPlain_bs_pending == 2) {
+		    HTPlain_bs_pending = 3;
+		    continue;
+		}
+	    }
+	    if (HTPlain_bs_pending >= 2)
+		HText_appendCharacter(me->text, '_');
+	    HTPlain_bs_pending = 0;
+	} else if (*p == '_') {
+	    if (!HTPlain_bs_pending) {
+		HTPlain_bs_pending = 2;
+		HTPlain_lastraw = UCH(*p);
+		continue;
+	    }
+	}
+
+	/*
+	 * Try to handle lone LFs, CRLFs and lone CRs as newline, and to deal
+	 * with control, ASCII, and 8-bit characters based on best guesses of
+	 * what's appropriate.  - FM
+	 */
+	if ((HTPlain_lastraw == '\r') && *p == '\n') {
+	    HTPlain_lastraw = -1;
+	    continue;
+	}
+
+	if (HTPlain_bs_pending &&
+	    !(UCH(*p) >= ' ' && *p != '\r' && *p != '\n' &&
+	      (HTPlain_lastraw == UCH(*p) ||
+	       HTPlain_lastraw == UCH('_') ||
+	       *p == '_'))) {
+	    if (HTPlain_bs_pending >= 2)
+		HText_appendCharacter(me->text, '_');
+	    HTPlain_bs_pending = 0;
+	} else if (HTPlain_bs_pending == 1) {
+	    HTPlain_bs_pending = 0;
+	    continue;		/* ignore last two of "X\bX" or "X\b_" - kw */
+	} else if (HTPlain_bs_pending == 3) {
+	    if (*p == '_') {
+		HTPlain_bs_pending = 2;
+		continue;	/* ignore last two of "_\b_" - kw */
+	    } else {
+		HTPlain_bs_pending = 0;
+		/* ignore first two of "_\bX" - kw */
+	    }
+	} else if (HTPlain_bs_pending == 2) {
+	    HText_appendCharacter(me->text, '_');
+	    if (*p == '_')
+		continue;	/* keep second of "__" pending - kw */
+	    HTPlain_bs_pending = 0;
+	} else {
+	    HTPlain_bs_pending = 0;
+	}
+	HTPlain_lastraw = UCH(*p);
+	if (*p == '\r') {
+	    HText_appendCharacter(me->text, '\n');
+	    continue;
+	}
+	/*
+	 * Make sure the character is handled as Unicode whenever that's
+	 * appropriate.  - FM
+	 */
+	c = *p;
+	c_unsign = UCH(c);
+	code = (UCode_t) c_unsign;
+	saved_char_in = '\0';
+	/*
+	 * Combine any UTF-8 multibytes into Unicode to check for special
+	 * characters. - FM, TD
+	 */
+	if (me->T.decode_utf8) {
+	    switch (HTDecodeUTF8(&(me->U), &c, &code)) {
+	    case dUTF8_ok:
+		if (code < 256) {
+		    c = FROMASCII((char) code);
+		    c_unsign = UCH(c);
+		}
+		break;
+	    case dUTF8_err:
+		code = UCS_REPL;
+		strcpy(me->U.utf_buf, "\357\277\275");
+		me->U.utf_buf_p = (me->U.utf_buf + 3);
+		break;
+	    case dUTF8_more:
+		continue;
+	    }
+	}
+	/*
+	 * Convert characters from non-UTF-8 charsets to Unicode (if
+	 * appropriate).  - FM
+	 */
+	if (!(me->T.decode_utf8 &&
+	      UCH(*p) > 127)) {
+	    if (me->T.trans_to_uni &&
+		(TOASCII(code) >= LYlowest_eightbit[me->inUCLYhndl] ||	/* S/390 -- gil -- 0389 */
+		 (code < ' ' && code != 0 &&
+		  me->T.trans_C0_to_uni))) {
+		/*
+		 * Convert the octet to Unicode.  - FM
+		 */
+		code = (UCode_t) UCTransToUni(c, me->inUCLYhndl);
+		if (code > 0) {
+		    saved_char_in = c;
+		    if (code < 256) {
+			c = FROMASCII((char) code);
+			c_unsign = UCH(c);
+		    }
+		}
+	    } else if (code < 32 && code != 0 &&
+		       me->T.trans_C0_to_uni) {
+		/*
+		 * Quote from SGML.c:
+		 * "This else if may be too ugly to keep.  - KW"
+		 */
+		if (me->T.trans_from_uni &&
+		    (((code = UCTransToUni(c, me->inUCLYhndl)) >= 32) ||
+		     (me->T.transp &&
+		      (code = UCTransToUni(c, me->inUCLYhndl)) > 0))) {
+		    saved_char_in = c;
+		    if (code < 256) {
+			c = FROMASCII((char) code);
+			c_unsign = UCH(c);
+		    }
+		} else {
+		    uck = -1;
+		    if (me->T.transp) {
+			uck = UCTransCharStr(replace_buf, 60, c,
+					     me->inUCLYhndl,
+					     me->inUCLYhndl, NO);
+		    }
+		    if (!me->T.transp || uck < 0) {
+			uck = UCTransCharStr(replace_buf, 60, c,
+					     me->inUCLYhndl,
+					     me->outUCLYhndl, YES);
+		    }
+		    if (uck == 0) {
+			continue;
+		    } else if (uck < 0) {
+			me->U.utf_buf[0] = '\0';
+		    } else {
+			c = replace_buf[0];
+			if (c && replace_buf[1]) {
+			    HText_appendText(me->text, replace_buf);
+			    continue;
+			}
+		    }
+		    me->U.utf_buf[0] = '\0';
+		    code = UCH(c);
+		}		/*  Next line end of ugly stuff for C0. - KW */
+	    } else {
+		me->U.utf_buf[0] = '\0';
+		code = UCH(c);
+	    }
+	}
+	/*
+	 * At this point we have either code in Unicode (and c in latin1 if
+	 * code is in the latin1 range), or code and c will have to be passed
+	 * raw.
+	 */
+
+	/*
+	 * If CJK mode is on, we'll assume the document matches the user's
+	 * display character set, and if not, the user should toggle off
+	 * raw/CJK mode to reload.  - FM
+	 */
+	if (IS_CJK_TTY) {
+	    HText_appendCharacter(me->text, c);
+
+#define PASSHICTRL (me->T.transp || \
+		    code >= LYlowest_eightbit[me->inUCLYhndl])
+#define PASS8859SPECL me->T.pass_160_173_raw
+#define PASSHI8BIT (HTPassEightBitRaw || \
+		    (me->T.do_8bitraw && !me->T.trans_from_uni))
+	    /*
+	     * If HTPassHighCtrlRaw is set (e.g., for KOI8-R) assume the
+	     * document matches and pass 127-160 8-bit characters.  If it
+	     * doesn't match, the user should toggle raw/CJK mode off.  - FM
+	     */
+	} else if (TOASCII(code) >= 127 && TOASCII(code) < 161 &&	/* S/390 -- gil -- 0427 */
+		   PASSHICTRL && PASS8859SPECL) {
+	    HText_appendCharacter(me->text, c);
+	} else if (code == CH_SHY && PASS8859SPECL) {
+	    HText_appendCharacter(me->text, c);
+	    /*
+	     * If neither HTPassHighCtrlRaw nor CJK is set, play it safe and
+	     * treat 160 (nbsp) as an ASCII space (32).  - FM
+	     */
+	} else if (code == CH_NBSP) {
+	    HText_appendCharacter(me->text, ' ');
+	    /*
+	     * If neither HTPassHighCtrlRaw nor CJK is set, play it safe and
+	     * ignore 173 (shy).  - FM
+	     * Now only ignore it for color style, which doesn't handle it
+	     * anyway.  Otherwise pass it on as LY_SOFT_HYPHEN and let HText
+	     * deal with it.  It should be either ignored, or displayed as a
+	     * hyphen if it was indeed at the end of a line.  Well it should. 
+	     * - kw
+	     */
+	} else if (code == CH_SHY) {
+#ifndef USE_COLOR_STYLE
+	    HText_appendCharacter(me->text, LY_SOFT_HYPHEN);
+#endif
+	    continue;
+	    /*
+	     * If we get to here, pass the displayable ASCII characters.  - FM
+	     */
+	} else if ((code >= ' ' && code != UCS_REPL && TOASCII(code) < 127) ||
+		   (PASSHI8BIT &&
+		    c >= LYlowest_eightbit[me->outUCLYhndl]) ||
+		   *p == '\n' || *p == '\t') {
+	    HText_appendCharacter(me->text, c);
+	    /*
+	     * Use an ASCII space (32) for ensp, emsp or thinsp.  - FM
+	     */
+	} else if (code == 8194 || code == 8195 || code == 8201) {
+	    HText_appendCharacter(me->text, ' ');
+	    /*
+	     * If we want the raw character, pass it now.  - FM
+	     */
+	} else if (me->T.use_raw_char_in && saved_char_in) {
+	    HText_appendCharacter(me->text, saved_char_in);
+/******************************************************************
+ * I.  LATIN-1 OR UCS2 TO DISPLAY CHARSET
+ ******************************************************************/
+	} else if ((chk = (BOOL) (me->T.trans_from_uni && code >= 160)) &&
+		   (uck = UCTransUniChar(code,
+					 me->outUCLYhndl)) >= ' ' &&	/* S/390 -- gil -- 0464 */
+		   uck < 256) {
+	    CTRACE((tfp, "UCTransUniChar returned 0x%.2" PRI_UCode_t
+		    ":'%c'.\n",
+		    uck, FROMASCII(UCH(uck))));
+	    HText_appendCharacter(me->text, ((char) (uck & 0xff)));
+	} else if (chk &&
+		   (uck == -4 ||
+		    (me->T.repl_translated_C0 && uck > 0 && uck < ' ')) &&	/* S/390 -- gil -- 0481 */
+	    /*
+	     * Not found; look for replacement string.
+	     */
+		   (uck = UCTransUniCharStr(replace_buf, 60, code,
+					    me->outUCLYhndl, 0) >= 0)) {
+	    /*
+	     * No further tests for valididy - assume that whoever defined
+	     * replacement strings knew what she was doing.
+	     */
+	    HText_appendText(me->text, replace_buf);
+	    /*
+	     * If we get to here, and should have translated, translation has
+	     * failed so far.
+	     */
+	} else if (chk && TOASCII(code) > 127 && me->T.output_utf8) {	/* S/390 -- gil -- 0498 */
+	    /*
+	     * We want UTF-8 output, so do it now.  - FM
+	     */
+	    if (*me->U.utf_buf) {
+		HText_appendText(me->text, me->U.utf_buf);
+		me->U.utf_buf[0] = '\0';
+		me->U.utf_buf_p = me->U.utf_buf;
+	    } else if (UCConvertUniToUtf8(code, replace_buf)) {
+		HText_appendText(me->text, replace_buf);
+	    } else {
+		/*
+		 * Out of luck, so use the UHHH notation (ugh).  - gil
+		 */
+		/* S/390 -- gil -- 0517 */
+		sprintf(replace_buf, "U%.2lX", (unsigned long) TOASCII(code));
+		HText_appendText(me->text, replace_buf);
+	    }
+	    /*
+	     * If we don't actually want the character, make it safe and output
+	     * that now.  - FM
+	     */
+	} else if ((c_unsign > 0 &&
+		    (int) c_unsign < LYlowest_eightbit[me->outUCLYhndl]) ||
+		   (me->T.trans_from_uni && !HTPassEightBitRaw)) {
+	    /*
+	     * If we do not have the "7-bit approximations" as our output
+	     * character set (in which case we did it already) seek a
+	     * translation for that.  Otherwise, or if the translation fails,
+	     * use UHHH notation.  - FM
+	     */
+	    if ((chk = (BOOL) (me->outUCLYhndl !=
+			       UCGetLYhndl_byMIME("us-ascii"))) &&
+		(uck = UCTransUniChar(code,
+				      UCGetLYhndl_byMIME("us-ascii")))
+		>= ' ' && TOASCII(uck) < 127) {		/* S/390 -- gil -- 0535 */
+		/*
+		 * Got an ASCII character (yippey).  - FM
+		 */
+		c = FROMASCII((char) uck);
+		HText_appendCharacter(me->text, c);
+	    } else if ((chk && uck == -4) &&
+		       (uck = UCTransUniCharStr(replace_buf,
+						60, code,
+						UCGetLYhndl_byMIME("us-ascii"),
+						0) >= 0)) {
+		/*
+		 * Got a replacement string (yippey).  - FM
+		 */
+		HText_appendText(me->text, replace_buf);
+	    } else if (code == 8204 || code == 8205) {
+		/*
+		 * Ignore 8204 (zwnj) or 8205 (zwj), if we get to here.  - FM
+		 */
+		CTRACE((tfp, "HTPlain_write: Ignoring '%" PRI_UCode_t "'.\n", code));
+	    } else if (code == 8206 || code == 8207) {
+		/*
+		 * Ignore 8206 (lrm) or 8207 (rlm), if we get to here.  - FM
+		 */
+		CTRACE((tfp, "HTPlain_write: Ignoring '%" PRI_UCode_t "'.\n", code));
+	    } else {
+		/*
+		 * Out of luck, so use the UHHH notation (ugh).  - FM
+		 */
+		/* do not print UHHH for now
+		   sprintf(replace_buf, "U%.2lX", code);
+		   HText_appendText(me->text, replace_buf);
+		 */
+	    }
+	    /*
+	     * If we get to here and have a monobyte character, pass it.  - FM
+	     */
+	} else if (c_unsign != 0 && c_unsign < 256) {
+	    HText_appendCharacter(me->text, c);
+	}
+#endif /* REMOVE_CR_ONLY */
+    }
+}
+
+/*	Free an HTML object
+ *	-------------------
+ *
+ *	Note that the SGML parsing context is freed, but the created object is
+ *	not, as it takes on an existence of its own unless explicitly freed.
+ */
+static void HTPlain_free(HTStream *me)
+{
+    if (HTPlain_bs_pending >= 2)
+	HText_appendCharacter(me->text, '_');
+    FREE(me);
+}
+
+/*	End writing
+*/
+static void HTPlain_abort(HTStream *me, HTError e GCC_UNUSED)
+{
+    HTPlain_free(me);
+}
+
+/*		Structured Object Class
+ *		-----------------------
+ */
+static const HTStreamClass HTPlain =
+{
+    "PlainPresenter",
+    HTPlain_free,
+    HTPlain_abort,
+    HTPlain_put_character, HTPlain_put_string, HTPlain_write,
+};
+
+/*		New object
+ *		----------
+ */
+HTStream *HTPlainPresent(HTPresentation *pres GCC_UNUSED, HTParentAnchor *anchor,
+			 HTStream *sink GCC_UNUSED)
+{
+
+    HTStream *me = (HTStream *) malloc(sizeof(*me));
+
+    if (me == NULL)
+	outofmem(__FILE__, "HTPlain_new");
+
+    me->isa = &HTPlain;
+
+    HTPlain_lastraw = -1;
+
+    me->U.utf_count = 0;
+    me->U.utf_char = 0;
+    me->U.utf_buf[0] = me->U.utf_buf[6] = me->U.utf_buf[7] = '\0';
+    me->U.utf_buf_p = me->U.utf_buf;
+    me->outUCLYhndl = HTAnchor_getUCLYhndl(anchor, UCT_STAGE_HTEXT);
+    me->inUCLYhndl = HTAnchor_getUCLYhndl(anchor, UCT_STAGE_PARSER);
+    HTPlain_getChartransInfo(me, anchor);
+    UCSetTransParams(&me->T,
+		     me->inUCLYhndl, me->inUCI,
+		     me->outUCLYhndl,
+		     HTAnchor_getUCInfoStage(anchor, UCT_STAGE_HTEXT));
+
+    me->text = HText_new(anchor);
+    HText_setStyle(me->text, LYstyles(HTML_XMP));
+    HText_beginAppend(me->text);
+
+    return (HTStream *) me;
+}
diff --git a/WWW/Library/Implementation/HTPlain.h b/WWW/Library/Implementation/HTPlain.h
new file mode 100644
index 0000000..24fd669
--- /dev/null
+++ b/WWW/Library/Implementation/HTPlain.h
@@ -0,0 +1,21 @@
+/*                  /Net/dxcern/userd/timbl/hypertext/WWW/Library/Implementation/HTPlain.html
+                                    PLAIN TEXT OBJECT
+                                             
+ */
+#ifndef HTPLAIN_H
+#define HTPLAIN_H
+
+#include <HTStream.h>
+#include <HTAnchor.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern HTStream *HTPlainPresent(HTPresentation *pres,
+				    HTParentAnchor *anchor,
+				    HTStream *sink);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTPLAIN_H */
diff --git a/WWW/Library/Implementation/HTRules.c b/WWW/Library/Implementation/HTRules.c
new file mode 100644
index 0000000..91ac93d
--- /dev/null
+++ b/WWW/Library/Implementation/HTRules.c
@@ -0,0 +1,704 @@
+/*
+ * $LynxId: HTRules.c,v 1.47 2017/07/02 19:45:22 tom Exp $
+ *
+ *	Configuration manager for Hypertext Daemon		HTRules.c
+ *	==========================================
+ *
+ *
+ * History:
+ *	 3 Jun 91	Written TBL
+ *	10 Aug 91	Authorisation added after Daniel Martin (pass, fail)
+ *			Rule order in file changed
+ *			Comments allowed with # on 1st char of rule line
+ *	17 Jun 92	Bug fix: pass and fail failed if didn't contain '*' TBL
+ *	 1 Sep 93	Bug fix: no memory check - Nathan Torkington
+ *			BYTE_ADDRESSING removed - Arthur Secret
+ *	11 Sep 93  MD	Changed %i into %d in debug printf.
+ *			VMS does not recognize %i.
+ *			Bug Fix: in case of PASS, only one parameter to printf.
+ *	19 Sep 93  AL	Added Access Authorization stuff.
+ *	 1 Nov 93  AL	Added htbin.
+ *	25 May 99  KW	Added redirect for lynx.
+ *
+ */
+
+#include <HTUtils.h>
+
+/* (c) CERN WorldWideWeb project 1990,91. See Copyright.html for details */
+#include <HTRules.h>
+
+#include <HTFile.h>
+#include <LYLeaks.h>
+#include <HTAAProt.h>
+
+#define LINE_LENGTH 256
+
+typedef struct _rule {
+    struct _rule *next;
+    HTRuleOp op;
+    char *pattern;
+    char *equiv;
+    char *condition_op;		/* as strings - may be inefficient, */
+    char *condition;		/* but this is not for a server - kw */
+} rule;
+
+#ifndef NO_RULES
+
+#include <HTTP.h>		/* for redirecting_url, indirectly HTPermitRedir - kw */
+#include <LYGlobalDefs.h>	/* for LYUserSpecifiedURL - kw */
+#include <LYStrings.h>		/* for LYscanFloat */
+#include <LYUtils.h>		/* for LYFixCursesOn - kw */
+#include <HTAlert.h>
+
+/*	Global variables
+ *	----------------
+ */
+char *HTBinDir = NULL;		/* Physical /htbin directory path.      */
+
+				/* In future this should not be global. */
+char *HTSearchScript = NULL;	/* Search script name.          */
+
+/*	Module-wide variables
+ *	---------------------
+ */
+
+static rule *rules = 0;		/* Pointer to first on list */
+
+#ifndef PUT_ON_HEAD
+static rule *rule_tail = 0;	/* Pointer to last on list */
+#endif
+
+/*	Add rule to the list					HTAddRule()
+ *	--------------------
+ *
+ *  On entry,
+ *	pattern		points to 0-terminated string containing a single "*"
+ *	equiv		points to the equivalent string with * for the
+ *			place where the text matched by * goes.
+ *  On exit,
+ *	returns		0 if success, -1 if error.
+ */
+
+int HTAddRule(HTRuleOp op, const char *pattern,
+	      const char *equiv,
+	      const char *cond_op,
+	      const char *cond)
+{				/* BYTE_ADDRESSING removed and memory check - AS - 1 Sep 93 */
+    rule *temp;
+    char *pPattern = NULL;
+
+    temp = typecalloc(rule);
+    if (temp == NULL)
+	outofmem(__FILE__, "HTAddRule");
+
+    if (equiv) {		/* Two operands */
+	char *pEquiv = NULL;
+
+	StrAllocCopy(pEquiv, equiv);
+	temp->equiv = pEquiv;
+    } else {
+	temp->equiv = 0;
+    }
+    if (cond_op) {
+	StrAllocCopy(temp->condition_op, cond_op);
+	StrAllocCopy(temp->condition, cond);
+    }
+    StrAllocCopy(pPattern, pattern);
+    temp->pattern = pPattern;
+    temp->op = op;
+
+    if (equiv) {
+	CTRACE((tfp, "Rule: For `%s' op %d `%s'", pattern, (int) op, equiv));
+    } else {
+	CTRACE((tfp, "Rule: For `%s' op %d", pattern, (int) op));
+    }
+    if (cond_op) {
+	CTRACE((tfp, "\t%s %s\n", cond_op, NONNULL(cond)));
+    } else {
+	CTRACE((tfp, "\n"));
+    }
+
+    if (!rules) {
+#ifdef LY_FIND_LEAKS
+	atexit(HTClearRules);
+#endif
+    }
+#ifdef PUT_ON_HEAD
+    temp->next = rules;
+    rules = temp;
+#else
+    temp->next = 0;
+    if (rule_tail)
+	rule_tail->next = temp;
+    else
+	rules = temp;
+    rule_tail = temp;
+#endif
+
+    return 0;
+}
+
+/*	Clear all rules						HTClearRules()
+ *	---------------
+ *
+ * On exit,
+ *	There are no rules
+ *
+ * See also
+ *	HTAddRule()
+ */
+void HTClearRules(void)
+{
+    while (rules) {
+	rule *temp = rules;
+
+	rules = temp->next;
+	FREE(temp->pattern);
+	FREE(temp->equiv);
+	FREE(temp->condition_op);
+	FREE(temp->condition);
+	FREE(temp);
+    }
+#ifndef PUT_ON_HEAD
+    rule_tail = 0;
+#endif
+}
+
+static BOOL rule_cond_ok(rule * r)
+{
+    BOOL result;
+
+    if (!r->condition_op)
+	return YES;
+    if (strcmp(r->condition_op, "if") && strcmp(r->condition_op, "unless")) {
+	CTRACE((tfp, "....... rule ignored, unrecognized `%s'!\n",
+		r->condition_op));
+	return NO;
+    }
+    if (!strcmp(r->condition, "redirected"))
+	result = (BOOL) (redirection_attempts > 0);
+    else if (!strcmp(r->condition, "userspec"))
+	result = LYUserSpecifiedURL;
+    else {
+	CTRACE((tfp, "....... rule ignored, unrecognized `%s %s'!\n",
+		r->condition_op, NONNULL(r->condition)));
+	return NO;
+    }
+    if (!strcmp(r->condition_op, "if"))
+	return result;
+    else
+	return (BOOL) (!result);
+
+}
+
+/*	Translate by rules					HTTranslate()
+ *	------------------
+ *
+ *	The most recently defined rules are applied first.
+ *
+ * On entry,
+ *	required	points to a string whose equivalent value is needed
+ * On exit,
+ *	returns		the address of the equivalent string allocated from
+ *			the heap which the CALLER MUST FREE. If no translation
+ *			occurred, then it is a copy of the original.
+ * NEW FEATURES:
+ *			When a "protect" or "defprot" rule is matched,
+ *			a call to HTAA_setCurrentProtection() or
+ *			HTAA_setDefaultProtection() is made to notify
+ *			the Access Authorization module that the file is
+ *			protected, and so it knows how to handle it.
+ *								-- AL
+ */
+char *HTTranslate(const char *required)
+{
+    rule *r;
+    char *current = NULL;
+    char *msgtmp = NULL;
+    const char *pMsg;
+    int proxy_none_flag = 0;
+    int permitredir_flag = 0;
+
+    StrAllocCopy(current, required);
+
+    HTAA_clearProtections();	/* Reset from previous call -- AL */
+
+    for (r = rules; r; r = r->next) {
+	char *p = r->pattern;
+	int m = 0;		/* Number of characters matched against wildcard */
+	const char *q = current;
+
+	for (; *p && *q; p++, q++) {	/* Find first mismatch */
+	    if (*p != *q)
+		break;
+	}
+
+	if (*p == '*') {	/* Match up to wildcard */
+	    m = (int) strlen(q) - (int) strlen(p + 1);	/* Amount to match to wildcard */
+	    if (m < 0)
+		continue;	/* tail is too short to match */
+	    if (0 != strcmp(q + m, p + 1))
+		continue;	/* Tail mismatch */
+	} else
+	    /* Not wildcard */ if (*p != *q)
+	    continue;		/* plain mismatch: go to next rule */
+
+	if (!rule_cond_ok(r))	/* check condition, next rule if false - kw */
+	    continue;
+
+	switch (r->op) {	/* Perform operation */
+
+	case HT_DefProt:
+	case HT_Protect:
+#ifdef ACCESS_AUTH
+	    {
+		char *local_copy = NULL;
+		char *p2;
+		char *eff_ids = NULL;
+		char *prot_file = NULL;
+
+		CTRACE((tfp, "HTRule: `%s' matched %s %s: `%s'\n",
+			current,
+			(r->op == HT_Protect ? "Protect" : "DefProt"),
+			"rule, setup",
+			(r->equiv ? r->equiv :
+			 (r->op == HT_Protect ? "DEFAULT" : "NULL!!"))));
+
+		if (r->equiv) {
+		    StrAllocCopy(local_copy, r->equiv);
+		    p2 = local_copy;
+		    prot_file = HTNextField(&p2);
+		    eff_ids = HTNextField(&p2);
+		}
+
+		if (r->op == HT_Protect)
+		    HTAA_setCurrentProtection(current, prot_file, eff_ids);
+		else
+		    HTAA_setDefaultProtection(current, prot_file, eff_ids);
+
+		FREE(local_copy);
+
+		/* continue translating rules */
+	    }
+#endif /* ACCESS_AUTH */
+	    break;
+
+	case HT_UserMsg:	/* Produce message immediately */
+	    LYFixCursesOn("show rule message:");
+	    HTUserMsg2((r->equiv ? r->equiv : "Rule: %s"), current);
+	    break;
+	case HT_InfoMsg:	/* Produce messages immediately */
+	case HT_Progress:
+	case HT_Alert:
+	    LYFixCursesOn("show rule message:");	/* and fall through */
+	    /* FALLTHRU */
+	case HT_AlwaysAlert:
+	    pMsg = r->equiv ? r->equiv :
+		(r->op == HT_AlwaysAlert) ? "%s" : "Rule: %s";
+	    if (StrChr(pMsg, '%')) {
+		HTSprintf0(&msgtmp, pMsg, current);
+		pMsg = msgtmp;
+	    }
+	    switch (r->op) {	/* Actually produce message */
+	    case HT_InfoMsg:
+		HTInfoMsg(pMsg);
+		break;
+	    case HT_Progress:
+		HTProgress(pMsg);
+		break;
+	    case HT_Alert:
+		HTAlert(pMsg);
+		break;
+	    case HT_AlwaysAlert:
+		HTAlwaysAlert("Rule alert:", pMsg);
+		break;
+	    default:
+		break;
+	    }
+	    FREE(msgtmp);
+	    break;
+
+	case HT_PermitRedir:	/* Set special flag */
+	    permitredir_flag = 1;
+	    CTRACE((tfp, "HTRule: Mark for redirection permitted\n"));
+	    break;
+
+	case HT_Pass:		/* Authorised */
+	    if (!r->equiv) {
+		if (proxy_none_flag) {
+		    char *temp = NULL;
+
+		    StrAllocCopy(temp, "NoProxy=");
+		    StrAllocCat(temp, current);
+		    FREE(current);
+		    current = temp;
+		}
+		CTRACE((tfp, "HTRule: Pass `%s'\n", current));
+		return current;
+	    }
+	    /* FALLTHRU */
+
+	case HT_Map:
+	case HT_Redirect:
+	case HT_RedirectPerm:
+	    if (*p == *q) {	/* End of both strings, no wildcard */
+		CTRACE((tfp, "For `%s' using `%s'\n", current, r->equiv));
+		StrAllocCopy(current, r->equiv);	/* use entire translation */
+	    } else {
+		char *ins = StrChr(r->equiv, '*');	/* Insertion point */
+
+		if (ins) {	/* Consistent rule!!! */
+		    char *temp = NULL;
+
+		    HTSprintf0(&temp, "%.*s%.*s%s",
+			       (int) (ins - r->equiv),
+			       r->equiv,
+			       m,
+			       q,
+			       ins + 1);
+		    CTRACE((tfp, "For `%s' using `%s'\n",
+			    current, temp));
+		    FREE(current);
+		    current = temp;	/* Use this */
+
+		} else {	/* No insertion point */
+		    char *temp = NULL;
+
+		    StrAllocCopy(temp, r->equiv);
+		    CTRACE((tfp, "For `%s' using `%s'\n",
+			    current, temp));
+		    FREE(current);
+		    current = temp;	/* Use this */
+		}		/* If no insertion point exists */
+	    }
+	    if (r->op == HT_Pass) {
+		if (proxy_none_flag) {
+		    char *temp = NULL;
+
+		    StrAllocCopy(temp, "NoProxy=");
+		    StrAllocCat(temp, current);
+		    FREE(current);
+		    current = temp;
+		}
+		CTRACE((tfp, "HTRule: ...and pass `%s'\n",
+			current));
+		return current;
+	    } else if (r->op == HT_Redirect) {
+		CTRACE((tfp, "HTRule: ...and redirect to `%s'\n",
+			current));
+		redirecting_url = current;
+		HTPermitRedir = (BOOL) (permitredir_flag == 1);
+		return (char *) 0;
+	    } else if (r->op == HT_RedirectPerm) {
+		CTRACE((tfp, "HTRule: ...and redirect like 301 to `%s'\n",
+			current));
+		redirecting_url = current;
+		permanent_redirection = TRUE;
+		HTPermitRedir = (BOOL) (permitredir_flag == 1);
+		return (char *) 0;
+	    }
+	    break;
+
+	case HT_UseProxy:
+	    if (r->equiv && 0 == strcasecomp(r->equiv, "none")) {
+		CTRACE((tfp, "For `%s' will not use proxy\n", current));
+		proxy_none_flag = 1;
+	    } else if (proxy_none_flag) {
+		CTRACE((tfp, "For `%s' proxy server ignored: %s\n",
+			current,
+			NONNULL(r->equiv)));
+	    } else {
+		char *temp = NULL;
+
+		StrAllocCopy(temp, "Proxied=");
+		StrAllocCat(temp, r->equiv);
+		StrAllocCat(temp, current);
+		CTRACE((tfp, "HTRule: proxy server found: %s\n",
+			NONNULL(r->equiv)));
+		FREE(current);
+		return temp;
+	    }
+	    break;
+
+	case HT_Invalid:
+	case HT_Fail:		/* Unauthorised */
+	    CTRACE((tfp, "HTRule: *** FAIL `%s'\n", current));
+	    FREE(current);
+	    return (char *) 0;
+	}			/* if tail matches ... switch operation */
+
+    }				/* loop over rules */
+
+    if (proxy_none_flag) {
+	char *temp = NULL;
+
+	StrAllocCopy(temp, "NoProxy=");
+	StrAllocCat(temp, current);
+	FREE(current);
+	return temp;
+    }
+
+    return current;
+}
+
+/*	Load one line of configuration
+ *	------------------------------
+ *
+ *	Call this, for example, to load a X resource with config info.
+ *
+ * returns	0 OK, < 0 syntax error.
+ */
+int HTSetConfiguration(char *config)
+{
+    HTRuleOp op;
+    char *line = NULL;
+    char *pointer = NULL;
+    char *word1;
+    const char *word2;
+    const char *word3;
+    const char *cond_op = NULL;
+    const char *cond = NULL;
+    float quality, secs, secs_per_byte;
+    long maxbytes;
+    int status;
+
+    StrAllocCopy(line, config);
+    if (line != NULL) {
+	char *p = line;
+
+	/* Chop off comments */
+	while ((p = StrChr(p, '#'))) {
+	    if (p == line || isspace(UCH(*(p - 1)))) {
+		*p = 0;
+		break;
+	    } else {
+		p++;
+	    }
+	}
+    }
+    pointer = line;
+    word1 = HTNextField(&pointer);
+    if (!word1) {
+	FREE(line);
+	return 0;
+    };				/* Comment only or blank */
+
+    word2 = HTNextField(&pointer);
+
+    if (0 == strcasecomp(word1, "defprot") ||
+	0 == strcasecomp(word1, "protect"))
+	word3 = pointer;	/* The rest of the line to be parsed by AA module */
+    else
+	word3 = HTNextField(&pointer);	/* Just the next word */
+
+    if (!word2) {
+	fprintf(stderr, "HTRule: %s %s\n", RULE_NEEDS_DATA, line);
+	FREE(line);
+	return -2;		/*syntax error */
+    }
+
+    if (0 == strcasecomp(word1, "suffix")) {
+	char *encoding = HTNextField(&pointer);
+
+	status = 0;
+	if (pointer)
+	    status = LYscanFloat(pointer, &quality);
+
+	HTSetSuffix(word2, word3,
+		    encoding ? encoding : "binary",
+		    status >= 1 ? quality : (float) 1.0);
+
+    } else if (0 == strcasecomp(word1, "presentation")) {
+	status = 0;
+	if (pointer) {
+	    const char *temp = pointer;
+
+	    if (LYscanFloat2(&temp, &quality)) {
+		status = 1;
+		if (LYscanFloat2(&temp, &secs)) {
+		    status = 2;
+		    if (LYscanFloat2(&temp, &secs_per_byte)) {
+			status = 3;
+			if (sscanf(temp, "%ld", &maxbytes)) {
+			    status = 4;
+			}
+		    }
+		}
+	    }
+	}
+
+	HTSetPresentation(word2, word3, NULL,
+			  status >= 1 ? quality : 1.0,
+			  status >= 2 ? secs : 0.0,
+			  status >= 3 ? secs_per_byte : 0.0,
+			  status >= 4 ? maxbytes : 0,
+			  mediaCFG);
+
+    } else if (0 == strncasecomp(word1, "htbin", 5) ||
+	       0 == strncasecomp(word1, "bindir", 6)) {
+	StrAllocCopy(HTBinDir, word2);	/* Physical /htbin location */
+
+    } else if (0 == strncasecomp(word1, "search", 6)) {
+	StrAllocCopy(HTSearchScript, word2);	/* Search script name */
+
+    } else {
+	op = 0 == strcasecomp(word1, "map") ? HT_Map
+	    : 0 == strcasecomp(word1, "pass") ? HT_Pass
+	    : 0 == strcasecomp(word1, "fail") ? HT_Fail
+	    : 0 == strcasecomp(word1, "redirect") ? HT_Redirect
+	    : 0 == strncasecomp(word1, "redirectperm", 12) ? HT_RedirectPerm
+	    : 0 == strcasecomp(word1, "redirecttemp") ? HT_Redirect
+	    : 0 == strcasecomp(word1, "permitredirection") ? HT_PermitRedir
+	    : 0 == strcasecomp(word1, "useproxy") ? HT_UseProxy
+	    : 0 == strcasecomp(word1, "alert") ? HT_Alert
+	    : 0 == strcasecomp(word1, "alwaysalert") ? HT_AlwaysAlert
+	    : 0 == strcasecomp(word1, "progress") ? HT_Progress
+	    : 0 == strcasecomp(word1, "usermsg") ? HT_UserMsg
+	    : 0 == strcasecomp(word1, "infomsg") ? HT_InfoMsg
+	    : 0 == strcasecomp(word1, "defprot") ? HT_DefProt
+	    : 0 == strcasecomp(word1, "protect") ? HT_Protect
+	    : HT_Invalid;
+	if (op == HT_Invalid) {
+	    fprintf(stderr, "HTRule: %s '%s'\n", RULE_INCORRECT, config);
+	} else {
+	    switch (op) {
+	    case HT_Fail:	/* never a or other 2nd parameter */
+	    case HT_PermitRedir:
+		cond_op = word3;
+		if (cond_op && *cond_op) {
+		    word3 = NULL;
+		    cond = HTNextField(&pointer);
+		}
+		break;
+
+	    case HT_Pass:	/* possibly a URL2 */
+		if (word3 && (!strcasecomp(word3, "if") ||
+			      !strcasecomp(word3, "unless"))) {
+		    cond_op = word3;
+		    word3 = NULL;
+		    cond = HTNextField(&pointer);
+		    break;
+		}
+		/* else fall through */
+	    case HT_Map:	/* always a URL2 (or other 2nd parameter) */
+	    case HT_Redirect:
+	    case HT_RedirectPerm:
+	    case HT_UseProxy:
+		cond_op = HTNextField(&pointer);
+		/* check for extra status word in "Redirect" */
+		if (op == HT_Redirect && 0 == strcasecomp(word1, "redirect") &&
+		    cond_op &&
+		    strcasecomp(cond_op, "if") &&
+		    strcasecomp(cond_op, "unless")) {
+		    if (0 == strcmp(word2, "301") ||
+			0 == strcasecomp(word2, "permanent")) {
+			op = HT_RedirectPerm;
+		    } else if (!(0 == strcmp(word2, "302") ||
+				 0 == strcmp(word2, "303") ||
+				 0 == strcasecomp(word2, "temp") ||
+				 0 == strcasecomp(word2, "seeother"))) {
+			CTRACE((tfp, "Rule: Ignoring `%s' in Redirect\n", word2));
+		    }
+		    word2 = word3;
+		    word3 = cond_op;	/* cond_op isn't condition op after all */
+		    cond_op = HTNextField(&pointer);
+		}
+		if (cond_op && *cond_op)
+		    cond = HTNextField(&pointer);
+		break;
+
+	    case HT_Progress:
+	    case HT_InfoMsg:
+	    case HT_UserMsg:
+	    case HT_Alert:
+	    case HT_AlwaysAlert:
+		cond_op = HTNextField(&pointer);
+		if (cond_op && *cond_op)
+		    cond = HTNextField(&pointer);
+		if (word3) {	/* Fix string with too may %s - kw */
+		    const char *cp = word3;
+		    char *cp1, *cp2;
+
+		    while ((cp1 = StrChr(cp, '%'))) {
+			if (cp1[1] == '\0') {
+			    *cp1 = '\0';
+			    break;
+			} else if (cp1[1] == '%') {
+			    cp = cp1 + 2;
+			    continue;
+			} else
+			    while ((cp2 = StrChr(cp1 + 2, '%'))) {
+				if (cp2[1] == '\0') {
+				    *cp2 = '\0';
+				    break;
+				} else if (cp2[1] == '%') {
+				    cp1 = cp2;
+				} else {
+				    *cp2 = '?';		/* replace bad % */
+				    cp1 = cp2;
+				}
+			    }
+			break;
+		    }
+		}
+		break;
+
+	    default:
+		break;
+	    }
+	    if (cond_op && cond && *cond && !strcasecomp(cond_op, "unless")) {
+		cond_op = "unless";
+	    } else if (cond_op && cond && *cond &&
+		       !strcasecomp(cond_op, "if")) {
+		cond_op = "if";
+	    } else if (cond_op || cond) {
+		fprintf(stderr, "HTRule: %s '%s'\n", RULE_INCORRECT, config);
+		FREE(line);	/* syntax error, condition is a mess - kw */
+		return -2;	/* NB unrecognized cond passes here - kw */
+	    }
+	    if (cond && !strncasecomp(cond, "redirected", (int) strlen(cond))) {
+		cond = "redirected";	/* recognized, canonical case - kw */
+	    } else if (cond && strlen(cond) >= 8 &&
+		       !strncasecomp(cond, "userspecified", (int) strlen(cond))) {
+		cond = "userspec";	/* also allow abbreviation - kw */
+	    }
+	    HTAddRule(op, word2, word3, cond_op, cond);
+	}
+    }
+    FREE(line);
+    return 0;
+}
+
+/*	Load the rules from a file				HTLoadRules()
+ *	--------------------------
+ *
+ * On entry,
+ *	Rules can be in any state
+ * On exit,
+ *	Any existing rules will have been kept.
+ *	Any new rules will have been loaded.
+ *	Returns		0 if no error, 0 if error!
+ *
+ * Bugs:
+ *	The strings may not contain spaces.
+ */
+
+int HTLoadRules(const char *filename)
+{
+    FILE *fp = fopen(filename, TXT_R);
+    char line[LINE_LENGTH + 1];
+
+    if (!fp) {
+	CTRACE((tfp, "HTRules: Can't open rules file %s\n", filename));
+	return -1;		/* File open error */
+    }
+    for (;;) {
+	if (!fgets(line, LINE_LENGTH + 1, fp))
+	    break;		/* EOF or error */
+	(void) HTSetConfiguration(line);
+    }
+    fclose(fp);
+    return 0;			/* No error or syntax errors ignored */
+}
+
+#endif /* NO_RULES */
diff --git a/WWW/Library/Implementation/HTRules.h b/WWW/Library/Implementation/HTRules.h
new file mode 100644
index 0000000..9bb8593
--- /dev/null
+++ b/WWW/Library/Implementation/HTRules.h
@@ -0,0 +1,169 @@
+/*                                             Configuration Manager for libwww
+ *                            CONFIGURATION MANAGER
+ *
+ * Author Tim Berners-Lee/CERN.  Public domain.  Please mail changes to
+ * timbl@info.cern.ch.
+ *
+ * The configuration information loaded includes tables (file suffixes,
+ * presentation methods) in other modules.  The most likely routines needed by
+ * developers will be:
+ *
+ * HTSetConfiguration	to load configuration information.
+ *
+ * HTLoadRules		to load a whole file of configuration information
+ *
+ * HTTranslate		to translate a URL using the rule table.
+ *
+ */
+#ifndef HTRULE_H
+#define HTRULE_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef enum {
+	HT_Invalid,
+	HT_Map,
+	HT_Pass,
+	HT_Fail,
+	HT_DefProt,
+	HT_Protect,
+	HT_Progress,
+	HT_InfoMsg,
+	HT_UserMsg,
+	HT_Alert,
+	HT_AlwaysAlert,
+	HT_Redirect,
+	HT_RedirectPerm,
+	HT_PermitRedir,
+	HT_UseProxy
+    } HTRuleOp;
+
+#ifndef NO_RULES
+
+/*
+
+Server Side Script Execution
+
+   If a URL starts with /htbin/ it is understood to mean a script execution request on
+   server.  This feature needs to be turned on by setting HTBinDir by the htbin rule.
+   Index searching is enabled by setting HTSearchScript into the name of script in BinDir
+   doing the actual search by search rule (BinDir must also be set in this case, of
+   course).
+
+ */
+
+    extern char *HTBinDir;	/* Physical /htbin location */
+    extern char *HTSearchScript;	/* Search script name */
+
+/*
+
+HTAddRule:  Add rule to the list
+
+  ON ENTRY,
+
+  pattern                points to 0-terminated string containing a single "*"
+
+  equiv                  points to the equivalent string with * for the place where the
+                         text matched by * goes; or to other 2nd parameter
+                         meaning depends on op).			 
+
+  cond_op,               additional condition for applying rule; cond_op should
+  cond                   be either NULL (no additional condition), or one of
+                         the strings "if" or "unless"; if cond_op is not NULL,
+                         cond should point to a recognized condition keyword
+                         (as a string) such as "userspec", "redirected".
+
+  ON EXIT,
+
+  returns                0 if success, -1 if error.
+
+   Note that if BYTE_ADDRESSING is set, the three blocks required are allocated and
+   deallocated as one.  This will save time and storage, when malloc's allocation units are
+   large.
+
+ */
+    extern int HTAddRule(HTRuleOp op, const char *pattern,
+			 const char *equiv,
+			 const char *cond_op,
+			 const char *cond);
+
+/*
+
+HTClearRules: Clear all rules
+
+  ON EXIT,
+
+  Rule file               There are no rules
+
+ */
+
+    extern void HTClearRules(void);
+
+/*
+
+HTTranslate: Translate by rules
+
+ */
+
+/*
+
+  ON ENTRY,
+
+  required                points to a string whose equivalent value is needed
+
+  ON EXIT,
+
+  returns                 the address of the equivalent string allocated from the heap
+                         which the CALLER MUST FREE. If no translation occurred, then it is
+                         a copy of the original.
+
+ */
+    extern char *HTTranslate(const char *required);
+
+/*
+
+HTSetConfiguration:  Load one line of configuration information
+
+  ON ENTRY,
+
+  config                  is a string in the syntax of a rule file line.
+
+   This routine may be used for loading configuration information from sources other than
+   the  rule file, for example INI files for X resources.
+
+ */
+    extern int HTSetConfiguration(char *config);
+
+/*
+
+HtLoadRules:  Load the rules from a file
+
+  ON ENTRY,
+
+  Rule table              Rules can be in any state
+
+  ON EXIT,
+
+  Rule table              Any existing rules will have been kept.  Any new rules will have
+                         been loaded on top, so as to be tried first.
+
+  Returns                 0 if no error.
+
+ */
+
+    extern int HTLoadRules(const char *filename);
+
+/*
+
+ */
+
+#endif				/* NO_RULES */
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTRULE_H */
diff --git a/WWW/Library/Implementation/HTStream.h b/WWW/Library/Implementation/HTStream.h
new file mode 100644
index 0000000..a753266
--- /dev/null
+++ b/WWW/Library/Implementation/HTStream.h
@@ -0,0 +1,69 @@
+/*
+ * $LynxId: HTStream.h,v 1.16 2011/06/11 12:08:40 tom Exp $
+ *
+ *                                                      The Stream class definition -- libwww
+                                 STREAM OBJECT DEFINITION
+
+   A Stream object is something which accepts a stream of text.
+
+   The creation methods will vary on the type of Stream Object.  All creation
+   methods return a pointer to the stream type below.
+
+   As you can see, but the methods used to write to the stream and close it are
+   pointed to be the object itself.
+
+ */
+#ifndef HTSTREAM_H
+#define HTSTREAM_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    typedef struct _HTStream HTStream;
+
+/*
+
+   These are the common methods of all streams.  They should be
+   self-explanatory.
+
+ */
+    typedef struct _HTStreamClass {
+
+	const char *name;	/* Just for diagnostics */
+
+	void (*_free) (HTStream *me);
+
+	void (*_abort) (HTStream *me, HTError e);
+
+	void (*put_character) (HTStream *me, int ch);
+
+	void (*put_string) (HTStream *me, const char *str);
+
+	void (*put_block) (HTStream *me, const char *str, int len);
+
+    } HTStreamClass;
+
+#ifndef HTSTREAM_INTERNAL
+    struct _HTStream {
+	HTStreamClass *isa;
+    };
+#endif
+/*
+
+  Generic Error Stream
+
+   The Error stream simply signals an error on all output methods.
+   This can be used to stop a stream as soon as data arrives, for
+   example from the network.
+
+ */
+    extern HTStream *HTErrorStream(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTSTREAM_H */
diff --git a/WWW/Library/Implementation/HTString.c b/WWW/Library/Implementation/HTString.c
new file mode 100644
index 0000000..3cb8358
--- /dev/null
+++ b/WWW/Library/Implementation/HTString.c
@@ -0,0 +1,1464 @@
+/*
+ * $LynxId: HTString.c,v 1.82 2022/03/12 12:19:10 Gisle.Vanem Exp $
+ *
+ *	Case-independent string comparison		HTString.c
+ *
+ *	Original version came with listserv implementation.
+ *	Version TBL Oct 91 replaces one which modified the strings.
+ *	02-Dec-91 (JFG) Added stralloccopy and stralloccat
+ *	23 Jan 92 (TBL) Changed strallocc* to 8 char HTSAC* for VM and suchlike
+ *	 6 Oct 92 (TBL) Moved WWW_TraceFlag in here to be in library
+ *	15 Nov 98 (TD)  Added HTSprintf.
+ */
+
+#include <HTUtils.h>
+#include <HTFile.h>
+
+#include <LYLeaks.h>
+#include <LYUtils.h>
+#include <LYStrings.h>
+
+#ifdef USE_IGNORE_RC
+int ignore_unused;
+#endif
+
+#ifndef NO_LYNX_TRACE
+BOOLEAN WWW_TraceFlag = 0;	/* Global trace flag for ALL W3 code */
+int WWW_TraceMask = 0;		/* Global trace flag for ALL W3 code */
+#endif
+
+#ifdef _WINDOWS
+#undef VC
+#define VC "2.14FM"
+#endif
+
+#ifndef VC
+#define VC "2.14"
+#endif /* !VC */
+
+const char *HTLibraryVersion = VC;	/* String for help screen etc */
+
+/*
+ *     strcasecomp8 is a variant of strcasecomp (below)
+ *     ------------		    -----------
+ *     but uses 8bit upper/lower case information
+ *     from the current display charset.
+ *     It returns 0 if exact match.
+ */
+int strcasecomp8(const char *a,
+		 const char *b)
+{
+    const char *p = a;
+    const char *q = b;
+
+    for (; *p && *q; p++, q++) {
+	int diff = UPPER8(*p, *q);
+
+	if (diff)
+	    return diff;
+    }
+    if (*p)
+	return 1;		/* p was longer than q */
+    if (*q)
+	return -1;		/* p was shorter than q */
+    return 0;			/* Exact match */
+}
+
+/*
+ *     strncasecomp8 is a variant of strncasecomp (below)
+ *     -------------		     ------------
+ *     but uses 8bit upper/lower case information
+ *     from the current display charset.
+ *     It returns 0 if exact match.
+ */
+int strncasecomp8(const char *a,
+		  const char *b,
+		  int n)
+{
+    const char *p = a;
+    const char *q = b;
+
+    for (;; p++, q++) {
+	int diff;
+
+	if (p == (a + n))
+	    return 0;		/*   Match up to n characters */
+	if (!(*p && *q))
+	    return (*p - *q);
+	diff = UPPER8(*p, *q);
+	if (diff)
+	    return diff;
+    }
+    /*NOTREACHED */
+}
+
+#ifndef VM			/* VM has these already it seems */
+/*	Strings of any length
+ *	---------------------
+ */
+int strcasecomp(const char *a,
+		const char *b)
+{
+    const char *p = a;
+    const char *q = b;
+
+    for (; *p && *q; p++, q++) {
+	int diff = TOLOWER(*p) - TOLOWER(*q);
+
+	if (diff)
+	    return diff;
+    }
+    if (*p)
+	return 1;		/* p was longer than q */
+    if (*q)
+	return -1;		/* p was shorter than q */
+    return 0;			/* Exact match */
+}
+
+/*	With count limit
+ *	----------------
+ */
+int strncasecomp(const char *a,
+		 const char *b,
+		 int n)
+{
+    const char *p = a;
+    const char *q = b;
+
+    for (;; p++, q++) {
+	int diff;
+
+	if (p == (a + n))
+	    return 0;		/*   Match up to n characters */
+	if (!(*p && *q))
+	    return (*p - *q);
+	diff = TOLOWER(*p) - TOLOWER(*q);
+	if (diff)
+	    return diff;
+    }
+    /*NOTREACHED */
+}
+#endif /* VM */
+
+#define end_component(p) (*(p) == '.' || *(p) == '\0')
+
+#ifdef DEBUG_ASTERISK
+#define SHOW_ASTERISK CTRACE
+#else
+#define SHOW_ASTERISK(p)	/* nothing */
+#endif
+
+#define SHOW_ASTERISK_NUM(a,b,c)  \
+	SHOW_ASTERISK((tfp, "test @%d, '%s' vs '%s' (%d)\n", __LINE__, a,b,c))
+
+#define SHOW_ASTERISK_TXT(a,b,c)  \
+	SHOW_ASTERISK((tfp, "test @%d, '%s' vs '%s' %s\n", __LINE__, a,b,c))
+
+/*
+ * Compare names as described in RFC 2818: ignore case, allow wildcards. 
+ * Return zero on a match, nonzero on mismatch -TD
+ *
+ * From RFC 2818:
+ * Names may contain the wildcard character * which is considered to match any
+ * single domain name component or component fragment.  E.g., *.a.com matches
+ * foo.a.com but not bar.foo.a.com.  f*.com matches foo.com but not bar.com.
+ */
+int strcasecomp_asterisk(const char *a, const char *b)
+{
+    const char *p;
+    int result = 0;
+    int done = FALSE;
+
+    while (!result && !done) {
+	SHOW_ASTERISK_TXT(a, b, "main");
+	if (*a == '*') {
+	    p = b;
+	    for (;;) {
+		SHOW_ASTERISK_TXT(a, p, "loop");
+		if (end_component(p)) {
+		    if (end_component(a + 1)) {
+			b = p - 1;
+			result = 0;
+		    } else {
+			result = 1;
+		    }
+		    break;
+		} else if (strcasecomp_asterisk(a + 1, p)) {
+		    ++p;
+		} else {
+		    b = p - 1;
+		    result = 0;	/* found a match starting at 'p' */
+		    done = TRUE;
+		    break;
+		}
+	    }
+	    SHOW_ASTERISK_NUM(a, b, result);
+	} else if (*b == '*') {
+	    result = strcasecomp_asterisk(b, a);
+	    SHOW_ASTERISK_NUM(a, b, result);
+	    done = (result == 0);
+	} else if (*a == '\0' || *b == '\0') {
+	    result = (*a != *b);
+	    SHOW_ASTERISK_NUM(a, b, result);
+	    break;
+	} else if (TOLOWER(UCH(*a)) != TOLOWER(UCH(*b))) {
+	    result = 1;
+	    SHOW_ASTERISK_NUM(a, b, result);
+	    break;
+	}
+	++a;
+	++b;
+    }
+    return result;
+}
+
+#ifdef DEBUG_ASTERISK
+void mismatch_asterisk(void)
+{
+    /* *INDENT-OFF* */
+    static struct {
+	const char *a;
+	const char *b;
+	int	    code;
+    } table[] = {
+	{ "foo.bar",	 "*.*",	      0 },
+	{ "foo.bar",	 "*.b*",      0 },
+	{ "foo.bar",	 "*.ba*",     0 },
+	{ "foo.bar",	 "*.bar*",    0 },
+	{ "foo.bar",	 "*.*bar*",   0 },
+	{ "foo.bar",	 "*.*.",      1 },
+	{ "foo.bar",	 "fo*.b*",    0 },
+	{ "*oo.bar",	 "fo*.b*",    0 },
+	{ "*oo.bar.com", "fo*.b*",    1 },
+	{ "*oo.bar.com", "fo*.b*m",   1 },
+	{ "*oo.bar.com", "fo*.b*.c*", 0 },
+    };
+    /* *INDENT-ON* */
+
+    unsigned n;
+    int code;
+
+    CTRACE((tfp, "mismatch_asterisk testing\n"));
+    for (n = 0; n < TABLESIZE(table); ++n) {
+	CTRACE((tfp, "-------%d\n", n));
+	code = strcasecomp_asterisk(table[n].a, table[n].b);
+	if (code != table[n].code) {
+	    CTRACE((tfp, "mismatch_asterisk '%s' '%s' got %d, want %d\n",
+		    table[n].a, table[n].b, code, table[n].code));
+	}
+    }
+}
+#endif
+
+#ifdef NOT_ASCII
+
+/*	Case-insensitive with ASCII collating sequence
+ *	----------------
+ */
+int AS_casecomp(const char *p,
+		const char *q)
+{
+    int diff;
+
+    for (;; p++, q++) {
+	if (!(*p && *q))
+	    return (UCH(*p) - UCH(*q));
+	diff = TOASCII(TOLOWER(*p))
+	    - TOASCII(TOLOWER(*q));
+	if (diff)
+	    return diff;
+    }
+    /*NOTREACHED */
+}
+
+/*	With count limit and ASCII collating sequence
+ *	----------------
+ *	AS_cmp uses n == -1 to compare indefinite length.
+ */
+int AS_ncmp(const char *p,
+	    const char *q,
+	    unsigned int n)
+{
+    const char *a = p;
+    int diff;
+
+    for (; (unsigned) (p - a) < n; p++, q++) {
+	if (!(*p && *q))
+	    return (UCH(*p) - UCH(*q));
+	diff = TOASCII(*p)
+	    - TOASCII(*q);
+	if (diff)
+	    return diff;
+    }
+    return 0;			/*   Match up to n characters */
+}
+#endif /* NOT_ASCII */
+
+/*	Allocate a new copy of a string, and returns it
+*/
+char *HTSACopy(char **dest,
+	       const char *src)
+{
+    if (src != 0) {
+	if (src != *dest) {
+	    size_t size = strlen(src) + 1;
+
+	    FREE(*dest);
+	    *dest = (char *) malloc(size);
+	    if (*dest == NULL)
+		outofmem(__FILE__, "HTSACopy");
+	    MemCpy(*dest, src, size);
+	}
+    } else {
+	FREE(*dest);
+    }
+    return *dest;
+}
+
+/*	String Allocate and Concatenate
+*/
+char *HTSACat(char **dest,
+	      const char *src)
+{
+    if (src && *src && (src != *dest)) {
+	if (*dest) {
+	    size_t length = strlen(*dest);
+
+	    *dest = (char *) realloc(*dest, length + strlen(src) + 1);
+	    if (*dest == NULL)
+		outofmem(__FILE__, "HTSACat");
+	    strcpy(*dest + length, src);
+	} else {
+	    *dest = (char *) malloc(strlen(src) + 1);
+	    if (*dest == NULL)
+		outofmem(__FILE__, "HTSACat");
+	    strcpy(*dest, src);
+	}
+    }
+    return *dest;
+}
+
+/* optimized for heavily realloc'd strings, store length inside */
+
+#define EXTRA_TYPE size_t	/* type we use for length */
+#define EXTRA_SIZE sizeof(void *)	/* alignment >= sizeof(EXTRA_TYPE) */
+
+void HTSAFree_extra(char *s)
+{
+    free(s - EXTRA_SIZE);
+}
+
+/* never shrink */
+char *HTSACopy_extra(char **dest,
+		     const char *src)
+{
+    if (src != 0) {
+	size_t srcsize = strlen(src) + 1;
+	EXTRA_TYPE size = 0;
+
+	if (*dest != 0) {
+	    size = *(EXTRA_TYPE *) (void *) ((*dest) - EXTRA_SIZE);
+	}
+	if ((*dest == 0) || (size < srcsize)) {
+	    FREE_extra(*dest);
+	    size = srcsize * 2;	/* x2 step */
+	    *dest = (char *) malloc(size + EXTRA_SIZE);
+	    if (*dest == NULL)
+		outofmem(__FILE__, "HTSACopy_extra");
+	    *(EXTRA_TYPE *) (void *) (*dest) = size;
+	    *dest += EXTRA_SIZE;
+	}
+	MemCpy(*dest, src, srcsize);
+    } else {
+	Clear_extra(*dest);
+    }
+    return *dest;
+}
+
+/*	Find next Field
+ *	---------------
+ *
+ * On entry,
+ *	*pstr	points to a string containing white space separated
+ *		field, optionlly quoted.
+ *
+ * On exit,
+ *	*pstr	has been moved to the first delimiter past the
+ *		field
+ *		THE STRING HAS BEEN MUTILATED by a 0 terminator
+ *
+ *	returns a pointer to the first field
+ */
+char *HTNextField(char **pstr)
+{
+    char *p = *pstr;
+    char *start = NULL;		/* start of field */
+
+    if (p != NULL) {
+	while (*p && WHITE(*p))
+	    p++;		/* Strip white space */
+	if (!*p) {
+	    *pstr = p;
+	} else {
+	    if (*p == '"') {	/* quoted field */
+		p++;
+		start = p;
+		for (; *p && *p != '"'; p++) {
+		    if (*p == '\\' && p[1])
+			p++;	/* Skip escaped chars */
+		}
+	    } else {
+		start = p;
+		while (*p && !WHITE(*p))
+		    p++;	/* Skip first field */
+	    }
+	    if (*p)
+		*p++ = '\0';
+	    *pstr = p;
+	}
+    }
+    return start;
+}
+
+/*	Find next Token
+ *	---------------
+ *	Finds the next token in a string
+ *	On entry,
+ *	*pstr	points to a string to be parsed.
+ *	delims	lists characters to be recognized as delimiters.
+ *		If NULL, default is white space "," ";" or "=".
+ *		The word can optionally be quoted or enclosed with
+ *		chars from bracks.
+ *		Comments surrounded by '(' ')' are filtered out
+ *		unless they are specifically requested by including
+ *		' ' or '(' in delims or bracks.
+ *	bracks	lists bracketing chars.  Some are recognized as
+ *		special, for those give the opening char.
+ *		If NULL, defaults to <"> and "<" ">".
+ *	found	points to location to fill with the ending delimiter
+ *		found, or is NULL.
+ *
+ *	On exit,
+ *	*pstr	has been moved to the first delimiter past the
+ *		field
+ *		THE STRING HAS BEEN MUTILATED by a 0 terminator
+ *	found	points to the delimiter found unless it was NULL.
+ *	Returns a pointer to the first word or NULL on error
+ */
+char *HTNextTok(char **pstr,
+		const char *delims,
+		const char *bracks,
+		char *found)
+{
+    char *p = *pstr;
+    char *start = NULL;
+    BOOL get_blanks, skip_comments;
+    BOOL get_comments;
+    BOOL get_closing_char_too = FALSE;
+    char closer;
+
+    if (isEmpty(pstr))
+	return NULL;
+    if (!delims)
+	delims = " ;,=";
+    if (!bracks)
+	bracks = "<\"";
+
+    get_blanks = (BOOL) (!StrChr(delims, ' ') && !StrChr(bracks, ' '));
+    get_comments = (BOOL) (StrChr(bracks, '(') != NULL);
+    skip_comments = (BOOL) (!get_comments && !StrChr(delims, '(') && !get_blanks);
+#define skipWHITE(c) (!get_blanks && WHITE(c))
+
+    while (*p && skipWHITE(*p))
+	p++;			/* Strip white space */
+    if (!*p) {
+	*pstr = p;
+	if (found)
+	    *found = '\0';
+	return NULL;		/* No first field */
+    }
+    while (1) {
+	/* Strip white space and other delimiters */
+	while (*p && (skipWHITE(*p) || StrChr(delims, *p)))
+	    p++;
+	if (!*p) {
+	    *pstr = p;
+	    if (found)
+		*found = *(p - 1);
+	    return NULL;	/* No field */
+	}
+
+	if (*p == '(' && (skip_comments || get_comments)) {	/* Comment */
+	    int comment_level = 0;
+
+	    if (get_comments && !start)
+		start = p + 1;
+	    for (; *p && (*p != ')' || --comment_level > 0); p++) {
+		if (*p == '(')
+		    comment_level++;
+		else if (*p == '"') {	/* quoted field within Comment */
+		    for (p++; *p && *p != '"'; p++)
+			if (*p == '\\' && *(p + 1))
+			    p++;	/* Skip escaped chars */
+		    if (!*p)
+			break;	/* (invalid) end of string found, leave */
+		}
+		if (*p == '\\' && *(p + 1))
+		    p++;	/* Skip escaped chars */
+	    }
+	    if (get_comments)
+		break;
+	    if (*p)
+		p++;
+	    if (get_closing_char_too) {
+		if (!*p || (!StrChr(bracks, *p) && StrChr(delims, *p))) {
+		    break;
+		} else
+		    get_closing_char_too = (BOOL) (StrChr(bracks, *p) != NULL);
+	    }
+	} else if (StrChr(bracks, *p)) {	/* quoted or bracketed field */
+	    switch (*p) {
+	    case '<':
+		closer = '>';
+		break;
+	    case '[':
+		closer = ']';
+		break;
+	    case '{':
+		closer = '}';
+		break;
+	    case ':':
+		closer = ';';
+		break;
+	    default:
+		closer = *p;
+	    }
+	    if (!start)
+		start = ++p;
+	    for (; *p && *p != closer; p++)
+		if (*p == '\\' && *(p + 1))
+		    p++;	/* Skip escaped chars */
+	    if (get_closing_char_too) {
+		p++;
+		if (!*p || (!StrChr(bracks, *p) && StrChr(delims, *p))) {
+		    break;
+		} else
+		    get_closing_char_too = (BOOL) (StrChr(bracks, *p) != NULL);
+	    } else
+		break;		/* kr95-10-9: needs to stop here */
+	} else {		/* Spool field */
+	    if (!start)
+		start = p;
+	    while (*p && !skipWHITE(*p) && !StrChr(bracks, *p) &&
+		   !StrChr(delims, *p))
+		p++;
+	    if (*p && StrChr(bracks, *p)) {
+		get_closing_char_too = TRUE;
+	    } else {
+		if (*p == '(' && skip_comments) {
+		    *pstr = p;
+		    HTNextTok(pstr, NULL, "(", found);	/*      Advance pstr */
+		    *p = '\0';
+		    if (*pstr && **pstr)
+			(*pstr)++;
+		    return start;
+		}
+		break;		/* Got it */
+	    }
+	}
+    }
+    if (found)
+	*found = *p;
+
+    if (*p)
+	*p++ = '\0';
+    *pstr = p;
+    return start;
+}
+
+static char *HTAlloc(char *ptr, size_t length)
+{
+    if (ptr != 0)
+	ptr = (char *) realloc(ptr, length);
+    else
+	ptr = (char *) malloc(length);
+    if (ptr == 0)
+	outofmem(__FILE__, "HTAlloc");
+    return ptr;
+}
+
+/*
+ * If SAVE_TIME_NOT_SPACE is defined, StrAllocVsprintf will hang on to
+ * its temporary string buffers instead of allocating and freeing them
+ * in each invocation.  They only grow and never shrink, and won't be
+ * cleaned up on exit. - kw
+ */
+#if defined(_REENTRANT) || defined(_THREAD_SAFE) || defined(LY_FIND_LEAKS)
+#undef SAVE_TIME_NOT_SPACE
+#endif
+
+/*
+ * Replacement for sprintf, allocates buffer on the fly according to what's
+ * needed for its arguments.  Unlike sprintf, this always concatenates to the
+ * destination buffer, so we do not have to provide both flavors.
+ */
+typedef enum {
+    Flags,
+    Width,
+    Prec,
+    Type,
+    Format
+} PRINTF;
+
+#define VA_INTGR(type) ival = (int)    va_arg((*ap), type)
+#define VA_FLOAT(type) fval = (double) va_arg((*ap), type)
+#define VA_POINT(type) pval = (char *) va_arg((*ap), type)
+
+#define NUM_WIDTH 10		/* allow for width substituted for "*" in "%*s" */
+		/* also number of chars assumed to be needed in addition
+		   to a given precision in floating point formats */
+
+#define GROW_EXPR(n) (((n) * 3) / 2)
+#define GROW_SIZE 256
+
+PUBLIC_IF_FIND_LEAKS char *StrAllocVsprintf(char **pstr,
+					    size_t dst_len,
+					    const char *fmt,
+					    va_list *ap)
+{
+#ifdef HAVE_VASPRINTF
+    /*
+     * Use vasprintf() if we have it, since it is simplest.
+     */
+    char *result = 0;
+    char *temp = 0;
+
+    /* discard old destination if no length was given */
+    if (pstr && !dst_len) {
+	if (*pstr)
+	    FREE(*pstr);
+    }
+
+    if (vasprintf(&temp, fmt, *ap) >= 0) {
+	if (dst_len != 0) {
+	    size_t src_len = strlen(temp);
+	    size_t new_len = dst_len + src_len + 1;
+
+	    result = HTAlloc(pstr ? *pstr : 0, new_len);
+	    if (result != 0) {
+		strcpy(result + dst_len, temp);
+	    }
+	    (free) (temp);
+	} else {
+	    result = temp;
+	    mark_malloced(temp, strlen(temp));
+	}
+    }
+
+    if (pstr != 0)
+	*pstr = result;
+
+    return result;
+#else /* !HAVE_VASPRINTF */
+    /*
+     * If vasprintf() is not available, this works - but does not implement
+     * the POSIX '$' formatting character which may be used in some of the
+     * ".po" files.
+     */
+#ifdef SAVE_TIME_NOT_SPACE
+    static size_t tmp_len = 0;
+    static size_t fmt_len = 0;
+    static char *tmp_ptr = NULL;
+    static char *fmt_ptr = NULL;
+
+#else
+    size_t tmp_len = GROW_SIZE;
+    char *tmp_ptr = 0;
+    char *fmt_ptr;
+#endif /* SAVE_TIME_NOT_SPACE */
+    size_t have, need;
+    char *dst_ptr = pstr ? *pstr : NULL;
+    const char *format = fmt;
+
+    if (isEmpty(fmt))
+	return 0;
+
+    need = strlen(fmt) + 1;
+#ifdef SAVE_TIME_NOT_SPACE
+    if (!fmt_ptr || fmt_len < need * NUM_WIDTH) {
+	fmt_ptr = HTAlloc(fmt_ptr, fmt_len = need * NUM_WIDTH);
+    }
+    if (!tmp_ptr || tmp_len < GROW_SIZE) {
+	tmp_ptr = HTAlloc(tmp_ptr, tmp_len = GROW_SIZE);
+    }
+#else
+    if ((fmt_ptr = malloc(need * NUM_WIDTH)) == 0
+	|| (tmp_ptr = malloc(tmp_len)) == 0) {
+	outofmem(__FILE__, "StrAllocVsprintf");
+    }
+#endif /* SAVE_TIME_NOT_SPACE */
+
+    if (dst_ptr == 0) {
+	dst_ptr = HTAlloc(dst_ptr, have = GROW_SIZE + need);
+    } else {
+	have = strlen(dst_ptr) + 1;
+	need += dst_len;
+	if (have < need)
+	    dst_ptr = HTAlloc(dst_ptr, have = GROW_SIZE + need);
+    }
+
+    while (*fmt != '\0') {
+	if (*fmt == '%') {
+	    static char dummy[] = "";
+	    PRINTF state = Flags;
+	    char *pval = dummy;	/* avoid const-cast */
+	    double fval = 0.0;
+	    int done = FALSE;
+	    int ival = 0;
+	    int prec = -1;
+	    int type = 0;
+	    int used = 0;
+	    int width = -1;
+	    size_t f = 0;
+
+	    fmt_ptr[f++] = *fmt;
+	    while (*++fmt != '\0' && !done) {
+		fmt_ptr[f++] = *fmt;
+
+		if (isdigit(UCH(*fmt))) {
+		    int num = *fmt - '0';
+
+		    if (state == Flags && num != 0)
+			state = Width;
+		    if (state == Width) {
+			if (width < 0)
+			    width = 0;
+			width = (width * 10) + num;
+		    } else if (state == Prec) {
+			if (prec < 0)
+			    prec = 0;
+			prec = (prec * 10) + num;
+		    }
+		} else if (*fmt == '*') {
+		    VA_INTGR(int);
+
+		    if (state == Flags)
+			state = Width;
+		    if (state == Width) {
+			width = ival;
+		    } else if (state == Prec) {
+			prec = ival;
+		    }
+		    sprintf(&fmt_ptr[--f], "%d", ival);
+		    f = strlen(fmt_ptr);
+		} else if (isalpha(UCH(*fmt))) {
+		    done = TRUE;
+		    switch (*fmt) {
+		    case 'Z':	/* FALLTHRU */
+		    case 'h':	/* FALLTHRU */
+		    case 'l':	/* FALLTHRU */
+		    case 'L':	/* FALLTHRU */
+			done = FALSE;
+			type = *fmt;
+			break;
+		    case 'o':	/* FALLTHRU */
+		    case 'i':	/* FALLTHRU */
+		    case 'd':	/* FALLTHRU */
+		    case 'u':	/* FALLTHRU */
+		    case 'x':	/* FALLTHRU */
+		    case 'X':	/* FALLTHRU */
+			if (type == 'l')
+			    VA_INTGR(long);
+
+			else if (type == 'Z')
+			    VA_INTGR(size_t);
+
+			else
+			    VA_INTGR(int);
+
+			used = 'i';
+			break;
+		    case 'f':	/* FALLTHRU */
+		    case 'e':	/* FALLTHRU */
+		    case 'E':	/* FALLTHRU */
+		    case 'g':	/* FALLTHRU */
+		    case 'G':	/* FALLTHRU */
+			VA_FLOAT(double);
+
+			used = 'f';
+			break;
+		    case 'c':
+			VA_INTGR(int);
+
+			used = 'c';
+			break;
+		    case 's':
+			VA_POINT(char *);
+
+			if (prec < 0)
+			    prec = (int) strlen(pval);
+			used = 's';
+			break;
+		    case 'p':
+			VA_POINT(void *);
+
+			used = 'p';
+			break;
+		    case 'n':
+			VA_POINT(int *);
+
+			used = 0;
+			break;
+		    default:
+			CTRACE((tfp, "unknown format character '%c' in %s\n",
+				*fmt, format));
+			break;
+		    }
+		} else if (*fmt == '.') {
+		    state = Prec;
+		} else if (*fmt == '%') {
+		    done = TRUE;
+		    used = '%';
+		}
+	    }
+	    fmt_ptr[f] = '\0';
+
+	    if (prec > 0) {
+		switch (used) {
+		case 'f':
+		    if (width < prec + NUM_WIDTH)
+			width = prec + NUM_WIDTH;
+		    /* FALLTHRU */
+		case 'i':
+		    /* FALLTHRU */
+		case 'p':
+		    if (width < prec + 2)
+			width = prec + 2;	/* leading sign/space/zero, "0x" */
+		    break;
+		case 'c':
+		    break;
+		case '%':
+		    break;
+		default:
+		    if (width < prec)
+			width = prec;
+		    break;
+		}
+	    }
+	    if (width >= (int) tmp_len) {
+		tmp_len = GROW_EXPR(tmp_len + width);
+		tmp_ptr = HTAlloc(tmp_ptr, tmp_len);
+	    }
+
+	    switch (used) {
+	    case 'i':
+	    case 'c':
+		sprintf(tmp_ptr, fmt_ptr, ival);
+		break;
+	    case 'f':
+		sprintf(tmp_ptr, fmt_ptr, fval);
+		break;
+	    default:
+		sprintf(tmp_ptr, fmt_ptr, pval);
+		break;
+	    }
+	    need = dst_len + strlen(tmp_ptr) + 1;
+	    if (need >= have) {
+		dst_ptr = HTAlloc(dst_ptr, have = GROW_EXPR(need));
+	    }
+	    strcpy(dst_ptr + dst_len, tmp_ptr);
+	    dst_len += strlen(tmp_ptr);
+	} else {
+	    if ((dst_len + 2) >= have) {
+		dst_ptr = HTAlloc(dst_ptr, (have += GROW_SIZE));
+	    }
+	    dst_ptr[dst_len++] = *fmt++;
+	}
+    }
+
+#ifndef SAVE_TIME_NOT_SPACE
+    FREE(tmp_ptr);
+    FREE(fmt_ptr);
+#endif
+    dst_ptr[dst_len] = '\0';
+    if (pstr)
+	*pstr = dst_ptr;
+    return (dst_ptr);
+#endif /* HAVE_VASPRINTF */
+}
+#undef SAVE_TIME_NOT_SPACE
+
+/*
+ * Replacement for sprintf, allocates buffer on the fly according to what's
+ * needed for its arguments.  Unlike sprintf, this always concatenates to the
+ * destination buffer.
+ */
+/* Note: if making changes, also check the memory tracking version
+ * LYLeakHTSprintf in LYLeaks.c. - kw */
+#ifdef HTSprintf		/* if hidden by LYLeaks stuff */
+#undef HTSprintf
+#endif
+char *HTSprintf(char **pstr, const char *fmt, ...)
+{
+    char *result = 0;
+    size_t inuse = 0;
+    va_list ap;
+
+    LYva_start(ap, fmt);
+    {
+	if (pstr != 0 && *pstr != 0)
+	    inuse = strlen(*pstr);
+	result = StrAllocVsprintf(pstr, inuse, fmt, &ap);
+    }
+    va_end(ap);
+
+    return (result);
+}
+
+/*
+ * Replacement for sprintf, allocates buffer on the fly according to what's
+ * needed for its arguments.  Like sprintf, this always resets the destination
+ * buffer.
+ */
+/* Note: if making changes, also check the memory tracking version
+ * LYLeakHTSprintf0 in LYLeaks.c. - kw */
+#ifdef HTSprintf0		/* if hidden by LYLeaks stuff */
+#undef HTSprintf0
+#endif
+char *HTSprintf0(char **pstr, const char *fmt, ...)
+{
+    char *result = 0;
+    va_list ap;
+
+    LYva_start(ap, fmt);
+    {
+	result = StrAllocVsprintf(pstr, (size_t) 0, fmt, &ap);
+    }
+    va_end(ap);
+
+    return (result);
+}
+
+/*
+ * Returns a quoted or escaped form of the given parameter, suitable for use in
+ * a command string.
+ */
+#if USE_QUOTED_PARAMETER
+#define S_QUOTE '\''
+#define D_QUOTE '"'
+char *HTQuoteParameter(const char *parameter)
+{
+    size_t i;
+    size_t last;
+    size_t n = 0;
+    size_t quoted = 0;
+    char *result;
+
+    if (parameter == 0)
+	parameter = "";
+
+    last = strlen(parameter);
+    for (i = 0; i < last; ++i)
+	if (StrChr("\\&#$^*?(){}<>\"';`|", parameter[i]) != 0
+	    || isspace(UCH(parameter[i])))
+	    ++quoted;
+
+    result = (char *) malloc(last + 5 * quoted + 3);
+    if (result == NULL)
+	outofmem(__FILE__, "HTQuoteParameter");
+
+    n = 0;
+#if (USE_QUOTED_PARAMETER == 1)
+    /*
+     * Only double-quotes are used in Win32/DOS -TD
+     */
+    if (quoted)
+	result[n++] = D_QUOTE;
+    for (i = 0; i < last; i++) {
+	result[n++] = parameter[i];
+    }
+    if (quoted)
+	result[n++] = D_QUOTE;
+#else
+    if (quoted)
+	result[n++] = S_QUOTE;
+    for (i = 0; i < last; i++) {
+	if (parameter[i] == S_QUOTE) {
+	    result[n++] = S_QUOTE;
+	    result[n++] = D_QUOTE;
+	    result[n++] = parameter[i];
+	    result[n++] = D_QUOTE;
+	    result[n++] = S_QUOTE;
+	} else {
+	    /* Note:  No special handling of other characters, including
+	       backslash, since we are constructing a single-quoted string!
+	       Backslash has no special escape meaning within those for sh
+	       and compatible shells, so trying to escape a backslash by
+	       doubling it is unnecessary and would be interpreted by the
+	       shell as an additional data character. - kw 2000-05-02
+	     */
+	    result[n++] = parameter[i];
+	}
+    }
+    if (quoted)
+	result[n++] = S_QUOTE;
+#endif
+    result[n] = '\0';
+    return result;
+}
+#endif
+
+#define HTIsParam(string) ((string[0] == '%' && string[1] == 's'))
+
+/*
+ * Returns the number of "%s" tokens in a system command-template.
+ */
+int HTCountCommandArgs(const char *command)
+{
+    int number = 0;
+
+    while (command[0] != 0) {
+	if (HTIsParam(command))
+	    number++;
+	command++;
+    }
+    return number;
+}
+
+/*
+ * Returns a pointer into the given string after the given parameter number
+ */
+static const char *HTAfterCommandArg(const char *command,
+				     int number)
+{
+    while (number > 0) {
+	if (command[0] != 0) {
+	    if (HTIsParam(command)) {
+		number--;
+		command++;
+	    }
+	    command++;
+	} else {
+	    break;
+	}
+    }
+    return command;
+}
+
+#if USE_QUOTED_PARAMETER
+/*
+ * Recursively trim possible parameters of the source until an existing file
+ * is found.  If no file is found, return -1.  If a file is found, return
+ * the offset to a blank just after the filename.
+ *
+ * TODO: this could be smarter about trimming, e.g., matching quotes.
+ */
+static int skipPathname(const char *target, const char *source)
+{
+    int result = -1;
+    const char *last;
+    struct stat stat_info;
+
+    if (HTStat(target, &stat_info) == 0
+	&& S_ISREG(stat_info.st_mode)) {
+	result = 0;
+    } else if (*target != ' ' && (last = strrchr(target, ' ')) != NULL) {
+	char *temp = NULL;
+	int inner;
+
+	while (last != target && last[-1] == ' ')
+	    --last;
+
+	StrAllocCopy(temp, target);
+	result = (int) (last - target);
+	temp[result] = '\0';
+
+	if ((inner = skipPathname(temp, source)) < 0) {
+	    result = -1;
+	} else if (inner > 0) {
+	    result = inner;
+	}
+
+	FREE(temp);
+    }
+    CTRACE((tfp, "skip/recur %d '%s'\n", result, target));
+    return result;
+}
+#endif
+
+/*
+ * Like HTAddParam, but the parameter may be an environment variable, which we
+ * will expand and append.  Do this only for things like the command-verb,
+ * where we obtain the parameter from the user's configuration.  Any quoting
+ * required for the environment variable has to be done within its value, e.g.,
+ *
+ *	setenv EDITOR 'xvile -name "No such class"'
+ *
+ * This is useful only when we quote parameters, of course.
+ */
+#if USE_QUOTED_PARAMETER
+void HTAddXpand(char **result,
+		const char *command,
+		int number,
+		const char *parameter)
+{
+    if (parameter == NULL)
+	parameter = "";
+    if (number > 0) {
+	const char *last = HTAfterCommandArg(command, number - 1);
+	const char *next = last;
+
+	if (number <= 1) {
+	    FREE(*result);
+	}
+
+	while (next[0] != 0) {
+	    if (HTIsParam(next)) {
+		if (next != last) {
+		    size_t len = ((size_t) (next - last)
+				  + ((*result != 0)
+				     ? strlen(*result)
+				     : 0));
+
+		    HTSACat(result, last);
+		    (*result)[len] = 0;
+		}
+		if (LYisAbsPath(parameter)) {
+		    int skip = skipPathname(parameter, parameter);
+		    char *quoted;
+
+		    if (skip > 0) {
+			char *temp = NULL;
+
+			StrAllocCopy(temp, parameter);
+			temp[skip] = 0;
+
+			quoted = HTQuoteParameter(temp);
+			HTSACat(result, quoted);
+			FREE(quoted);
+
+			temp[skip] = ' ';
+			HTSACat(result, temp + skip);
+			FREE(temp);
+		    } else {
+			quoted = HTQuoteParameter(parameter);
+			HTSACat(result, quoted);
+			FREE(quoted);
+		    }
+		} else {
+		    /* leave it unquoted, e.g., environment variable expanded */
+		    HTSACat(result, parameter);
+		}
+		CTRACE((tfp, "PARAM-EXP:%s\n", *result));
+		return;
+	    }
+	    next++;
+	}
+    }
+}
+#endif /* USE_QUOTED_PARAMETER */
+
+/*
+ * Append string to a system command that we are constructing, without quoting. 
+ * We're given the index of the newest parameter we're processing.  Zero
+ * indicates none, so a value of '1' indicates that we copy from the beginning
+ * of the command string up to the first parameter, substitute the quoted
+ * parameter and return the result.
+ *
+ * Parameters are substituted at "%s" tokens, like printf.  Other printf-style
+ * tokens are not substituted; they are passed through without change.
+ */
+void HTAddToCmd(char **result,
+		const char *command,
+		int number,
+		const char *string)
+{
+    if (number > 0) {
+	const char *last = HTAfterCommandArg(command, number - 1);
+	const char *next = last;
+
+	if (number <= 1) {
+	    FREE(*result);
+	}
+	if (string == 0)
+	    string = "";
+	while (next[0] != 0) {
+	    if (HTIsParam(next)) {
+		if (next != last) {
+		    size_t len = ((size_t) (next - last)
+				  + ((*result != 0)
+				     ? strlen(*result)
+				     : 0));
+
+		    HTSACat(result, last);
+		    (*result)[len] = 0;
+		}
+		HTSACat(result, string);
+		CTRACE((tfp, "PARAM-ADD:%s\n", *result));
+		return;
+	    }
+	    next++;
+	}
+    }
+}
+
+/*
+ * Append string-parameter to a system command that we are constructing.  The
+ * string is a complete parameter (which is a necessary assumption so we can
+ * quote it properly).
+ */
+void HTAddParam(char **result,
+		const char *command,
+		int number,
+		const char *parameter)
+{
+    if (number > 0) {
+#if USE_QUOTED_PARAMETER
+	char *quoted = HTQuoteParameter(parameter);
+
+	HTAddToCmd(result, command, number, quoted);
+	FREE(quoted);
+#else
+	HTAddToCmd(result, command, number, parameter);
+#endif
+    }
+}
+
+/*
+ * Append the remaining command-string to a system command (compare with
+ * HTAddParam).  Any remaining "%s" tokens are copied as empty strings.
+ */
+void HTEndParam(char **result,
+		const char *command,
+		int number)
+{
+    const char *last;
+    int count;
+
+    count = HTCountCommandArgs(command);
+    if (count < number)
+	number = count;
+    last = HTAfterCommandArg(command, number);
+    if (last[0] != 0) {
+	HTSACat(result, last);
+    }
+    CTRACE((tfp, "PARAM-END:%s\n", *result));
+}
+
+/* Binary-strings (may have embedded nulls).  Some modules (HTGopher) assume
+ * there is a null on the end, anyway.
+ */
+
+/* (Re)allocate a bstring, e.g., to increase its buffer size for ad hoc
+ * operations.
+ */
+void HTSABAlloc(bstring **dest, int len)
+{
+    if (*dest == 0) {
+	*dest = typecalloc(bstring);
+
+	if (*dest == 0)
+	    outofmem(__FILE__, "HTSABAlloc");
+    }
+
+    if ((*dest)->len != len) {
+	(*dest)->str = typeRealloc(char, (*dest)->str, len);
+
+	if ((*dest)->str == 0)
+	    outofmem(__FILE__, "HTSABAlloc");
+
+	(*dest)->len = len;
+    }
+}
+
+/* Allocate a new bstring, and return it.
+*/
+void HTSABCopy(bstring **dest, const char *src,
+	       int len)
+{
+    bstring *t;
+    unsigned need = (unsigned) (len + 1);
+
+    CTRACE2(TRACE_BSTRING,
+	    (tfp, "HTSABCopy(%p, %p, %d)\n",
+	     (void *) dest, (const void *) src, len));
+    HTSABFree(dest);
+    if (src) {
+	if (TRACE_BSTRING) {
+	    CTRACE((tfp, "===    %4d:", len));
+	    trace_bstring2(src, len);
+	    CTRACE((tfp, "\n"));
+	}
+	if ((t = (bstring *) malloc(sizeof(bstring))) == NULL)
+	      outofmem(__FILE__, "HTSABCopy");
+
+	if ((t->str = typeMallocn(char, need)) == NULL)
+	      outofmem(__FILE__, "HTSABCopy");
+
+	MemCpy(t->str, src, len);
+	t->len = len;
+	t->str[t->len] = '\0';
+	*dest = t;
+    }
+    if (TRACE_BSTRING) {
+	CTRACE((tfp, "=>     %4d:", BStrLen(*dest)));
+	trace_bstring(*dest);
+	CTRACE((tfp, "\n"));
+    }
+}
+
+/*
+ * Initialize with a null-terminated string (discards the null).
+ */
+void HTSABCopy0(bstring **dest, const char *src)
+{
+    HTSABCopy(dest, src, (int) strlen(src));
+}
+
+/*
+ * Append a block of memory to a bstring.
+ */
+void HTSABCat(bstring **dest, const char *src,
+	      int len)
+{
+    bstring *t = *dest;
+
+    CTRACE2(TRACE_BSTRING,
+	    (tfp, "HTSABCat(%p, %p, %d)\n",
+	     (void *) dest, (const void *) src, len));
+    if (src) {
+	unsigned need = (unsigned) (len + 1);
+
+	if (TRACE_BSTRING) {
+	    CTRACE((tfp, "===    %4d:", len));
+	    trace_bstring2(src, len);
+	    CTRACE((tfp, "\n"));
+	}
+	if (t) {
+	    unsigned length = (unsigned) t->len + need;
+
+	    t->str = typeRealloc(char, t->str, length);
+	} else {
+	    if ((t = typecalloc(bstring)) == NULL)
+		  outofmem(__FILE__, "HTSACat");
+
+	    t->str = typeMallocn(char, need);
+	}
+	if (t->str == NULL)
+	    outofmem(__FILE__, "HTSACat");
+
+	MemCpy(t->str + t->len, src, len);
+	t->len += len;
+	t->str[t->len] = '\0';
+	*dest = t;
+    }
+    if (TRACE_BSTRING) {
+	CTRACE((tfp, "=>     %4d:", BStrLen(*dest)));
+	trace_bstring(*dest);
+	CTRACE((tfp, "\n"));
+    }
+}
+
+/*
+ * Append a null-terminated string (discards the null).
+ */
+void HTSABCat0(bstring **dest, const char *src)
+{
+    HTSABCat(dest, src, (int) strlen(src));
+}
+
+/*
+ * Compare two bstring's for equality
+ */
+BOOL HTSABEql(bstring *a, bstring *b)
+{
+    unsigned len_a = (unsigned) ((a != 0) ? a->len : 0);
+    unsigned len_b = (unsigned) ((b != 0) ? b->len : 0);
+
+    if (len_a == len_b) {
+	if (len_a == 0
+	    || MemCmp(a->str, b->str, a->len) == 0)
+	    return TRUE;
+    }
+    return FALSE;
+}
+
+/*
+ * Deallocate a bstring.
+ */
+void HTSABFree(bstring **ptr)
+{
+    if (*ptr != NULL) {
+	FREE((*ptr)->str);
+	FREE(*ptr);
+	*ptr = NULL;
+    }
+}
+
+/*
+ * Use this function to perform formatted sprintf's onto the end of a bstring.
+ * The bstring may contain embedded nulls; the formatted portions must not.
+ */
+bstring *HTBprintf(bstring **pstr, const char *fmt, ...)
+{
+    bstring *result = 0;
+    char *temp = 0;
+    va_list ap;
+
+    LYva_start(ap, fmt);
+    {
+	temp = StrAllocVsprintf(&temp, (size_t) 0, fmt, &ap);
+	if (non_empty(temp)) {
+	    HTSABCat(pstr, temp, (int) strlen(temp));
+	}
+	FREE(temp);
+	result = *pstr;
+    }
+    va_end(ap);
+
+    return (result);
+}
+
+/*
+ * Write binary-data to the logfile, making it safe for most editors to view.
+ * That is most, since we do not restrict line-length.  Nulls and other
+ * non-printing characters are addressed.
+ */
+void trace_bstring2(const char *text,
+		    int size)
+{
+    int n;
+
+    if (text != 0) {
+	for (n = 0; n < size; ++n) {
+	    int ch = UCH(text[n]);
+
+	    switch (ch) {
+	    case '\\':
+		fputs("\\\\", tfp);
+		break;
+	    case '\r':
+		fputs("\\r", tfp);
+		break;
+	    case '\t':
+		fputs("\\t", tfp);
+		break;
+	    case '\f':
+		fputs("\\f", tfp);
+		break;
+	    default:
+		if (isprint(ch) || isspace(ch)) {
+		    fputc(ch, tfp);
+		} else {
+		    fprintf(tfp, "\\%03o", ch);
+		}
+		break;
+	    }
+	}
+    }
+}
+
+void trace_bstring(bstring *data)
+{
+    trace_bstring2(BStrData(data), BStrLen(data));
+}
diff --git a/WWW/Library/Implementation/HTString.h b/WWW/Library/Implementation/HTString.h
new file mode 100644
index 0000000..82520ad
--- /dev/null
+++ b/WWW/Library/Implementation/HTString.h
@@ -0,0 +1,167 @@
+/*
+ * $LynxId: HTString.h,v 1.41 2021/06/09 19:30:55 tom Exp $
+ *						String handling for libwww
+ *                                         STRINGS
+ *                                            
+ * Case-independent string comparison and allocations with copies etc
+ */
+#ifndef HTSTRING_H
+#define HTSTRING_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif /* HTUTILS_H */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern const char *HTLibraryVersion;	/* String for help screen etc */
+
+/*
+ * EBCDIC string comparison using ASCII collating sequence
+ */
+#ifdef    NOT_ASCII
+    extern int AS_casecomp(const char *a, const char *b);
+    extern int AS_ncmp(const char *a, const char *b, unsigned int n);
+
+#define    AS_cmp( a, b )  ( AS_ncmp( ( a ), ( b ), -1 ) )
+
+#else
+#define AS_casecomp( a, b ) ( strcasecomp( ( a ), ( b ) ) )
+#define AS_ncmp( a, b, c )  ( StrNCmp( ( a ), ( b ), ( c ) ) )
+#define AS_cmp strcmp
+
+#endif				/* NOT_ASCII */
+
+#define StrNCat(a,b,c) strncat((a),(b),(size_t)(c))
+#define StrNCpy(a,b,c) strncpy((a),(b),(size_t)(c))
+#define StrNCmp(a,b,c) strncmp((a),(b),(size_t)(c))
+
+#define MemCpy(a,b,c)  memcpy((a),(b),(size_t)(c))
+#define MemCmp(a,b,c)  memcmp((a),(b),(size_t)(c))
+
+    /*
+     * Workaround for glibc header defect combined with -Wlogical-op warnings
+     */
+#define StrChr (strchr)
+
+    /*
+     * Case-insensitive string comparison
+     *
+     * The usual routines (comp instead of cmp) had some problem.
+     */
+    extern int strcasecomp(const char *a, const char *b);
+    extern int strncasecomp(const char *a, const char *b, int n);
+
+    extern int strcasecomp8(const char *a, const char *b);
+    extern int strncasecomp8(const char *a, const char *b, int n);
+
+    extern int strcasecomp_asterisk(const char *a, const char *b);
+
+    /*
+     * strcasecomp8 and strncasecomp8 are variants of strcasecomp and
+     * strncasecomp, but use 8bit upper/lower case information from the
+     * current display charset
+     */
+
+    /*
+     * Malloced string manipulation
+     */
+#define StrAllocCopy(dest, src) HTSACopy (&(dest), src)
+#define StrAllocCat(dest, src)  HTSACat  (&(dest), src)
+    extern char *HTSACopy(char **dest, const char *src);
+    extern char *HTSACat(char **dest, const char *src);
+
+    /*
+     * optimized for heavily realloc'd strings in temp objects
+     */
+#define StrAllocCopy_extra(dest, src) HTSACopy_extra (&(dest), src)
+#define FREE_extra(x)   {if (x != NULL) {HTSAFree_extra(x); x = NULL;}}
+#define Clear_extra(x)  {if (x != NULL) {*x = '\0';}}
+    extern char *HTSACopy_extra(char **dest, const char *src);
+    extern void HTSAFree_extra(char *s);
+
+    /*
+     * Next word or quoted string
+     */
+    extern char *HTNextField(char **pstr);
+
+    /* A more general parser - kw */
+    extern char *HTNextTok(char **pstr,
+			   const char *delims, const char *bracks, char *found);
+
+    extern char *HTSprintf(char **pstr, const char *fmt, ...) GCC_PRINTFLIKE(2,3);
+    extern char *HTSprintf0(char **pstr, const char *fmt, ...) GCC_PRINTFLIKE(2,3);
+
+#if defined(LY_FIND_LEAKS)	/* private otherwise */
+    extern char *StrAllocVsprintf(char **pstr,
+				  size_t len,
+				  const char *fmt,
+				  va_list *ap);
+#endif
+
+#if defined(__CYGWIN__)
+#define USE_QUOTED_PARAMETER 2	/* single and double-quoting */
+#elif defined(DOSPATH)
+#define USE_QUOTED_PARAMETER 1	/* double-quoting only */
+#elif (defined(VMS) || defined(__EMX__))
+#define USE_QUOTED_PARAMETER 0	/* no quoting */
+#else
+#define USE_QUOTED_PARAMETER 2	/* single and double-quoting */
+#endif
+
+#if USE_QUOTED_PARAMETER
+    extern char *HTQuoteParameter(const char *parameter);
+    extern void HTAddXpand(char **result, const char *command, int number, const char *parameter);
+
+#else
+#define HTQuoteParameter(parameter) parameter	/* simplify ifdef'ing */
+#define HTAddXpand(result,command,number,parameter)  HTAddParam(result,command,number,parameter)
+#endif
+
+    extern int HTCountCommandArgs(const char *command);
+    extern void HTAddToCmd(char **result, const char *command, int number, const char *string);
+    extern void HTAddParam(char **result, const char *command, int number, const char *parameter);
+    extern void HTEndParam(char **result, const char *command, int number);
+
+/* Force an option, with leading blanks, to be appended without quoting them */
+#define HTOptParam(result, command, number, parameter) HTSACat(result, parameter)
+
+/* Binary copy and concat */
+    typedef struct {
+	char *str;
+	int len;
+    } bstring;
+
+    extern void HTSABAlloc(bstring **dest, int len);
+    extern void HTSABCopy(bstring **dest, const char *src, int len);
+    extern void HTSABCopy0(bstring **dest, const char *src);
+    extern void HTSABCat(bstring **dest, const char *src, int len);
+    extern void HTSABCat0(bstring **dest, const char *src);
+    extern BOOL HTSABEql(bstring *a, bstring *b);
+    extern void HTSABFree(bstring **ptr);
+
+#define BStrLen(s)    (((s) != 0) ? (s)->len : 0)
+#define BStrData(s)   (((s) != 0) ? (s)->str : 0)
+
+#define BINEQ(a,b)    (HTSABEql(a,b))	/* like STREQ() */
+
+#define isBEmpty(p)   ((p) == 0 || BStrData(p) == 0 || BStrLen(p) == 0)
+
+#define BStrAlloc(d,n)   HTSABAlloc( &(d), n)
+#define BStrCopy(d,s)    HTSABCopy( &(d), BStrData(s), BStrLen(s))
+#define BStrCopy0(d,s)   HTSABCopy0( &(d), s)
+#define BStrCopy1(d,s,n) HTSABCopy(  &(d), s, n)
+#define BStrCat(d,s)     HTSABCat( &(d), BStrData(s), BStrLen(s))
+#define BStrCat0(d,s)    HTSABCat0( &(d), s)
+#define BStrFree(d)      HTSABFree( &(d))
+
+    extern bstring *HTBprintf(bstring **pstr, const char *fmt, ...) GCC_PRINTFLIKE(2,3);
+
+    extern void trace_bstring(bstring *data);
+    extern void trace_bstring2(const char *text, int size);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTSTRING_H */
diff --git a/WWW/Library/Implementation/HTStyle.c b/WWW/Library/Implementation/HTStyle.c
new file mode 100644
index 0000000..54c0bc5
--- /dev/null
+++ b/WWW/Library/Implementation/HTStyle.c
@@ -0,0 +1,378 @@
+/*
+ * $LynxId: HTStyle.c,v 1.16 2009/11/27 13:01:48 tom Exp $
+ *
+ *	Style Implementation for Hypertext			HTStyle.c
+ *	==================================
+ *
+ *	Styles allow the translation between a logical property
+ *	of a piece of text and its physical representation.
+ *
+ *	A StyleSheet is a collection of styles, defining the
+ *	translation necessary to
+ *	represent a document.  It is a linked list of styles.
+ */
+
+#include <HTUtils.h>
+#include <HTStyle.h>
+
+#include <LYLeaks.h>
+
+/*	Create a new style
+*/
+HTStyle *HTStyleNew(void)
+{
+    HTStyle *self = typecalloc(HTStyle);
+
+    if (self == NULL)
+	outofmem(__FILE__, "HTStyleNew");
+    return self;
+}
+
+/*	Create a new style with a name
+*/
+HTStyle *HTStyleNewNamed(const char *name)
+{
+    HTStyle *self = HTStyleNew();
+
+    StrAllocCopy(self->w_name, name);
+    self->id = -1;		/* <0 */
+    return self;
+}
+
+/*	Free a style
+*/
+HTStyle *HTStyleFree(HTStyle *self)
+{
+    FREE(self->w_name);
+    FREE(self->w_SGMLTag);
+    FREE(self);
+    return NULL;
+}
+
+#ifdef SUPPRESS			/* Only on the NeXT */
+/*	Read a style from a stream	(without its name)
+ *	--------------------------
+ *
+ *	Reads a style with paragraph information from a stream.
+ *	The style name is not read or written by these routines.
+ */
+#define NONE_STRING "(None)"
+#define HTStream NXStream
+
+HTStyle *HTStyleRead(HTStyle *style, HTStream *stream)
+{
+    char myTag[STYLE_NAME_LENGTH];
+    char fontName[STYLE_NAME_LENGTH];
+    NXTextStyle *p;
+    int tab;
+    int gotpara;		/* flag: have we got a paragraph definition? */
+
+    NXScanf(stream, "%s%s%f%d",
+	    myTag,
+	    fontName,
+	    &style->fontSize,
+	    &gotpara);
+    if (gotpara) {
+	if (!style->paragraph) {
+	    style->paragraph = malloc(sizeof(*(style->paragraph)));
+	    if (!style->paragraph)
+		outofmem(__FILE__, "HTStyleRead");
+	    style->paragraph->tabs = 0;
+	}
+	p = style->paragraph;
+	NXScanf(stream, "%f%f%f%f%hd%f%f%hd",
+		&p->indent1st,
+		&p->indent2nd,
+		&p->lineHt,
+		&p->descentLine,
+		&p->alignment,
+		&style->spaceBefore,
+		&style->spaceAfter,
+		&p->numTabs);
+	FREE(p->tabs);
+	p->tabs = malloc(p->numTabs * sizeof(p->tabs[0]));
+	if (!p->tabs)
+	    outofmem(__FILE__, "HTStyleRead");
+	for (tab = 0; tab < p->numTabs; tab++) {
+	    NXScanf(stream, "%hd%f",
+		    &p->tabs[tab].kind,
+		    &p->tabs[tab].x);
+	}
+    } else {			/* No paragraph */
+	FREE(style->paragraph);
+    }				/* if no paragraph */
+    StrAllocCopy(style->SGMLTag, myTag);
+    if (strcmp(fontName, NONE_STRING) == 0)
+	style->font = 0;
+    else
+      style->font =[Font newFont: fontName size:style->fontSize];
+    return NULL;
+}
+
+/*	Write a style to a stream in a compatible way
+*/
+HTStyle *HTStyleWrite(HTStyle *style, NXStream * stream)
+{
+    int tab;
+    NXTextStyle *p = style->paragraph;
+
+    NXPrintf(stream, "%s %s %f %d\n",
+	     style->SGMLTag,
+	     style->font ?[style->font name] : NONE_STRING,
+	     style->fontSize,
+	     p != 0);
+
+    if (p) {
+	NXPrintf(stream, "\t%f %f %f %f %d %f %f\t%d\n",
+		 p->indent1st,
+		 p->indent2nd,
+		 p->lineHt,
+		 p->descentLine,
+		 p->alignment,
+		 style->spaceBefore,
+		 style->spaceAfter,
+		 p->numTabs);
+
+	for (tab = 0; tab < p->numTabs; tab++)
+	    NXPrintf(stream, "\t%d %f\n",
+		     p->tabs[tab].kind,
+		     p->tabs[tab].x);
+    }
+    return style;
+}
+
+/*	Write a style to stdout for diagnostics
+*/
+HTStyle *HTStyleDump(HTStyle *style)
+{
+    int tab;
+    NXTextStyle *p = style->paragraph;
+
+    printf(STYLE_DUMP_FONT,
+	   style,
+	   style->name,
+	   style->SGMLTag,
+	   [style->font name],
+	   style->fontSize);
+    if (p) {
+	printf(STYLE_DUMP_IDENT,
+	       p->indent1st,
+	       p->indent2nd,
+	       p->lineHt,
+	       p->descentLine);
+	printf(STYLE_DUMP_ALIGN,
+	       p->alignment,
+	       p->numTabs,
+	       style->spaceBefore,
+	       style->spaceAfter);
+
+	for (tab = 0; tab < p->numTabs; tab++) {
+	    printf(STYLE_DUMP_TAB,
+		   p->tabs[tab].kind,
+		   p->tabs[tab].x);
+	}
+	printf("\n");
+    }				/* if paragraph */
+    return style;
+}
+#endif /* SUPPRESS */
+
+/*			StyleSheet Functions
+ *			====================
+ */
+
+/*	Searching for styles:
+*/
+HTStyle *HTStyleNamed(HTStyleSheet *self, const char *name)
+{
+    HTStyle *scan;
+
+    for (scan = self->styles; scan; scan = scan->next)
+	if (0 == strcmp(GetHTStyleName(scan), name))
+	    return scan;
+    CTRACE((tfp, "StyleSheet: No style named `%s'\n", name));
+    return NULL;
+}
+
+#ifdef NEXT_SUPRESS		/* Not in general common code */
+
+HTStyle *HTStyleMatching(HTStyleSheet *self, HTStyle *style)
+{
+    HTStyle *scan;
+
+    for (scan = self->styles; scan; scan = scan->next)
+	if (scan->paragraph == para)
+	    return scan;
+    return NULL;
+}
+
+/*	Find the style which best fits a given run
+ *	------------------------------------------
+ *
+ *	This heuristic is used for guessing the style for a run of
+ *	text which has been pasted in.  In order, we try:
+ *
+ *	A style whose paragraph structure is actually used by the run.
+ *	A style matching in font
+ *	A style matching in paragraph style exactly
+ *	A style matching in paragraph to a degree
+ */
+
+HTStyle *HTStyleForRun(HTStyleSheet *self, NXRun * run)
+{
+    HTStyle *scan;
+    HTStyle *best = 0;
+    int bestMatch = 0;
+    NXTextStyle *rp = run->paraStyle;
+
+    for (scan = self->styles; scan; scan = scan->next)
+	if (scan->paragraph == run->paraStyle)
+	    return scan;	/* Exact */
+
+    for (scan = self->styles; scan; scan = scan->next) {
+	NXTextStyle *sp = scan->paragraph;
+
+	if (sp) {
+	    int match = 0;
+
+	    if (sp->indent1st == rp->indent1st)
+		match = match + 1;
+	    if (sp->indent2nd == rp->indent2nd)
+		match = match + 2;
+	    if (sp->lineHt == rp->lineHt)
+		match = match + 1;
+	    if (sp->numTabs == rp->numTabs)
+		match = match + 1;
+	    if (sp->alignment == rp->alignment)
+		match = match + 3;
+	    if (scan->font == run->font)
+		match = match + 10;
+	    if (match > bestMatch) {
+		best = scan;
+		bestMatch = match;
+	    }
+	}
+    }
+    CTRACE((tfp, "HTStyleForRun: Best match for style is %d out of 18\n",
+	    bestMatch));
+    return best;
+}
+#endif /* NEXT_SUPRESS */
+
+/*	Add a style to a sheet
+ *	----------------------
+ */
+HTStyleSheet *HTStyleSheetAddStyle(HTStyleSheet *self, HTStyle *style)
+{
+    style->next = 0;		/* The style will go on the end */
+    if (!self->styles) {
+	self->styles = style;
+    } else {
+	HTStyle *scan;
+
+	for (scan = self->styles; scan->next; scan = scan->next) ;	/* Find end */
+	scan->next = style;
+    }
+    return self;
+}
+
+/*	Remove the given object from a style sheet if it exists
+*/
+HTStyleSheet *HTStyleSheetRemoveStyle(HTStyleSheet *self, HTStyle *style)
+{
+    if (self->styles == style) {
+	self->styles = style->next;
+	return self;
+    } else {
+	HTStyle *scan;
+
+	for (scan = self->styles; scan; scan = scan->next) {
+	    if (scan->next == style) {
+		scan->next = style->next;
+		return self;
+	    }
+	}
+    }
+    return NULL;
+}
+
+/*	Create new style sheet
+*/
+
+HTStyleSheet *HTStyleSheetNew(void)
+{
+    HTStyleSheet *self = typecalloc(HTStyleSheet);
+
+    if (self == NULL)
+	outofmem(__FILE__, "HTStyleSheetNew");
+    return self;
+}
+
+/*	Free off a style sheet pointer
+*/
+HTStyleSheet *HTStyleSheetFree(HTStyleSheet *self)
+{
+    HTStyle *style;
+
+    while ((style = self->styles) != 0) {
+	self->styles = style->next;
+	HTStyleFree(style);
+    }
+    FREE(self);
+    return NULL;
+}
+
+/*	Read a stylesheet from a typed stream
+ *	-------------------------------------
+ *
+ *	Reads a style sheet from a stream.  If new styles have the same names
+ *	as existing styles, they replace the old ones without changing the ids.
+ */
+
+#ifdef NEXT_SUPRESS		/* Only on the NeXT */
+HTStyleSheet *HTStyleSheetRead(HTStyleSheet *self, NXStream * stream)
+{
+    int numStyles;
+    int i;
+    HTStyle *style;
+    char styleName[80];
+
+    NXScanf(stream, " %d ", &numStyles);
+    CTRACE((tfp, "Stylesheet: Reading %d styles\n", numStyles));
+    for (i = 0; i < numStyles; i++) {
+	NXScanf(stream, "%s", styleName);
+	style = HTStyleNamed(self, styleName);
+	if (!style) {
+	    style = HTStyleNewNamed(styleName);
+	    (void) HTStyleSheetAddStyle(self, style);
+	}
+	(void) HTStyleRead(style, stream);
+	if (TRACE)
+	    HTStyleDump(style);
+    }
+    return self;
+}
+
+/*	Write a stylesheet to a typed stream
+ *	------------------------------------
+ *
+ *	Writes a style sheet to a stream.
+ */
+
+HTStyleSheet *HTStyleSheetWrite(HTStyleSheet *self, NXStream * stream)
+{
+    int numStyles = 0;
+    HTStyle *style;
+
+    for (style = self->styles; style; style = style->next)
+	numStyles++;
+    NXPrintf(stream, "%d\n", numStyles);
+
+    CTRACE((tfp, "StyleSheet: Writing %d styles\n", numStyles));
+    for (style = self->styles; style; style = style->next) {
+	NXPrintf(stream, "%s ", style->name);
+	(void) HTStyleWrite(style, stream);
+    }
+    return self;
+}
+#endif /* NEXT_SUPRESS */
diff --git a/WWW/Library/Implementation/HTStyle.h b/WWW/Library/Implementation/HTStyle.h
new file mode 100644
index 0000000..79ba003
--- /dev/null
+++ b/WWW/Library/Implementation/HTStyle.h
@@ -0,0 +1,241 @@
+/*
+ * $LynxId: HTStyle.h,v 1.18 2020/01/21 22:02:35 tom Exp $
+					    HTStyle: Style management for libwww
+                              STYLE DEFINITION FOR HYPERTEXT
+
+   Styles allow the translation between a logical property of a piece of text
+   and its physical representation.
+
+   A StyleSheet is a collection of styles, defining the translation necessary
+   to represent a document.  It is a linked list of styles.
+
+Overriding this module
+
+   Why is the style structure declared in the HTStyle.h module, instead of
+   having the user browser define the structure, and the HTStyle routines just
+   use sizeof() for copying?
+
+   It's not obvious whether HTStyle.c should be common code.  It's useful to
+   have common code for loading style sheets, especially if the movement toward
+   standard style sheets gets going.
+
+   If it IS common code, then both the hypertext object and HTStyle.c must know
+   the structure of a style, so HTStyle.h is a suitable place to put that. 
+   HTStyle.c has to be compiled with a knowledge of the
+
+   It we take it out of the library, then of course HTStyle could be declared
+   as an undefined structure.  The only references to it are in the
+   structure-flattening code HTML.c and HTPlain.c, which only use
+   HTStypeNamed().
+
+   You can in any case override this function in your own code, which will
+   prevent the HTStyle from being loaded.  You will be able to redefine your
+   style structure in this case without problems, as no other moule needs to
+   know it.
+
+ */
+#ifndef HTStyle_H
+#define HTStyle_H
+
+#include <HTAnchor.h>
+
+typedef long int HTFont;	/* Dummy definition instead */
+
+#ifdef NeXT_suppressed
+#include <appkit/appkit.h>
+typedef NXCoord HTCoord;
+
+#define HTParagraphStyle NXTextStyle
+#define HTCoord NXCoord
+typedef struct _color {
+    float grey;
+    int RGBColor;
+} HTColor;
+
+#else
+
+typedef int HTCoord;		/* changed from float to int - kw */
+
+typedef struct _HTParagraphStyle {
+    HTCoord left_indent;	/* @@@@ junk! etc etc */
+} HTParagraphStyle;
+
+typedef int HTColor;		/* Sorry about the US spelling! */
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define STYLE_NAME_LENGTH       80	/* @@@@@@@@@@@ */
+    typedef struct {
+	short kind;		/* only NX_LEFTTAB implemented */
+	HTCoord position;	/* x coordinate for stop */
+    } HTTabStop;
+
+/*      The Style Structure
+ *      -------------------
+ */
+
+    typedef struct _HTStyle {
+
+/*      Style management information
+*/
+	struct _HTStyle *next;	/* Link for putting into stylesheet */
+	char *w_name;		/* Style name */
+	const char *c_name;	/* Style name */
+	int id;			/* equivalent of name, for speed */
+	char *w_SGMLTag;	/* Tag name to start */
+	const char *c_SGMLTag;	/* Tag name to start */
+
+/*      Character attributes    (a la NXRun)
+*/
+	HTFont font;		/* Font id */
+	HTCoord fontSize;	/* The size of font, not independent */
+	HTColor color;		/* text gray of current run */
+	int superscript;	/* superscript (-sub) in points */
+
+	HTAnchor *anchor;	/* Anchor id if any, else zero */
+
+/*      Paragraph Attributes    (a la NXTextStyle)
+*/
+	HTCoord indent1st;	/* how far first line in paragraph is
+				   * indented */
+	HTCoord leftIndent;	/* how far second line is indented */
+	HTCoord rightIndent;	/* (Missing from NeXT version */
+	short alignment;	/* quad justification */
+	HTCoord lineHt;		/* line height */
+	HTCoord descentLine;	/* descender bottom from baseline */
+	const HTTabStop *tabs;	/* array of tab stops, 0 terminated */
+
+	BOOL wordWrap;		/* Yes means wrap at space not char */
+	BOOL freeFormat;	/* Yes means \n is just white space */
+	HTCoord spaceBefore;	/* Omissions from NXTextStyle */
+	HTCoord spaceAfter;
+	int paraFlags;		/* Paragraph flags, bits as follows: */
+
+#define PARA_KEEP       1	/* Do not break page within this paragraph */
+#define PARA_WITH_NEXT  2	/* Do not break page after this paragraph */
+
+#define HT_JUSTIFY 0		/* For alignment */
+#define HT_LEFT 1
+#define HT_RIGHT 2
+#define HT_CENTER 3
+
+    } HTStyle;
+
+#define GetHTStyleName(p) ((p)->w_name    ? (p)->w_name    : (p)->c_name)
+#define GetHTStyleSGML(p) ((p)->w_SGMLTag ? (p)->w_SGMLTag : (p)->c_SGMLTag)
+
+#define HTStyleInit( \
+	next, name, SGML_tag, \
+	font, fontsize, color, superscript, \
+	anchor, indent1st, leftIndent, rightIndent, \
+	alignment, lineHt, descentLine, \
+	tabs, wordWrap, freeFormat, spaceBefore, spaceAfter, paraFlags) \
+    { \
+	next, NULL, #name, ST_##name, NULL, SGML_tag, \
+	font, fontsize, color, superscript, \
+	anchor, indent1st, leftIndent, rightIndent, \
+	alignment, lineHt, descentLine, \
+	tabs, wordWrap, freeFormat, spaceBefore, spaceAfter, paraFlags }
+
+#define HT_ALIGN_NONE (-1)
+
+/*      Style functions:
+*/
+    extern HTStyle *HTStyleNew(void);
+    extern HTStyle *HTStyleNewNamed(const char *name);
+    extern HTStyle *HTStyleFree(HTStyle *self);
+
+#ifdef SUPRESS
+    extern HTStyle *HTStyleRead(HTStyle *self, HTStream *stream);
+    extern HTStyle *HTStyleWrite(HTStyle *self, HTStream *stream);
+#endif
+/*              Style Sheet
+ *              -----------
+ */
+    typedef struct _HTStyleSheet {
+	const char *name;
+	HTStyle *styles;
+    } HTStyleSheet;
+
+/*      Stylesheet functions:
+*/
+    extern HTStyleSheet *HTStyleSheetNew(void);
+    extern HTStyleSheet *HTStyleSheetFree(HTStyleSheet *self);
+    extern HTStyle *HTStyleNamed(HTStyleSheet *self, const char *name);
+    extern HTStyle *HTStyleForParagraph(HTStyleSheet *self, HTParagraphStyle * paraStyle);
+    extern HTStyle *HTStyleMatching(HTStyleSheet *self, HTStyle *style);
+
+/* extern HTStyle * HTStyleForRun (HTStyleSheet *self, NXRun * run); */
+    extern HTStyleSheet *HTStyleSheetAddStyle(HTStyleSheet *self, HTStyle *style);
+    extern HTStyleSheet *HTStyleSheetRemoveStyle(HTStyleSheet *self, HTStyle *style);
+
+#ifdef SUPPRESS
+    extern HTStyleSheet *HTStyleSheetRead(HTStyleSheet *self, HTStream *stream);
+    extern HTStyleSheet *HTStyleSheetWrite(HTStyleSheet *self, HTStream *stream);
+#endif
+#define CLEAR_POINTER ((void *)-1)	/* Pointer value means "clear me" */
+
+/* DefaultStyle.c */
+    extern HTStyleSheet *DefaultStyle(HTStyle ***result_array);
+
+/* enum, use this instead of HTStyle name comparisons */
+    enum HTStyle_Enum {
+	ST_Normal = 0,
+	ST_DivCenter,
+	ST_DivLeft,
+	ST_DivRight,
+	ST_Banner,
+	ST_Blockquote,
+	ST_Bq,
+	ST_Footnote,
+	ST_List,
+	ST_List1,
+	ST_List2,
+	ST_List3,
+	ST_List4,
+	ST_List5,
+	ST_List6,
+	ST_Menu,
+	ST_Menu1,
+	ST_Menu2,
+	ST_Menu3,
+	ST_Menu4,
+	ST_Menu5,
+	ST_Menu6,
+	ST_Glossary,
+	ST_Glossary1,
+	ST_Glossary2,
+	ST_Glossary3,
+	ST_Glossary4,
+	ST_Glossary5,
+	ST_Glossary6,
+	ST_GlossaryCompact,
+	ST_GlossaryCompact1,
+	ST_GlossaryCompact2,
+	ST_GlossaryCompact3,
+	ST_GlossaryCompact4,
+	ST_GlossaryCompact5,
+	ST_GlossaryCompact6,
+	ST_Example,
+	ST_Preformatted,
+	ST_Listing,
+	ST_Address,
+	ST_Note,
+	ST_Heading1,
+	ST_Heading2,
+	ST_Heading3,
+	ST_Heading4,
+	ST_Heading5,
+	ST_Heading6,
+	ST_HeadingCenter,
+	ST_HeadingLeft,
+	ST_HeadingRight
+    };
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTStyle_H */
diff --git a/WWW/Library/Implementation/HTTCP.c b/WWW/Library/Implementation/HTTCP.c
new file mode 100644
index 0000000..a3bfda6
--- /dev/null
+++ b/WWW/Library/Implementation/HTTCP.c
@@ -0,0 +1,2623 @@
+/*
+ * $LynxId: HTTCP.c,v 1.163 2022/04/01 23:18:35 Rajeev.V.Pillai Exp $
+ *
+ *			Generic Communication Code		HTTCP.c
+ *			==========================
+ *
+ *	This code is in common between client and server sides.
+ *
+ *	16 Jan 92  TBL	Fix strtol() undefined on CMU Mach.
+ *	25 Jun 92  JFG	Added DECNET option through TCP socket emulation.
+ *	13 Sep 93  MD	Added correct return of vmserrorno for HTInetStatus.
+ *			Added decoding of vms error message for MULTINET.
+ *	7-DEC-1993 Bjorn S. Nilsson, ALEPH, CERN, VMS UCX ioctl() changes
+ *			(done of Mosaic)
+ *	19 Feb 94  Danny Mayer	Added Bjorn Fixes to Lynx version
+ *	 7 Mar 94  Danny Mayer	Added Fix UCX version for full domain name
+ *	20 May 94  Andy Harper	Added support for CMU TCP/IP transport
+ *	17 Nov 94  Andy Harper	Added support for SOCKETSHR transport
+ *	16 Jul 95  S. Bjorndahl added kluge to deal with LIBCMU bug
+ */
+
+#define LYNX_ADDRINFO	struct addrinfo
+#define LYNX_HOSTENT	struct hostent
+
+#include <HTUtils.h>
+#include <HTParse.h>
+#include <HTAlert.h>
+#include <HTTCP.h>
+#include <LYGlobalDefs.h>	/* added for no_suspend */
+#include <LYUtils.h>
+
+#ifdef NSL_FORK
+#include <signal.h>
+#include <www_wait.h>
+#define FREE_NSL_FORK(p) { FREE(p); }
+#elif defined(_WINDOWS_NSL)
+#define FREE_NSL_FORK(p) if ((p) == gbl_phost) { FREE(p); }
+#else
+#define FREE_NSL_FORK(p)	/* nothing */
+#endif /* NSL_FORK */
+
+#ifdef HAVE_RESOLV_H
+#include <resolv.h>
+#endif
+
+#ifdef __DJGPP__
+#include <netdb.h>
+#endif /* __DJGPP__ */
+
+#define OK_HOST(p) ((p) != 0 && ((p)->h_length) != 0)
+
+#ifdef SVR4_BSDSELECT
+int BSDselect(int nfds,
+	      fd_set * readfds,
+	      fd_set * writefds,
+	      fd_set * exceptfds,
+	      struct timeval *select_timeout);
+
+#ifdef select
+#undef select
+#endif /* select */
+#define select BSDselect
+#ifdef SOCKS
+#ifdef Rselect
+#undef Rselect
+#endif /* Rselect */
+#define Rselect BSDselect
+#endif /* SOCKS */
+#endif /* SVR4_BSDSELECT */
+
+#include <LYLeaks.h>
+
+/*
+ *  Module-Wide variables
+ */
+static char *hostname = NULL;	/* The name of this host */
+
+/*
+ *  PUBLIC VARIABLES
+ */
+#ifdef SOCKS
+unsigned long socks_bind_remoteAddr;	/* for long Rbind */
+#endif /* SOCKS */
+
+/*	Encode INET status (as in sys/errno.h)			  inet_status()
+ *	------------------
+ *
+ *  On entry,
+ *	where		gives a description of what caused the error
+ *	global errno	gives the error number in the Unix way.
+ *
+ *  On return,
+ *	returns		a negative status in the Unix way.
+ */
+
+#ifdef DECL_SYS_ERRLIST
+extern char *sys_errlist[];	/* see man perror on cernvax */
+extern int sys_nerr;
+#endif /* DECL_SYS_ERRLIST */
+
+#ifdef __DJGPP__
+static int ResolveYield(void)
+{
+    return HTCheckForInterrupt()? 0 : 1;
+}
+#endif
+
+#if defined(VMS) && defined(UCX)
+/*
+ *  A routine to mimic the ioctl function for UCX.
+ *  Bjorn S. Nilsson, 25-Nov-1993. Based on an example in the UCX manual.
+ */
+#include <HTioctl.h>
+
+int HTioctl(int d,
+	    int request,
+	    int *argp)
+{
+    int sdc, status;
+    unsigned short fun, iosb[4];
+    char *p5, *p6;
+    struct comm {
+	int command;
+	char *addr;
+    } ioctl_comm;
+    struct it2 {
+	unsigned short len;
+	unsigned short opt;
+	struct comm *addr;
+    } ioctl_desc;
+
+    if ((sdc = vaxc$get_sdc(d)) == 0) {
+	set_errno(EBADF);
+	return -1;
+    }
+    ioctl_desc.opt = UCX$C_IOCTL;
+    ioctl_desc.len = sizeof(struct comm);
+
+    ioctl_desc.addr = &ioctl_comm;
+    if (request & IOC_OUT) {
+	fun = IO$_SENSEMODE;
+	p5 = 0;
+	p6 = (char *) &ioctl_desc;
+    } else {
+	fun = IO$_SETMODE;
+	p5 = (char *) &ioctl_desc;
+	p6 = 0;
+    }
+    ioctl_comm.command = request;
+    ioctl_comm.addr = (char *) argp;
+    status = sys$qiow(0, sdc, fun, iosb, 0, 0, 0, 0, 0, 0, p5, p6);
+    if (!(status & 01)) {
+	set_errno(status);
+	return -1;
+    }
+    if (!(iosb[0] & 01)) {
+	set_errno(iosb[0]);
+	return -1;
+    }
+    return 0;
+}
+#endif /* VMS && UCX */
+
+#define MY_FORMAT "TCP: Error %d in `SOCKET_ERRNO' after call to %s() failed.\n\t%s\n"
+	   /* third arg is transport/platform specific */
+
+/*	Report Internet Error
+ *	---------------------
+ */
+int HTInetStatus(const char *where)
+{
+    int status;
+    int saved_errno = errno;
+
+#ifdef VMS
+#ifdef MULTINET
+    SOCKET_ERRNO = vmserrno;
+#endif /* MULTINET */
+#endif /* VMS */
+
+#ifdef VM
+    CTRACE((tfp, MY_FORMAT, SOCKET_ERRNO, where,
+	    "(Error number not translated)"));	/* What Is the VM equiv? */
+#define ER_NO_TRANS_DONE
+#endif /* VM */
+
+#ifdef VMS
+#ifdef MULTINET
+    CTRACE((tfp, MY_FORMAT, SOCKET_ERRNO, where,
+	    vms_errno_string()));
+#else
+    CTRACE((tfp, MY_FORMAT, SOCKET_ERRNO, where,
+	    ((SOCKET_ERRNO > 0 && SOCKET_ERRNO <= 65) ?
+	     strerror(SOCKET_ERRNO) : "(Error number not translated)")));
+#endif /* MULTINET */
+#define ER_NO_TRANS_DONE
+#endif /* VMS */
+
+#ifdef HAVE_STRERROR
+    CTRACE((tfp, MY_FORMAT, SOCKET_ERRNO, where,
+	    strerror(SOCKET_ERRNO)));
+#define ER_NO_TRANS_DONE
+#endif /* HAVE_STRERROR */
+
+#ifndef ER_NO_TRANS_DONE
+    CTRACE((tfp, MY_FORMAT, SOCKET_ERRNO, where,
+	    (SOCKET_ERRNO < sys_nerr ?
+	     sys_errlist[SOCKET_ERRNO] : "Unknown error")));
+#endif /* !ER_NO_TRANS_DONE */
+
+#ifdef VMS
+#ifndef MULTINET
+    CTRACE((tfp,
+	    "         Unix error number (SOCKET_ERRNO) = %ld dec\n",
+	    SOCKET_ERRNO));
+    CTRACE((tfp,
+	    "         VMS error (vaxc$errno)    = %lx hex\n",
+	    vaxc$errno));
+#endif /* MULTINET */
+#endif /* VMS */
+
+    set_errno(saved_errno);
+
+#ifdef VMS
+    /*
+     * uerrno and errno happen to be zero if vmserrno <> 0
+     */
+#ifdef MULTINET
+    status = -vmserrno;
+#else
+    status = -vaxc$errno;
+#endif /* MULTINET */
+#else
+    status = -SOCKET_ERRNO;
+#endif /* VMS */
+    return status;
+}
+
+/*	Parse a cardinal value				       parse_cardinal()
+ *	----------------------
+ *
+ * On entry,
+ *	*pp	    points to first character to be interpreted, terminated by
+ *		    non 0:9 character.
+ *	*pstatus    points to status already valid
+ *	maxvalue    gives the largest allowable value.
+ *
+ * On exit,
+ *	*pp	    points to first unread character
+ *	*pstatus    points to status updated iff bad
+ */
+unsigned int HTCardinal(int *pstatus,
+			char **pp,
+			unsigned int max_value)
+{
+    unsigned int n;
+
+    if ((**pp < '0') || (**pp > '9')) {		/* Null string is error */
+	*pstatus = -3;		/* No number where one expected */
+	return 0;
+    }
+
+    n = 0;
+    while ((**pp >= '0') && (**pp <= '9'))
+	n = n * 10 + (unsigned) (*((*pp)++) - '0');
+
+    if (n > max_value) {
+	*pstatus = -4;		/* Cardinal outside range */
+	return 0;
+    }
+
+    return n;
+}
+
+#ifndef DECNET			/* Function only used below for a trace message */
+/*	Produce a string for an Internet address
+ *	----------------------------------------
+ *
+ *  On exit,
+ *	returns a pointer to a static string which must be copied if
+ *		it is to be kept.
+ */
+const char *HTInetString(LY_SOCKADDR * soc_A)
+{
+#ifdef INET6
+    static char hostbuf[MAXHOSTNAMELEN];
+    struct sockaddr *soc_addr = &(soc_A->soc_address);
+
+    getnameinfo(soc_addr,
+		SA_LEN(soc_addr),
+		hostbuf, (socklen_t) sizeof(hostbuf),
+		NULL, 0,
+		NI_NUMERICHOST);
+    return hostbuf;
+#else
+    struct sockaddr_in *soc_in = &(soc_A->soc_in);
+    static char string[20];
+
+    sprintf(string, "%d.%d.%d.%d",
+	    (int) *((unsigned char *) (&soc_in->sin_addr) + 0),
+	    (int) *((unsigned char *) (&soc_in->sin_addr) + 1),
+	    (int) *((unsigned char *) (&soc_in->sin_addr) + 2),
+	    (int) *((unsigned char *) (&soc_in->sin_addr) + 3));
+    return string;
+#endif /* INET6 */
+}
+#endif /* !DECNET */
+
+/*	Check whether string is a valid Internet hostname - kw
+ *	-------------------------------------------------
+ *
+ *  Checks whether
+ *  - contains only valid chars for domain names (actually, the
+ *    restrictions are somewhat relaxed),
+ *  - no leading dots or empty segments,
+ *  - no segment starts with '-' or '+' [this protects telnet command],
+ *  - max. length of dot-separated segment <= 63 (RFC 1034,1035),
+ *  - total length <= 254 (if it ends with dot) or 253 (otherwise)
+ *     [an interpretation of RFC 1034,1035, although RFC 1123
+ *      suggests 255 as limit - kw].
+ *
+ *  Note: user (before '@') and port (after ':') components from
+ *      host part of URL should be already stripped (if appropriate)
+ *      from the input string.
+ *
+ *  On exit,
+ *	returns 1 if valid, otherwise 0.
+ */
+BOOL valid_hostname(char *name)
+{
+    int i = 1, iseg = 0;
+    char *cp = name;
+
+    if (!(name && *name))
+	return NO;
+    for (; (*cp && i <= 253); cp++, i++) {
+	if (*cp == '.') {
+	    if (iseg == 0) {
+		return NO;
+	    } else {
+		iseg = 0;
+		continue;
+	    }
+	} else if (iseg == 0 && (*cp == '-' || *cp == '+')) {
+	    return NO;
+	} else if (++iseg > 63) {
+	    return NO;
+	}
+	if (!isalnum(UCH(*cp)) &&
+	    *cp != '-' && *cp != '_' &&
+	    *cp != '$' && *cp != '+') {
+	    return NO;
+	}
+    }
+    return (BOOL) (*cp == '\0' || (*cp == '.' && iseg != 0 && cp[1] == '\0'));
+}
+
+/* for transfer of status from child to parent: */
+typedef struct _statuses {
+    size_t rehostentlen;
+    int h_length;
+    int child_errno;		/* sometimes useful to pass this on */
+    int child_h_errno;
+    BOOL h_errno_valid;
+} STATUSES;
+
+/*
+ *  Function to allow us to be killed with a normal signal (not
+ *  SIGKILL), but don't go through normal libc exit() processing, which
+ *  would screw up parent's stdio.  -BL
+ */
+#ifdef NSL_FORK
+static void quench(int sig GCC_UNUSED)
+{
+    _exit(2);
+}
+#endif
+
+int lynx_nsl_status = HT_OK;
+
+#define DEBUG_HOSTENT		/* disable in case of problems */
+#define DEBUG_HOSTENT_CHILD	/* for NSL_FORK, may screw up trace file */
+
+/*
+ *  dump_hostent - dumps the contents of a LYNX_HOSTENT to the
+ *  trace log or stderr, including all pointer values, strings, and
+ *  addresses, in a format inspired by gdb's print format. - kw
+ */
+static void dump_hostent(const char *msgprefix,
+			 const void *data)
+{
+    if (TRACE) {
+	int i;
+	char **pcnt;
+	const LYNX_HOSTENT *phost = data;
+
+	CTRACE((tfp, "%s: %p ", msgprefix, (const void *) phost));
+	if (phost) {
+	    CTRACE((tfp, "{ h_name = %p", (void *) phost->h_name));
+	    if (phost->h_name) {
+		CTRACE((tfp, " \"%s\",", phost->h_name));
+	    } else {
+		CTRACE((tfp, ","));
+	    }
+	    CTRACE((tfp, "\n\t h_aliases = %p", (void *) phost->h_aliases));
+	    if (phost->h_aliases) {
+		CTRACE((tfp, " {"));
+		for (pcnt = phost->h_aliases; *pcnt; pcnt++) {
+		    CTRACE((tfp, "%s %p \"%s\"",
+			    (pcnt == phost->h_aliases ? " " : ", "),
+			    (void *) *pcnt, *pcnt));
+		}
+		CTRACE((tfp, "%s0x0 },\n\t",
+			(*phost->h_aliases ? ", " : " ")));
+	    } else {
+		CTRACE((tfp, ",\n\t"));
+	    }
+	    CTRACE((tfp, " h_addrtype = %d,", phost->h_addrtype));
+	    CTRACE((tfp, " h_length = %d,\n\t", phost->h_length));
+	    CTRACE((tfp, " h_addr_list = %p", (void *) phost->h_addr_list));
+	    if (phost->h_addr_list) {
+		CTRACE((tfp, " {"));
+		for (pcnt = phost->h_addr_list; *pcnt; pcnt++) {
+		    CTRACE((tfp, "%s %p",
+			    (pcnt == phost->h_addr_list ? "" : ","),
+			    (void *) *pcnt));
+		    for (i = 0; i < phost->h_length; i++) {
+			CTRACE((tfp, "%s%d%s", (i == 0 ? " \"" : "."),
+				(int) *((unsigned char *) (*pcnt) + i),
+				(i + 1 == phost->h_length ? "\"" : "")));
+		    }
+		}
+		if (*phost->h_addr_list) {
+		    CTRACE((tfp, ", 0x0 } }"));
+		} else {
+		    CTRACE((tfp, " 0x0 } }"));
+		}
+	    } else {
+		CTRACE((tfp, "}"));
+	    }
+	}
+	CTRACE((tfp, "\n"));
+	fflush(tfp);
+    }
+}
+
+#ifdef NSL_FORK
+
+/*
+ * Even though it is a small amount, we cannot count on reading the whole
+ * struct via a pipe in one read -TD
+ */
+static unsigned read_bytes(int fd, char *buffer, size_t length)
+{
+    unsigned result = 0;
+
+    while (length != 0) {
+	unsigned got = (unsigned) read(fd, buffer, length);
+
+	if ((int) got > 0) {
+	    result += got;
+	    buffer += got;
+	    length -= got;
+	} else {
+	    break;
+	}
+    }
+    return result;
+}
+
+static unsigned read_hostent(int fd, char *buffer, size_t length)
+{
+    unsigned have = read_bytes(fd, buffer, length);
+
+    if (have) {
+	LYNX_HOSTENT *data = (LYNX_HOSTENT *) (void *) buffer;
+	char *next_char = (char *) data + sizeof(*data);
+	char **next_ptr = (char **) (void *) next_char;
+	long offset = 0;
+	int n;
+	int num_addrs = 0;
+	int num_aliases = 0;
+
+	if (data->h_addr_list) {
+	    data->h_addr_list = next_ptr;
+	    while (next_ptr[num_addrs] != 0) {
+		++num_addrs;
+	    }
+	    next_ptr += (num_addrs + 1);
+	    next_char += (size_t) (num_addrs + 1) * sizeof(data->h_addr_list[0]);
+	}
+
+	if (data->h_aliases) {
+	    data->h_aliases = next_ptr;
+	    while (next_ptr[num_aliases] != 0) {
+		++num_aliases;
+	    }
+	    next_char += (size_t) (num_aliases + 1) * sizeof(data->h_aliases[0]);
+	}
+
+	if (data->h_name) {
+	    offset = next_char - data->h_name;
+	    data->h_name = next_char;
+	} else if (data->h_addr_list) {
+	    offset = next_char - (char *) data->h_addr_list[0];
+	} else if (data->h_aliases) {
+	    offset = next_char - (char *) data->h_aliases[0];
+	}
+
+	if (data->h_addr_list) {
+	    for (n = 0; n < num_addrs; ++n) {
+		data->h_addr_list[n] += offset;
+	    }
+	}
+
+	if (data->h_aliases) {
+	    for (n = 0; n < num_aliases; ++n) {
+		data->h_aliases[n] += offset;
+	    }
+	}
+    }
+
+    return have;
+}
+#endif /* NSL_FORK */
+
+/*
+ *  fill_rehostent - copies as much as possible relevant content from
+ *  the LYNX_HOSTENT pointed to by phost to the char buffer given
+ *  by rehostent, subject to maximum output length rehostentsize,
+ *  following pointers and building self-contained output which can be
+ *  cast to a LYNX_HOSTENT. - kw
+ *  See also description of LYGetHostByName.
+ */
+#if defined(NSL_FORK) || defined(_WINDOWS_NSL)
+
+#define REHOSTENT_SIZE 128	/* not bigger than pipe buffer! */
+
+typedef struct {
+    LYNX_HOSTENT h;
+    char rest[REHOSTENT_SIZE];
+} AlignedHOSTENT;
+
+static size_t fill_rehostent(void **rehostent,
+			     const LYNX_HOSTENT *phost)
+{
+    static const char *this_func = "fill_rehostent";
+
+    LYNX_HOSTENT *data = 0;
+    int num_addrs = 0;
+    int num_aliases = 0;
+    char *result = 0;
+    char *p_next_char;
+    char **p_next_charptr;
+    size_t name_len = 0;
+    size_t need = sizeof(LYNX_HOSTENT);
+    int n;
+
+    if (!phost)
+	return 0;
+
+    if (phost->h_name) {
+	name_len = strlen(phost->h_name);
+	need += name_len + 1;
+    }
+    if (phost->h_addr_list) {
+	while (phost->h_addr_list[num_addrs]) {
+	    num_addrs++;
+	}
+	need += ((size_t) num_addrs + 1) * ((size_t) phost->h_length
+					    + sizeof(phost->h_addr_list[0]));
+    }
+    if (phost->h_aliases) {
+	while (phost->h_aliases[num_aliases]) {
+	    need += strlen(phost->h_aliases[num_aliases]) + 1;
+	    num_aliases++;
+	}
+	need += ((size_t) num_aliases + 1) * sizeof(phost->h_aliases[0]);
+    }
+
+    if ((result = calloc(need, sizeof(char))) == 0)
+	  outofmem(__FILE__, this_func);
+
+    *rehostent = result;
+
+    data = (LYNX_HOSTENT *) (void *) result;
+
+    data->h_addrtype = phost->h_addrtype;
+    data->h_length = phost->h_length;
+
+    p_next_char = result + sizeof(LYNX_HOSTENT);
+
+    p_next_charptr = (char **) (void *) p_next_char;
+    if (phost->h_addr_list)
+	p_next_char += (size_t) (num_addrs + 1) * sizeof(phost->h_addr_list[0]);
+    if (phost->h_aliases)
+	p_next_char += (size_t) (num_aliases + 1) * sizeof(phost->h_aliases[0]);
+
+    if (phost->h_name) {
+	data->h_name = p_next_char;
+	strcpy(p_next_char, phost->h_name);
+	p_next_char += name_len + 1;
+    }
+
+    if (phost->h_addr_list) {
+	data->h_addr_list = p_next_charptr;
+	for (n = 0; n < num_addrs; ++n) {
+	    MemCpy(p_next_char, phost->h_addr_list[n], phost->h_length);
+	    *p_next_charptr++ = p_next_char;
+	    p_next_char += phost->h_length;
+	}
+	++p_next_charptr;
+    }
+
+    if (phost->h_aliases) {
+	data->h_aliases = p_next_charptr;
+	for (n = 0; n < num_aliases; ++n) {
+	    strcpy(p_next_char, phost->h_aliases[n]);
+	    *p_next_charptr++ = p_next_char;
+	    p_next_char += strlen(phost->h_aliases[n]) + 1;;
+	}
+    }
+    return need;
+}
+#endif /* NSL_FORK */
+
+/*
+ * This chunk of code is used in both win32 and cygwin.
+ */
+#if defined(_WINDOWS_NSL)
+static LYNX_HOSTENT *gbl_phost;	/* Pointer to host - See netdb.h */
+
+#if !(defined(__CYGWIN__) && defined(NSL_FORK))
+static int donelookup;
+
+static unsigned long __stdcall _fork_func(void *arg)
+{
+    const char *host = (const char *) arg;
+    static AlignedHOSTENT aligned_full_rehostent;
+    char *rehostent = (char *) &aligned_full_rehostent;
+    size_t rehostentlen = 0;
+
+#ifdef SH_EX
+    unsigned long addr;
+
+    addr = (unsigned long) inet_addr(host);
+    if (addr != INADDR_NONE)
+	gbl_phost = gethostbyaddr((char *) &addr, sizeof(addr), AF_INET);
+    else
+	gbl_phost = gethostbyname(host);
+#else
+    gbl_phost = gethostbyname(host);
+#endif
+
+    if (gbl_phost) {
+	rehostentlen = fill_rehostent((void **) &rehostent, gbl_phost);
+	if (rehostentlen == 0) {
+	    gbl_phost = (LYNX_HOSTENT *) NULL;
+	} else {
+	    gbl_phost = (LYNX_HOSTENT *) rehostent;
+	}
+    }
+
+    donelookup = TRUE;
+    return (unsigned long) (gbl_phost);
+}
+#endif /* __CYGWIN__ */
+#endif /* _WINDOWS_NSL */
+
+#ifdef NSL_FORK
+
+#ifndef HAVE_H_ERRNO
+#undef  h_errno
+#define h_errno my_errno
+static int my_errno;
+
+#else /* we do HAVE_H_ERRNO: */
+#ifndef h_errno			/* there may be a macro as well as the extern data */
+extern int h_errno;
+#endif
+#endif
+
+static BOOL setup_nsl_fork(void (*really) (const char *,
+					   const char *,
+					   STATUSES *,
+					   void **),
+			   unsigned (*readit) (int, char *, size_t),
+			   void (*dumpit) (const char *, const void *),
+			   const char *host,
+			   const char *port,
+			   void **rehostent)
+{
+    static const char *this_func = "setup_nsl_fork";
+
+    STATUSES statuses;
+
+    /*
+     * fork-based gethostbyname() with checks for interrupts.
+     * - Tom Zerucha (tz@execpc.com) & FM
+     */
+    int got_rehostent = 0;
+
+#if HAVE_SIGACTION
+    sigset_t old_sigset;
+    sigset_t new_sigset;
+#endif
+    /*
+     * Pipe, child pid, status buffers, start time, select() control
+     * variables.
+     */
+    int fpid, waitret;
+    int pfd[2], selret;
+    unsigned readret;
+
+#ifdef HAVE_TYPE_UNIONWAIT
+    union wait waitstat;
+
+#else
+    int waitstat = 0;
+#endif
+    time_t start_time = time((time_t *) 0);
+    fd_set readfds;
+    struct timeval one_second;
+    long dns_patience = 30;	/* how many seconds will we wait for DNS? */
+    int child_exited = 0;
+
+    memset(&statuses, 0, sizeof(STATUSES));
+    statuses.h_errno_valid = NO;
+
+    /*
+     * Reap any children that have terminated since last time through.
+     * This might include children that we killed, then waited with WNOHANG
+     * before they were actually ready to be reaped.  (Should be max of 1
+     * in this state, but the loop is safe if waitpid() is implemented
+     * correctly:  returns 0 when children exist but none have exited; -1
+     * with errno == ECHILD when no children.) -BL
+     */
+    do {
+	waitret = waitpid(-1, 0, WNOHANG);
+    } while (waitret > 0 || (waitret == -1 && errno == EINTR));
+    waitret = 0;
+
+    IGNORE_RC(pipe(pfd));
+
+#if HAVE_SIGACTION
+    /*
+     * Attempt to prevent a rare situation where the child could execute
+     * the Lynx signal handlers because it gets killed before it even has a
+     * chance to reset its handlers, resulting in bogus 'Exiting via
+     * interrupt' message and screen corruption or worse.
+     * Should that continue to be reported, for systems without
+     * sigprocmask(), we need to find a different solutions for those.  -
+     * kw 19990430
+     */
+    sigemptyset(&new_sigset);
+    sigaddset(&new_sigset, SIGTERM);
+    sigaddset(&new_sigset, SIGINT);
+#ifndef NOSIGHUP
+    sigaddset(&new_sigset, SIGHUP);
+#endif /* NOSIGHUP */
+#ifdef SIGTSTP
+    sigaddset(&new_sigset, SIGTSTP);
+#endif /* SIGTSTP */
+#ifdef SIGWINCH
+    sigaddset(&new_sigset, SIGWINCH);
+#endif /* SIGWINCH */
+    sigprocmask(SIG_BLOCK, &new_sigset, &old_sigset);
+#endif /* HAVE_SIGACTION */
+
+    if ((fpid = fork()) == 0) {
+	/*
+	 * Child - for the long call.
+	 *
+	 * Make sure parent can kill us at will.  -BL
+	 */
+	(void) signal(SIGTERM, quench);
+
+	/*
+	 * Also make sure the child does not run one of the signal handlers
+	 * that may have been installed by Lynx if one of those signals
+	 * occurs.  For example we don't want the child to remove temp
+	 * files on ^C, let the parent deal with that.  - kw
+	 */
+	(void) signal(SIGINT, quench);
+#ifndef NOSIGHUP
+	(void) signal(SIGHUP, quench);
+#endif /* NOSIGHUP */
+#ifdef SIGTSTP
+	if (no_suspend)
+	    (void) signal(SIGTSTP, SIG_IGN);
+	else
+	    (void) signal(SIGTSTP, SIG_DFL);
+#endif /* SIGTSTP */
+#ifdef SIGWINCH
+	(void) signal(SIGWINCH, SIG_IGN);
+#endif /* SIGWINCH */
+#ifndef __linux__
+#ifndef DOSPATH
+	signal(SIGBUS, SIG_DFL);
+#endif /* DOSPATH */
+#endif /* !__linux__ */
+	signal(SIGSEGV, SIG_DFL);
+	signal(SIGILL, SIG_DFL);
+
+#if HAVE_SIGACTION
+	/* Restore signal mask to whatever it was before the fork. -kw */
+	sigprocmask(SIG_SETMASK, &old_sigset, NULL);
+#endif /* HAVE_SIGACTION */
+
+	/*
+	 * Child won't use read side.  -BL
+	 */
+	close(pfd[0]);
+#ifdef HAVE_H_ERRNO
+	/* to detect cases when it doesn't get set although it should */
+	h_errno = -2;
+#endif
+	set_errno(0);
+	really(host, port, &statuses, rehostent);
+	/*
+	 * Send variables indicating status of lookup to parent.  That
+	 * includes rehostentlen, which the parent will use as the size for
+	 * the second read (if > 0).
+	 */
+	if (!statuses.child_errno)
+	    statuses.child_errno = errno;
+	IGNORE_RC(write(pfd[1], &statuses, sizeof(statuses)));
+
+	if (statuses.rehostentlen) {
+	    /*
+	     * Return our resulting rehostent through pipe...
+	     */
+	    IGNORE_RC(write(pfd[1], *rehostent, statuses.rehostentlen));
+	    close(pfd[1]);
+	    _exit(0);
+	} else {
+	    /*
+	     * ...  or return error as exit code.
+	     */
+	    _exit(1);
+	}
+    }
+#if HAVE_SIGACTION
+    /*
+     * (parent) Restore signal mask to whatever it was before the fork.  -
+     * kw
+     */
+    sigprocmask(SIG_SETMASK, &old_sigset, NULL);
+#endif /* HAVE_SIGACTION */
+
+    /*
+     * (parent) Wait until lookup finishes, or interrupt, or cycled too
+     * many times (just in case) -BL
+     */
+
+    close(pfd[1]);		/* parent won't use write side -BL */
+
+    if (fpid < 0) {		/* fork failed */
+	close(pfd[0]);
+	goto failed;
+    }
+
+    while (child_exited || (long) (time((time_t *) 0) - start_time) < dns_patience) {
+
+	FD_ZERO(&readfds);
+	/*
+	 * This allows us to abort immediately, not after 1-second timeout,
+	 * when user hits abort key.  Can't do this when using SLANG (or at
+	 * least I don't know how), so SLANG users must live with up-to-1s
+	 * timeout.  -BL
+	 *
+	 * Whoops -- we need to make sure stdin is actually selectable!
+	 * /dev/null isn't, on some systems, which makes some useful Lynx
+	 * invocations fail.  -BL
+	 */
+	{
+	    int kbd_fd = LYConsoleInputFD(TRUE);
+
+	    if (kbd_fd != INVSOC) {
+		FD_SET(kbd_fd, &readfds);
+	    }
+	}
+
+	one_second.tv_sec = 1;
+	one_second.tv_usec = 0;
+	FD_SET(pfd[0], &readfds);
+
+	/*
+	 * Return when data received, interrupted, or failed.  If nothing
+	 * is waiting, we sleep for 1 second in select(), to be nice to the
+	 * system.  -BL
+	 */
+#ifdef SOCKS
+	if (socks_flag)
+	    selret = Rselect(pfd[0] + 1, &readfds, NULL, NULL, &one_second);
+	else
+#endif /* SOCKS */
+	    selret = select(pfd[0] + 1, &readfds, NULL, NULL, &one_second);
+
+	if ((selret > 0) && FD_ISSET(pfd[0], &readfds)) {
+	    /*
+	     * First get status, including length of address.  -BL, kw
+	     */
+	    readret = read_bytes(pfd[0], (char *) &statuses, sizeof(statuses));
+	    if (readret == sizeof(statuses)) {
+		h_errno = statuses.child_h_errno;
+		set_errno(statuses.child_errno);
+#ifdef HAVE_H_ERRNO
+		if (statuses.h_errno_valid) {
+		    lynx_nsl_status = HT_H_ERRNO_VALID;
+		    /*
+		     * If something went wrong in the child process other
+		     * than normal lookup errors, and it appears that we
+		     * have enough info to know what went wrong, generate
+		     * diagnostic output.  ENOMEM observed on linux in
+		     * processes constrained with ulimit.  It would be too
+		     * unkind to abort the session, access to local files
+		     * or through a proxy may still work.  - kw
+		     */
+		    if (
+#ifdef NETDB_INTERNAL		/* linux glibc: defined in netdb.h */
+			   (errno && h_errno == NETDB_INTERNAL) ||
+#endif
+			   (errno == ENOMEM &&
+			    statuses.rehostentlen == 0 &&
+		    /* should probably be NETDB_INTERNAL if child
+		       memory exhausted, but we may find that
+		       h_errno remains unchanged. - kw */
+			    h_errno == -2)) {
+#ifndef MULTINET
+			HTInetStatus("CHILD gethostbyname");
+#endif
+			HTAlert(LYStrerror(statuses.child_errno));
+			if (errno == ENOMEM) {
+			    /*
+			     * Not much point in continuing, right?  Fake a
+			     * 'z', should shorten pointless guessing
+			     * cycle.  - kw
+			     */
+			    LYFakeZap(YES);
+			}
+		    }
+		}
+#endif /* HAVE_H_ERRNO */
+		if (statuses.rehostentlen != 0) {
+		    /*
+		     * Then get the full reorganized hostent.  -BL, kw
+		     */
+		    if ((*rehostent = malloc(statuses.rehostentlen)) == 0)
+			outofmem(__FILE__, this_func);
+		    readret = (*readit) (pfd[0], *rehostent, statuses.rehostentlen);
+#ifdef DEBUG_HOSTENT
+		    dumpit("Read from pipe", *rehostent);
+#endif
+		    if (readret == statuses.rehostentlen) {
+			got_rehostent = 1;
+			lynx_nsl_status = HT_OK;
+		    } else if (!statuses.h_errno_valid) {
+			lynx_nsl_status = HT_INTERNAL;
+		    }
+		}
+	    } else {
+		lynx_nsl_status = HT_ERROR;
+	    }
+	    /*
+	     * Make sure child is cleaned up.  -BL
+	     */
+	    if (!child_exited)
+		waitret = waitpid(fpid, &waitstat, WNOHANG);
+	    if (!WIFEXITED(waitstat) && !WIFSIGNALED(waitstat)) {
+		kill(fpid, SIGTERM);
+		waitret = waitpid(fpid, &waitstat, WNOHANG);
+	    }
+	    break;
+	}
+
+	/*
+	 * Clean up if child exited before & no data received.  -BL
+	 */
+	if (child_exited) {
+	    waitret = waitpid(fpid, &waitstat, WNOHANG);
+	    break;
+	}
+	/*
+	 * If child exited, loop once more looking for data.  -BL
+	 */
+	if ((waitret = waitpid(fpid, &waitstat, WNOHANG)) > 0) {
+	    /*
+	     * Data will be arriving right now, so make sure we don't
+	     * short-circuit out for too many loops, and skip the interrupt
+	     * check.  -BL
+	     */
+	    child_exited = 1;
+	    continue;
+	}
+
+	/*
+	 * Abort if interrupt key pressed.
+	 */
+	if (HTCheckForInterrupt()) {
+	    CTRACE((tfp, "%s: INTERRUPTED gethostbyname.\n", this_func));
+	    kill(fpid, SIGTERM);
+	    waitpid(fpid, NULL, WNOHANG);
+	    close(pfd[0]);
+	    lynx_nsl_status = HT_INTERRUPTED;
+	    return FALSE;
+	}
+    }
+    close(pfd[0]);
+    if (waitret <= 0) {
+	kill(fpid, SIGTERM);
+	waitret = waitpid(fpid, &waitstat, WNOHANG);
+    }
+    if (waitret > 0) {
+	if (WIFEXITED(waitstat)) {
+	    CTRACE((tfp,
+		    "%s: NSL_FORK child %d exited, status 0x%x.\n",
+		    this_func, (int) waitret, WEXITSTATUS(waitstat)));
+	} else if (WIFSIGNALED(waitstat)) {
+	    CTRACE((tfp,
+		    "%s: NSL_FORK child %d got signal, status 0x%x!\n",
+		    this_func, (int) waitret, WTERMSIG(waitstat)));
+#ifdef WCOREDUMP
+	    if (WCOREDUMP(waitstat)) {
+		CTRACE((tfp,
+			"%s: NSL_FORK child %d dumped core!\n",
+			this_func, (int) waitret));
+	    }
+#endif /* WCOREDUMP */
+	} else if (WIFSTOPPED(waitstat)) {
+	    CTRACE((tfp,
+		    "%s: NSL_FORK child %d is stopped, status 0x%x!\n",
+		    this_func, (int) waitret, WSTOPSIG(waitstat)));
+	}
+    }
+    if (!got_rehostent) {
+	goto failed;
+    }
+    return TRUE;
+  failed:
+    return FALSE;
+}
+
+/*
+ * This is called via the child-side of the fork.
+ */
+static void really_gethostbyname(const char *host,
+				 const char *port GCC_UNUSED,
+				 STATUSES * statuses,
+				 void **rehostent)
+{
+    LYNX_HOSTENT *phost;	/* Pointer to host - See netdb.h */
+    LYNX_HOSTENT *result = 0;
+
+    (void) port;
+
+    phost = gethostbyname(host);
+    statuses->rehostentlen = 0;
+    statuses->child_errno = errno;
+    statuses->child_h_errno = h_errno;
+#ifdef HAVE_H_ERRNO
+    statuses->h_errno_valid = YES;
+#endif
+#ifdef MVS
+    CTRACE((tfp, "really_gethostbyname() returned %d\n", phost));
+#endif /* MVS */
+
+#ifdef DEBUG_HOSTENT_CHILD
+    dump_hostent("CHILD gethostbyname", phost);
+#endif
+    if (OK_HOST(phost)) {
+	statuses->rehostentlen = fill_rehostent(rehostent, phost);
+	result = (LYNX_HOSTENT *) (*rehostent);
+#ifdef DEBUG_HOSTENT_CHILD
+	dump_hostent("CHILD fill_rehostent", result);
+#endif
+    }
+    if (statuses->rehostentlen <= sizeof(LYNX_HOSTENT) || !OK_HOST(result)) {
+	statuses->rehostentlen = 0;
+	statuses->h_length = 0;
+    } else {
+	statuses->h_length = result->h_length;
+#ifdef HAVE_H_ERRNO
+	if (h_errno == -2)	/* success, but h_errno unchanged? */
+	    statuses->h_errno_valid = NO;
+#endif
+    }
+}
+#endif /* NSL_FORK */
+
+/*	Resolve an internet hostname, like gethostbyname
+ *	------------------------------------------------
+ *
+ *  On entry,
+ *	host	points to the given host name, not numeric address,
+ *		without colon or port number.
+ *
+ *  On exit,
+ *	returns a pointer to a LYNX_HOSTENT in static storage,
+ *	or NULL in case of error or user interruption.
+ *
+ *  The interface is intended to be exactly the same as for (Unix)
+ *  gethostbyname(), except for the following:
+ *
+ *  If NSL_FORK is not used, the result of gethostbyname is returned
+ *  directly.  Otherwise:
+ *  All lists, addresses, and strings referred to by pointers in the
+ *  returned struct are located, together with the returned struct
+ *  itself, in a buffer of size REHOSTENT_SIZE.  If not everything fits,
+ *  some info is omitted, but the function is careful to still return
+ *  a valid structure, without truncating strings; it tries to return,
+ *  in order of decreasing priority, the first address (h_addr_list[0]), the
+ *  official name (h_name), the additional addresses, then alias names.
+ *
+ *  If NULL is returned, the reason is made available in the global
+ *  variable lynx_nsl_status, with one of the following values:
+ *	HT_INTERRUPTED		Interrupted by user
+ *	HT_NOT_ACCEPTABLE	Hostname detected as invalid
+ *				(also sets h_errno)
+ *	HT_H_ERRNO_VALID	An error occurred, and h_errno holds
+ *				an appropriate value
+ *	HT_ERROR		Resolver error, reason not known
+ *	HT_INTERNAL		Internal error
+ */
+static LYNX_HOSTENT *LYGetHostByName(char *host)
+{
+    static const char *this_func = "LYGetHostByName";
+
+#ifdef NSL_FORK
+    /* for transfer of result between from child to parent: */
+    LYNX_HOSTENT *rehostent = 0;
+#endif /* NSL_FORK */
+
+    LYNX_HOSTENT *result_phost = NULL;
+
+#ifdef __DJGPP__
+    _resolve_hook = ResolveYield;
+#endif
+
+    if (!host) {
+	CTRACE((tfp, "%s: Can't parse `NULL'.\n", this_func));
+	lynx_nsl_status = HT_INTERNAL;
+	return NULL;
+    }
+    CTRACE((tfp, "%s: parsing `%s'.\n", this_func, host));
+
+    /*  Could disable this if all our callers already check - kw */
+    if (HTCheckForInterrupt()) {
+	CTRACE((tfp, "%s: INTERRUPTED for '%s'.\n", this_func, host));
+	lynx_nsl_status = HT_INTERRUPTED;
+	return NULL;
+    }
+
+    if (!valid_hostname(host)) {
+	lynx_nsl_status = HT_NOT_ACCEPTABLE;
+#ifdef NO_RECOVERY
+#ifdef _WINDOWS
+	WSASetLastError(NO_RECOVERY);
+#else
+	h_errno = NO_RECOVERY;
+#endif
+#endif
+	return NULL;
+    }
+#ifdef MVS			/* Outstanding problem with crash in MVS gethostbyname */
+    CTRACE((tfp, "%s: Calling gethostbyname(%s)\n", this_func, host));
+#endif /* MVS */
+
+    CTRACE_FLUSH(tfp);		/* so child messages will not mess up parent log */
+
+    lynx_nsl_status = HT_INTERNAL;	/* should be set to something else below */
+
+#ifdef NSL_FORK
+    if (!setup_nsl_fork(really_gethostbyname,
+			read_hostent,
+			dump_hostent,
+			host, NULL, (void **) &rehostent)) {
+	goto failed;
+    }
+    result_phost = rehostent;
+#else /* Not NSL_FORK: */
+
+#ifdef _WINDOWS_NSL
+    {
+	HANDLE hThread;
+	DWORD dwThreadID;
+
+#ifndef __CYGWIN__
+	if (!system_is_NT) {	/* for Windows9x */
+	    unsigned long t;
+
+	    t = (unsigned long) inet_addr(host);
+	    if (t != INADDR_NONE)
+		gbl_phost = gethostbyaddr((char *) &t, sizeof(t), AF_INET);
+	    else
+		gbl_phost = gethostbyname(host);
+	} else {		/* for Windows NT */
+#endif /* !__CYGWIN__ */
+	    gbl_phost = (LYNX_HOSTENT *) NULL;
+	    donelookup = FALSE;
+
+#if defined(__CYGWIN__) || defined(USE_WINSOCK2_H)
+	    SetLastError(WSAHOST_NOT_FOUND);
+#else
+	    WSASetLastError(WSAHOST_NOT_FOUND);
+#endif
+
+	    hThread = CreateThread(NULL, 4096UL, _fork_func, host, 0UL,
+				   &dwThreadID);
+	    if (!hThread)
+		MessageBox(NULL, "CreateThread",
+			   "CreateThread Failed", 0L);
+
+	    while (!donelookup) {
+		if (HTCheckForInterrupt()) {
+		    /* Note that host is a character array and is not freed */
+		    /* to avoid possible subthread problems: */
+		    if (!CloseHandle(hThread)) {
+			MessageBox((void *) NULL,
+				   "CloseHandle", "CloseHandle Failed", 0L);
+		    }
+		    lynx_nsl_status = HT_INTERRUPTED;
+		    return NULL;
+		}
+	    }
+#ifndef __CYGWIN__
+	}
+#endif /* !__CYGWIN__ */
+	if (gbl_phost) {
+	    lynx_nsl_status = HT_OK;
+	    result_phost = gbl_phost;
+	} else {
+	    lynx_nsl_status = HT_ERROR;
+	    goto failed;
+	}
+    }
+
+#else /* !NSL_FORK, !_WINDOWS_NSL: */
+    {
+	LYNX_HOSTENT *phost;
+
+	phost = gethostbyname(host);	/* See netdb.h */
+#ifdef MVS
+	CTRACE((tfp, "%s: gethostbyname() returned %d\n", this_func, phost));
+#endif /* MVS */
+	if (phost) {
+	    lynx_nsl_status = HT_OK;
+	    result_phost = phost;
+	} else {
+	    lynx_nsl_status = HT_H_ERRNO_VALID;
+	    goto failed;
+	}
+    }
+#endif /* !NSL_FORK, !_WINDOWS_NSL */
+#endif /* !NSL_FORK */
+
+#ifdef DEBUG_HOSTENT
+    dump_hostent(this_func, result_phost);
+    CTRACE((tfp, "%s: Resolved name to a hostent.\n", this_func));
+#endif
+
+    return result_phost;	/* OK */
+
+  failed:
+    CTRACE((tfp, "%s: Can't find internet node name `%s'.\n", this_func, host));
+    return NULL;
+}
+
+BOOLEAN LYCheckHostByName(char *host)
+{
+    LYNX_HOSTENT *data = LYGetHostByName(host);
+    BOOLEAN result = (data != NULL);
+
+    FREE_NSL_FORK(data);
+    return result;
+}
+
+/*	Parse a network node address and port
+ *	-------------------------------------
+ *
+ *  On entry,
+ *	str	points to a string with a node name or number,
+ *		with optional trailing colon and port number.
+ *	soc_in	points to the binary internet or decnet address field.
+ *
+ *  On exit,
+ *	*soc_in is filled in.  If no port is specified in str, that
+ *		field is left unchanged in *soc_in.
+ */
+#ifndef INET6
+static int HTParseInet(SockA *soc_in, const char *str)
+{
+    static const char *this_func = "HTParseInet";
+
+    char *port;
+    int dotcount_ip = 0;	/* for dotted decimal IP addr */
+    char *strptr;
+    char *host = NULL;
+
+    if (!str) {
+	CTRACE((tfp, "%s: Can't parse `NULL'.\n", this_func));
+	return -1;
+    }
+    CTRACE((tfp, "%s: parsing `%s'.\n", this_func, str));
+    if (HTCheckForInterrupt()) {
+	CTRACE((tfp, "%s: INTERRUPTED for '%s'.\n", this_func, str));
+	return -1;
+    }
+    StrAllocCopy(host, str);	/* Make a copy we can mutilate */
+    /*
+     * Parse port number if present.
+     */
+    if ((port = StrChr(host, ':')) != NULL) {
+	*port++ = 0;		/* Chop off port */
+	strptr = port;
+	if (port[0] >= '0' && port[0] <= '9') {
+#ifdef UNIX
+	    soc_in->sin_port = (PortNumber) htons(strtol(port, &strptr, 10));
+#else /* VMS: */
+#ifdef DECNET
+	    soc_in->sdn_objnum = (unsigned char) (strtol(port, &strptr, 10));
+#else
+	    soc_in->sin_port = htons((PortNumber) strtol(port, &strptr, 10));
+#endif /* Decnet */
+#endif /* Unix vs. VMS */
+#ifdef SUPPRESS			/* 1. crashes!?!.  2. URL syntax has number not name */
+	} else {
+	    struct servent *serv = getservbyname(port, (char *) 0);
+
+	    if (serv) {
+		soc_in->sin_port = serv->s_port;
+	    } else {
+		CTRACE((tfp, "TCP: Unknown service %s\n", port));
+	    }
+#endif /* SUPPRESS */
+	}
+	if (strptr && *strptr != '\0') {
+	    FREE(host);
+	    HTAlwaysAlert(NULL, gettext("Address has invalid port"));
+	    return -1;
+	}
+    }
+#ifdef DECNET
+    /*
+     * Read Decnet node name.  @@ Should know about DECnet addresses, but it's
+     * probably worth waiting until the Phase transition from IV to V.
+     */
+    soc_in->sdn_nam.n_len = min(DN_MAXNAML, strlen(host));	/* <=6 in phase 4 */
+    StrNCpy(soc_in->sdn_nam.n_name, host, soc_in->sdn_nam.n_len + 1);
+    CTRACE((tfp,
+	    "DECnet: Parsed address as object number %d on host %.6s...\n",
+	    soc_in->sdn_objnum, host));
+#else /* parse Internet host: */
+
+    if (*host >= '0' && *host <= '9') {		/* Test for numeric node address: */
+	strptr = host;
+	while (*strptr) {
+	    if (*strptr == '.') {
+		dotcount_ip++;
+	    } else if (!isdigit(UCH(*strptr))) {
+		break;
+	    }
+	    strptr++;
+	}
+	if (*strptr) {		/* found non-numeric, assume domain name */
+	    dotcount_ip = 0;
+	}
+    }
+
+    /*
+     * Parse host number if present.
+     */
+    if (dotcount_ip == 3)	/* Numeric node address: */
+    {
+#ifdef GUSI
+	soc_in->sin_addr = inet_addr(host);	/* See netinet/in.h */
+#else
+#ifdef HAVE_INET_ATON
+	if (!inet_aton(host, &(soc_in->sin_addr))) {
+	    CTRACE((tfp, "inet_aton(%s) returns error\n", host));
+	    FREE(host);
+	    return -1;
+	}
+#else
+	soc_in->sin_addr.s_addr = inet_addr(host);	/* See arpa/inet.h */
+#endif /* HAVE_INET_ATON */
+#endif /* GUSI */
+	FREE(host);
+    } else {			/* Alphanumeric node name: */
+
+#ifdef MVS			/* Outstanding problem with crash in MVS gethostbyname */
+	CTRACE((tfp, "%s: Calling LYGetHostByName(%s)\n", this_func, host));
+#endif /* MVS */
+
+#ifdef _WINDOWS_NSL
+	gbl_phost = LYGetHostByName(host);	/* See above */
+	if (!gbl_phost)
+	    goto failed;
+	MemCpy((void *) &soc_in->sin_addr, gbl_phost->h_addr_list[0], gbl_phost->h_length);
+	FREE(gbl_phost);
+#else /* !_WINDOWS_NSL */
+	{
+	    LYNX_HOSTENT *phost;
+
+	    phost = LYGetHostByName(host);	/* See above */
+
+	    if (!phost)
+		goto failed;
+	    if (phost->h_length != sizeof soc_in->sin_addr) {
+		HTAlwaysAlert(host, gettext("Address length looks invalid"));
+	    }
+	    MemCpy((void *) &soc_in->sin_addr, phost->h_addr_list[0], phost->h_length);
+	    FREE_NSL_FORK(phost);
+	}
+#endif /* _WINDOWS_NSL */
+
+	FREE(host);
+    }				/* Alphanumeric node name */
+
+    CTRACE((tfp,
+	    "%s: Parsed address as port %d, IP address %d.%d.%d.%d\n",
+	    this_func,
+	    (int) ntohs(soc_in->sin_port),
+	    (int) *((unsigned char *) (&soc_in->sin_addr) + 0),
+	    (int) *((unsigned char *) (&soc_in->sin_addr) + 1),
+	    (int) *((unsigned char *) (&soc_in->sin_addr) + 2),
+	    (int) *((unsigned char *) (&soc_in->sin_addr) + 3)));
+#endif /* Internet vs. Decnet */
+
+    return 0;			/* OK */
+
+  failed:
+    CTRACE((tfp, "%s: Can't find internet node name `%s'.\n",
+	    this_func, host));
+    FREE(host);
+    switch (lynx_nsl_status) {
+    case HT_NOT_ACCEPTABLE:
+    case HT_INTERRUPTED:
+	return lynx_nsl_status;
+    default:
+	return -1;
+    }
+}
+#endif /* !INET6 */
+
+#ifdef INET6
+
+static void dump_addrinfo(const char *tag, const void *data)
+{
+    const LYNX_ADDRINFO *res;
+    int count = 0;
+
+    CTRACE((tfp, "dump_addrinfo %s:\n", tag));
+    for (res = (const LYNX_ADDRINFO *) data; res; res = res->ai_next) {
+	char hostbuf[1024], portbuf[1024];
+
+	++count;
+	hostbuf[0] = '\0';
+	portbuf[0] = '\0';
+	getnameinfo(res->ai_addr, res->ai_addrlen,
+		    hostbuf, (socklen_t) sizeof(hostbuf),
+		    portbuf, (socklen_t) sizeof(portbuf),
+		    NI_NUMERICHOST | NI_NUMERICSERV);
+
+	CTRACE((tfp,
+		"\t[%d] family %d, socktype %d, protocol %d addr %s port %s\n",
+		count,
+		res->ai_family,
+		res->ai_socktype,
+		res->ai_protocol,
+		hostbuf,
+		portbuf));
+    }
+}
+
+#if defined(NSL_FORK)
+
+/*
+ * Copy the relevant information (on the child-side).
+ */
+static size_t fill_addrinfo(void **buffer,
+			    const LYNX_ADDRINFO *phost)
+{
+    static const char *this_func = "fill_addinfo";
+
+    const LYNX_ADDRINFO *q;
+    LYNX_ADDRINFO *actual;
+    LYNX_ADDRINFO *result;
+    int count = 0;
+    int limit = 0;
+    size_t need = sizeof(LYNX_ADDRINFO);
+    char *heap;
+
+    CTRACE((tfp, "filladdr_info %p\n", (const void *) phost));
+    for (q = phost; q != 0; q = q->ai_next) {
+	++limit;
+	need += phost->ai_addrlen;
+	need += sizeof(LYNX_ADDRINFO);
+    }
+    CTRACE((tfp, "...fill_addrinfo %d:%lu\n", limit, (unsigned long) need));
+
+    if ((result = (LYNX_ADDRINFO *) calloc(1, need)) == 0)
+	outofmem(__FILE__, this_func);
+
+    *buffer = actual = result;
+    heap = ((char *) actual) + ((size_t) limit * sizeof(LYNX_ADDRINFO));
+
+    for (count = 0; count < limit; ++count) {
+
+	/*
+	 * copying the whole structure seems simpler but because it is not
+	 * packed, uninitialized gaps make it hard to analyse with valgrind.
+	 */
+	/* *INDENT-EQLS* */
+	actual->ai_flags    = phost->ai_flags;
+	actual->ai_family   = phost->ai_family;
+	actual->ai_socktype = phost->ai_socktype;
+	actual->ai_protocol = phost->ai_protocol;
+	actual->ai_addrlen  = phost->ai_addrlen;
+	actual->ai_addr     = (struct sockaddr *) (void *) heap;
+
+	MemCpy(heap, phost->ai_addr, phost->ai_addrlen);
+	heap += phost->ai_addrlen;
+
+	phost = phost->ai_next;
+
+	actual->ai_next = ((count + 1 < limit)
+			   ? (actual + 1)
+			   : 0);
+	++actual;
+    }
+    return (size_t) (heap - (char *) result);
+}
+
+/*
+ * Read data, repair pointers as done in fill_addrinfo().
+ */
+static unsigned read_addrinfo(int fd, char *buffer, size_t length)
+{
+    unsigned result = read_bytes(fd, buffer, length);
+    LYNX_ADDRINFO *actual = (LYNX_ADDRINFO *) (void *) buffer;
+    LYNX_ADDRINFO *res;
+    int count = 0;
+    int limit;
+    char *heap;
+
+    CTRACE((tfp, "read_addrinfo length %lu\n", (unsigned long) length));
+    for (limit = 0; actual[limit].ai_next; ++limit) {
+    }
+    ++limit;
+    heap = (char *) (actual + limit);
+    CTRACE((tfp, "...read_addrinfo %d items\n", limit));
+
+    for (res = actual, count = 0; count < limit; ++count) {
+	res->ai_addr = (struct sockaddr *) (void *) heap;
+	heap += res->ai_addrlen;
+	if (count < limit - 1) {
+	    res->ai_next = (res + 1);
+	    ++res;
+	} else {
+	    res->ai_next = 0;
+	}
+    }
+
+#ifdef DEBUG_HOSTENT
+    dump_addrinfo("read_addrinfo", buffer);
+#endif
+    return result;
+}
+
+/*
+ * This is called via the child-side of the fork.
+ */
+static void really_getaddrinfo(const char *host,
+			       const char *port,
+			       STATUSES * statuses,
+			       void **result)
+{
+    LYNX_ADDRINFO hints, *res = 0;
+    int error;
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = PF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    error = getaddrinfo(host, port, &hints, &res);
+    if (error) {
+	CTRACE((tfp, "HTGetAddrInfo: getaddrinfo(%s, %s): %s\n", host, port,
+		gai_strerror(error)));
+    } else {
+	statuses->child_errno = errno;
+	statuses->child_h_errno = h_errno;
+#ifdef HAVE_H_ERRNO
+	statuses->h_errno_valid = YES;
+#endif
+
+#ifdef DEBUG_HOSTENT_CHILD
+	dump_addrinfo("CHILD getaddrinfo", res);
+#endif
+	statuses->rehostentlen = fill_addrinfo(result, res);
+#ifdef DEBUG_HOSTENT_CHILD
+	dump_addrinfo("CHILD fill_addrinfo", (const LYNX_ADDRINFO *) (*result));
+#endif
+	if (statuses->rehostentlen <= sizeof(LYNX_ADDRINFO) || (*result) == NULL) {
+	    statuses->rehostentlen = 0;
+	    statuses->h_length = 0;
+	} else {
+	    statuses->h_length = (int) (((LYNX_ADDRINFO *) (*result))->ai_addrlen);
+	}
+	freeaddrinfo(res);
+    }
+}
+#endif /* NSL_FORK */
+
+static LYNX_ADDRINFO *HTGetAddrInfo(const char *str,
+				    const int defport)
+{
+#ifdef NSL_FORK
+    /* for transfer of result between from child to parent: */
+    void *readdrinfo = 0;
+
+#else
+    LYNX_ADDRINFO hints;
+    int error;
+#endif /* NSL_FORK */
+    LYNX_ADDRINFO *res;
+    char *p;
+    char *s = NULL;
+    char *host, *port;
+    char pbuf[80];
+
+    StrAllocCopy(s, str);
+
+    if (s[0] == '[' && (p = StrChr(s, ']')) != NULL) {
+	*p++ = '\0';
+	host = s + 1;
+    } else {
+	p = s;
+	host = &s[0];
+    }
+    port = strrchr(p, ':');
+    if (port) {
+	*port++ = '\0';
+    } else {
+	sprintf(pbuf, "%d", defport);
+	port = pbuf;
+    }
+
+#ifdef NSL_FORK
+    if (setup_nsl_fork(really_getaddrinfo,
+		       read_addrinfo,
+		       dump_addrinfo,
+		       host, port, &readdrinfo)) {
+	res = readdrinfo;
+    } else {
+	res = NULL;
+    }
+#else
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = PF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    error = getaddrinfo(host, port, &hints, &res);
+    if (error || !res) {
+	CTRACE((tfp, "HTGetAddrInfo: getaddrinfo(%s, %s): %s\n", host, port,
+		gai_strerror(error)));
+	res = NULL;
+    }
+#endif
+
+    free(s);
+#ifdef DEBUG_HOSTENT
+    dump_addrinfo("HTGetAddrInfo", res);
+#endif
+    return res;
+}
+
+BOOLEAN HTCheckAddrInfo(const char *str, const int defport)
+{
+    LYNX_ADDRINFO *data = HTGetAddrInfo(str, defport);
+    BOOLEAN result = (data != 0);
+
+    FREE_NSL_FORK(data);
+    return result;
+}
+#endif /* INET6 */
+
+#ifdef LY_FIND_LEAKS
+/*	Free our name for the host on which we are - FM
+ *	-------------------------------------------
+ *
+ */
+static void free_HTTCP_hostname(void)
+{
+    FREE(hostname);
+}
+#endif /* LY_FIND_LEAKS */
+
+/*	Derive the name of the host on which we are
+ *	-------------------------------------------
+ *
+ */
+static void get_host_details(void)
+{
+    char name[MAXHOSTNAMELEN + 1];	/* The name of this host */
+
+#ifdef UCX
+    char *domain_name;		/* The name of this host domain */
+#endif /* UCX */
+#ifdef NEED_HOST_ADDRESS	/* no -- needs name server! */
+#ifdef INET6
+    LYNX_ADDRINFO hints, *res;
+    int error;
+
+#else
+    LYNX_HOSTENT *phost;	/* Pointer to host -- See netdb.h */
+#endif /* INET6 */
+#endif /* NEED_HOST_ADDRESS */
+    size_t namelength = sizeof(name);
+
+    if (hostname)
+	return;			/* Already done */
+    gethostname(name, namelength);	/* Without domain */
+    StrAllocCopy(hostname, name);
+#ifdef LY_FIND_LEAKS
+    atexit(free_HTTCP_hostname);
+#endif
+#ifdef UCX
+    /*
+     * UCX doesn't give the complete domain name.  Get rest from UCX$BIND_DOM
+     * logical.
+     */
+    if (StrChr(hostname, '.') == NULL) {	/* Not full address */
+	domain_name = LYGetEnv("UCX$BIND_DOMAIN");
+	if (domain_name == NULL)
+	    domain_name = LYGetEnv("TCPIP$BIND_DOMAIN");
+	if (domain_name != NULL) {
+	    StrAllocCat(hostname, ".");
+	    StrAllocCat(hostname, domain_name);
+	}
+    }
+#endif /* UCX */
+    CTRACE((tfp, "TCP: Local host name is %s\n", hostname));
+
+#ifndef DECNET			/* Decnet ain't got no damn name server 8#OO */
+#ifdef NEED_HOST_ADDRESS	/* no -- needs name server! */
+#ifdef INET6
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = PF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags = AI_CANONNAME;
+    error = getaddrinfo(name, NULL, &hints, &res);
+    if (error || !res || !res->ai_canonname) {
+	CTRACE((tfp, "TCP: %s: `%s'\n", gai_strerror(error), name));
+	if (res)
+	    freeaddrinfo(res);
+	return;			/* Fail! */
+    }
+    StrAllocCopy(hostname, res->ai_canonname);
+    MemCpy(&HTHostAddress, res->ai_addr, res->ai_addrlen);
+    freeaddrinfo(res);
+#else
+    phost = gethostbyname(name);	/* See netdb.h */
+    if (!OK_HOST(phost)) {
+	CTRACE((tfp,
+		"TCP: Can't find my own internet node address for `%s'!!\n",
+		name));
+	return;			/* Fail! */
+    }
+    StrAllocCopy(hostname, phost->h_name);
+    MemCpy(&HTHostAddress, &phost->h_addr_list[0], phost->h_length);
+#endif /* INET6 */
+    CTRACE((tfp, "     Name server says that I am `%s' = %s\n",
+	    hostname, HTInetString(&HTHostAddress)));
+#endif /* NEED_HOST_ADDRESS */
+
+#endif /* !DECNET */
+}
+
+const char *HTHostName(void)
+{
+    get_host_details();
+    return hostname;
+}
+
+#ifdef _WINDOWS
+#define SET_EINTR WSASetLastError(EINTR)
+#else
+#define SET_EINTR SOCKET_ERRNO = EINTR
+#endif
+
+static BOOL HTWasInterrupted(int *status)
+{
+    BOOL result = FALSE;
+
+    if (HTCheckForInterrupt()) {
+	result = TRUE;
+	*status = HT_INTERRUPTED;
+	SET_EINTR;
+    }
+    return result;
+}
+
+#define TRIES_PER_SECOND 10
+
+/*
+ * Set the select-timeout to 0.1 seconds.
+ */
+static void set_timeout(struct timeval *timeoutp)
+{
+    timeoutp->tv_sec = 0;
+    timeoutp->tv_usec = 100000;
+}
+
+#ifndef MULTINET		/* SOCKET_ERRNO != errno ? */
+#if !defined(UCX) || !defined(VAXC)	/* errno not modifiable ? */
+#define SOCKET_DEBUG_TRACE	/* show errno status after some system calls */
+#endif /* UCX && VAXC */
+#endif /* MULTINET */
+/*
+ *  Interruptible connect as implemented for Mosaic by Marc Andreesen
+ *  and hacked in for Lynx years ago by Lou Montulli, and further
+ *  modified over the years by numerous Lynx lovers. - FM
+ */
+int HTDoConnect(const char *url,
+		const char *protocol,
+		int default_port,
+		int *s)
+{
+    char *socks5_host = NULL;
+    unsigned socks5_host_len = 0;
+    int socks5_port;
+    const char *socks5_orig_url;
+    char *socks5_new_url = NULL;
+    char *socks5_protocol = NULL;
+    int status = HT_OK;
+    char *line = NULL;
+    char *p1 = NULL;
+    char *host = NULL;
+    char const *emsg;
+
+#ifdef INET6
+    LYNX_ADDRINFO *res = 0, *res0 = 0;
+
+#else
+    struct sockaddr_in sock_A;
+    struct sockaddr_in *soc_in = &sock_A;
+#endif
+
+    *s = -1;			/* nothing is open yet */
+
+    /* In case of a present SOCKS5 proxy, marshal */
+    if (socks5_proxy == NULL)
+	socks5_proxy = LYGetEnv("SOCKS5_PROXY");
+    if ((socks5_orig_url = socks5_proxy) != NULL) {
+	int xport;
+
+	xport = default_port;
+	socks5_orig_url = url;
+	StrAllocCopy(socks5_new_url, url);
+
+	/* Get node name and optional port number of wanted URL */
+	if ((p1 = HTParse(socks5_new_url, "", PARSE_HOST)) != NULL) {
+	    StrAllocCopy(socks5_host, p1);
+	    strip_userid(socks5_host, FALSE);
+	    FREE(p1);
+	}
+
+	if (isEmpty(socks5_host)) {
+	    emsg = gettext("SOCKS5: no hostname found.");
+	    status = HT_ERROR;
+	    goto report_error;
+	}
+
+	if (strlen(socks5_host) > 255) {
+	    emsg = gettext("SOCKS5: hostname too long.");
+	    status = HT_ERROR;
+	    goto report_error;
+	}
+	socks5_host_len = (unsigned) strlen(socks5_host);
+
+	if (HTParsePort(socks5_new_url, &socks5_port) == NULL)
+	    socks5_port = xport;
+	FREE(socks5_new_url);
+
+	/* And switch over to our SOCKS5 config; in order to embed that into
+	 * lynx environment, prepend protocol prefix */
+	default_port = 1080;	/* RFC 1928 */
+	HTSACat(&socks5_new_url, "socks://");
+	HTSACat(&socks5_new_url, socks5_proxy);
+	url = socks5_new_url;
+
+	HTSprintf0(&socks5_protocol,
+		   gettext("(for %s at %s) SOCKS5"),
+		   protocol, socks5_host);
+	protocol = socks5_protocol;
+    }
+#ifndef INET6
+    /*
+     * Set up defaults.
+     */
+    memset(soc_in, 0, sizeof(*soc_in));
+    soc_in->sin_family = AF_INET;
+    soc_in->sin_port = htons((PortNumber) default_port);
+#endif /* INET6 */
+
+    /*
+     * Get node name and optional port number.
+     */
+    p1 = HTParse(url, "", PARSE_HOST);
+    StrAllocCopy(host, p1);
+    strip_userid(host, FALSE);
+    FREE(p1);
+
+    HTSprintf0(&line, "%s%s", WWW_FIND_MESSAGE, host);
+    _HTProgress(line);
+#ifdef INET6
+    /* HTParseInet() is useless! */
+    res0 = HTGetAddrInfo(host, default_port);
+    if (res0 == NULL) {
+	HTSprintf0(&line, gettext("Unable to locate remote host %s."), host);
+	_HTProgress(line);
+	status = HT_NO_DATA;
+	goto cleanup;
+    }
+#else
+    status = HTParseInet(soc_in, host);
+    if (status) {
+	if (status != HT_INTERRUPTED) {
+	    if (status == HT_NOT_ACCEPTABLE) {
+		/* Not HTProgress, so warning won't be overwritten immediately;
+		 * but not HTAlert, because typically there will be other
+		 * alerts from the callers.  - kw
+		 */
+		HTUserMsg2(gettext("Invalid hostname %s"), host);
+	    } else {
+		HTSprintf0(&line,
+			   gettext("Unable to locate remote host %s."), host);
+		_HTProgress(line);
+	    }
+	    status = HT_NO_DATA;
+	}
+	goto cleanup;
+    }
+#endif /* INET6 */
+
+    HTSprintf0(&line, gettext("Making %s connection to %s"), protocol, host);
+    _HTProgress(line);
+
+    /*
+     * Now, let's get a socket set up from the server for the data.
+     */
+#ifndef INET6
+    *s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (*s == -1) {
+	status = HT_NO_DATA;
+	emsg = gettext("socket failed.");
+	goto report_error;
+    }
+#else
+    for (res = res0; res; res = res->ai_next) {
+	*s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+	if (*s == -1) {
+	    char hostbuf[1024], portbuf[1024];
+
+	    getnameinfo(res->ai_addr, res->ai_addrlen,
+			hostbuf, (socklen_t) sizeof(hostbuf),
+			portbuf, (socklen_t) sizeof(portbuf),
+			NI_NUMERICHOST | NI_NUMERICSERV);
+	    HTSprintf0(&line,
+		       gettext("socket failed: family %d addr %s port %s."),
+		       res->ai_family, hostbuf, portbuf);
+	    _HTProgress(line);
+	    continue;
+	}
+#endif /* INET6 */
+
+#if !defined(DOSPATH) || defined(__DJGPP__)
+#if !defined(NO_IOCTL) || defined(USE_FCNTL)
+	/*
+	 * Make the socket non-blocking, so the connect can be canceled.  This
+	 * means that when we issue the connect we should NOT have to wait for
+	 * the accept on the other end.
+	 */
+	{
+#ifdef USE_FCNTL
+	    int ret = fcntl(*s, F_SETFL, O_NONBLOCK);
+
+#else
+	    int val = 1;
+	    int ret = IOCTL(*s, FIONBIO, &val);
+#endif /* USE_FCNTL */
+	    if (ret == -1)
+		_HTProgress(gettext("Could not make connection non-blocking."));
+	}
+#endif /* !NO_IOCTL || USE_FCNTL */
+#endif /* !DOSPATH || __DJGPP__ */
+
+	/*
+	 * Issue the connect.  Since the server can't do an instantaneous
+	 * accept and we are non-blocking, this will almost certainly return a
+	 * negative status.
+	 */
+#ifdef SOCKS
+	if (socks_flag) {
+#ifdef INET6
+	    status = Rconnect(*s, res->ai_addr, res->ai_addrlen);
+#else
+	    status = Rconnect(*s, SOCKADDR_OF(sock_A), sizeof(sock_A));
+#endif /* INET6 */
+	} else
+#endif /* SOCKS */
+#ifdef INET6
+	    status = connect(*s, res->ai_addr, res->ai_addrlen);
+#else
+	    status = connect(*s, SOCKADDR_OF(sock_A), sizeof(sock_A));
+#endif /* INET6 */
+
+	/*
+	 * According to the Sun man page for connect:
+	 *  EINPROGRESS         The socket is non-blocking and the  con-
+	 *                      nection cannot be completed immediately.
+	 *                      It is possible to select(2) for  comple-
+	 *                      tion  by  selecting the socket for writ-
+	 *                      ing.
+	 * According to the Motorola SVR4 man page for connect:
+	 *  EAGAIN              The socket is non-blocking and the  con-
+	 *                      nection cannot be completed immediately.
+	 *                      It is possible to select for  completion
+	 *                      by  selecting  the  socket  for writing.
+	 *                      However, this is only  possible  if  the
+	 *                      socket  STREAMS  module  is  the topmost
+	 *                      module on  the  protocol  stack  with  a
+	 *                      write  service  procedure.  This will be
+	 *                      the normal case.
+	 */
+	CTRACE((tfp, "connect(): status: %d, SOCK_ERRNO: %d\n", status, SOCKET_ERRNO));
+
+	if ((status < 0) &&
+	    (SOCKET_ERRNO == EINPROGRESS
+#ifdef EAGAIN
+	     || SOCKET_ERRNO == EAGAIN
+#endif
+	    )) {
+	    struct timeval select_timeout;
+	    int ret;
+	    int tries = 0;
+
+#ifdef SOCKET_DEBUG_TRACE
+	    if (SOCKET_ERRNO != EINPROGRESS) {
+		HTInetStatus("this socket's first connect");
+	    }
+#endif /* SOCKET_DEBUG_TRACE */
+	    ret = 0;
+	    while (ret <= 0) {
+		fd_set writefds;
+
+		/*
+		 * Protect against an infinite loop.
+		 */
+		if ((tries++ / TRIES_PER_SECOND) >= connect_timeout) {
+		    HTAlert(gettext("Connection failed (too many retries)."));
+#ifdef INET6
+#ifndef NSL_FORK
+		    if (res0)
+			freeaddrinfo(res0);
+#endif
+#endif /* INET6 */
+		    status = HT_NO_DATA;
+		    goto cleanup;
+		}
+		set_timeout(&select_timeout);
+		FD_ZERO(&writefds);
+		FD_SET((LYNX_FD) *s, &writefds);
+#ifdef SOCKS
+		if (socks_flag)
+		    ret = Rselect(*s + 1, NULL,
+				  &writefds, NULL, &select_timeout);
+		else
+#endif /* SOCKS */
+		    ret = select(*s + 1,
+				 NULL,
+				 &writefds,
+				 NULL,
+				 &select_timeout);
+
+#ifdef SOCKET_DEBUG_TRACE
+		if (tries == 1) {
+		    if (SOCKET_ERRNO != EINPROGRESS) {
+			HTInetStatus("this socket's first select");
+		    }
+		}
+#endif /* SOCKET_DEBUG_TRACE */
+		/*
+		 * If we suspend, then it is possible that select will be
+		 * interrupted.  Allow for this possibility.  - JED
+		 */
+		if ((ret == -1) && (SOCKET_ERRNO == EINTR))
+		    continue;
+
+#ifdef SOCKET_DEBUG_TRACE
+		if (ret < 0) {
+		    HTInetStatus("failed select");
+		}
+#endif /* SOCKET_DEBUG_TRACE */
+		/*
+		 * Again according to the Sun and Motorola man pages for
+		 * connect:
+		 *  EALREADY    The socket is non-blocking and a  previ-
+		 *              ous  connection attempt has not yet been
+		 *              completed.
+		 * Thus if the SOCKET_ERRNO is NOT EALREADY we have a real
+		 * error, and should break out here and return that error.
+		 * Otherwise if it is EALREADY keep on trying to complete the
+		 * connection.
+		 */
+		if ((ret < 0) && (SOCKET_ERRNO != EALREADY)) {
+		    status = ret;
+		    break;
+		} else if (((SOCKET_ERRNO == EALREADY) ||
+			    (SOCKET_ERRNO == EINPROGRESS)) &&
+			   HTCheckForInterrupt()) {
+		    status = HT_INTERRUPTED;
+		    break;
+		} else if (ret > 0) {
+		    /*
+		     * Extra check here for connection success, if we try to
+		     * connect again, and get EISCONN, it means we have a
+		     * successful connection.  But don't check with SOCKS.
+		     */
+#ifdef SOCKS
+		    if (socks_flag) {
+			status = 0;
+		    } else {
+#endif /* SOCKS */
+#ifdef INET6
+			status = connect(*s, res->ai_addr, res->ai_addrlen);
+#else
+			status = connect(*s, SOCKADDR_OF(sock_A), sizeof(sock_A));
+#endif /* INET6 */
+#ifdef UCX
+			/*
+			 * A UCX feature:  Instead of returning EISCONN UCX
+			 * returns EADDRINUSE.  Test for this status also.
+			 */
+			if ((status < 0) && ((SOCKET_ERRNO == EISCONN) ||
+					     (SOCKET_ERRNO == EADDRINUSE)))
+#else
+			if ((status < 0) && (SOCKET_ERRNO == EISCONN))
+#endif /* UCX */
+			{
+			    status = 0;
+			}
+
+			if (status && (SOCKET_ERRNO == EALREADY))	/* new stuff LJM */
+			    ret = 0;	/* keep going */
+			else {
+#ifdef SOCKET_DEBUG_TRACE
+			    if (status < 0) {
+				HTInetStatus("confirm-ready connect");
+			    }
+#endif /* SOCKET_DEBUG_TRACE */
+			    break;
+			}
+#ifdef SOCKS
+		    }
+#endif /* SOCKS */
+		}
+#ifdef SOCKS
+		else if (!socks_flag)
+#else
+		else
+#endif /* SOCKS */
+		{
+		    /*
+		     * The select says we aren't ready yet.  Try to connect
+		     * again to make sure.  If we don't get EALREADY or
+		     * EISCONN, something has gone wrong.  Break out and report
+		     * it.
+		     *
+		     * For some reason, SVR4 returns EAGAIN here instead of
+		     * EALREADY, even though the man page says it should be
+		     * EALREADY.
+		     *
+		     * For some reason, UCX pre 3 apparently returns errno =
+		     * 18242 instead of EALREADY or EISCONN.
+		     */
+#ifdef INET6
+		    status = connect(*s, res->ai_addr, res->ai_addrlen);
+#else
+		    status = connect(*s, SOCKADDR_OF(sock_A), sizeof(sock_A));
+#endif /* INET6 */
+		    if ((status < 0) &&
+			(SOCKET_ERRNO != EALREADY
+#ifdef EAGAIN
+			 && SOCKET_ERRNO != EAGAIN
+#endif
+			) &&
+#ifdef UCX
+			(SOCKET_ERRNO != 18242) &&
+#endif /* UCX */
+			(SOCKET_ERRNO != EISCONN)) {
+#ifdef SOCKET_DEBUG_TRACE
+			HTInetStatus("confirm-not-ready connect");
+#endif /* SOCKET_DEBUG_TRACE */
+			break;
+		    }
+		}
+		if (HTWasInterrupted(&status)) {
+		    CTRACE((tfp, "*** INTERRUPTED in middle of connect.\n"));
+		    break;
+		}
+	    }
+	}
+#ifdef SOCKET_DEBUG_TRACE
+	else if (status < 0) {
+	    HTInetStatus("this socket's first and only connect");
+	}
+#endif /* SOCKET_DEBUG_TRACE */
+#ifdef INET6
+	if (status < 0) {
+	    NETCLOSE(*s);
+	    *s = -1;
+	    if (status != HT_INTERRUPTED)
+		continue;
+	}
+	break;
+    }
+#endif /* INET6 */
+
+#ifdef INET6
+    if (*s < 0)
+#else
+    if (status < 0)
+#endif /* INET6 */
+    {
+	/*
+	 * The connect attempt failed or was interrupted, so close up the
+	 * socket.
+	 */
+	NETCLOSE(*s);
+    }
+#if !defined(DOSPATH) || defined(__DJGPP__)
+#if !defined(NO_IOCTL) || defined(USE_FCNTL)
+    else {
+	/*
+	 * Make the socket blocking again on good connect.
+	 */
+#ifdef USE_FCNTL
+	int ret = fcntl(*s, F_SETFL, 0);
+
+#else
+	int val = 0;
+	int ret = IOCTL(*s, FIONBIO, &val);
+#endif /* USE_FCNTL */
+	if (ret == -1)
+	    _HTProgress(gettext("Could not restore socket to blocking."));
+    }
+#endif /* !NO_IOCTL || USE_FCNTL */
+#endif /* !DOSPATH || __DJGPP__ */
+
+#ifdef INET6
+#ifdef NSL_FORK
+    FREE_NSL_FORK(res0);
+#else
+    if (res0)
+	freeaddrinfo(res0);
+#endif
+#endif /* INET6 */
+
+    /* Now if this was a SOCKS5 proxy connection, go for the real one */
+    if (status >= 0 && socks5_orig_url != NULL) {
+	unsigned char pbuf[4 + 1 + 255 + 2];
+	unsigned i;
+
+	/* RFC 1928: version identifier/method selection message */
+	pbuf[0] = 0x05;		/* VER: protocol version: X'05' */
+	pbuf[1] = 0x01;		/* NMETHODS: 1 */
+	pbuf[2] = 0x00;		/* METHOD: X'00' NO AUTHENTICATION REQUIRED */
+	if (NETWRITE(*s, (char *) pbuf, 3) != 3) {
+	    goto report_system_err;
+	} else if (HTDoRead(*s, pbuf, 2) != 2) {
+	    goto report_system_err;
+	} else if (pbuf[0] != 0x05 || pbuf[1] != 0x00) {
+	    goto report_unexpected_reply;
+	}
+
+	/* RFC 1928: CONNECT request */
+	HTSprintf0(&line, gettext("SOCKS5: connecting to %s"), socks5_host);
+	_HTProgress(line);
+	pbuf[0] = 0x05;		/* VER: protocol version: X'05' */
+	pbuf[1] = 0x01;		/* CMD: CONNECT X'01' */
+	pbuf[2] = 0x00;		/* RESERVED */
+	pbuf[3] = 0x03;		/* ATYP: domain name */
+	pbuf[4] = (unsigned char) socks5_host_len;
+	memcpy(&pbuf[i = 5], socks5_host, socks5_host_len);
+	i += socks5_host_len;
+	/* C99 */  {
+	    unsigned short x;	/* XXX 16-bit? */
+
+	    x = htons((PortNumber) socks5_port);
+	    memcpy(&pbuf[i], (unsigned char *) &x, sizeof x);
+	    i += (unsigned) sizeof(x);
+	}
+	if ((size_t) NETWRITE(*s, (char *) pbuf, i) != i) {
+	    goto report_system_err;
+	} else if ((unsigned) HTDoRead(*s, pbuf, 4) != 4) {
+	    goto report_system_err;
+	}
+	/* Version 5, reserved must be 0 */
+	if (pbuf[0] == 0x05 && pbuf[2] == 0x00) {
+	    /* Result */
+	    switch (pbuf[1]) {
+	    case 0x00:
+		emsg = NULL;
+		break;
+	    case 0x01:
+		emsg = gettext("SOCKS server failure");
+		break;
+	    case 0x02:
+		emsg = gettext("connection not allowed by ruleset");
+		break;
+	    case 0x03:
+		emsg = gettext("network unreachable");
+		break;
+	    case 0x04:
+		emsg = gettext("host unreachable");
+		break;
+	    case 0x05:
+		emsg = gettext("connection refused");
+		break;
+	    case 0x06:
+		emsg = gettext("TTL expired");
+		break;
+	    case 0x07:
+		emsg = gettext("command not supported");
+		break;
+	    case 0x08:
+		emsg = gettext("address type not supported");
+		break;
+	    default:
+		emsg = gettext("unknown SOCKS error code");
+		break;
+	    }
+	    if (emsg != NULL) {
+		goto report_no_connection;
+	    }
+	} else {
+	    goto report_unexpected_reply;
+	}
+
+	/* Address type variable; read the BND.PORT with it.
+	 * This is actually false since RFC 1928 says that the BND.ADDR reply
+	 * to CONNECT contains the IP address, so only 0x01 and 0x04 are
+	 * allowed */
+	switch (pbuf[3]) {
+	case 0x01:
+	    i = 4;
+	    break;
+	case 0x03:
+	    i = 1;
+	    break;
+	case 0x04:
+	    i = 16;
+	    break;
+	default:
+	    goto report_unexpected_reply;
+	}
+	i += (unsigned) sizeof(unsigned short);
+
+	if ((size_t) HTDoRead(*s, pbuf, i) != i) {
+	    goto report_system_err;
+	} else if (i == 1 + sizeof(unsigned short)) {
+	    i = pbuf[0];
+	    if ((size_t) HTDoRead(*s, pbuf, i) != i) {
+		goto report_system_err;
+	    }
+	}
+    }
+    goto cleanup;
+
+  report_system_err:
+    emsg = LYStrerror(errno);
+    goto report_no_connection;
+
+  report_unexpected_reply:
+    emsg = gettext("unexpected reply\n");
+    /* FALLTHRU */
+
+  report_no_connection:
+    status = HT_NO_CONNECTION;
+    /* FALLTHRU */
+
+  report_error:
+    HTAlert(emsg);
+    if (*s != -1) {
+	NETCLOSE(*s);
+    }
+
+  cleanup:
+    if (socks5_proxy != NULL) {
+	FREE(socks5_new_url);
+	FREE(socks5_protocol);
+	FREE(socks5_host);
+    }
+    FREE(host);
+    FREE(line);
+    return status;
+}
+
+/*
+ *  This is interruptible so reads can be implemented cleanly.
+ */
+int HTDoRead(int fildes,
+	     void *buf,
+	     unsigned nbyte)
+{
+    int result;
+    BOOL ready;
+
+#if !defined(NO_IOCTL)
+    int ret;
+    fd_set readfds;
+    struct timeval select_timeout;
+    int tries = 0;
+
+#ifdef USE_READPROGRESS
+    int otries = 0;
+    time_t otime = time((time_t *) 0);
+    time_t start = otime;
+#endif
+#endif /* !NO_IOCTL */
+
+#if defined(UNIX) && !defined(__BEOS__)
+    if (fildes == 0) {
+	/*
+	 * 0 can be a valid socket fd, but if it's a tty something must have
+	 * gone wrong.  - kw
+	 */
+	if (isatty(fildes)) {
+	    CTRACE((tfp, "HTDoRead - refusing to read fd 0 which is a tty!\n"));
+	    return -1;
+	}
+    } else
+#endif
+    if (fildes <= 0) {
+	CTRACE((tfp, "HTDoRead - no file descriptor!\n"));
+	return -1;
+    }
+
+    if (HTWasInterrupted(&result)) {
+	CTRACE((tfp, "HTDoRead - interrupted before starting!\n"));
+	return (result);
+    }
+#if defined(NO_IOCTL)
+    ready = TRUE;
+#else
+    ready = FALSE;
+    while (!ready) {
+	/*
+	 * Protect against an infinite loop.
+	 */
+	if ((tries++ / TRIES_PER_SECOND) >= reading_timeout) {
+	    HTAlert(gettext("Socket read failed (too many tries)."));
+	    SET_EINTR;
+	    result = HT_INTERRUPTED;
+	    break;
+	}
+#ifdef USE_READPROGRESS
+	if (tries - otries > TRIES_PER_SECOND) {
+	    time_t t = time((time_t *) 0);
+
+	    otries = tries;
+	    if (t - otime >= 5) {
+		otime = t;
+		HTReadProgress((off_t) (-1), (off_t) 0);	/* Put "stalled" message */
+	    }
+	}
+#endif
+
+	/*
+	 * If we suspend, then it is possible that select will be interrupted.
+	 * Allow for this possibility.  - JED
+	 */
+	do {
+	    set_timeout(&select_timeout);
+	    FD_ZERO(&readfds);
+	    FD_SET((LYNX_FD) fildes, &readfds);
+#ifdef SOCKS
+	    if (socks_flag)
+		ret = Rselect(fildes + 1,
+			      &readfds, NULL, NULL, &select_timeout);
+	    else
+#endif /* SOCKS */
+		ret = select(fildes + 1,
+			     &readfds, NULL, NULL, &select_timeout);
+	} while ((ret == -1) && (errno == EINTR));
+
+	if (ret < 0) {
+	    result = -1;
+	    break;
+	} else if (ret > 0) {
+	    ready = TRUE;
+	} else if (HTWasInterrupted(&result)) {
+	    break;
+	}
+    }
+#endif /* !NO_IOCTL */
+
+    if (ready) {
+#if defined(UCX) && defined(VAXC)
+	/*
+	 * VAXC and UCX problem only.
+	 */
+	errno = vaxc$errno = 0;
+	result = SOCKET_READ(fildes, buf, nbyte);
+	CTRACE((tfp,
+		"Read - result,errno,vaxc$errno: %d %d %d\n", result, errno, vaxc$errno));
+	if ((result <= 0) && TRACE)
+	    perror("HTTCP.C:HTDoRead:read");	/* RJF */
+	/*
+	 * An errno value of EPIPE and result < 0 indicates end-of-file on VAXC.
+	 */
+	if ((result <= 0) && (errno == EPIPE)) {
+	    result = 0;
+	    set_errno(0);
+	}
+#else
+#ifdef UNIX
+	while ((result = (int) SOCKET_READ(fildes, buf, nbyte)) == -1) {
+	    if (errno == EINTR)
+		continue;
+#ifdef ERESTARTSYS
+	    if (errno == ERESTARTSYS)
+		continue;
+#endif /* ERESTARTSYS */
+	    HTInetStatus("read");
+	    break;
+	}
+#else /* UNIX */
+	result = NETREAD(fildes, (char *) buf, nbyte);
+#endif /* !UNIX */
+#endif /* UCX && VAXC */
+    }
+#ifdef USE_READPROGRESS
+    CTRACE2(TRACE_TIMING, (tfp, "...HTDoRead returns %d (%" PRI_time_t
+			   " seconds)\n",
+			   result, CAST_time_t (time((time_t *)0) - start)));
+#endif
+    return result;
+}
+
+#ifdef SVR4_BSDSELECT
+/*
+ *  This is a fix for the difference between BSD's select() and
+ *  SVR4's select().  SVR4's select() can never return a value larger
+ *  than the total number of file descriptors being checked.  So, if
+ *  you select for read and write on one file descriptor, and both
+ *  are true, SVR4 select() will only return 1.  BSD select in the
+ *  same situation will return 2.
+ *
+ *	Additionally, BSD select() on timing out, will zero the masks,
+ *	while SVR4 does not.  This is fixed here as well.
+ *
+ *	Set your tabstops to 4 characters to have this code nicely formatted.
+ *
+ *	Jerry Whelan, guru@bradley.edu, June 12th, 1993
+ */
+#ifdef select
+#undef select
+#endif /* select */
+
+#ifdef SOCKS
+#ifdef Rselect
+#undef Rselect
+#endif /* Rselect */
+#endif /* SOCKS */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/select.h>
+
+int BSDselect(int nfds,
+	      fd_set * readfds,
+	      fd_set * writefds,
+	      fd_set * exceptfds,
+	      struct timeval *select_timeout)
+{
+    int rval, i;
+
+#ifdef SOCKS
+    if (socks_flag)
+	rval = Rselect(nfds, readfds, writefds, exceptfds, select_timeout);
+    else
+#endif /* SOCKS */
+	rval = select(nfds, readfds, writefds, exceptfds, select_timeout);
+
+    switch (rval) {
+    case -1:
+	return (rval);
+
+    case 0:
+	if (readfds != NULL)
+	    FD_ZERO(readfds);
+	if (writefds != NULL)
+	    FD_ZERO(writefds);
+	if (exceptfds != NULL)
+	    FD_ZERO(exceptfds);
+	return (rval);
+
+    default:
+	for (i = 0, rval = 0; i < nfds; i++) {
+	    if ((readfds != NULL) && FD_ISSET(i, readfds))
+		rval++;
+	    if ((writefds != NULL) && FD_ISSET(i, writefds))
+		rval++;
+	    if ((exceptfds != NULL) && FD_ISSET(i, exceptfds))
+		rval++;
+
+	}
+	return (rval);
+    }
+/* Should never get here */
+}
+#endif /* SVR4_BSDSELECT */
diff --git a/WWW/Library/Implementation/HTTCP.h b/WWW/Library/Implementation/HTTCP.h
new file mode 100644
index 0000000..a15b290
--- /dev/null
+++ b/WWW/Library/Implementation/HTTCP.h
@@ -0,0 +1,111 @@
+/*
+ * $LynxId: HTTCP.h,v 1.27 2018/05/16 19:48:16 tom Exp $
+ *
+ *                               /Net/dxcern/userd/timbl/hypertext/WWW/Library/src/HTTCP.html
+ *                             GENERIC TCP/IP COMMUNICATION
+ *
+ * This module has the common code for handling TCP/IP connections etc.
+ */
+#ifndef HTTCP_H
+#define HTTCP_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*      Produce a string for an internet address
+ *      ---------------------------------------
+ *
+ * On exit:
+ *           returns a pointer to a static string which must be copied if
+ *                it is to be kept.
+ */
+    extern const char *HTInetString(LY_SOCKADDR * mysin);
+
+/*      Encode INET status (as in sys/errno.h)                    inet_status()
+ *      ------------------
+ *
+ * On entry:
+ *              where gives a description of what caused the error
+ *      global errno gives the error number in the unix way.
+ *
+ * On return:
+ *      returns a negative status in the unix way.
+ */
+    extern int HTInetStatus(const char *where);
+
+/*      Publicly accessible variables
+*/
+/* extern struct sockaddr_in HTHostAddress; */
+    /* The internet address of the host */
+    /* Valid after call to HTHostName() */
+
+/*      Parse a cardinal value                                 parse_cardinal()
+ *      ----------------------
+ *
+ * On entry:
+ *      *pp points to first character to be interpreted, terminated by
+ *      non 0..9 character.
+ *      *pstatus points to status already valid,
+ *      maxvalue gives the largest allowable value.
+ *
+ * On exit:
+ *      *pp points to first unread character,
+ *      *pstatus points to status updated iff bad
+ */
+
+    extern unsigned int HTCardinal(int *pstatus,
+				   char **pp,
+				   unsigned int max_value);
+
+/*	Check whether string is a valid Internet hostname
+ *	-------------------------------------------------
+ */
+
+    extern BOOL valid_hostname(char *name);
+
+/*	Resolve an internet hostname, like gethostbyname
+ *	------------------------------------------------
+ *
+ *  On entry,
+ *	str	points to the given host name, not numeric address,
+ *		without colon or port number.
+ *
+ *  On exit,
+ *	returns a pointer to a struct hostent in static storage,
+ *	or NULL in case of error or user interruption.
+ *
+ *  The interface is intended to be the same as for gethostbyname(),
+ *  but additional status is returned in lynx_nsl_status.
+ */
+    extern int lynx_nsl_status;
+
+    extern BOOLEAN LYCheckHostByName(char *host);
+
+#ifdef INET6
+    extern BOOLEAN HTCheckAddrInfo(const char *str, const int defport);
+#endif
+
+/*      Get Name of This Machine
+ *      ------------------------
+ *
+ */
+
+    extern const char *HTHostName(void);
+
+    extern int HTDoConnect(const char *url,
+			   const char *protocol,
+			   int default_port,
+			   int *s);
+
+    extern int HTDoRead(int fildes,
+			void *buf,
+			unsigned nbyte);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTTCP_H */
diff --git a/WWW/Library/Implementation/HTTP.c b/WWW/Library/Implementation/HTTP.c
new file mode 100644
index 0000000..e3c5a4a
--- /dev/null
+++ b/WWW/Library/Implementation/HTTP.c
@@ -0,0 +1,2838 @@
+/*
+ * $LynxId: HTTP.c,v 1.183 2022/04/01 00:10:19 tom Exp $
+ *
+ * HyperText Transfer Protocol	- Client implementation		HTTP.c
+ * ===========================
+ * Modified:
+ * 27 Jan 1994	PDM  Added Ari Luotonen's Fix for Reload when using proxy
+ *		     servers.
+ * 28 Apr 1997	AJL,FM Do Proxy Authorisation.
+ */
+
+#include <HTUtils.h>
+#include <HTTP.h>
+#include <LYUtils.h>
+
+#ifdef USE_SSL
+#include <HTNews.h>
+#endif
+
+#define HTTP_PORT   80
+#define HTTPS_PORT  443
+#define SNEWS_PORT  563
+
+#define INIT_LINE_SIZE		1536	/* Start with line buffer this big */
+#define LINE_EXTEND_THRESH	256	/* Minimum read size */
+#define VERSION_LENGTH		20	/* for returned protocol version */
+
+#include <HTParse.h>
+#include <HTTCP.h>
+#include <HTFormat.h>
+#include <HTFile.h>
+#include <HTAlert.h>
+#include <HTMIME.h>
+#include <HTML.h>
+#include <HTInit.h>
+#include <HTAABrow.h>
+#include <HTAccess.h>		/* Are we using an HTTP gateway? */
+
+#include <LYCookie.h>
+#include <LYGlobalDefs.h>
+#include <GridText.h>
+#include <LYStrings.h>
+#include <LYUtils.h>
+#include <LYrcFile.h>
+#include <LYLeaks.h>
+#include <LYCurses.h>
+
+#ifdef USE_SSL
+
+#ifdef USE_OPENSSL_INCL
+#include <openssl/x509v3.h>
+#endif
+
+#if defined(LIBRESSL_VERSION_NUMBER)
+/* OpenSSL and LibreSSL version numbers do not correspond */
+
+#if LIBRESSL_VERSION_NUMBER >= 0x2060100fL
+#define SSL_set_no_TLSV1()		SSL_set_min_proto_version(handle, TLS1_1_VERSION)
+#endif
+
+#elif defined(OPENSSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+
+#define SSLEAY_VERSION_NUMBER		OPENSSL_VERSION_NUMBER
+#undef  SSL_load_error_strings
+#undef  SSLeay_add_ssl_algorithms
+#define ASN1_STRING_data		ASN1_STRING_get0_data
+#define TLS_client_method()		SSLv23_client_method()
+#define SSL_load_error_strings()	/* nothing */
+#define SSLeay_add_ssl_algorithms()	/* nothing */
+#define SSL_set_no_TLSV1()		SSL_set_min_proto_version(handle, TLS1_1_VERSION)
+
+#elif defined(SSLEAY_VERSION_NUMBER)
+
+#define TLS_client_method()		SSLv23_client_method()
+
+#endif
+
+#ifndef SSL_set_no_TLSV1
+#define SSL_set_no_TLSV1()		SSL_set_options(handle, SSL_OP_NO_TLSv1)
+#endif
+
+#ifdef USE_GNUTLS_INCL
+#include <gnutls/x509.h>
+#endif
+
+#endif /* USE_SSL */
+
+BOOLEAN reloading = FALSE;	/* Reloading => send no-cache pragma to proxy */
+char *redirecting_url = NULL;	/* Location: value. */
+BOOL permanent_redirection = FALSE;	/* Got 301 status? */
+BOOL redirect_post_content = FALSE;	/* Don't convert to GET? */
+
+#ifdef USE_SSL
+SSL_CTX *ssl_ctx = NULL;	/* SSL ctx */
+SSL *SSL_handle = NULL;
+static int ssl_okay;
+
+static void free_ssl_ctx(void)
+{
+    if (ssl_ctx != NULL)
+	SSL_CTX_free(ssl_ctx);
+}
+
+static BOOL needs_limit(const char *actual)
+{
+    return ((int) strlen(actual) > LYcols - 7) ? TRUE : FALSE;
+}
+
+static char *limited_string(const char *source, const char *actual)
+{
+    int limit = ((int) strlen(source)
+		 - ((int) strlen(actual) - (LYcols - 10)));
+    char *temp = NULL;
+
+    StrAllocCopy(temp, source);
+    if (limit < 0)
+	limit = 0;
+    strcpy(temp + limit, "...");
+    return temp;
+}
+
+/*
+ * If the error message is too long to fit in the line, truncate that to fit
+ * within the limits for prompting.
+ */
+static void SSL_single_prompt(char **target, const char *source)
+{
+    HTSprintf0(target, SSL_FORCED_PROMPT, source);
+    if (needs_limit(*target)) {
+	char *temp = limited_string(source, *target);
+
+	*target = NULL;
+	HTSprintf0(target, SSL_FORCED_PROMPT, temp);
+	free(temp);
+    }
+}
+
+static void SSL_double_prompt(char **target, const char *format, const char
+			      *arg1, const char *arg2)
+{
+    HTSprintf0(target, format, arg1, arg2);
+    if (needs_limit(*target)) {
+	char *parg2 = limited_string(arg2, *target);
+
+	*target = NULL;
+	HTSprintf0(target, format, arg1, parg2);
+	if (needs_limit(*target)) {
+	    char *parg1 = limited_string(arg1, *target);
+
+	    *target = NULL;
+	    HTSprintf0(target, format, parg1, parg2);
+	    free(parg1);
+	}
+	free(parg2);
+    }
+}
+
+static int HTSSLCallback(int preverify_ok, X509_STORE_CTX * x509_ctx GCC_UNUSED)
+{
+    char *msg = NULL;
+    int result = 1;
+
+#ifdef USE_X509_SUPPORT
+    HTSprintf0(&msg,
+	       gettext("SSL callback:%s, preverify_ok=%d, ssl_okay=%d"),
+	       X509_verify_cert_error_string((long) X509_STORE_CTX_get_error(x509_ctx)),
+	       preverify_ok, ssl_okay);
+    _HTProgress(msg);
+    FREE(msg);
+#endif
+
+#ifndef USE_NSS_COMPAT_INCL
+    if (!(preverify_ok || ssl_okay || ssl_noprompt)) {
+#ifdef USE_X509_SUPPORT
+	SSL_single_prompt(&msg,
+			  X509_verify_cert_error_string((long)
+							X509_STORE_CTX_get_error(x509_ctx)));
+	if (HTForcedPrompt(ssl_noprompt, msg, NO))
+	    ssl_okay = 1;
+	else
+	    result = 0;
+#endif
+
+	FREE(msg);
+    }
+#endif
+    return result;
+}
+
+SSL *HTGetSSLHandle(void)
+{
+#ifdef USE_GNUTLS_INCL
+    static char *certfile = NULL;
+#endif
+    static char *client_keyfile = NULL;
+    static char *client_certfile = NULL;
+
+    if (ssl_ctx == NULL) {
+	/*
+	 * First time only.
+	 */
+#if SSLEAY_VERSION_NUMBER < 0x0800
+	if ((ssl_ctx = SSL_CTX_new()) != NULL) {
+	    X509_set_default_verify_paths(ssl_ctx->cert);
+	}
+#else
+	SSLeay_add_ssl_algorithms();
+	if ((ssl_ctx = SSL_CTX_new(TLS_client_method())) != NULL) {
+#ifdef SSL_OP_NO_SSLv2
+	    SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL | SSL_OP_NO_SSLv2);
+#else
+	    SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL);
+#endif
+#ifdef SSL_OP_NO_COMPRESSION
+	    SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_COMPRESSION);
+#endif
+#ifdef SSL_MODE_AUTO_RETRY
+	    SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
+#endif
+#ifdef SSL_MODE_RELEASE_BUFFERS
+	    SSL_CTX_set_mode(ssl_ctx, SSL_MODE_RELEASE_BUFFERS);
+#endif
+	    SSL_CTX_set_default_verify_paths(ssl_ctx);
+	    SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER, HTSSLCallback);
+	}
+#endif /* SSLEAY_VERSION_NUMBER < 0x0800 */
+#if defined(USE_PROGRAM_DIR) & !defined(USE_GNUTLS_INCL)
+	if (ssl_ctx != NULL) {
+	    X509_LOOKUP *lookup;
+
+	    lookup = X509_STORE_add_lookup(ssl_ctx->cert_store,
+					   X509_LOOKUP_file());
+	    if (lookup != NULL) {
+		char *certfile = NULL;
+
+		HTSprintf0(&certfile, "%s\\cert.pem", program_dir);
+		X509_LOOKUP_load_file(lookup, certfile, X509_FILETYPE_PEM);
+		FREE(certfile);
+	    }
+	}
+#endif
+#ifdef USE_GNUTLS_INCL
+	if ((certfile = LYGetEnv("SSL_CERT_FILE")) != NULL) {
+	    CTRACE((tfp,
+		    "HTGetSSLHandle: certfile is set to %s by SSL_CERT_FILE\n",
+		    certfile));
+	} else {
+	    if (non_empty(SSL_cert_file)) {
+		certfile = SSL_cert_file;
+		CTRACE((tfp,
+			"HTGetSSLHandle: certfile is set to %s by config SSL_CERT_FILE\n",
+			certfile));
+	    }
+#if defined(USE_PROGRAM_DIR)
+	    else {
+		HTSprintf0(&(certfile), "%s\\cert.pem", program_dir);
+		CTRACE((tfp,
+			"HTGetSSLHandle: certfile is set to %s by installed directory\n", certfile));
+	    }
+#endif
+	}
+#endif
+	atexit(free_ssl_ctx);
+    }
+
+    if (non_empty(SSL_client_key_file)) {
+	client_keyfile = SSL_client_key_file;
+	CTRACE((tfp,
+		"HTGetSSLHandle: client key file is set to %s by config SSL_CLIENT_KEY_FILE\n",
+		client_keyfile));
+    }
+
+    if (non_empty(SSL_client_cert_file)) {
+	client_certfile = SSL_client_cert_file;
+	CTRACE((tfp,
+		"HTGetSSLHandle: client cert file is set to %s by config SSL_CLIENT_CERT_FILE\n",
+		client_certfile));
+    }
+#ifdef USE_GNUTLS_INCL
+    ssl_ctx->certfile = certfile;
+    ssl_ctx->certfile_type = GNUTLS_X509_FMT_PEM;
+    ssl_ctx->client_keyfile = client_keyfile;
+    ssl_ctx->client_keyfile_type = GNUTLS_X509_FMT_PEM;
+    ssl_ctx->client_certfile = client_certfile;
+    ssl_ctx->client_certfile_type = GNUTLS_X509_FMT_PEM;
+#elif SSLEAY_VERSION_NUMBER >= 0x0930
+    if (client_certfile != NULL) {
+	if (client_keyfile == NULL) {
+	    client_keyfile = client_certfile;
+	}
+	SSL_CTX_use_certificate_chain_file(ssl_ctx, client_certfile);
+	SSL_CTX_use_PrivateKey_file(ssl_ctx, client_keyfile, SSL_FILETYPE_PEM);
+    }
+#endif
+    ssl_okay = 0;
+    return (SSL_new(ssl_ctx));
+}
+
+void HTSSLInitPRNG(void)
+{
+#if SSLEAY_VERSION_NUMBER >= 0x00905100
+    if (RAND_status() == 0) {
+	char rand_file[256];
+	time_t t;
+	long l, seed;
+
+#ifndef _WINDOWS
+	pid_t pid;
+
+#else
+	DWORD pid;
+#endif
+
+	t = time(NULL);
+
+#ifndef _WINDOWS
+	pid = getpid();
+#else
+	pid = GetCurrentThreadId();
+#endif
+
+	RAND_file_name(rand_file, 256L);
+	CTRACE((tfp, "HTTP: Seeding PRNG\n"));
+	/* Seed as much as 1024 bytes from RAND_file_name */
+	RAND_load_file(rand_file, 1024L);
+	/* Seed in time (mod_ssl does this) */
+	RAND_seed((unsigned char *) &t, (int) sizeof(time_t));
+
+	/* Seed in pid (mod_ssl does this) */
+	RAND_seed((unsigned char *) &pid, (int) sizeof(pid));
+	/* Initialize system's random number generator */
+	RAND_bytes((unsigned char *) &seed, (int) sizeof(long));
+
+	lynx_srand((unsigned) seed);
+	while (RAND_status() == 0) {
+	    /* Repeatedly seed the PRNG using the system's random number generator until it has been seeded with enough data */
+	    l = (long) lynx_rand();
+	    RAND_seed((unsigned char *) &l, (int) sizeof(long));
+	}
+	/* Write a rand_file */
+	RAND_write_file(rand_file);
+    }
+#endif /* SSLEAY_VERSION_NUMBER >= 0x00905100 */
+    return;
+}
+
+#define HTTP_NETREAD(sock, buff, size, handle) \
+	(handle \
+	 ? SSL_read(handle, buff, size) \
+	 : NETREAD(sock, buff, size))
+
+#define HTTP_NETWRITE(sock, buff, size, handle) \
+	(handle \
+	 ? SSL_write(handle, buff, size) \
+	 : NETWRITE(sock, buff, size))
+
+#define HTTP_NETCLOSE(sock, handle)  \
+	{ (void)NETCLOSE(sock); \
+	  if (handle) \
+	      SSL_free(handle); \
+	  SSL_handle = handle = NULL; \
+	}
+
+#else
+#define HTTP_NETREAD(a, b, c, d)   NETREAD(a, b, c)
+#define HTTP_NETWRITE(a, b, c, d)  NETWRITE(a, b, c)
+#define HTTP_NETCLOSE(a, b)  (void)NETCLOSE(a)
+#endif /* USE_SSL */
+
+#ifdef _WINDOWS			/* 1997/11/06 (Thu) 13:00:08 */
+
+#define	BOX_TITLE	"Lynx " __FILE__
+#define	BOX_FLAG	(MB_ICONINFORMATION | MB_SETFOREGROUND)
+
+typedef struct {
+    int fd;
+    char *buf;
+    int len;
+} recv_data_t;
+
+int ws_read_per_sec = 0;
+static int ws_errno = 0;
+
+static DWORD g_total_times = 0;
+static DWORD g_total_bytes = 0;
+
+/* The same like read, but takes care of EINTR and uses select to
+   timeout the stale connections.  */
+
+static int ws_read(int fd, char *buf, int len)
+{
+    int res;
+    int retry = 3;
+
+    do {
+	res = recv(fd, buf, len, 0);
+	if (WSAEWOULDBLOCK == WSAGetLastError()) {
+	    Sleep(100);
+	    if (retry-- > 0)
+		continue;
+	}
+    } while (res == SOCKET_ERROR && SOCKET_ERRNO == EINTR);
+
+    return res;
+}
+
+#define DWORD_ERR ((DWORD)-1)
+
+static DWORD __stdcall _thread_func(void *p)
+{
+    DWORD result;
+    int i, val;
+    recv_data_t *q = (recv_data_t *) p;
+
+    i = 0;
+    i++;
+    val = ws_read(q->fd, q->buf, q->len);
+
+    if (val == SOCKET_ERROR) {
+	ws_errno = WSAGetLastError();
+#if 0
+	char buff[256];
+
+	sprintf(buff, "Thread read: %d, error (%ld), fd = %d, len = %d",
+		i, ws_errno, q->fd, q->len);
+	MessageBox(NULL, buff, BOX_TITLE, BOX_FLAG);
+#endif
+	result = DWORD_ERR;
+    } else {
+	result = val;
+    }
+
+    return result;
+}
+
+/* The same like read, but takes care of EINTR and uses select to
+   timeout the stale connections.  */
+
+int ws_netread(int fd, char *buf, int len)
+{
+    int i;
+    char buff[256];
+
+    /* 1998/03/30 (Mon) 09:01:21 */
+    HANDLE hThread;
+    DWORD dwThreadID;
+    DWORD exitcode = 0;
+    DWORD ret_val = DWORD_ERR;
+    DWORD val, process_time, now_TickCount, save_TickCount;
+
+    static recv_data_t para;
+
+#define TICK	5
+#define STACK_SIZE	0x2000uL
+
+    EnterCriticalSection(&critSec_READ);
+
+    para.fd = fd;
+    para.buf = buf;
+    para.len = len;
+
+    ws_read_per_sec = 0;
+    save_TickCount = GetTickCount();
+
+    hThread = CreateThread(NULL, STACK_SIZE,
+			   _thread_func,
+			   (void *) &para, 0UL, &dwThreadID);
+
+    if (hThread == 0) {
+	HTInfoMsg("CreateThread Failed (read)");
+	goto read_exit;
+    }
+
+    i = 0;
+    while (1) {
+	val = WaitForSingleObject(hThread, 1000 / TICK);
+	i++;
+	if (val == WAIT_FAILED) {
+	    HTInfoMsg("Wait Failed");
+	    ret_val = DWORD_ERR;
+	    break;
+	} else if (val == WAIT_TIMEOUT) {
+	    i++;
+	    if (i / TICK > (AlertSecs + 2)) {
+		sprintf(buff, "Read Waiting (%2d.%01d) for %d Bytes",
+			i / TICK, (i % TICK) * 10 / TICK, len);
+		SetConsoleTitle(buff);
+	    }
+	    if (win32_check_interrupt() || ((i / TICK) > lynx_timeout)) {
+		if (CloseHandle(hThread) == FALSE) {
+		    HTInfoMsg("Thread terminate Failed");
+		}
+		WSASetLastError(ETIMEDOUT);
+		ret_val = HT_INTERRUPTED;
+		break;
+	    }
+	} else if (val == WAIT_OBJECT_0) {
+	    if (GetExitCodeThread(hThread, &exitcode) == FALSE) {
+		exitcode = DWORD_ERR;
+	    }
+	    if (CloseHandle(hThread) == FALSE) {
+		HTInfoMsg("Thread terminate Failed");
+	    }
+	    now_TickCount = GetTickCount();
+	    if (now_TickCount >= save_TickCount)
+		process_time = now_TickCount - save_TickCount;
+	    else
+		process_time = now_TickCount + (0xffffffff - save_TickCount);
+
+	    if (process_time == 0)
+		process_time = 1;
+	    g_total_times += process_time;
+
+	    /*
+	     * DWORD is unsigned, and could be an error code which is signed.
+	     */
+	    if ((long) exitcode > 0)
+		g_total_bytes += exitcode;
+
+	    ws_read_per_sec = g_total_bytes;
+	    if (ws_read_per_sec > 2000000) {
+		if (g_total_times > 1000)
+		    ws_read_per_sec /= (g_total_times / 1000);
+	    } else {
+		ws_read_per_sec *= 1000;
+		ws_read_per_sec /= g_total_times;
+	    }
+
+	    ret_val = exitcode;
+	    break;
+	}
+    }				/* end while(1) */
+
+  read_exit:
+    LeaveCriticalSection(&critSec_READ);
+    return ret_val;
+}
+#endif /* _WINDOWS */
+
+/*
+ * RFC-1738 says we can have user/password using these ASCII characters
+ *    safe           = "$" | "-" | "_" | "." | "+"
+ *    extra          = "!" | "*" | "'" | "(" | ")" | ","
+ *    hex            = digit | "A" | "B" | "C" | "D" | "E" | "F" |
+ *                             "a" | "b" | "c" | "d" | "e" | "f"
+ *    escape         = "%" hex hex
+ *    unreserved     = alpha | digit | safe | extra
+ *    uchar          = unreserved | escape
+ *    user           = *[ uchar | ";" | "?" | "&" | "=" ]
+ *    password       = *[ uchar | ";" | "?" | "&" | "=" ]
+ * and we cannot have a password without user, i.e., no leading ":"
+ * and ":", "@", "/" must be encoded, i.e., will not appear as such.
+ *
+ * However, in a URL
+ *    //<user>:<password>@<host>:<port>/<url-path>
+ * valid characters in the host are different, not allowing most of those
+ * punctuation characters.
+ *
+ * RFC-3986 amends this, using
+ *     userinfo    = *( unreserved / pct-encoded / sub-delims / ":" )
+ *     unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ *     reserved      = gen-delims / sub-delims
+ *     gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+ *     sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
+ *                     / "*" / "+" / "," / ";" / "="
+ * and
+ *     host          = IP-literal / IPv4address / reg-name
+ *     reg-name      = *( unreserved / pct-encoded / sub-delims )
+ */
+char *HTSkipToAt(char *host, int *gen_delims)
+{
+    char *result = 0;
+    char *s = host;
+    int pass = 0;
+    int ch;
+    int last = -1;
+
+    *gen_delims = 0;
+    while ((ch = UCH(*s)) != '\0') {
+	if (ch == ':') {
+	    if (pass++)
+		break;
+	} else if (ch == '@') {
+	    if (s != host && last != ':')
+		result = s;
+	    break;
+	} else if (RFC_3986_GEN_DELIMS(ch)) {
+	    *gen_delims += 1;
+	    if (!RFC_3986_GEN_DELIMS(s[1]))
+		break;
+	} else if (ch == '%') {
+	    if (!(isxdigit(UCH(s[1])) && isxdigit(UCH(s[2]))))
+		break;
+	} else if (!(RFC_3986_UNRESERVED(ch) ||
+		     RFC_3986_SUB_DELIMS(ch))) {
+	    break;
+	}
+	++s;
+	last = ch;
+    }
+    return result;
+}
+
+static char *fake_hostname(char *auth)
+{
+    char *result = NULL;
+    char *colon = NULL;
+
+    StrAllocCopy(result, auth);
+    if ((colon = strchr(result, ':')) != 0)
+	*colon = '\0';
+    if (strchr(result, '.') == 0)
+	FREE(result);
+    return result;
+}
+
+/*
+ * Strip any username from the given string so we retain only the host.
+ */
+void strip_userid(char *host, int parse_only)
+{
+    int gen_delims = 0;
+    char *p1 = host;
+    char *p2 = HTSkipToAt(host, &gen_delims);
+
+    if (p2 != 0) {
+	char *msg = NULL;
+	char *auth = NULL;
+	char *fake = NULL;
+	char *p3 = p2;
+	int sub_delims = 0;
+	int my_delimit = UCH(*p2);
+	int do_trimming = (my_delimit == '@');
+
+	*p2++ = '\0';
+
+	StrAllocCopy(auth, host);
+
+	/*
+	 * Trailing "gen-delims" demonstrates that there is no user/password.
+	 */
+	while ((p3 != host) && RFC_3986_GEN_DELIMS(p3[-1])) {
+	    *(--p3) = '\0';
+	}
+	/*
+	 * While legal, punctuation-only user/password is questionable.
+	 */
+	while ((p3 != host) && RFC_3986_SUB_DELIMS(p3[-1])) {
+	    ++sub_delims;
+	    *(--p3) = '\0';
+	}
+	/*
+	 * Trim trailing "gen-delims" from the real hostname.
+	 */
+	for (p3 = p2; *p3 != '\0'; ++p3) {
+	    if (RFC_3986_GEN_DELIMS(*p3)) {
+		*p3 = '\0';
+		break;
+	    }
+	}
+	CTRACE((tfp, "trim auth:    result:`%s'\n", host));
+
+	if (gen_delims || strcmp(host, auth)) {
+	    do_trimming = !gen_delims;
+	}
+	if (*host == '\0' && sub_delims) {
+	    HTSprintf0(&msg,
+		       gettext("User/password contains only punctuation: %s"),
+		       auth);
+	} else if ((fake = fake_hostname(host)) != NULL) {
+	    HTSprintf0(&msg,
+		       gettext("User/password may be confused with hostname: '%s' (e.g, '%s')"),
+		       auth, fake);
+	}
+	if (msg != 0 && !parse_only)
+	    HTAlert(msg);
+	if (do_trimming) {
+	    while ((*p1++ = *p2++) != '\0') {
+		;
+	    }
+	    CTRACE((tfp, "trim host:    result:`%s'\n", host));
+	}
+	FREE(fake);
+	FREE(auth);
+	FREE(msg);
+    }
+}
+
+/*
+ * Check if the user's options specified to use the given encoding.  Normally
+ * all encodings with compiled-in support are specified (encodingALL).
+ */
+static BOOL acceptEncoding(int code)
+{
+    BOOL result = FALSE;
+
+    if ((code & LYAcceptEncoding) != 0) {
+	const char *program = 0;
+
+	switch (code) {
+	case encodingGZIP:
+	    program = HTGetProgramPath(ppGZIP);
+	    break;
+	case encodingDEFLATE:
+	    program = HTGetProgramPath(ppINFLATE);
+	    break;
+	case encodingCOMPRESS:
+	    program = HTGetProgramPath(ppCOMPRESS);
+	    break;
+	case encodingBZIP2:
+	    program = HTGetProgramPath(ppBZIP2);
+	    break;
+	case encodingBROTLI:
+	    program = HTGetProgramPath(ppBROTLI);
+	    break;
+	default:
+	    break;
+	}
+	/*
+	 * FIXME:  if lynx did not rely upon external programs to decompress
+	 * files for external viewers, this check could be relaxed.
+	 */
+	result = (BOOL) (program != 0);
+    }
+    return result;
+}
+
+#ifdef USE_SSL
+static void show_cert_issuer(X509 * peer_cert GCC_UNUSED)
+{
+#if defined(USE_OPENSSL_INCL) || defined(USE_GNUTLS_FUNCS)
+    char ssl_dn[1024];
+    char *msg = NULL;
+
+    X509_NAME_oneline(X509_get_issuer_name(peer_cert), ssl_dn, (int) sizeof(ssl_dn));
+    HTSprintf0(&msg, gettext("Certificate issued by: %s"), ssl_dn);
+    _HTProgress(msg);
+    FREE(msg);
+#elif defined(USE_GNUTLS_INCL)
+    /* the OpenSSL "compat" code compiles but dumps core with GNU TLS */
+#endif
+}
+#endif
+
+/*
+ * Remove IPv6 brackets (and any port-number) from the given host-string.
+ */
+#ifdef USE_SSL
+static char *StripIpv6Brackets(char *host)
+{
+    int port_number;
+    char *p;
+
+    if ((p = HTParsePort(host, &port_number)) != 0)
+	*p = '\0';
+
+    if (*host == '[') {
+	p = host + strlen(host) - 1;
+	if (*p == ']') {
+	    *p = '\0';
+	    for (p = host; (p[0] = p[1]) != '\0'; ++p) {
+		;		/* EMPTY */
+	    }
+	}
+    }
+    return host;
+}
+#endif
+
+/*
+ * Remove user/password, if any, from the given host-string.
+ */
+#ifdef USE_SSL
+static char *StripUserAuthents(char *host)
+{
+    char *p = strchr(host, '@');
+
+    if (p != NULL) {
+	char *q = host;
+
+	while ((*q++ = *++p) != '\0') ;
+    }
+    return host;
+}
+#endif
+
+/*		Load Document from HTTP Server			HTLoadHTTP()
+ *		==============================
+ *
+ *	Given a hypertext address, this routine loads a document.
+ *
+ *
+ *  On entry,
+ *	arg	is the hypertext reference of the article to be loaded.
+ *
+ *  On exit,
+ *	returns >=0	If no error, a good socket number
+ *		<0	Error.
+ *
+ *	The socket must be closed by the caller after the document has been
+ *	read.
+ *
+ */
+static int HTLoadHTTP(const char *arg,
+		      HTParentAnchor *anAnchor,
+		      HTFormat format_out,
+		      HTStream *sink)
+{
+    static char empty[1];
+    int s;			/* Socket number for returned data */
+    const char *url = arg;	/* The URL which get_physical() returned */
+    bstring *command = NULL;	/* The whole command */
+    char *eol;			/* End of line if found */
+    char *start_of_data;	/* Start of body of reply */
+    int status;			/* tcp return */
+    off_t bytes_already_read;
+    char crlf[3];		/* A CR LF equivalent string */
+    HTStream *target;		/* Unconverted data */
+    HTFormat format_in;		/* Format arriving in the message */
+    BOOL do_head = FALSE;	/* Whether or not we should do a head */
+    BOOL do_post = FALSE;	/* ARE WE posting ? */
+    const char *METHOD;
+
+    char *line_buffer = NULL;
+    char *line_kept_clean = NULL;
+
+#ifdef SH_EX			/* FIX BUG by kaz@maczuka.hitachi.ibaraki.jp */
+    int real_length_of_line = 0;
+#endif
+    BOOL extensions;		/* Assume good HTTP server */
+    char *linebuf = NULL;
+    char temp[80];
+    BOOL first_Accept = TRUE;
+    BOOL show_401 = FALSE;
+    BOOL show_407 = FALSE;
+    BOOL auth_proxy = NO;	/* Generate a proxy authorization. - AJL */
+
+    int length, rawlength, rv;
+    int server_status = 0;
+    BOOL doing_redirect, already_retrying = FALSE;
+    int len = 0;
+
+#ifdef USE_SSL
+    unsigned long SSLerror;
+    BOOL do_connect = FALSE;	/* ARE WE going to use a proxy tunnel ? */
+    BOOL did_connect = FALSE;	/* ARE WE actually using a proxy tunnel ? */
+    const char *connect_url = NULL;	/* The URL being proxied */
+    char *connect_host = NULL;	/* The host being proxied */
+    SSL *handle = NULL;		/* The SSL handle */
+    X509 *peer_cert;		/* The peer certificate */
+    char ssl_dn[1024];
+    char *cert_host;
+    char *ssl_host;
+    char *p;
+    char *msg = NULL;
+    int status_sslcertcheck;
+    char *ssl_dn_start;
+    char *ssl_all_cns = NULL;
+
+#ifdef USE_GNUTLS_INCL
+    int ret;
+    unsigned tls_status;
+#endif
+
+#if (SSLEAY_VERSION_NUMBER >= 0x0900) && !defined(USE_GNUTLS_FUNCS)
+    BOOL try_tls = TRUE;
+#endif /* SSLEAY_VERSION_NUMBER >= 0x0900 */
+    SSL_handle = NULL;
+#else
+    void *handle = NULL;
+#endif /* USE_SSL */
+
+    if (anAnchor->isHEAD)
+	do_head = TRUE;
+    else if (anAnchor->post_data)
+	do_post = TRUE;
+
+    if (!url) {
+	status = -3;
+	_HTProgress(BAD_REQUEST);
+	goto done;
+    }
+    if (!*url) {
+	status = -2;
+	_HTProgress(BAD_REQUEST);
+	goto done;
+    }
+#ifdef USE_SSL
+    if (using_proxy && !StrNCmp(url, "http://", 7)) {
+	int portnumber;
+
+	if ((connect_url = strstr((url + 7), "https://"))) {
+	    do_connect = TRUE;
+	    connect_host = HTParse(connect_url, "https", PARSE_HOST);
+	    if (!HTParsePort(connect_host, &portnumber)) {
+		sprintf(temp, ":%d", HTTPS_PORT);
+		StrAllocCat(connect_host, temp);
+	    }
+	    CTRACE((tfp, "HTTP: connect_url = '%s'\n", connect_url));
+	    CTRACE((tfp, "HTTP: connect_host = '%s'\n", connect_host));
+	} else if ((connect_url = strstr((url + 7), "snews://"))) {
+	    do_connect = TRUE;
+	    connect_host = HTParse(connect_url, "snews", PARSE_HOST);
+	    if (!HTParsePort(connect_host, &portnumber)) {
+		sprintf(temp, ":%d", SNEWS_PORT);
+		StrAllocCat(connect_host, temp);
+	    }
+	    CTRACE((tfp, "HTTP: connect_url = '%s'\n", connect_url));
+	    CTRACE((tfp, "HTTP: connect_host = '%s'\n", connect_host));
+	}
+    }
+#endif /* USE_SSL */
+
+    sprintf(crlf, "%c%c", CR, LF);
+
+    /*
+     * At this point, we're talking HTTP/1.0.
+     */
+    extensions = YES;
+
+  try_again:
+    /*
+     * All initializations are moved down here from up above, so we can start
+     * over here...
+     */
+    eol = 0;
+    length = 0;
+    doing_redirect = FALSE;
+    permanent_redirection = FALSE;
+    redirect_post_content = FALSE;
+    target = NULL;
+    line_buffer = NULL;
+    line_kept_clean = NULL;
+
+#ifdef USE_SSL
+    if (!StrNCmp(url, "https", 5))
+	status = HTDoConnect(url, "HTTPS", HTTPS_PORT, &s);
+    else
+	status = HTDoConnect(url, "HTTP", HTTP_PORT, &s);
+#else
+    if (!StrNCmp(url, "https", 5)) {
+	HTAlert(gettext("This client does not contain support for HTTPS URLs."));
+	status = HT_NOT_LOADED;
+	goto done;
+    }
+    status = HTDoConnect(arg, "HTTP", HTTP_PORT, &s);
+#endif /* USE_SSL */
+    if (status == HT_INTERRUPTED) {
+	/*
+	 * Interrupt cleanly.
+	 */
+	CTRACE((tfp, "HTTP: Interrupted on connect; recovering cleanly.\n"));
+	_HTProgress(CONNECTION_INTERRUPTED);
+	status = HT_NOT_LOADED;
+	goto done;
+    }
+    if (status < 0) {
+#ifdef _WINDOWS
+	CTRACE((tfp, "HTTP: Unable to connect to remote host for `%s'\n"
+		" (status = %d, sock_errno = %d).\n",
+		url, status, SOCKET_ERRNO));
+#else
+	CTRACE((tfp,
+		"HTTP: Unable to connect to remote host for `%s' (errno = %d).\n",
+		url, SOCKET_ERRNO));
+#endif
+	HTAlert(gettext("Unable to connect to remote host."));
+	status = HT_NOT_LOADED;
+	goto done;
+    }
+#ifdef USE_SSL
+  use_tunnel:
+    /*
+     * If this is an https document, then do the SSL stuff here.
+     */
+    if (did_connect || !StrNCmp(url, "https", 5)) {
+	SSL_handle = handle = HTGetSSLHandle();
+	SSL_set_fd(handle, s);
+	/* get host we're connecting to */
+	ssl_host = HTParse(url, "", PARSE_HOST);
+	ssl_host = StripIpv6Brackets(ssl_host);
+	ssl_host = StripUserAuthents(ssl_host);
+#if defined(USE_GNUTLS_FUNCS)
+	ret = gnutls_server_name_set(handle->gnutls_state,
+				     GNUTLS_NAME_DNS,
+				     ssl_host, strlen(ssl_host));
+	CTRACE((tfp, "...called gnutls_server_name_set(%s) ->%d\n", ssl_host, ret));
+#elif SSLEAY_VERSION_NUMBER >= 0x0900
+#ifndef USE_NSS_COMPAT_INCL
+	if (!try_tls) {
+	    SSL_set_no_TLSV1();
+	    CTRACE((tfp, "...adding SSL_OP_NO_TLSv1\n"));
+	}
+#if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
+	else {
+	    int ret = (int) SSL_set_tlsext_host_name(handle, ssl_host);
+
+	    CTRACE((tfp, "...called SSL_set_tlsext_host_name(%s) ->%d\n",
+		    ssl_host, ret));
+	}
+#endif
+#endif
+#endif /* SSLEAY_VERSION_NUMBER >= 0x0900 */
+	HTSSLInitPRNG();
+	status = SSL_connect(handle);
+
+	if (status <= 0) {
+#if (SSLEAY_VERSION_NUMBER >= 0x0900)
+#if !defined(USE_GNUTLS_FUNCS)
+	    if (try_tls) {
+		_HTProgress(gettext("Retrying connection without TLS."));
+		try_tls = FALSE;
+		if (did_connect)
+		    HTTP_NETCLOSE(s, handle);
+		goto try_again;
+	    } else
+#endif
+	    {
+		CTRACE((tfp,
+			"HTTP: Unable to complete SSL handshake for '%s', SSL_connect=%d, SSL error stack dump follows\n",
+			url, status));
+		SSL_load_error_strings();
+		while ((SSLerror = ERR_get_error()) != 0) {
+		    CTRACE((tfp, "HTTP: SSL: %s\n", ERR_error_string(SSLerror, NULL)));
+		}
+		HTAlert("Unable to make secure connection to remote host.");
+		if (did_connect)
+		    HTTP_NETCLOSE(s, handle);
+		status = HT_NOT_LOADED;
+		goto done;
+	    }
+#else
+	    unsigned long SSLerror;
+
+	    CTRACE((tfp,
+		    "HTTP: Unable to complete SSL handshake for '%s', SSL_connect=%d, SSL error stack dump follows\n",
+		    url, status));
+	    SSL_load_error_strings();
+	    while ((SSLerror = ERR_get_error()) != 0) {
+		CTRACE((tfp, "HTTP: SSL: %s\n", ERR_error_string(SSLerror, NULL)));
+	    }
+	    HTAlert("Unable to make secure connection to remote host.");
+	    if (did_connect)
+		HTTP_NETCLOSE(s, handle);
+	    status = HT_NOT_LOADED;
+	    goto done;
+#endif /* SSLEAY_VERSION_NUMBER >= 0x0900 */
+	}
+#ifdef USE_GNUTLS_INCL
+	gnutls_certificate_set_verify_flags(handle->gnutls_cred,
+					    GNUTLS_VERIFY_DO_NOT_ALLOW_SAME |
+					    GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT);
+	ret = gnutls_certificate_verify_peers2(handle->gnutls_state, &tls_status);
+	if (ret < 0 || tls_status != 0) {
+	    int flag_continue = 1;
+
+#if GNUTLS_VERSION_NUMBER >= 0x030104
+	    int type;
+	    gnutls_datum_t out;
+
+	    if (ret < 0) {
+		SSL_single_prompt(&msg,
+				  gettext("GnuTLS error when trying to verify certificate."));
+	    } else {
+		type = gnutls_certificate_type_get(handle->gnutls_state);
+		(void) gnutls_certificate_verification_status_print(tls_status,
+								    type,
+								    &out, 0);
+		SSL_single_prompt(&msg, (const char *) out.data);
+		gnutls_free(out.data);
+	    }
+#else
+	    char *msg2;
+
+	    if (ret == 0 && tls_status & GNUTLS_CERT_SIGNER_NOT_FOUND) {
+		msg2 = gettext("the certificate has no known issuer");
+	    } else if (tls_status & GNUTLS_CERT_SIGNER_NOT_FOUND) {
+		msg2 = gettext("no issuer was found");
+	    } else if (tls_status & GNUTLS_CERT_SIGNER_NOT_CA) {
+		msg2 = gettext("issuer is not a CA");
+	    } else if (tls_status & GNUTLS_CERT_REVOKED) {
+		msg2 = gettext("the certificate has been revoked");
+	    } else {
+		msg2 = gettext("the certificate is not trusted");
+	    }
+	    SSL_single_prompt(&msg, msg2);
+#endif
+	    CTRACE((tfp, "HTLoadHTTP: %s\n", msg));
+	    if (!ssl_noprompt) {
+		if (!HTForcedPrompt(ssl_noprompt, msg, NO)) {
+		    flag_continue = 0;
+		}
+	    } else if (ssl_noprompt == FORCE_PROMPT_NO) {
+		flag_continue = 0;
+	    }
+	    FREE(msg);
+	    if (flag_continue == 0) {
+		status = HT_NOT_LOADED;
+		FREE(msg);
+		goto done;
+	    }
+	}
+#endif
+
+	peer_cert = (X509 *) SSL_get_peer_certificate(handle);
+#if defined(USE_OPENSSL_INCL) || defined(USE_GNUTLS_FUNCS)
+	X509_NAME_oneline(X509_get_subject_name(peer_cert),
+			  ssl_dn, (int) sizeof(ssl_dn));
+#elif defined(USE_GNUTLS_INCL)
+	X509_NAME_oneline(X509_get_subject_name(peer_cert),
+			  ssl_dn + 1, (int) sizeof(ssl_dn) - 1);
+
+	/* Iterate over DN in incompatible GnuTLS format to bring it into OpenSSL format */
+	ssl_dn[0] = '/';
+	ssl_dn_start = ssl_dn;
+	while (*ssl_dn_start) {
+	    if ((*ssl_dn_start == ',') && (*(ssl_dn_start + 1) == ' ')) {
+		*ssl_dn_start++ = '/';
+		if (*(p = ssl_dn_start) != 0) {
+		    while ((p[0] = p[1]) != 0)
+			++p;
+		}
+	    } else {
+		ssl_dn_start++;
+	    }
+	}
+#endif
+
+	/*
+	 * X.509 DN validation taking ALL CN fields into account
+	 * (c) 2006 Thorsten Glaser <tg@mirbsd.de>
+	 */
+
+	/* initialise status information */
+	status_sslcertcheck = 0;	/* 0 = no CN found in DN */
+	ssl_dn_start = ssl_dn;
+
+	/* validate all CNs found in DN */
+	CTRACE((tfp, "Validating CNs in '%s'\n", ssl_dn_start));
+	while ((cert_host = strstr(ssl_dn_start, "/CN=")) != NULL) {
+	    status_sslcertcheck = 1;	/* 1 = could not verify CN */
+	    /* start of CommonName */
+	    cert_host += 4;
+	    /* find next part of DistinguishedName */
+	    if ((p = StrChr(cert_host, '/')) != NULL) {
+		*p = '\0';
+		ssl_dn_start = p;	/* yes this points to the NUL byte */
+	    } else
+		ssl_dn_start = NULL;
+	    cert_host = StripIpv6Brackets(cert_host);
+
+	    /* verify this CN */
+	    CTRACE((tfp, "Matching\n\tssl_host  '%s'\n\tcert_host '%s'\n",
+		    ssl_host, cert_host));
+	    if (!strcasecomp_asterisk(ssl_host, cert_host)) {
+		status_sslcertcheck = 2;	/* 2 = verified peer */
+		/* I think this is cool to have in the logs -TG */
+		HTSprintf0(&msg,
+			   gettext("Verified connection to %s (cert=%s)"),
+			   ssl_host, cert_host);
+		_HTProgress(msg);
+		FREE(msg);
+		/* no need to continue the verification loop */
+		break;
+	    }
+
+	    /* add this CN to list of failed CNs */
+	    if (ssl_all_cns == NULL)
+		StrAllocCopy(ssl_all_cns, "CN<");
+	    else
+		StrAllocCat(ssl_all_cns, ":CN<");
+	    StrAllocCat(ssl_all_cns, cert_host);
+	    StrAllocCat(ssl_all_cns, ">");
+	    /* if we cannot retry, don't try it */
+	    if (ssl_dn_start == NULL)
+		break;
+	    /* now retry next CN found in DN */
+	    *ssl_dn_start = '/';	/* formerly NUL byte */
+	}
+
+	/* check the X.509v3 Subject Alternative Name */
+#ifdef USE_GNUTLS_INCL
+	if (status_sslcertcheck < 2) {
+	    int i;
+	    size_t size;
+	    gnutls_x509_crt_t cert;
+	    static char buf[2048];
+
+	    /* import the certificate to the x509_crt format */
+	    if (gnutls_x509_crt_init(&cert) == 0) {
+
+		if (gnutls_x509_crt_import(cert, peer_cert,
+					   GNUTLS_X509_FMT_DER) < 0) {
+		    gnutls_x509_crt_deinit(cert);
+		    goto done;
+		}
+
+		ret = 0;
+		for (i = 0; !(ret < 0); i++) {
+		    size = sizeof(buf);
+		    ret = gnutls_x509_crt_get_subject_alt_name(cert,
+							       (unsigned) i,
+							       buf, &size,
+							       NULL);
+
+		    if (strcasecomp_asterisk(ssl_host, buf) == 0) {
+			status_sslcertcheck = 2;
+			HTSprintf0(&msg,
+				   gettext("Verified connection to %s (subj=%s)"),
+				   ssl_host, buf);
+			_HTProgress(msg);
+			FREE(msg);
+			break;
+		    }
+
+		}
+	    }
+	}
+#endif
+#ifdef USE_OPENSSL_INCL
+	if (status_sslcertcheck < 2) {
+	    STACK_OF(GENERAL_NAME) * gens;
+	    int i, numalts;
+	    const GENERAL_NAME *gn;
+
+	    gens = (STACK_OF(GENERAL_NAME) *)
+		X509_get_ext_d2i(peer_cert, NID_subject_alt_name, NULL, NULL);
+
+	    if (gens != NULL) {
+		numalts = sk_GENERAL_NAME_num(gens);
+		for (i = 0; i < numalts; ++i) {
+		    gn = sk_GENERAL_NAME_value(gens, i);
+		    if (gn->type == GEN_DNS)
+			cert_host = (char *) ASN1_STRING_data(gn->d.ia5);
+		    else if (gn->type == GEN_IPADD) {
+			/* XXX untested -TG */
+			size_t j = (size_t) ASN1_STRING_length(gn->d.ia5);
+
+			cert_host = (char *) malloc(j + 1);
+			MemCpy(cert_host, ASN1_STRING_data(gn->d.ia5), j);
+			cert_host[j] = '\0';
+		    } else
+			continue;
+		    status_sslcertcheck = 1;	/* got at least one */
+		    /* verify this SubjectAltName (see above) */
+		    cert_host = StripIpv6Brackets(cert_host);
+		    if (!(gn->type == GEN_IPADD ? strcasecomp :
+			  strcasecomp_asterisk) (ssl_host, cert_host)) {
+			status_sslcertcheck = 2;
+			HTSprintf0(&msg,
+				   gettext("Verified connection to %s (subj=%s)"),
+				   ssl_host, cert_host);
+			_HTProgress(msg);
+			FREE(msg);
+			if (gn->type == GEN_IPADD)
+			    free(cert_host);
+			break;
+		    }
+		    /* add to list of failed CNs */
+		    if (ssl_all_cns == NULL)
+			StrAllocCopy(ssl_all_cns, "SAN<");
+		    else
+			StrAllocCat(ssl_all_cns, ":SAN<");
+		    if (gn->type == GEN_DNS)
+			StrAllocCat(ssl_all_cns, "DNS=");
+		    else if (gn->type == GEN_IPADD)
+			StrAllocCat(ssl_all_cns, "IP=");
+		    StrAllocCat(ssl_all_cns, cert_host);
+		    StrAllocCat(ssl_all_cns, ">");
+		    if (gn->type == GEN_IPADD)
+			free(cert_host);
+		}
+		sk_GENERAL_NAME_free(gens);
+	    }
+	}
+#endif /* USE_OPENSSL_INCL */
+
+	/* if an error occurred, format the appropriate message */
+	if (status_sslcertcheck == 0) {
+	    SSL_single_prompt(&msg,
+			      gettext("Can't find common name in certificate"));
+	} else if (status_sslcertcheck == 1) {
+	    SSL_double_prompt(&msg,
+			      gettext("SSL error:host(%s)!=cert(%s)-Continue?"),
+			      ssl_host, ssl_all_cns);
+	}
+
+	/* if an error occurred, let the user decide how much he trusts */
+	if (status_sslcertcheck < 2) {
+	    if (msg == NULL)
+		StrAllocCopy(msg, gettext("SSL error"));
+	    if (!HTForcedPrompt(ssl_noprompt, msg, NO)) {
+		status = HT_NOT_LOADED;
+		FREE(msg);
+		FREE(ssl_all_cns);
+		goto done;
+	    }
+	    SSL_double_prompt(&msg,
+			      gettext("UNVERIFIED connection to %s (cert=%s)"),
+			      ssl_host, ssl_all_cns ? ssl_all_cns : "NONE");
+	    _HTProgress(msg);
+	    FREE(msg);
+	}
+
+	show_cert_issuer(peer_cert);
+
+	HTSprintf0(&msg,
+		   gettext("Secure %d-bit %s (%s) HTTP connection"),
+		   SSL_get_cipher_bits(handle, NULL),
+		   SSL_get_cipher_version(handle),
+		   SSL_get_cipher(handle));
+	_HTProgress(msg);
+	FREE(msg);
+	FREE(ssl_all_cns);
+	FREE(ssl_host);
+    }
+#endif /* USE_SSL */
+
+    /* Ask that node for the document, omitting the host name & anchor
+     */
+    {
+	char *p1 = (HTParse(url, "", PARSE_PATH | PARSE_PUNCTUATION));
+
+#ifdef USE_SSL
+	if (do_connect) {
+	    METHOD = "CONNECT";
+	    BStrCopy0(command, "CONNECT ");
+	} else
+#endif /* USE_SSL */
+	if (do_post) {
+	    METHOD = "POST";
+	    BStrCopy0(command, "POST ");
+	} else if (do_head) {
+	    METHOD = "HEAD";
+	    BStrCopy0(command, "HEAD ");
+	} else {
+	    METHOD = "GET";
+	    BStrCopy0(command, "GET ");
+	}
+
+	/*
+	 * If we are using a proxy gateway don't copy in the first slash of
+	 * say:  /gopher://a;lkdjfl;ajdf;lkj/;aldk/adflj so that just
+	 * gopher://....  is sent.
+	 */
+#ifdef USE_SSL
+	if (using_proxy && !did_connect) {
+	    if (do_connect)
+		BStrCat0(command, connect_host);
+	    else
+		BStrCat0(command, p1 + 1);
+	}
+#else
+	if (using_proxy)
+	    BStrCat0(command, p1 + 1);
+#endif /* USE_SSL */
+	else
+	    BStrCat0(command, p1);
+	FREE(p1);
+    }
+    if (extensions) {
+	BStrCat0(command, " ");
+	BStrCat0(command, ((HTprotocolLevel == HTTP_1_0)
+			   ? "HTTP/1.0"
+			   : "HTTP/1.1"));
+    }
+
+    BStrCat0(command, crlf);	/* CR LF, as in rfc 977 */
+
+    if (extensions) {
+	int n, i;
+	char *host = NULL;
+
+	if ((host = HTParse(anAnchor->address, "", PARSE_HOST)) != NULL) {
+	    strip_userid(host, TRUE);
+	    HTBprintf(&command, "Host: %s%c%c", host, CR, LF);
+	    FREE(host);
+	}
+	if (HTprotocolLevel >= HTTP_1_1) {
+	    HTBprintf(&command, "Connection: close%c%c", CR, LF);
+	}
+
+	if (!HTPresentations)
+	    HTFormatInit();
+	n = HTList_count(HTPresentations);
+
+	first_Accept = TRUE;
+	len = 0;
+	for (i = 0; i < n; i++) {
+	    HTPresentation *pres =
+	    (HTPresentation *) HTList_objectAt(HTPresentations, i);
+
+	    if (pres->get_accept) {
+		if (pres->quality < 1.0) {
+		    if (pres->maxbytes > 0) {
+			sprintf(temp, ";q=%4.3f;mxb=%" PRI_off_t "",
+				pres->quality, CAST_off_t (pres->maxbytes));
+		    } else {
+			sprintf(temp, ";q=%4.3f", pres->quality);
+		    }
+		} else if (pres->maxbytes > 0) {
+		    sprintf(temp, ";mxb=%" PRI_off_t "", CAST_off_t (pres->maxbytes));
+		} else {
+		    temp[0] = '\0';
+		}
+		HTSprintf0(&linebuf, "%s%s%s",
+			   (first_Accept ?
+			    "Accept: " : ", "),
+			   HTAtom_name(pres->rep),
+			   temp);
+		len += (int) strlen(linebuf);
+		if (len > 252 && !first_Accept) {
+		    BStrCat0(command, crlf);
+		    HTSprintf0(&linebuf, "Accept: %s%s",
+			       HTAtom_name(pres->rep),
+			       temp);
+		    len = (int) strlen(linebuf);
+		}
+		BStrCat0(command, linebuf);
+		first_Accept = FALSE;
+	    }
+	}
+	HTBprintf(&command, "%s*/*;q=0.01%c%c",
+		  (first_Accept ?
+		   "Accept: " : ", "), CR, LF);
+
+	/*
+	 * FIXME:  suppressing the "Accept-Encoding" in this case is done to
+	 * work around limitations of the presentation logic used for the
+	 * command-line "-base" option.  The remote site may transmit the
+	 * document gzip'd, but the ensuing logic in HTSaveToFile() would see
+	 * the mime-type as gzip rather than text/html, and not prepend the
+	 * base URL.  This is less efficient than accepting the compressed data
+	 * and uncompressing it, adding the base URL but is simpler than
+	 * augmenting the dump's presentation logic -TD
+	 */
+	if (LYPrependBaseToSource && dump_output_immediately) {
+	    CTRACE((tfp,
+		    "omit Accept-Encoding to work-around interaction with -source\n"));
+	} else {
+	    char *list = 0;
+	    int j, k;
+
+	    for (j = 1; j < encodingALL; j <<= 1) {
+		if (acceptEncoding(j)) {
+		    for (k = 0; tbl_preferred_encoding[k].name != 0; ++k) {
+			if (tbl_preferred_encoding[k].value == j) {
+			    if (list != 0)
+				StrAllocCat(list, ", ");
+			    StrAllocCat(list, tbl_preferred_encoding[k].name);
+			    break;
+			}
+		    }
+		}
+	    }
+
+	    if (list != 0) {
+		HTBprintf(&command, "Accept-Encoding: %s%c%c", list, CR, LF);
+		free(list);
+	    }
+	}
+
+	if (non_empty(language)) {
+	    HTBprintf(&command, "Accept-Language: %s%c%c", language, CR, LF);
+	}
+
+	if (non_empty(pref_charset)) {
+	    BStrCat0(command, "Accept-Charset: ");
+	    StrAllocCopy(linebuf, pref_charset);
+	    if (linebuf[strlen(linebuf) - 1] == ',')
+		linebuf[strlen(linebuf) - 1] = '\0';
+	    LYLowerCase(linebuf);
+	    if (strstr(linebuf, "iso-8859-1") == NULL)
+		StrAllocCat(linebuf, ", iso-8859-1;q=0.01");
+	    if (strstr(linebuf, "us-ascii") == NULL)
+		StrAllocCat(linebuf, ", us-ascii;q=0.01");
+	    BStrCat0(command, linebuf);
+	    HTBprintf(&command, "%c%c", CR, LF);
+	}
+#if 0
+	/*
+	 * Promote 300 (Multiple Choices) replies, if supported, over 406 (Not
+	 * Acceptable) replies.  - FM
+	 *
+	 * This used to be done in versions 2.7 and 2.8*, but violates the
+	 * specs for transparent content negotiation and has the effect that
+	 * servers supporting those specs will send 300 (Multiple Choices)
+	 * instead of a normal response (e.g.  200 OK), since they will assume
+	 * that the client wants to make the choice.  It is not clear whether
+	 * there are any servers or sites for which sending this header really
+	 * improves anything.
+	 *
+	 * If there ever is a need to send "Negotiate:  trans" and really mean
+	 * it, we should send "Negotiate:  trans,trans" or similar, since that
+	 * is semantically equivalent and some servers may ignore "Negotiate:
+	 * trans" as a special case when it comes from Lynx (to work around the
+	 * old faulty behavior).  - kw
+	 *
+	 * References:
+	 * RFC 2295 (see also RFC 2296), and mail to lynx-dev and
+	 * new-httpd@apache.org from Koen Holtman, Jan 1999.
+	 */
+	if (!do_post) {
+	    HTBprintf(&command, "Negotiate: trans%c%c", CR, LF);
+	}
+#endif /* 0 */
+
+	/*
+	 * When reloading give no-cache pragma to proxy server to make it
+	 * refresh its cache.  -- Ari L.  <luotonen@dxcern.cern.ch>
+	 *
+	 * Also send it as a Cache-Control header for HTTP/1.1.  - FM
+	 */
+	if (reloading) {
+	    HTBprintf(&command, "Pragma: no-cache%c%c", CR, LF);
+	    HTBprintf(&command, "Cache-Control: no-cache%c%c", CR, LF);
+	}
+
+	if (LYSendUserAgent || no_useragent) {
+	    if (non_empty(LYUserAgent)) {
+		char *cp = LYSkipBlanks(LYUserAgent);
+
+		/* Won't send it at all if all blank - kw */
+		if (*cp != '\0')
+		    HTBprintf(&command, "User-Agent: %.*s%c%c",
+			      INIT_LINE_SIZE - 15, LYUserAgent, CR, LF);
+	    } else {
+		HTBprintf(&command, "User-Agent: %s/%s  libwww-FM/%s%c%c",
+			  HTAppName ? HTAppName : "unknown",
+			  HTAppVersion ? HTAppVersion : "0.0",
+			  HTLibraryVersion, CR, LF);
+	    }
+	}
+
+	if (non_empty(personal_mail_address) && !LYNoFromHeader) {
+	    HTBprintf(&command, "From: %s%c%c", personal_mail_address, CR, LF);
+	}
+
+	if (!(LYUserSpecifiedURL ||
+	      LYNoRefererHeader || LYNoRefererForThis) &&
+	    strcmp(HTLoadedDocumentURL(), "")) {
+	    const char *cp = LYRequestReferer;
+
+	    if (!cp)
+		cp = HTLoadedDocumentURL();	/* @@@ Try both? - kw */
+	    BStrCat0(command, "Referer: ");
+	    if (isLYNXIMGMAP(cp)) {
+		char *pound = findPoundSelector(cp);
+		int nn = (pound ? (int) (pound - cp) : (int) strlen(cp));
+
+		HTSABCat(&command, cp + LEN_LYNXIMGMAP, nn);
+	    } else {
+		BStrCat0(command, cp);
+	    }
+	    HTBprintf(&command, "%c%c", CR, LF);
+	} {
+	    char *abspath;
+	    char *docname;
+	    char *hostname;
+	    char *colon;
+	    int portnumber;
+	    char *auth, *cookie = NULL;
+	    BOOL secure = (BOOL) (StrNCmp(anAnchor->address, "https", 5)
+				  ? FALSE
+				  : TRUE);
+
+	    abspath = HTParse(arg, "", PARSE_PATH | PARSE_PUNCTUATION);
+	    docname = HTParse(arg, "", PARSE_PATH);
+	    hostname = HTParse(arg, "", PARSE_HOST);
+	    if (hostname &&
+		NULL != (colon = HTParsePort(hostname, &portnumber))) {
+		*colon = '\0';	/* Chop off port number */
+	    } else if (!StrNCmp(arg, "https", 5)) {
+		portnumber = HTTPS_PORT;
+	    } else {
+		portnumber = HTTP_PORT;
+	    }
+
+	    /*
+	     * Add Authorization, Proxy-Authorization, and/or Cookie headers,
+	     * if applicable.
+	     */
+	    if (using_proxy) {
+		/*
+		 * If we are using a proxy, first determine if we should
+		 * include an Authorization header and/or Cookie header for the
+		 * ultimate target of this request.  - FM & AJL
+		 */
+		char *host2 = NULL, *path2 = NULL;
+		int port2 = (StrNCmp(docname, "https", 5) ?
+			     HTTP_PORT : HTTPS_PORT);
+
+		host2 = HTParse(docname, "", PARSE_HOST);
+		path2 = HTParse(docname, "", PARSE_PATH | PARSE_PUNCTUATION);
+		if ((colon = HTParsePort(host2, &port2)) != NULL) {
+		    /* Use non-default port number */
+		    *colon = '\0';
+		}
+
+		/*
+		 * This composeAuth() does file access, i.e., for the ultimate
+		 * target of the request.  - AJL
+		 */
+		auth_proxy = NO;
+		auth = HTAA_composeAuth(host2, port2, path2, auth_proxy);
+		if (auth == NULL) {
+		    CTRACE((tfp, "HTTP: Not sending authorization (yet).\n"));
+		} else if (*auth != '\0') {
+		    /*
+		     * We have an Authorization header to be included.
+		     */
+		    HTBprintf(&command, "%s%c%c", auth, CR, LF);
+		    CTRACE((tfp, "HTTP: Sending authorization: %s\n", auth));
+		} else {
+		    /*
+		     * The user either cancelled or made a mistake with the
+		     * username and password prompt.
+		     */
+		    if (!(traversal || dump_output_immediately) &&
+			HTConfirm(CONFIRM_WO_PASSWORD)) {
+			show_401 = TRUE;
+		    } else {
+			if (traversal || dump_output_immediately)
+			    HTAlert(FAILED_NEED_PASSWD);
+#ifdef USE_SSL
+			if (did_connect)
+			    HTTP_NETCLOSE(s, handle);
+#endif /* USE_SSL */
+			BStrFree(command);
+			FREE(hostname);
+			FREE(docname);
+			FREE(abspath);
+			FREE(host2);
+			FREE(path2);
+			status = HT_NOT_LOADED;
+			goto done;
+		    }
+		}
+		/*
+		 * Add 'Cookie:' header, if it's HTTP or HTTPS document being
+		 * proxied.
+		 */
+		if (!StrNCmp(docname, "http", 4)) {
+		    cookie = LYAddCookieHeader(host2, path2, port2, secure);
+		}
+		FREE(host2);
+		FREE(path2);
+		/*
+		 * The next composeAuth() will be for the proxy.  - AJL
+		 */
+		auth_proxy = YES;
+	    } else {
+		/*
+		 * Add cookie for a non-proxied request.  - FM
+		 */
+		cookie = LYAddCookieHeader(hostname, abspath, portnumber, secure);
+		auth_proxy = NO;
+	    }
+	    /*
+	     * If we do have a cookie set, add it to the request buffer.  - FM
+	     */
+	    if (cookie != NULL) {
+		if (*cookie != '$' && USE_RFC_2965) {
+		    /*
+		     * It's a historical cookie, so signal to the server that
+		     * we support modern cookies.  - FM
+		     */
+		    BStrCat0(command, "Cookie2: $Version=\"1\"");
+		    BStrCat0(command, crlf);
+		    CTRACE((tfp, "HTTP: Sending Cookie2: $Version =\"1\"\n"));
+		}
+		if (*cookie != '\0') {
+		    /*
+		     * It's not a zero-length string, so add the header.  Note
+		     * that any folding of long strings has been done already
+		     * in LYCookie.c.  - FM
+		     */
+		    BStrCat0(command, "Cookie: ");
+		    BStrCat0(command, cookie);
+		    BStrCat0(command, crlf);
+		    CTRACE((tfp, "HTTP: Sending Cookie: %s\n", cookie));
+		}
+		FREE(cookie);
+	    }
+	    FREE(abspath);
+
+	    /*
+	     * If we are using a proxy, auth_proxy should be YES, and we check
+	     * here whether we want a Proxy-Authorization header for it.  If we
+	     * are not using a proxy, auth_proxy should still be NO, and we
+	     * check here for whether we want an Authorization header.  - FM &
+	     * AJL
+	     */
+	    if ((auth = HTAA_composeAuth(hostname,
+					 portnumber,
+					 docname,
+					 auth_proxy)) != NULL &&
+		*auth != '\0') {
+		/*
+		 * If auth is not NULL nor zero-length, it's an Authorization
+		 * or Proxy-Authorization header to be included.  - FM
+		 */
+		HTBprintf(&command, "%s%c%c", auth, CR, LF);
+		CTRACE((tfp, (auth_proxy ?
+			      "HTTP: Sending proxy authorization: %s\n" :
+			      "HTTP: Sending authorization: %s\n"),
+			auth));
+	    } else if (auth && *auth == '\0') {
+		/*
+		 * If auth is a zero-length string, the user either cancelled
+		 * or goofed at the username and password prompt.  - FM
+		 */
+		if (!(traversal || dump_output_immediately) && HTConfirm(CONFIRM_WO_PASSWORD)) {
+		    if (auth_proxy == TRUE) {
+			show_407 = TRUE;
+		    } else {
+			show_401 = TRUE;
+		    }
+		} else {
+		    if (traversal || dump_output_immediately)
+			HTAlert(FAILED_NEED_PASSWD);
+		    BStrFree(command);
+		    FREE(hostname);
+		    FREE(docname);
+		    status = HT_NOT_LOADED;
+		    goto done;
+		}
+	    } else {
+		CTRACE((tfp, (auth_proxy ?
+			      "HTTP: Not sending proxy authorization (yet).\n" :
+			      "HTTP: Not sending authorization (yet).\n")));
+	    }
+	    FREE(hostname);
+	    FREE(docname);
+	}
+    }
+
+    if (
+#ifdef USE_SSL
+	   !do_connect &&
+#endif /* USE_SSL */
+	   do_post) {
+	CTRACE((tfp, "HTTP: Doing post, content-type '%s'\n",
+		anAnchor->post_content_type
+		? anAnchor->post_content_type
+		: "lose"));
+	HTBprintf(&command, "Content-Type: %s%c%c",
+		  anAnchor->post_content_type
+		  ? anAnchor->post_content_type
+		  : "lose",
+		  CR, LF);
+
+	HTBprintf(&command, "Content-Length: %d%c%c",
+		  !isBEmpty(anAnchor->post_data)
+		  ? BStrLen(anAnchor->post_data)
+		  : 0,
+		  CR, LF);
+
+	BStrCat0(command, crlf);	/* Blank line means "end" of headers */
+
+	BStrCat(command, anAnchor->post_data);
+    } else
+	BStrCat0(command, crlf);	/* Blank line means "end" of headers */
+
+    if (TRACE) {
+	CTRACE((tfp, "Writing:\n"));
+	trace_bstring(command);
+#ifdef USE_SSL
+	CTRACE((tfp, "%s",
+		(anAnchor->post_data && !do_connect ? crlf : "")));
+#else
+	CTRACE((tfp, "%s",
+		(anAnchor->post_data ? crlf : "")));
+#endif /* USE_SSL */
+	CTRACE((tfp, "----------------------------------\n"));
+    }
+
+    _HTProgress(gettext("Sending HTTP request."));
+
+#ifdef    NOT_ASCII		/* S/390 -- gil -- 0548 */
+    {
+	char *p2;
+
+	for (p2 = BStrData(command);
+	     p2 < BStrData(command) + BStrLen(command);
+	     p2++)
+	    *p2 = TOASCII(*p2);
+    }
+#endif /* NOT_ASCII */
+    status = (int) HTTP_NETWRITE(s,
+				 BStrData(command),
+				 BStrLen(command),
+				 handle);
+    BStrFree(command);
+    FREE(linebuf);
+    if (status <= 0) {
+	if (status == 0) {
+	    CTRACE((tfp, "HTTP: Got status 0 in initial write\n"));
+	    /* Do nothing. */
+	} else if ((SOCKET_ERRNO == ENOTCONN ||
+		    SOCKET_ERRNO == ECONNRESET ||
+		    SOCKET_ERRNO == EPIPE) &&
+		   !already_retrying &&
+	    /* Don't retry if we're posting. */ !do_post) {
+	    /*
+	     * Arrrrgh, HTTP 0/1 compatibility problem, maybe.
+	     */
+	    CTRACE((tfp,
+		    "HTTP: BONZO ON WRITE Trying again with HTTP0 request.\n"));
+	    _HTProgress(RETRYING_AS_HTTP0);
+	    HTTP_NETCLOSE(s, handle);
+	    extensions = NO;
+	    already_retrying = TRUE;
+	    goto try_again;
+	} else {
+	    CTRACE((tfp,
+		    "HTTP: Hit unexpected network WRITE error; aborting connection.\n"));
+	    HTTP_NETCLOSE(s, handle);
+	    status = -1;
+	    HTAlert(gettext("Unexpected network write error; connection aborted."));
+	    goto done;
+	}
+    }
+
+    CTRACE((tfp, "HTTP: WRITE delivered OK\n"));
+    _HTProgress(gettext("HTTP request sent; waiting for response."));
+
+    /*    Read the first line of the response
+     * -----------------------------------
+     */
+    {
+	/* Get numeric status etc */
+	BOOL end_of_file = NO;
+	int buffer_length = INIT_LINE_SIZE;
+
+	line_buffer = typecallocn(char, (size_t) buffer_length);
+
+	if (line_buffer == NULL)
+	    outofmem(__FILE__, "HTLoadHTTP");
+
+	HTReadProgress(bytes_already_read = 0, (off_t) 0);
+	do {			/* Loop to read in the first line */
+	    /*
+	     * Extend line buffer if necessary for those crazy WAIS URLs ;-)
+	     */
+	    if (buffer_length - length < LINE_EXTEND_THRESH) {
+		buffer_length = buffer_length + buffer_length;
+		line_buffer =
+		    (char *) realloc(line_buffer, ((unsigned) buffer_length *
+						   sizeof(char)));
+
+		if (line_buffer == NULL)
+		    outofmem(__FILE__, "HTLoadHTTP");
+	    }
+	    CTRACE((tfp, "HTTP: Trying to read %d\n", buffer_length - length - 1));
+	    status = HTTP_NETREAD(s,
+				  line_buffer + length,
+				  (buffer_length - length - 1),
+				  handle);
+	    CTRACE((tfp, "HTTP: Read %d\n", status));
+	    if (status <= 0) {
+		/*
+		 * Retry if we get nothing back too.
+		 * Bomb out if we get nothing twice.
+		 */
+		if (status == HT_INTERRUPTED) {
+		    CTRACE((tfp, "HTTP: Interrupted initial read.\n"));
+		    _HTProgress(CONNECTION_INTERRUPTED);
+		    HTTP_NETCLOSE(s, handle);
+		    status = HT_NO_DATA;
+		    goto clean_up;
+		} else if (status < 0 &&
+			   (SOCKET_ERRNO == ENOTCONN ||
+#ifdef _WINDOWS			/* 1997/11/09 (Sun) 16:59:58 */
+			    SOCKET_ERRNO == ETIMEDOUT ||
+#endif
+			    SOCKET_ERRNO == ECONNRESET ||
+			    SOCKET_ERRNO == EPIPE) &&
+			   !already_retrying && !do_post) {
+		    /*
+		     * Arrrrgh, HTTP 0/1 compatibility problem, maybe.
+		     */
+		    CTRACE((tfp,
+			    "HTTP: BONZO Trying again with HTTP0 request.\n"));
+		    HTTP_NETCLOSE(s, handle);
+		    FREE(line_buffer);
+		    FREE(line_kept_clean);
+
+		    extensions = NO;
+		    already_retrying = TRUE;
+		    _HTProgress(RETRYING_AS_HTTP0);
+		    goto try_again;
+		}
+#ifdef USE_SSL
+		else if ((SSLerror = ERR_get_error()) != 0) {
+		    CTRACE((tfp,
+			    "HTTP: Hit unexpected network read error; aborting connection; status %d:%s.\n",
+			    status, ERR_error_string(SSLerror, NULL)));
+		    HTAlert(gettext("Unexpected network read error; connection aborted."));
+		    HTTP_NETCLOSE(s, handle);
+		    status = -1;
+		    goto clean_up;
+		}
+#endif
+		else {
+		    CTRACE((tfp,
+			    "HTTP: Hit unexpected network read error; aborting connection; status %d.\n",
+			    status));
+		    HTAlert(gettext("Unexpected network read error; connection aborted."));
+		    HTTP_NETCLOSE(s, handle);
+		    status = -1;
+		    goto clean_up;
+		}
+	    }
+#ifdef    NOT_ASCII		/* S/390 -- gil -- 0564 */
+	    {
+		char *p2;
+
+		for (p2 = line_buffer + length;
+		     p2 < line_buffer + length + status;
+		     p2++)
+		    *p2 = FROMASCII(*p2);
+	    }
+#endif /* NOT_ASCII */
+
+	    bytes_already_read += status;
+	    HTReadProgress(bytes_already_read, (off_t) 0);
+
+#ifdef UCX			/* UCX returns -1 on EOF */
+	    if (status == 0 || status == -1)
+#else
+	    if (status == 0)
+#endif
+	    {
+		break;
+	    }
+	    line_buffer[length + status] = 0;
+
+	    if (line_buffer) {
+		FREE(line_kept_clean);
+		line_kept_clean = (char *) malloc((unsigned) buffer_length *
+						  sizeof(char));
+
+		if (line_kept_clean == NULL)
+		    outofmem(__FILE__, "HTLoadHTTP");
+		MemCpy(line_kept_clean, line_buffer, buffer_length);
+#ifdef SH_EX			/* FIX BUG by kaz@maczuka.hitachi.ibaraki.jp */
+		real_length_of_line = length + status;
+#endif
+	    }
+
+	    eol = StrChr(line_buffer + length, LF);
+	    /* Do we *really* want to do this? */
+	    if (eol && eol != line_buffer && *(eol - 1) == CR)
+		*(eol - 1) = ' ';
+
+	    length = length + status;
+
+	    /* Do we really want to do *this*? */
+	    if (eol)
+		*eol = 0;	/* Terminate the line */
+	}
+	/* All we need is the first line of the response.  If it's a HTTP/1.0
+	 * response, then the first line will be absurdly short and therefore
+	 * we can safely gate the number of bytes read through this code (as
+	 * opposed to below) to ~1000.
+	 *
+	 * Well, let's try 100.
+	 */
+	while (!eol && !end_of_file && bytes_already_read < 100);
+    }				/* Scope of loop variables */
+
+    /* save total length, in case we decide later to show it all - kw */
+    rawlength = length;
+
+    /*    We now have a terminated unfolded line.  Parse it.
+     * --------------------------------------------------
+     */
+    CTRACE((tfp, "HTTP: Rx: %s\n", line_buffer));
+
+    /*
+     * Kludge to work with old buggy servers and the VMS Help gateway.  They
+     * can't handle the third word, so we try again without it.
+     */
+    if (extensions &&		/* Old buggy server or Help gateway? */
+	(0 == StrNCmp(line_buffer, "<TITLE>Bad File Request</TITLE>", 31) ||
+	 0 == StrNCmp(line_buffer, "Address should begin with", 25) ||
+	 0 == StrNCmp(line_buffer, "<TITLE>Help ", 12) ||
+	 0 == strcmp(line_buffer,
+		     "Document address invalid or access not authorised"))) {
+	FREE(line_buffer);
+	FREE(line_kept_clean);
+	extensions = NO;
+	already_retrying = TRUE;
+	CTRACE((tfp, "HTTP: close socket %d to retry with HTTP0\n", s));
+	HTTP_NETCLOSE(s, handle);
+	/* print a progress message */
+	_HTProgress(RETRYING_AS_HTTP0);
+	goto try_again;
+    } {
+	int fields;
+	char server_version[VERSION_LENGTH + 1];
+
+	server_version[0] = 0;
+
+	fields = sscanf(line_buffer, "%20s %d",
+			server_version,
+			&server_status);
+
+	CTRACE((tfp, "HTTP: Scanned %d fields from line_buffer\n", fields));
+
+	if (non_empty(http_error_file)) {
+	    /* Make the status code externally available */
+	    FILE *error_file;
+
+#ifdef SERVER_STATUS_ONLY
+	    error_file = fopen(http_error_file, TXT_W);
+	    if (error_file) {	/* Managed to open the file */
+		fprintf(error_file, "error=%d\n", server_status);
+		fclose(error_file);
+	    }
+#else
+	    error_file = fopen(http_error_file, TXT_A);
+	    if (error_file) {	/* Managed to open the file */
+		fprintf(error_file, "   URL=%s (%s)\n", url, METHOD);
+		fprintf(error_file, "STATUS=%s\n", line_buffer);
+		fclose(error_file);
+	    }
+#endif /* SERVER_STATUS_ONLY */
+	}
+
+	/*
+	 * Rule out a non-HTTP/1.n reply as best we can.
+	 */
+	if (fields < 2 || !server_version[0] || server_version[0] != 'H' ||
+	    server_version[1] != 'T' || server_version[2] != 'T' ||
+	    server_version[3] != 'P' || server_version[4] != '/' ||
+	    server_version[6] != '.') {
+	    /*
+	     * Ugh!  An HTTP0 reply,
+	     */
+	    HTAtom *encoding;
+
+	    CTRACE((tfp, "--- Talking HTTP0.\n"));
+
+	    format_in = HTFileFormat(url, &encoding, NULL);
+	    /*
+	     * Treat all plain text as HTML.  This sucks but its the only
+	     * solution without without looking at content.
+	     */
+	    if (!StrNCmp(HTAtom_name(format_in), STR_PLAINTEXT, 10)) {
+		CTRACE((tfp, "HTTP: format_in being changed to text/HTML\n"));
+		format_in = WWW_HTML;
+	    }
+	    if (!IsUnityEnc(encoding)) {
+		/*
+		 * Change the format to that for "www/compressed".
+		 */
+		CTRACE((tfp, "HTTP: format_in is '%s',\n", HTAtom_name(format_in)));
+		StrAllocCopy(anAnchor->content_type, HTAtom_name(format_in));
+		StrAllocCopy(anAnchor->content_encoding, HTAtom_name(encoding));
+		format_in = HTAtom_for("www/compressed");
+		CTRACE((tfp, "        Treating as '%s' with encoding '%s'\n",
+			"www/compressed", HTAtom_name(encoding)));
+	    }
+
+	    start_of_data = line_kept_clean;
+	} else {
+	    /*
+	     * Set up to decode full HTTP/1.n response.  - FM
+	     */
+	    format_in = HTAtom_for("www/mime");
+	    CTRACE((tfp, "--- Talking HTTP1.\n"));
+
+	    /*
+	     * We set start_of_data to "" when !eol here because there will be
+	     * a put_block done below; we do *not* use the value of
+	     * start_of_data (as a pointer) in the computation of length (or
+	     * anything else) when !eol.  Otherwise, set the value of length to
+	     * what we have beyond eol (i.e., beyond the status line).  - FM
+	     */
+	    if (eol != 0) {
+		start_of_data = (eol + 1);
+	    } else {
+		start_of_data = empty;
+	    }
+	    length = (eol
+		      ? length - (int) (start_of_data - line_buffer)
+		      : 0);
+
+	    /*
+	     * Trim trailing spaces in line_buffer so that we can use it in
+	     * messages which include the status line.  - FM
+	     */
+	    while (line_buffer[strlen(line_buffer) - 1] == ' ')
+		line_buffer[strlen(line_buffer) - 1] = '\0';
+
+	    /*
+	     * Take appropriate actions based on the status.  - FM
+	     */
+	    switch (server_status / 100) {
+	    case 1:
+		/*
+		 * HTTP/1.1 Informational statuses.
+		 * 100 Continue.
+		 * 101 Switching Protocols.
+		 * > 101 is unknown.
+		 * We should never get these, and they have only the status
+		 * line and possibly other headers, so we'll deal with them by
+		 * showing the full header to the user as text/plain.  - FM
+		 */
+		HTAlert(gettext("Got unexpected Informational Status."));
+		do_head = TRUE;
+		break;
+
+	    case 2:
+		/*
+		 * Good:  Got MIME object!  (Successful) - FM
+		 */
+		if (do_head) {
+		    /*
+		     * If HEAD was requested, show headers (and possibly bogus
+		     * body) for all 2xx status codes as text/plain - KW
+		     */
+		    HTProgress(line_buffer);
+		    break;
+		}
+		switch (server_status) {
+		case 204:
+		    /*
+		     * No Content.
+		     */
+		    HTAlert(line_buffer);
+		    HTTP_NETCLOSE(s, handle);
+		    HTNoDataOK = 1;
+		    status = HT_NO_DATA;
+		    goto clean_up;
+
+		case 205:
+		    /*
+		     * Reset Content.  The server has fulfilled the request but
+		     * nothing is returned and we should reset any form
+		     * content.  We'll instruct the user to do that, and
+		     * restore the current document.  - FM
+		     */
+		    HTAlert(gettext("Request fulfilled.  Reset Content."));
+		    HTTP_NETCLOSE(s, handle);
+		    status = HT_NO_DATA;
+		    goto clean_up;
+
+		case 206:
+		    /*
+		     * Partial Content.  We didn't send a Range so something
+		     * went wrong somewhere.  Show the status message and
+		     * restore the current document.  - FM
+		     */
+		    HTAlert(line_buffer);
+		    HTTP_NETCLOSE(s, handle);
+		    status = HT_NO_DATA;
+		    goto clean_up;
+
+		default:
+		    /*
+		     * 200 OK.
+		     * 201 Created.
+		     * 202 Accepted.
+		     * 203 Non-Authoritative Information.
+		     * > 206 is unknown.
+		     * All should return something to display.
+		     */
+#if defined(USE_SSL)		/* && !defined(DISABLE_NEWS)  _H */
+		    if (do_connect) {
+			CTRACE((tfp,
+				"HTTP: Proxy tunnel to '%s' established.\n",
+				connect_host));
+			do_connect = FALSE;
+			url = connect_url;
+			FREE(line_buffer);
+			FREE(line_kept_clean);
+#ifndef DISABLE_NEWS
+			if (!StrNCmp(connect_url, "snews", 5)) {
+			    CTRACE((tfp,
+				    "      Will attempt handshake and snews connection.\n"));
+			    status = HTNewsProxyConnect(s, url, anAnchor,
+							format_out, sink);
+			    goto done;
+			}
+#endif /* DISABLE_NEWS */
+			did_connect = TRUE;
+			already_retrying = TRUE;
+			eol = 0;
+			length = 0;
+			doing_redirect = FALSE;
+			permanent_redirection = FALSE;
+			target = NULL;
+			CTRACE((tfp,
+				"      Will attempt handshake and resubmit headers.\n"));
+			goto use_tunnel;
+		    }
+#endif /* USE_SSL */
+		    HTProgress(line_buffer);
+		}		/* case 2 switch */
+		break;
+
+	    case 3:
+		/*
+		 * Various forms of Redirection.  - FM
+		 * 300 Multiple Choices.
+		 * 301 Moved Permanently.
+		 * 302 Found (temporary; we can, and do, use GET).
+		 * 303 See Other (temporary; always use GET).
+		 * 304 Not Modified.
+		 * 305 Use Proxy.
+		 * 306 Set Proxy.
+		 * 307 Temporary Redirect with method retained.
+		 * > 308 is unknown.
+		 */
+		if (no_url_redirection || do_head || keep_mime_headers) {
+		    /*
+		     * If any of these flags are set, we do not redirect, but
+		     * instead show what was returned to the user as
+		     * text/plain.  - FM
+		     */
+		    HTProgress(line_buffer);
+		    break;
+		}
+
+		if (server_status == 300) {	/* Multiple Choices */
+		    /*
+		     * For client driven content negotiation.  The server
+		     * should be sending some way for the user-agent to make a
+		     * selection, so we'll show the user whatever the server
+		     * returns.  There might be a Location:  header with the
+		     * server's preference present, but the choice should be up
+		     * to the user, someday based on an Alternates:  header,
+		     * and a body always should be present with descriptions
+		     * and links for the choices (i.e., we use the latter, for
+		     * now).  - FM
+		     */
+		    HTAlert(line_buffer);
+		    if (traversal) {
+			HTTP_NETCLOSE(s, handle);
+			status = -1;
+			goto clean_up;
+		    }
+		    if (!dump_output_immediately &&
+			format_out == WWW_DOWNLOAD) {
+			/*
+			 * Convert a download request to a presentation request
+			 * for interactive users.  - FM
+			 */
+			format_out = WWW_PRESENT;
+		    }
+		    break;
+		}
+
+		if (server_status == 304) {	/* Not Modified */
+		    /*
+		     * We didn't send an "If-Modified-Since" header, so this
+		     * status is inappropriate.  We'll deal with it by showing
+		     * the full header to the user as text/plain.  - FM
+		     */
+		    HTAlert(gettext("Got unexpected 304 Not Modified status."));
+		    do_head = TRUE;
+		    break;
+		}
+
+		if (server_status == 305 ||
+		    server_status == 306 ||
+		    server_status > 307) {
+		    /*
+		     * Show user the content, if any, for 305, 306, or unknown
+		     * status.  - FM
+		     */
+		    HTAlert(line_buffer);
+		    if (traversal) {
+			HTTP_NETCLOSE(s, handle);
+			status = -1;
+			goto clean_up;
+		    }
+		    if (!dump_output_immediately &&
+			format_out == WWW_DOWNLOAD) {
+			/*
+			 * Convert a download request to a presentation request
+			 * for interactive users.  - FM
+			 */
+			format_out = WWW_PRESENT;
+		    }
+		    break;
+		}
+
+		/*
+		 * We do not load the file, but read the headers for the
+		 * "Location:", check out that redirecting_url and if it's
+		 * acceptable (e.g., not a telnet URL when we have that
+		 * disabled), initiate a new fetch.  If that's another
+		 * redirecting_url, we'll repeat the checks, and fetch
+		 * initiations if acceptable, until we reach the actual URL, or
+		 * the redirection limit set in HTAccess.c is exceeded.  If the
+		 * status was 301 indicating that the relocation is permanent,
+		 * we set the permanent_redirection flag to make it permanent
+		 * for the current anchor tree (i.e., will persist until the
+		 * tree is freed or the client exits).  If the redirection
+		 * would include POST content, we seek confirmation from an
+		 * interactive user, with option to use 303 for 301 (but not
+		 * for 307), and otherwise refuse the redirection.  We also
+		 * don't allow permanent redirection if we keep POST content.
+		 * If we don't find the Location header or it's value is
+		 * zero-length, we display whatever the server returned, and
+		 * the user should RELOAD that to try again, or make a
+		 * selection from it if it contains links, or Left-Arrow to the
+		 * previous document.  - FM
+		 */
+		{
+		    if ((dump_output_immediately || traversal) &&
+			do_post &&
+			server_status != 303 &&
+			server_status != 302 &&
+			server_status != 301) {
+			/*
+			 * Don't redirect POST content without approval from an
+			 * interactive user.  - FM
+			 */
+			HTTP_NETCLOSE(s, handle);
+			status = -1;
+			HTAlert(gettext("Redirection of POST content requires user approval."));
+			if (traversal)
+			    HTProgress(line_buffer);
+			goto clean_up;
+		    }
+
+		    HTProgress(line_buffer);
+		    if (server_status == 301) {		/* Moved Permanently */
+			if (do_post) {
+			    /*
+			     * Don't make the redirection permanent if we have
+			     * POST content.  - FM
+			     */
+			    CTRACE((tfp,
+				    "HTTP: Have POST content.  Treating 301 (Permanent) as Temporary.\n"));
+			    HTAlert(gettext("Have POST content.  Treating Permanent Redirection as Temporary.\n"));
+			} else {
+			    permanent_redirection = TRUE;
+			}
+		    }
+		    doing_redirect = TRUE;
+
+		    break;
+		}
+
+	    case 4:
+		/*
+		 * "I think I goofed!" (Client Error) - FM
+		 */
+		switch (server_status) {
+		case 401:	/* Unauthorized */
+		    /*
+		     * Authorization for origin server required.  If show_401
+		     * is set, proceed to showing the 401 body.  Otherwise, if
+		     * we can set up authorization based on the
+		     * WWW-Authenticate header, and the user provides a
+		     * username and password, try again.  Otherwise, check
+		     * whether to show the 401 body or restore the current
+		     * document - FM
+		     */
+		    if (show_401)
+			break;
+		    if (HTAA_shouldRetryWithAuth(start_of_data, (size_t)
+						 length, s, NO)) {
+
+			HTTP_NETCLOSE(s, handle);
+			if (dump_output_immediately &&
+			    !HTAA_HaveUserinfo(HTParse(arg, "", PARSE_HOST)) &&
+			    !authentication_info[0]) {
+			    fprintf(stderr,
+				    "HTTP: Access authorization required.\n");
+			    fprintf(stderr,
+				    "       Use the -auth=id:pw parameter.\n");
+			    status = HT_NO_DATA;
+			    goto clean_up;
+			}
+
+			CTRACE((tfp, "%s %d %s\n",
+				"HTTP: close socket", s,
+				"to retry with Access Authorization"));
+
+			_HTProgress(gettext("Retrying with access authorization information."));
+			FREE(line_buffer);
+			FREE(line_kept_clean);
+#ifdef USE_SSL
+			if (using_proxy && !StrNCmp(url, "https://", 8)) {
+			    url = arg;
+			    do_connect = TRUE;
+			    did_connect = FALSE;
+			}
+#endif /* USE_SSL */
+			goto try_again;
+		    } else if (!(traversal || dump_output_immediately) &&
+			       HTConfirm(gettext("Show the 401 message body?"))) {
+			break;
+		    } else {
+			if (traversal || dump_output_immediately)
+			    HTAlert(FAILED_RETRY_WITH_AUTH);
+			HTTP_NETCLOSE(s, handle);
+			status = -1;
+			goto clean_up;
+		    }
+
+		case 407:
+		    /*
+		     * Authorization for proxy server required.  If we are not
+		     * in fact using a proxy, or show_407 is set, proceed to
+		     * showing the 407 body.  Otherwise, if we can set up
+		     * authorization based on the Proxy-Authenticate header,
+		     * and the user provides a username and password, try
+		     * again.  Otherwise, check whether to show the 401 body or
+		     * restore the current document.  - FM & AJL
+		     */
+		    if (!using_proxy || show_407)
+			break;
+		    if (HTAA_shouldRetryWithAuth(start_of_data, (size_t)
+						 length, s, YES)) {
+
+			HTTP_NETCLOSE(s, handle);
+			if (dump_output_immediately && !proxyauth_info[0]) {
+			    fprintf(stderr,
+				    "HTTP: Proxy authorization required.\n");
+			    fprintf(stderr,
+				    "       Use the -pauth=id:pw parameter.\n");
+			    status = HT_NO_DATA;
+			    goto clean_up;
+			}
+
+			CTRACE((tfp, "%s %d %s\n",
+				"HTTP: close socket", s,
+				"to retry with Proxy Authorization"));
+
+			_HTProgress(HTTP_RETRY_WITH_PROXY);
+			FREE(line_buffer);
+			FREE(line_kept_clean);
+			goto try_again;
+		    } else if (!(traversal || dump_output_immediately) &&
+			       HTConfirm(gettext("Show the 407 message body?"))) {
+			if (!dump_output_immediately &&
+			    format_out == WWW_DOWNLOAD) {
+			    /*
+			     * Convert a download request to a presentation
+			     * request for interactive users.  - FM
+			     */
+			    format_out = WWW_PRESENT;
+			}
+			break;
+		    } else {
+			if (traversal || dump_output_immediately)
+			    HTAlert(FAILED_RETRY_WITH_PROXY);
+			HTTP_NETCLOSE(s, handle);
+			status = -1;
+			goto clean_up;
+		    }
+
+		case 408:
+		    /*
+		     * Request Timeout.  Show the status message and restore
+		     * the current document.  - FM
+		     */
+		    HTAlert(line_buffer);
+		    HTTP_NETCLOSE(s, handle);
+		    status = HT_NO_DATA;
+		    goto clean_up;
+
+		default:
+		    /*
+		     * 400 Bad Request.
+		     * 402 Payment Required.
+		     * 403 Forbidden.
+		     * 404 Not Found.
+		     * 405 Method Not Allowed.
+		     * 406 Not Acceptable.
+		     * 409 Conflict.
+		     * 410 Gone.
+		     * 411 Length Required.
+		     * 412 Precondition Failed.
+		     * 413 Request Entity Too Large.
+		     * 414 Request-URI Too Long.
+		     * 415 Unsupported Media Type.
+		     * 416 List Response (for content negotiation).
+		     * > 416 is unknown.
+		     * Show the status message, and display the returned text
+		     * if we are not doing a traversal.  - FM
+		     */
+		    HTAlert(line_buffer);
+		    if (traversal) {
+			HTTP_NETCLOSE(s, handle);
+			status = -1;
+			goto clean_up;
+		    }
+		    if (!dump_output_immediately &&
+			format_out == WWW_DOWNLOAD) {
+			/*
+			 * Convert a download request to a presentation request
+			 * for interactive users.  - FM
+			 */
+			format_out = WWW_PRESENT;
+		    }
+		    break;
+		}		/* case 4 switch */
+		break;
+
+	    case 5:
+		/*
+		 * "I think YOU goofed!" (server error)
+		 * 500 Internal Server Error
+		 * 501 Not Implemented
+		 * 502 Bad Gateway
+		 * 503 Service Unavailable
+		 * 504 Gateway Timeout
+		 * 505 HTTP Version Not Supported
+		 * > 505 is unknown.
+		 * Should always include a message, which we always should
+		 * display.  - FM
+		 */
+		HTAlert(line_buffer);
+		if (traversal) {
+		    HTTP_NETCLOSE(s, handle);
+		    status = -1;
+		    goto clean_up;
+		}
+		if (!dump_output_immediately &&
+		    format_out == WWW_DOWNLOAD) {
+		    /*
+		     * Convert a download request to a presentation request for
+		     * interactive users.  - FM
+		     */
+		    format_out = WWW_PRESENT;
+		}
+		break;
+
+	    default:
+		/*
+		 * Bad or unknown server_status number.  Take a chance and hope
+		 * there is something to display.  - FM
+		 */
+		HTAlert(gettext("Unknown status reply from server!"));
+		HTAlert(line_buffer);
+		if (traversal) {
+		    HTTP_NETCLOSE(s, handle);
+		    status = -1;
+		    goto clean_up;
+		}
+		if (!dump_output_immediately &&
+		    format_out == WWW_DOWNLOAD) {
+		    /*
+		     * Convert a download request to a presentation request for
+		     * interactive users.  - FM
+		     */
+		    format_out = WWW_PRESENT;
+		}
+		break;
+	    }			/* Switch on server_status/100 */
+
+	}			/* Full HTTP reply */
+    }				/* scope of fields */
+
+    /*
+     * The user may have pressed the 'z'ap key during the pause caused by one
+     * of the HTAlerts above if the server reported an error, to skip loading
+     * of the error response page.  Checking here before setting up the stream
+     * stack and feeding it data avoids doing unnecessary work, it also can
+     * avoid unnecessarily pushing a loaded document out of the cache to make
+     * room for the unwanted error page.  - kw
+     */
+    if (HTCheckForInterrupt()) {
+	HTTP_NETCLOSE(s, handle);
+	if (doing_redirect) {
+	    /*
+	     * Impatient user.  - FM
+	     */
+	    CTRACE((tfp, "HTTP: Interrupted followup read.\n"));
+	    _HTProgress(CONNECTION_INTERRUPTED);
+	}
+	status = HT_INTERRUPTED;
+	goto clean_up;
+    }
+    /*
+     * Set up the stream stack to handle the body of the message.
+     */
+    if (do_head || keep_mime_headers) {
+	/*
+	 * It was a HEAD request, or we want the headers and source.
+	 */
+	start_of_data = line_kept_clean;
+#ifdef SH_EX			/* FIX BUG by kaz@maczuka.hitachi.ibaraki.jp */
+/* GIF file contains \0, so strlen does not return the data length */
+	length = real_length_of_line;
+#else
+	length = rawlength;
+#endif
+	format_in = HTAtom_for(STR_PLAINTEXT);
+
+    } else if (doing_redirect) {
+
+	format_in = HTAtom_for("message/x-http-redirection");
+	StrAllocCopy(anAnchor->content_type, HTAtom_name(format_in));
+	if (traversal) {
+	    format_out = WWW_DEBUG;
+	    if (!sink)
+		sink = HTErrorStream();
+	} else if (!dump_output_immediately &&
+		   format_out == WWW_DOWNLOAD) {
+	    /*
+	     * Convert a download request to a presentation request for
+	     * interactive users.  - FM
+	     */
+	    format_out = WWW_PRESENT;
+	}
+    }
+
+    target = HTStreamStack(format_in,
+			   format_out,
+			   sink, anAnchor);
+
+    if (target == NULL) {
+	char *buffer = NULL;
+
+	HTTP_NETCLOSE(s, handle);
+	HTSprintf0(&buffer, CANNOT_CONVERT_I_TO_O,
+		   HTAtom_name(format_in), HTAtom_name(format_out));
+	_HTProgress(buffer);
+	FREE(buffer);
+	status = -1;
+	goto clean_up;
+    }
+
+    /*
+     * Recycle the first chunk of data, in all cases.
+     */
+    (*target->isa->put_block) (target, start_of_data, length);
+
+    /*
+     * Go pull the bulk of the data down.
+     */
+    rv = HTCopy(anAnchor, s, (void *) handle, target);
+
+    /*
+     * If we get here with doing_redirect set, it means that we were looking
+     * for a Location header.  We either have got it now in redirecting_url -
+     * in that case the stream should not have loaded any data.  Or we didn't
+     * get it, in that case the stream may have presented the message body
+     * normally.  - kw
+     */
+
+    if (rv == -1) {
+	/*
+	 * Intentional interrupt before data were received, not an error
+	 */
+	if (doing_redirect && traversal)
+	    status = -1;
+	else
+	    status = HT_INTERRUPTED;
+	HTTP_NETCLOSE(s, handle);
+	goto clean_up;
+    }
+
+    if (rv == -2) {
+	/*
+	 * Aw hell, a REAL error, maybe cuz it's a dumb HTTP0 server
+	 */
+	(*target->isa->_abort) (target, NULL);
+	if (doing_redirect && redirecting_url) {
+	    /*
+	     * Got a location before the error occurred?  Then consider it an
+	     * interrupt but proceed below as normal.  - kw
+	     */
+	    /* do nothing here */
+	} else {
+	    HTTP_NETCLOSE(s, handle);
+	    if (!doing_redirect && !already_retrying && !do_post) {
+		CTRACE((tfp, "HTTP: Trying again with HTTP0 request.\n"));
+		/*
+		 * May as well consider it an interrupt -- right?
+		 */
+		FREE(line_buffer);
+		FREE(line_kept_clean);
+		extensions = NO;
+		already_retrying = TRUE;
+		_HTProgress(RETRYING_AS_HTTP0);
+		goto try_again;
+	    } else {
+		status = HT_NOT_LOADED;
+		goto clean_up;
+	    }
+	}
+    }
+
+    /*
+     * Free if complete transmission (socket was closed before return).  Close
+     * socket if partial transmission (was freed on abort).
+     */
+    if (rv != HT_INTERRUPTED && rv != -2) {
+	(*target->isa->_free) (target);
+    } else {
+	HTTP_NETCLOSE(s, handle);
+    }
+
+    if (doing_redirect) {
+	if (redirecting_url) {
+	    /*
+	     * Set up for checking redirecting_url in LYGetFile.c for
+	     * restrictions before we seek the document at that Location.  - FM
+	     */
+	    CTRACE((tfp, "HTTP: Picked up location '%s'\n",
+		    redirecting_url));
+	    if (rv == HT_INTERRUPTED) {
+		/*
+		 * Intentional interrupt after data were received, not an error
+		 * (probably).  We take it as a user request to abandon the
+		 * redirection chain.
+		 *
+		 * This could reasonably be changed (by just removing this
+		 * block), it would make sense if there are redirecting
+		 * resources that "hang" after sending the headers.  - kw
+		 */
+		FREE(redirecting_url);
+		CTRACE((tfp, "HTTP: Interrupted followup read.\n"));
+		status = HT_INTERRUPTED;
+		goto clean_up;
+	    }
+	    HTProgress(line_buffer);
+	    if (server_status == 305) {		/* Use Proxy */
+		/*
+		 * Make sure the proxy field ends with a slash.  - FM
+		 */
+		if (redirecting_url[strlen(redirecting_url) - 1]
+		    != '/')
+		    StrAllocCat(redirecting_url, "/");
+		/*
+		 * Append our URL.  - FM
+		 */
+		StrAllocCat(redirecting_url, anAnchor->address);
+		CTRACE((tfp, "HTTP: Proxy URL is '%s'\n",
+			redirecting_url));
+	    }
+	    if (!do_post ||
+		server_status == 303 ||
+		server_status == 302) {
+		/*
+		 * We don't have POST content (nor support PUT or DELETE), or
+		 * the status is "See Other" or "General Redirection" and we
+		 * can convert to GET, so go back and check out the new URL.  -
+		 * FM
+		 */
+		status = HT_REDIRECTING;
+		goto clean_up;
+	    }
+	    /*
+	     * Make sure the user wants to redirect the POST content, or treat
+	     * as GET - FM & DK
+	     */
+	    switch (HTConfirmPostRedirect(redirecting_url,
+					  server_status)) {
+		/*
+		 * User failed to confirm.  Abort the fetch.
+		 */
+	    case 0:
+		FREE(redirecting_url);
+		status = HT_NO_DATA;
+		goto clean_up;
+
+		/*
+		 * User wants to treat as GET with no content.  Go back to
+		 * check out the URL.
+		 */
+	    case 303:
+		break;
+
+		/*
+		 * Set the flag to retain the POST content and go back to check
+		 * out the URL.  - FM
+		 */
+	    default:
+		redirect_post_content = TRUE;
+	    }
+
+	    /* Lou's old comment:  - FM */
+	    /* OK, now we've got the redirection URL temporarily stored
+	       in external variable redirecting_url, exported from HTMIME.c,
+	       since there's no straightforward way to do this in the library
+	       currently.  Do the right thing. */
+
+	    status = HT_REDIRECTING;
+
+	} else {
+	    status = traversal ? -1 : HT_LOADED;
+	}
+
+    } else {
+	/*
+	 * If any data were received, treat as a complete transmission
+	 */
+	status = HT_LOADED;
+    }
+
+    /*
+     * Clean up
+     */
+  clean_up:
+    FREE(line_buffer);
+    FREE(line_kept_clean);
+
+  done:
+    /*
+     * Clear out on exit, just in case.
+     */
+    reloading = FALSE;
+#ifdef USE_SSL
+    FREE(connect_host);
+    if (handle) {
+	SSL_free(handle);
+	SSL_handle = handle = NULL;
+    }
+#endif /* USE_SSL */
+    dump_server_status = server_status;
+    return status;
+}
+
+/*	Protocol descriptor
+*/
+#ifdef GLOBALDEF_IS_MACRO
+#define _HTTP_C_GLOBALDEF_1_INIT { "http", HTLoadHTTP, 0}
+GLOBALDEF(HTProtocol, HTTP, _HTTP_C_GLOBALDEF_1_INIT);
+#define _HTTP_C_GLOBALDEF_2_INIT { "https", HTLoadHTTP, 0}
+GLOBALDEF(HTProtocol, HTTPS, _HTTP_C_GLOBALDEF_2_INIT);
+#else
+GLOBALDEF HTProtocol HTTP =
+{"http", HTLoadHTTP, 0};
+GLOBALDEF HTProtocol HTTPS =
+{"https", HTLoadHTTP, 0};
+#endif /* GLOBALDEF_IS_MACRO */
diff --git a/WWW/Library/Implementation/HTTP.h b/WWW/Library/Implementation/HTTP.h
new file mode 100644
index 0000000..ea0f835
--- /dev/null
+++ b/WWW/Library/Implementation/HTTP.h
@@ -0,0 +1,47 @@
+/*
+ * $LynxId: HTTP.h,v 1.12 2020/01/21 21:59:06 tom Exp $
+ *
+ * /Net/dxcern/userd/timbl/hypertext/WWW/Library/Implementation/HTTP.html
+ *                                HYPERTEXT TRANSFER PROTOCOL
+ */
+#ifndef HTTP_H
+#define HTTP_H
+
+#include <HTAccess.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef GLOBALREF_IS_MACRO
+    extern GLOBALREF (HTProtocol, HTTP);
+    extern GLOBALREF (HTProtocol, HTTPS);
+
+#else
+    GLOBALREF HTProtocol HTTP;
+    GLOBALREF HTProtocol HTTPS;
+#endif				/* GLOBALREF_IS_MACRO */
+
+#define URL_GET_METHOD  1
+#define URL_POST_METHOD 2
+#define URL_MAIL_METHOD 3
+
+    /*
+     * Special value for 'reloading' used to tell HTLoadDocument() that the
+     * user asked for a reload, versus Lynx doing a reload for other reasons.
+     */
+#define REAL_RELOAD (TRUE + 1)
+
+    extern int ws_read_per_sec;
+    extern BOOLEAN reloading;
+    extern char *redirecting_url;
+    extern BOOL permanent_redirection;
+    extern BOOL redirect_post_content;
+
+#ifdef USE_SSL
+    extern SSL *SSL_handle;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTTP_H */
diff --git a/WWW/Library/Implementation/HTTelnet.c b/WWW/Library/Implementation/HTTelnet.c
new file mode 100644
index 0000000..fb0098a
--- /dev/null
+++ b/WWW/Library/Implementation/HTTelnet.c
@@ -0,0 +1,553 @@
+/*
+ * $LynxId: HTTelnet.c,v 1.41 2013/11/28 11:15:19 tom Exp $
+ *
+ *		Telnet Access, Rlogin, etc			HTTelnet.c
+ *		==========================
+ *
+ * Authors
+ *	TBL	Tim Berners-Lee timbl@info.cern.ch
+ *	JFG	Jean-Francois Groff jgh@next.com
+ *	DD	Denis DeLaRoca (310) 825-4580  <CSP1DWD@mvs.oac.ucla.edu>
+ * History
+ *	 8 Jun 92 Telnet hopping prohibited as telnet is not secure (TBL)
+ *	26 Jun 92 When over DECnet, suppressed FTP, Gopher and News. (JFG)
+ *	 6 Oct 92 Moved HTClientHost and logfile into here. (TBL)
+ *	17 Dec 92 Tn3270 added, bug fix. (DD)
+ *	 2 Feb 93 Split from HTAccess.c.  Registration.(TBL)
+ */
+
+#include <HTUtils.h>
+#include <LYUtils.h>
+
+/* Implements:
+*/
+#include <HTTelnet.h>
+
+#include <HTParse.h>
+#include <HTAnchor.h>
+#include <HTTP.h>
+#include <HTFile.h>
+
+#include <HTTCP.h>
+#include <HText.h>
+
+#include <HTAccess.h>
+#include <HTAlert.h>
+
+#include <LYStrings.h>
+#include <LYClean.h>
+#include <LYLeaks.h>
+
+#ifdef __GNUC__
+static void do_system(char *) GCC_UNUSED;
+#endif
+
+static void do_system(char *command)
+{
+    if (non_empty(command)) {
+	CTRACE((tfp, "HTTelnet: Command is: %s\n\n", command));
+	LYSystem(command);
+    }
+    FREE(command);
+}
+
+/*	Telnet or "rlogin" access
+ *	-------------------------
+ */
+static int remote_session(char *acc_method, char *host)
+{
+    const char *program;
+    char *user = host;
+    char *password = NULL;
+    char *cp;
+    char *hostname;
+    char *port;
+    char *command = NULL;
+    enum _login_protocol {
+	telnet,
+	rlogin,
+	tn3270
+    } login_protocol =
+      strcmp(acc_method, "rlogin") == 0 ? rlogin :
+      strcmp(acc_method, "tn3270") == 0 ? tn3270 : telnet;
+
+    /*
+     * Modified to allow for odd chars in a username only if exists.
+     * 05-28-94 Lynx 2-3-1 Garrett Arch Blythe
+     */
+    /* prevent telnet://hostname;rm -rf *  URL's (VERY BAD)
+     *  *cp=0;        // terminate at any ;,<,>,`,|,",' or space or return
+     * or tab to prevent security hole
+     */
+    for (cp = (StrChr(host, '@') ? StrChr(host, '@') : host); *cp != '\0';
+	 cp++) {
+	if (!isalnum(UCH(*cp)) && *cp != '_' && *cp != '-' &&
+	    *cp != ':' && *cp != '.' && *cp != '@') {
+	    *cp = '\0';
+	    break;
+	}
+    }
+
+    hostname = StrChr(host, '@');
+
+    if (hostname) {
+	*hostname++ = '\0';	/* Split */
+    } else {
+	hostname = host;
+	user = NULL;		/* No user specified */
+    }
+
+    port = StrChr(hostname, ':');
+    if (port)
+	*port++ = '\0';		/* Split */
+
+    if (*hostname == '\0') {
+	CTRACE((tfp, "HTTelnet: No host specified!\n"));
+	return HT_NO_DATA;
+    } else if (!valid_hostname(hostname)) {
+	char *prefix = NULL;
+	char *line = NULL;
+
+	CTRACE((tfp, "HTTelnet: Invalid hostname %s!\n", host));
+	HTSprintf0(&prefix,
+		   gettext("remote %s session:"), acc_method);
+	HTSprintf0(&line,
+		   gettext("Invalid hostname %s"), host);
+	HTAlwaysAlert(prefix, line);
+	FREE(prefix);
+	FREE(line);
+	return HT_NO_DATA;
+    }
+
+    if (user) {
+	password = StrChr(user, ':');
+	if (password) {
+	    *password++ = '\0';
+	}
+    }
+
+    /* If the person is already telnetting etc, forbid hopping */
+    /* This is a security precaution, for us and remote site */
+
+    if (HTSecure) {
+
+#ifdef TELNETHOPPER_MAIL
+	HTSprintf0(&command,
+		   "finger @%s | mail -s \"**telnethopper %s\" tbl@dxcern.cern.ch",
+		   HTClientHost, HTClientHost);
+	do_system(command);
+#endif
+	printf("\n\nSorry, but the service you have selected is one\n");
+	printf("to which you have to log in.  If you were running www\n");
+	printf("on your own computer, you would be automatically connected.\n");
+	printf("For security reasons, this is not allowed when\n");
+	printf("you log in to this information service remotely.\n\n");
+
+	printf("You can manually connect to this service using %s\n",
+	       acc_method);
+	printf("to host %s", hostname);
+	if (user)
+	    printf(", user name %s", user);
+	if (password)
+	    printf(", password %s", password);
+	if (port)
+	    printf(", port %s", port);
+	printf(".\n\n");
+	return HT_NO_DATA;
+    }
+
+    /* Not all telnet servers get it even if user name is specified so we
+     * always tell the guy what to log in as.
+     */
+    if (user && login_protocol != rlogin)
+	printf("When you are connected, log in as:  %s\n", user);
+    if (password && login_protocol != rlogin)
+	printf("                  The password is:  %s\n", password);
+    fflush(stdout);
+
+/*
+ *	NeXTSTEP is the implied version of the NeXT operating system.
+ *		You may need to define this yourself.
+ */
+#if	!defined(TELNET_DONE) && (defined(NeXT) && defined(NeXTSTEP) && NeXTSTEP<=20100)
+#define FMT_TELNET "%s%s%s %s %s"
+
+    if ((program = HTGetProgramPath(ppTELNET)) != NULL) {
+	HTAddParam(&command, FMT_TELNET, 1, program);
+	HTOptParam(&command, FMT_TELNET, 2, user ? " -l " : "");
+	HTAddParam(&command, FMT_TELNET, 3, user);
+	HTAddParam(&command, FMT_TELNET, 4, hostname);
+	HTAddParam(&command, FMT_TELNET, 5, port);
+	HTEndParam(&command, FMT_TELNET, 5);
+    }
+    do_system(command);
+#define TELNET_DONE
+#endif
+
+/* Most unix machines support username only with rlogin */
+#if !defined(TELNET_DONE) && (defined(UNIX) || defined(DOSPATH) || defined(__CYGWIN__))
+
+#define FMT_RLOGIN "%s %s%s%s"
+#define FMT_TN3270 "%s %s %s"
+#define FMT_TELNET "%s %s %s"
+
+    switch (login_protocol) {
+    case rlogin:
+	if ((program = HTGetProgramPath(ppRLOGIN)) != NULL) {
+	    HTAddParam(&command, FMT_RLOGIN, 1, program);
+	    HTAddParam(&command, FMT_RLOGIN, 2, hostname);
+	    HTOptParam(&command, FMT_RLOGIN, 3, user ? " -l " : "");
+	    HTAddParam(&command, FMT_RLOGIN, 4, user);
+	    HTEndParam(&command, FMT_RLOGIN, 4);
+	}
+	break;
+
+    case tn3270:
+	if ((program = HTGetProgramPath(ppTN3270)) != NULL) {
+	    HTAddParam(&command, FMT_TN3270, 1, program);
+	    HTAddParam(&command, FMT_TN3270, 2, hostname);
+	    HTAddParam(&command, FMT_TN3270, 3, port);
+	    HTEndParam(&command, FMT_TN3270, 3);
+	}
+	break;
+
+    case telnet:
+	if ((program = HTGetProgramPath(ppTELNET)) != NULL) {
+	    HTAddParam(&command, FMT_TELNET, 1, program);
+	    HTAddParam(&command, FMT_TELNET, 2, hostname);
+	    HTAddParam(&command, FMT_TELNET, 3, port);
+	    HTEndParam(&command, FMT_TELNET, 3);
+	}
+	break;
+    }
+
+    LYSystem(command);
+#define TELNET_DONE
+#endif /* unix */
+
+/* VMS varieties */
+#if !defined(TELNET_DONE) && (defined(MULTINET))
+    if (login_protocol == rlogin) {
+	HTSprintf0(&command, "RLOGIN%s%s%s%s%s %s",	/*lm 930713 */
+		   user ? "/USERNAME=\"" : "",
+		   NonNull(user),
+		   user ? "\"" : "",
+		   port ? "/PORT=" : "",
+		   NonNull(port),
+		   hostname);
+
+    } else if (login_protocol == tn3270) {
+	HTSprintf0(&command, "TELNET/TN3270 %s%s %s",
+		   port ? "/PORT=" : "",
+		   NonNull(port),
+		   hostname);
+
+    } else {			/* TELNET */
+	HTSprintf0(&command, "TELNET %s%s %s",
+		   port ? "/PORT=" : "",
+		   NonNull(port),
+		   hostname);
+    }
+
+    do_system(command);
+#define TELNET_DONE
+#endif /* MULTINET */
+
+#if !defined(TELNET_DONE) && defined(WIN_TCP)
+    if ((cp = getenv("WINTCP_COMMAND_STYLE")) != NULL &&
+	0 == strncasecomp(cp, "VMS", 3)) {	/* VMS command syntax */
+	if (login_protocol == rlogin) {
+	    HTSprintf0(&command, "RLOGIN%s%s%s%s%s %s",		/*lm 930713 */
+		       user ? "/USERNAME=\"" : "",
+		       NonNull(user),
+		       user ? "\"" : "",
+		       port ? "/PORT=" : "",
+		       NonNull(port),
+		       hostname);
+
+	} else if (login_protocol == tn3270) {
+	    HTSprintf0(&command, "TELNET/TN3270 %s%s %s",
+		       port ? "/PORT=" : "",
+		       NonNull(port),
+		       hostname);
+
+	} else {		/* TELNET */
+	    HTSprintf0(&command, "TELNET %s%s %s",
+		       port ? "/PORT=" : "",
+		       NonNull(port),
+		       hostname);
+	}
+
+    } else {			/* UNIX command syntax */
+	if (login_protocol == rlogin) {
+	    HTSprintf0(&command, "RLOGIN %s%s%s%s%s",
+		       hostname,
+		       user ? " -l " : "",
+		       user ? "\"" : "",
+		       NonNull(user),
+		       user ? "\"" : "");
+
+	} else if (login_protocol == tn3270) {
+	    HTSprintf0(&command, "TN3270 %s %s",
+		       hostname,
+		       NonNull(port));
+
+	} else {		/* TELNET */
+	    HTSprintf0(&command, "TELNET %s %s",
+		       hostname,
+		       NonNull(port));
+	}
+    }
+
+    do_system(command);
+#define TELNET_DONE
+#endif /* WIN_TCP */
+
+#if !defined(TELNET_DONE) && defined(UCX)
+    if (login_protocol == rlogin) {
+	HTSprintf0(&command, "RLOGIN%s%s%s %s %s",
+		   user ? "/USERNAME=\"" : "",
+		   NonNull(user),
+		   user ? "\"" : "",
+		   hostname,
+		   NonNull(port));
+
+    } else if (login_protocol == tn3270) {
+	HTSprintf0(&command, "TN3270 %s %s",
+		   hostname,
+		   NonNull(port));
+
+    } else {			/* TELNET */
+	HTSprintf0(&command, "TELNET %s %s",
+		   hostname,
+		   NonNull(port));
+    }
+
+    do_system(command);
+#define TELNET_DONE
+#endif /* UCX */
+
+#if !defined(TELNET_DONE) && defined(CMU_TCP)
+    if (login_protocol == telnet) {
+	HTSprintf0(&command, "TELNET %s%s %s",
+		   port ? "/PORT=" : "",
+		   NonNull(port),
+		   hostname);
+	do_system(command);
+    } else {
+	printf("\nSorry, this browser was compiled without the %s access option.\n",
+	       acc_method);
+	printf("\nPress <return> to return to Lynx.");
+	LYgetch();
+	HadVMSInterrupt = FALSE;
+    }
+#define TELNET_DONE
+#endif /* CMU_TCP */
+
+#if !defined(TELNET_DONE) && defined(SOCKETSHR_TCP)
+    if (getenv("MULTINET_SOCKET_LIBRARY") != NULL) {
+	if (login_protocol == rlogin) {
+	    HTSprintf0(&command, "MULTINET RLOGIN%s%s%s%s %s",	/*lm 930713 */
+		       user ? "/USERNAME=" : "",
+		       NonNull(user),
+		       port ? "/PORT=" : "",
+		       NonNull(port),
+		       hostname);
+
+	} else if (login_protocol == tn3270) {
+	    HTSprintf0(&command, "MULTINET TELNET/TN3270 %s%s %s",
+		       port ? "/PORT=" : "",
+		       NonNull(port),
+		       hostname);
+
+	} else {		/* TELNET */
+	    HTSprintf0(&command, "MULTINET TELNET %s%s %s",
+		       port ? "/PORT=" : "",
+		       NonNull(port),
+		       hostname);
+	}
+
+	do_system(command);
+	return HT_NO_DATA;	/* Ok - it was done but no data */
+    } else if ((cp = getenv("WINTCP_COMMAND_STYLE")) != NULL) {
+	if (0 == strncasecomp(cp, "VMS", 3)) {	/* VMS command syntax */
+	    if (login_protocol == rlogin) {
+		HTSprintf0(&command, "RLOGIN%s%s%s%s %s",	/*lm 930713 */
+			   user ? "/USERNAME=" : "",
+			   NonNull(user),
+			   port ? "/PORT=" : "",
+			   NonNull(port),
+			   hostname);
+	    } else if (login_protocol == tn3270) {
+		HTSprintf0(&command, "TELNET/TN3270 %s%s %s",
+			   port ? "/PORT=" : "",
+			   NonNull(port),
+			   hostname);
+	    } else {		/* TELNET */
+		HTSprintf0(&command, "TELNET %s%s %s",
+			   port ? "/PORT=" : "",
+			   NonNull(port),
+			   hostname);
+	    }
+	} else {		/* UNIX command syntax */
+	    if (login_protocol == rlogin) {
+		HTSprintf0(&command, "RLOGIN %s%s%s",
+			   hostname,
+			   user ? " -l " : "",
+			   NonNull(user));
+	    } else if (login_protocol == tn3270) {
+		HTSprintf0(&command, "TN3270 %s %s",
+			   hostname,
+			   NonNull(port));
+	    } else {		/* TELNET */
+		HTSprintf0(&command, "TELNET %s %s",
+			   hostname,
+			   NonNull(port));
+	    }
+	}
+
+	do_system(command);
+	return HT_NO_DATA;	/* Ok - it was done but no data */
+    } else if (getenv("UCX$DEVICE") != NULL
+	       || getenv("TCPIP$DEVICE") != NULL) {
+	if (login_protocol == rlogin) {
+	    HTSprintf0(&command, "RLOGIN%s%s %s %s",
+		       user ? "/USERNAME=" : "",
+		       NonNull(user),
+		       hostname,
+		       NonNull(port));
+
+	} else if (login_protocol == tn3270) {
+	    HTSprintf0(&command, "TN3270 %s %s",
+		       hostname,
+		       NonNull(port));
+
+	} else {		/* TELNET */
+	    HTSprintf0(&command, "TELNET %s %s",
+		       hostname,
+		       NonNull(port));
+	}
+
+	do_system(command);
+	return HT_NO_DATA;	/* Ok - it was done but no data */
+    } else if (getenv("CMUTEK_ROOT") != NULL) {
+	if (login_protocol == telnet) {
+	    HTSprintf0(&command, "TELNET %s%s %s",
+		       port ? "/PORT=" : "",
+		       NonNull(port),
+		       hostname);
+	    do_system(command);
+	} else {
+	    printf("\nSorry, this browser was compiled without the %s access option.\n",
+		   acc_method);
+	    printf("\nPress <return> to return to Lynx.");
+	    LYgetch();
+	    HadVMSInterrupt = FALSE;
+	}
+    } else {
+	if (login_protocol == telnet) {
+	    HTSprintf0(&command, "TELNET %s%s %s",
+		       port ? "/PORT=" : "",
+		       NonNull(port),
+		       hostname);
+	    do_system(command);
+	} else {
+	    printf("\nSorry, this browser was compiled without the %s access option.\n",
+		   acc_method);
+	    printf("\nPress <return> to return to Lynx.");
+	    LYgetch();
+	    HadVMSInterrupt = FALSE;
+	}
+    }
+#define TELNET_DONE
+#endif /* SOCKETSHR_TCP */
+
+#if !defined(TELNET_DONE) && (defined(SIMPLE_TELNET) || defined(VM))
+    if (login_protocol == telnet) {	/* telnet only */
+	HTSprintf0(&command, "TELNET  %s",	/* @@ Bug: port ignored */
+		   hostname);
+	do_system(command);
+	return HT_NO_DATA;	/* Ok - it was done but no data */
+    }
+#define TELNET_DONE
+#endif
+
+#ifndef TELNET_DONE
+    printf("\nSorry, this browser was compiled without the %s access option.\n",
+	   acc_method);
+    printf("\nTo access the information you must %s to %s", acc_method, hostname);
+    if (port)
+	printf(" (port %s)", port);
+    if (user)
+	printf("\nlogging in with username %s", user);
+    printf(".\n");
+    {
+	printf("\nPress <return> to return to Lynx.");
+	fflush(stdout);
+	LYgetch();
+#ifdef VMS
+	HadVMSInterrupt = FALSE;
+#endif /* VMS */
+    }
+#endif /* !TELNET_DONE */
+    return HT_NO_DATA;
+}
+
+/*	"Load a document" -- establishes a session
+ *	------------------------------------------
+ *
+ * On entry,
+ *	addr		must point to the fully qualified hypertext reference.
+ *
+ * On exit,
+ *	returns		<0	Error has occurred.
+ *			>=0	Value of file descriptor or socket to be used
+ *				 to read data.
+ *	*pFormat	Set to the format of the file, if known.
+ *			(See WWW.h)
+ *
+ */
+static int HTLoadTelnet(const char *addr,
+			HTParentAnchor *anchor GCC_UNUSED,
+			HTFormat format_out GCC_UNUSED,
+			HTStream *sink)		/* Ignored */
+{
+    char *acc_method;
+    char *host;
+    int status;
+
+    if (sink) {
+	CTRACE((tfp,
+		"HTTelnet: Can't output a live session -- must be interactive!\n"));
+	return HT_NO_DATA;
+    }
+    acc_method = HTParse(addr, STR_FILE_URL, PARSE_ACCESS);
+
+    host = HTParse(addr, "", PARSE_HOST);
+    if (!host || *host == '\0') {
+	status = HT_NO_DATA;
+	CTRACE((tfp, "HTTelnet: No host specified!\n"));
+    } else {
+	status = remote_session(acc_method, host);
+    }
+
+    FREE(host);
+    FREE(acc_method);
+    return status;
+}
+
+#ifdef GLOBALDEF_IS_MACRO
+#define _HTTELNET_C_1_INIT { "telnet", HTLoadTelnet, NULL }
+#define _HTTELNET_C_2_INIT { "rlogin", HTLoadTelnet, NULL }
+#define _HTTELNET_C_3_INIT { "tn3270", HTLoadTelnet, NULL }
+GLOBALDEF(HTProtocol, HTTelnet, _HTTELNET_C_1_INIT);
+GLOBALDEF(HTProtocol, HTRlogin, _HTTELNET_C_2_INIT);
+GLOBALDEF(HTProtocol, HTTn3270, _HTTELNET_C_3_INIT);
+#else
+GLOBALDEF HTProtocol HTTelnet =
+{"telnet", HTLoadTelnet, NULL};
+GLOBALDEF HTProtocol HTRlogin =
+{"rlogin", HTLoadTelnet, NULL};
+GLOBALDEF HTProtocol HTTn3270 =
+{"tn3270", HTLoadTelnet, NULL};
+#endif /* GLOBALDEF_IS_MACRO */
diff --git a/WWW/Library/Implementation/HTTelnet.h b/WWW/Library/Implementation/HTTelnet.h
new file mode 100644
index 0000000..f2208d8
--- /dev/null
+++ b/WWW/Library/Implementation/HTTelnet.h
@@ -0,0 +1,28 @@
+/*                 /Net/dxcern/userd/timbl/hypertext/WWW/Library/Implementation/HTTelnet.html
+                            TELNET AND SIMILAR ACCESS METHODS
+                                             
+ */
+
+#ifndef HTTELNET_H
+#define HTTELNET_H
+
+#include <HTAccess.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef GLOBALREF_IS_MACRO
+    extern GLOBALREF (HTProtocol, HTTelnet);
+    extern GLOBALREF (HTProtocol, HTRlogin);
+    extern GLOBALREF (HTProtocol, HTTn3270);
+
+#else
+    GLOBALREF HTProtocol HTTelnet;
+    GLOBALREF HTProtocol HTRlogin;
+    GLOBALREF HTProtocol HTTn3270;
+#endif				/* GLOBALREF_IS_MACRO */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTTELNET_H */
diff --git a/WWW/Library/Implementation/HTUU.c b/WWW/Library/Implementation/HTUU.c
new file mode 100644
index 0000000..4848cce
--- /dev/null
+++ b/WWW/Library/Implementation/HTUU.c
@@ -0,0 +1,210 @@
+/*
+ * $LynxId: HTUU.c,v 1.11 2010/09/21 23:55:12 tom Exp $
+ *
+ * MODULE							HTUU.c
+ *			UUENCODE AND UUDECODE
+ *
+ * ACKNOWLEDGEMENT:
+ *	This code is taken from rpem distribution, and was originally
+ *	written by Mark Riordan.
+ *
+ * AUTHORS:
+ *	MR	Mark Riordan	riordanmr@clvax1.cl.msu.edu
+ *	AL	Ari Luotonen	luotonen@dxcern.cern.ch
+ *
+ * HISTORY:
+ *	Added as part of the WWW library and edited to conform
+ *	with the WWW project coding standards by:	AL  5 Aug 1993
+ *	Originally written by:				MR 12 Aug 1990
+ *	Original header text:
+ * -------------------------------------------------------------
+ *  File containing routines to convert a buffer
+ *  of bytes to/from RFC 1113 printable encoding format.
+ *
+ *  This technique is similar to the familiar Unix uuencode
+ *  format in that it maps 6 binary bits to one ASCII
+ *  character (or more aptly, 3 binary bytes to 4 ASCII
+ *  characters).  However, RFC 1113 does not use the same
+ *  mapping to printable characters as uuencode.
+ *
+ *  Mark Riordan   12 August 1990 and 17 Feb 1991.
+ *  This code is hereby placed in the public domain.
+ * -------------------------------------------------------------
+ */
+
+#include <HTUtils.h>
+#include <HTUU.h>
+
+#include <LYLeaks.h>
+
+static char six2pr[64] =
+{
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
+};
+
+static unsigned char pr2six[256];
+
+/*--- function HTUU_encode -----------------------------------------------
+ *
+ * Encode a single line of binary data to a standard format that
+ * uses only printing ASCII characters (but takes up 33% more bytes).
+ *
+ *    Entry    bufin    points to a buffer of bytes.  If nbytes is not
+ *                      a multiple of three, then the byte just beyond
+ *                      the last byte in the buffer must be 0.
+ *             nbytes   is the number of bytes in that buffer.
+ *                      This cannot be more than 48.
+ *             bufcoded points to an output buffer.  Be sure that this
+ *                      can hold at least 1 + (4*nbytes)/3 characters.
+ *
+ *    Exit     bufcoded contains the coded line.  The first 4*nbytes/3 bytes
+ *                      contain printing ASCII characters representing
+ *                      those binary bytes.  This may include one or
+ *                      two '=' characters used as padding at the end.
+ *                      The last byte is a zero byte.
+ *             Returns the number of ASCII characters in "bufcoded".
+ */
+int HTUU_encode(unsigned char *bufin,
+		size_t nbytes,
+		char *bufcoded)
+{
+/* ENC is the basic 1 character encoding function to make a char printing */
+#define ENC(c) six2pr[c]
+
+    register char *outptr = bufcoded;
+    size_t i;
+
+    /* This doesn't seem to be needed (AL):   register unsigned char *inptr  = bufin; */
+
+    for (i = 0; i < nbytes; i += 3) {
+	*(outptr++) = ENC(*bufin >> 2);		/* c1 */
+	*(outptr++) = ENC(((*bufin << 4) & 060) | ((bufin[1] >> 4) & 017));	/*c2 */
+	*(outptr++) = ENC(((bufin[1] << 2) & 074) | ((bufin[2] >> 6) & 03));	/*c3 */
+	*(outptr++) = ENC(bufin[2] & 077);	/* c4 */
+
+	bufin += 3;
+    }
+
+    /* If nbytes was not a multiple of 3, then we have encoded too
+     * many characters.  Adjust appropriately.
+     */
+    if (i == nbytes + 1) {
+	/* There were only 2 bytes in that last group */
+	outptr[-1] = '=';
+    } else if (i == nbytes + 2) {
+	/* There was only 1 byte in that last group */
+	outptr[-1] = '=';
+	outptr[-2] = '=';
+    }
+    *outptr = '\0';
+    return (int) (outptr - bufcoded);
+}
+
+/*--- function HTUU_decode ------------------------------------------------
+ *
+ * Decode an ASCII-encoded buffer back to its original binary form.
+ *
+ *    Entry    bufcoded    points to a uuencoded string.  It is
+ *                         terminated by any character not in
+ *                         the printable character table six2pr, but
+ *                         leading whitespace is stripped.
+ *             bufplain    points to the output buffer; must be big
+ *                         enough to hold the decoded string (generally
+ *                         shorter than the encoded string) plus
+ *                         as many as two extra bytes used during
+ *                         the decoding process.
+ *             outbufsize  is the maximum number of bytes that
+ *                         can fit in bufplain.
+ *
+ *    Exit     Returns the number of binary bytes decoded.
+ *             bufplain    contains these bytes.
+ */
+int HTUU_decode(char *bufcoded,
+		unsigned char *bufplain,
+		int outbufsize)
+{
+/* single character decode */
+#define DEC(c) pr2six[(int)c]
+#define MAXVAL 63
+
+    static int first = 1;
+
+    int nbytesdecoded, j;
+    register char *bufin;
+    register unsigned char *bufout = bufplain;
+    register int nprbytes;
+
+    /* If this is the first call, initialize the mapping table.
+     * This code should work even on non-ASCII machines.
+     */
+    if (first) {
+	first = 0;
+	for (j = 0; j < 256; j++)
+	    pr2six[j] = MAXVAL + 1;
+
+	for (j = 0; j < 64; j++)
+	    pr2six[UCH(six2pr[j])] = UCH(j);
+#if 0
+      /* *INDENT-OFF* */
+      pr2six['A']= 0; pr2six['B']= 1; pr2six['C']= 2; pr2six['D']= 3;
+      pr2six['E']= 4; pr2six['F']= 5; pr2six['G']= 6; pr2six['H']= 7;
+      pr2six['I']= 8; pr2six['J']= 9; pr2six['K']=10; pr2six['L']=11;
+      pr2six['M']=12; pr2six['N']=13; pr2six['O']=14; pr2six['P']=15;
+      pr2six['Q']=16; pr2six['R']=17; pr2six['S']=18; pr2six['T']=19;
+      pr2six['U']=20; pr2six['V']=21; pr2six['W']=22; pr2six['X']=23;
+      pr2six['Y']=24; pr2six['Z']=25; pr2six['a']=26; pr2six['b']=27;
+      pr2six['c']=28; pr2six['d']=29; pr2six['e']=30; pr2six['f']=31;
+      pr2six['g']=32; pr2six['h']=33; pr2six['i']=34; pr2six['j']=35;
+      pr2six['k']=36; pr2six['l']=37; pr2six['m']=38; pr2six['n']=39;
+      pr2six['o']=40; pr2six['p']=41; pr2six['q']=42; pr2six['r']=43;
+      pr2six['s']=44; pr2six['t']=45; pr2six['u']=46; pr2six['v']=47;
+      pr2six['w']=48; pr2six['x']=49; pr2six['y']=50; pr2six['z']=51;
+      pr2six['0']=52; pr2six['1']=53; pr2six['2']=54; pr2six['3']=55;
+      pr2six['4']=56; pr2six['5']=57; pr2six['6']=58; pr2six['7']=59;
+      pr2six['8']=60; pr2six['9']=61; pr2six['+']=62; pr2six['/']=63;
+      /* *INDENT-ON* */
+
+#endif
+    }
+
+    /* Strip leading whitespace. */
+
+    while (*bufcoded == ' ' || *bufcoded == '\t')
+	bufcoded++;
+
+    /* Figure out how many characters are in the input buffer.
+     * If this would decode into more bytes than would fit into
+     * the output buffer, adjust the number of input bytes downwards.
+     */
+    bufin = bufcoded;
+    while (pr2six[UCH(*(bufin++))] <= MAXVAL) ;
+    nprbytes = (int) (bufin - bufcoded - 1);
+    nbytesdecoded = ((nprbytes + 3) / 4) * 3;
+    if (nbytesdecoded > outbufsize) {
+	nprbytes = (outbufsize * 4) / 3;
+    }
+
+    bufin = bufcoded;
+
+    while (nprbytes > 0) {
+	*(bufout++) = UCH((DEC(bufin[0]) << 2) | (DEC(bufin[1]) >> 4));
+	*(bufout++) = UCH((DEC(bufin[1]) << 4) | (DEC(bufin[2]) >> 2));
+	*(bufout++) = UCH((DEC(bufin[2]) << 6) | (DEC(bufin[3])));
+	bufin += 4;
+	nprbytes -= 4;
+    }
+
+    if (nprbytes & 03) {
+	if (pr2six[(int) bufin[-2]] > MAXVAL) {
+	    nbytesdecoded -= 2;
+	} else {
+	    nbytesdecoded -= 1;
+	}
+    }
+
+    return (nbytesdecoded);
+}
diff --git a/WWW/Library/Implementation/HTUU.h b/WWW/Library/Implementation/HTUU.h
new file mode 100644
index 0000000..93ba435
--- /dev/null
+++ b/WWW/Library/Implementation/HTUU.h
@@ -0,0 +1,36 @@
+/*
+ * $LynxId: HTUU.h,v 1.11 2010/09/25 11:43:27 tom Exp $
+ *
+ *                              ENCODING TO PRINTABLE CHARACTERS
+
+   File module provides functions HTUU_encode() and HTUU_decode() which convert
+   a buffer of bytes to/from RFC 1113 printable encoding format.  This
+   technique is similar to the familiar Unix uuencode format in that it maps 6
+   binary bits to one ASCII character (or more aptly, 3 binary bytes to 4 ASCII
+   characters).  However, RFC 1113 does not use the same mapping to printable
+   characters as uuencode.
+
+ */
+
+#ifndef HTUU_H
+#define HTUU_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern int HTUU_encode(unsigned char *bufin,
+			   size_t nbytes,
+			   char *bufcoded);
+
+    extern int HTUU_decode(char *bufcoded,
+			   unsigned char *bufplain,
+			   int outbufsize);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTUU_H */
diff --git a/WWW/Library/Implementation/HTUtils.h b/WWW/Library/Implementation/HTUtils.h
new file mode 100644
index 0000000..d01d0dd
--- /dev/null
+++ b/WWW/Library/Implementation/HTUtils.h
@@ -0,0 +1,847 @@
+/*
+ * $LynxId: HTUtils.h,v 1.134 2021/06/29 22:01:12 tom Exp $
+ *
+ * Utility macros for the W3 code library
+ * MACROS FOR GENERAL USE
+ * 
+ * See also:  the system dependent file "www_tcp.h", which is included here.
+ */
+
+#ifndef NO_LYNX_TRACE
+#define DEBUG			/* Turns on trace; turn off for smaller binary */
+#endif
+
+#ifndef HTUTILS_H
+#define HTUTILS_H
+
+#ifdef HAVE_CONFIG_H
+#include <lynx_cfg.h>		/* generated by autoconf 'configure' script */
+
+#ifdef HAVE_STDNORETURN_H
+#include <stdnoreturn.h>
+#undef GCC_NORETURN
+#define GCC_NORETURN _Noreturn
+#endif
+
+/* see AC_FUNC_ALLOCA macro */
+#ifdef __GNUC__
+# define alloca(size) __builtin_alloca(size)
+#else
+# ifdef _MSC_VER
+#  include <malloc.h>
+#  ifndef alloca
+#   define alloca(size) _alloca(size)
+#  endif
+# else
+#  if HAVE_ALLOCA_H
+#   include <alloca.h>
+#  else
+#   ifdef _AIX
+#pragma alloca
+#   else
+#    ifndef alloca		/* predefined by HP cc +Olibcalls */
+char *alloca();
+
+#    endif
+#   endif
+#  endif
+# endif
+#endif
+
+#include <sys/types.h>
+#include <stdio.h>
+
+#else /* HAVE_CONFIG_H */
+
+#ifdef DJGPP
+#include <sys/config.h>		/* pseudo-autoconf values for DJGPP libc/headers */
+#define HAVE_TRUNCATE 1
+#define HAVE_ALLOCA 1
+#include <limits.h>
+#endif /* DJGPP */
+
+#include <sys/types.h>
+#include <stdio.h>
+
+/* Explicit system-configure */
+#ifdef VMS
+#define NO_SIZECHANGE
+
+#if defined(VAXC) && !defined(__DECC)
+#define NO_UNISTD_H		/* DEC C has unistd.h, but not VAX C */
+#endif
+
+#define NO_KEYPAD
+#define NO_UTMP
+
+#undef NO_FILIO_H
+#define NO_FILIO_H
+
+#define NOUSERS
+#define DISP_PARTIAL		/* experimental */
+#endif
+
+#if defined(VMS) || defined(_WINDOWS)
+#define HAVE_STDLIB_H 1
+#endif
+
+/* Accommodate non-autoconf'd Makefile's (VMS, DJGPP, etc) */
+
+#ifndef NO_ARPA_INET_H
+#define HAVE_ARPA_INET_H 1
+#endif
+
+#ifndef NO_CBREAK
+#define HAVE_CBREAK 1
+#endif
+
+#ifndef NO_CUSERID
+#define HAVE_CUSERID 1
+#endif
+
+#ifndef NO_FILIO_H
+#define HAVE_SYS_FILIO_H 1
+#endif
+
+#ifndef NO_GETCWD
+#define HAVE_GETCWD 1
+#endif
+
+#ifndef USE_SLANG
+#ifndef NO_KEYPAD
+#define HAVE_KEYPAD 1
+#endif
+#ifndef NO_TTYTYPE
+#define HAVE_TTYTYPE 1
+#endif
+#endif /* USE_SLANG */
+
+#ifndef NO_PUTENV
+#define HAVE_PUTENV 1
+#endif
+
+#ifndef NO_SIZECHANGE
+#define HAVE_SIZECHANGE 1
+#endif
+
+#ifndef NO_UNISTD_H
+#undef  HAVE_UNISTD_H
+#define HAVE_UNISTD_H 1
+#endif
+
+#ifndef NO_UTMP
+#define HAVE_UTMP 1
+#endif
+
+#endif /* HAVE_CONFIG_H */
+
+#include <assert.h>
+
+/* suppress inadvertent use of gettext in makeuctb when cross-compiling */
+#ifdef DONT_USE_GETTEXT
+#undef HAVE_GETTEXT
+#undef HAVE_LIBGETTEXT_H
+#undef HAVE_LIBINTL_H
+#endif
+
+#ifndef HAVE_ICONV
+#undef USE_JAPANESEUTF8_SUPPORT
+#endif
+
+#ifndef lynx_srand
+#define lynx_srand srand
+#endif
+
+#ifndef lynx_rand
+#define lynx_rand rand
+#endif
+
+#if '0' != 48
+#define NOT_ASCII
+#endif
+
+#if '0' == 240
+#define EBCDIC
+#endif
+
+#ifndef LY_MAXPATH
+#define LY_MAXPATH 256
+#endif
+
+#ifndef GCC_NORETURN
+#define GCC_NORETURN		/* nothing */
+#endif
+
+#ifndef GCC_UNUSED
+#define GCC_UNUSED		/* nothing */
+#endif
+
+#if defined(__GNUC__) && defined(_FORTIFY_SOURCE)
+#define USE_IGNORE_RC
+extern int ignore_unused;
+
+#define IGNORE_RC(func) ignore_unused = (int) func
+#else
+#define IGNORE_RC(func) (void) func
+#endif /* gcc workarounds */
+
+#if defined(__CYGWIN32__) && ! defined(__CYGWIN__)
+#define __CYGWIN__ 1
+#endif
+
+#if defined(__CYGWIN__)		/* 1998/12/31 (Thu) 16:13:46 */
+#ifdef USE_OPENSSL_INCL
+#define NOCRYPT			/* workaround for openssl 1.0.1e bug */
+#endif
+#include <windows.h>		/* #include "windef.h" */
+#define BOOLEAN_DEFINED
+#undef HAVE_POPEN		/* FIXME: does this not work, or is it missing */
+#undef small			/* see <w32api/rpcndr.h> */
+#endif
+
+#if defined(__DARWIN_NO_LONG_LONG)
+#undef HAVE_ATOLL
+#endif
+
+#if defined(HAVE_ATOLL)
+#define LYatoll(n) atoll(n)
+#else
+extern off_t LYatoll(const char *value);
+#endif
+
+/* cygwin, mingw32, etc. */
+#ifdef FILE_DOES_NOT_EXIST
+#undef FILE_DOES_NOT_EXIST	/* see <w32api/winnt.h> */
+#endif
+
+/*
+ * VS .NET 2003 includes winsock.h unconditionally from windows.h,
+ * so we do not want to include windows.h if we want winsock2.h
+ */
+#if defined(_WINDOWS) && !defined(__CYGWIN__)
+
+#ifndef __GNUC__
+#pragma warning (disable : 4100)	/* unreferenced formal parameter */
+#pragma warning (disable : 4127)	/* conditional expression is constant */
+#pragma warning (disable : 4201)	/* nameless struct/union */
+#pragma warning (disable : 4214)	/* bit field types other than int */
+#pragma warning (disable : 4310)	/* cast truncates constant value */
+#pragma warning (disable : 4514)	/* unreferenced inline function has been removed */
+#pragma warning (disable : 4996)	/* This function or variable may be unsafe. ... */
+#endif
+
+#if defined(USE_WINSOCK2_H) && (_MSC_VER >= 1300) && (_MSC_VER < 1400)
+#include <winsock2.h>		/* includes windows.h, in turn windef.h */
+#else
+#include <windows.h>		/* #include "windef.h" */
+#endif
+
+#define BOOLEAN_DEFINED
+
+#if !_WIN_CC			/* 1999/09/29 (Wed) 22:00:53 */
+#include <dos.h>
+#endif
+
+#if defined(DECL_SLEEP) && defined(HAVE_CONFIG_H)
+#  undef sleep
+#  if defined(__MINGW32__)
+#    define sleep(n) Sleep((n)*100)
+#  else
+extern void sleep(unsigned __seconds);
+#  endif
+#elif !defined(__MINGW32__)
+#  undef sleep
+extern void sleep(unsigned __seconds);
+#endif
+
+#define popen _popen
+#define pclose _pclose
+
+#if defined(_MSC_VER) && (_MSC_VER > 0)
+typedef unsigned short mode_t;
+#endif
+
+#endif /* _WINDOWS */
+
+#if defined(USE_DEFAULT_COLORS) && !defined(HAVE_USE_DEFAULT_COLORS)
+    /* if we don't have use_default_colors() */
+#  undef USE_DEFAULT_COLORS
+#endif
+
+#ifndef USE_COLOR_STYLE
+    /* it's useless for such setup */
+#  define NO_EMPTY_HREFLESS_A
+#endif
+
+#if  defined(__EMX__) || defined(WIN_EX) || defined(HAVE_POPEN)
+#  define CAN_CUT_AND_PASTE
+#endif
+
+#if defined(USE_SLANG) || (defined(USE_COLOR_STYLE) && defined(__EMX__))
+#  define USE_BLINK
+#endif
+
+#if defined(DOSPATH) || defined(__EMX__)
+#  define USE_DOS_DRIVES	/* we allow things like "c:" in paths */
+#endif
+
+#if defined(UNIX)
+#  if (defined(__BEOS__) || defined(__CYGWIN__) || defined(__DJGPP__) || defined(__EMX__) || defined(__MINGW32__))
+#    define SINGLE_USER_UNIX	/* well, at least they try */
+#  else
+#    define MULTI_USER_UNIX
+#  endif
+#endif
+
+/*
+
+  ERROR TYPE
+
+   This is passed back when streams are aborted. It might be nice to have some structure
+   of error messages, numbers, and recursive pointers to reasons.  Currently this is a
+   placeholder for something more sophisticated.
+
+ */
+typedef void *HTError;		/* Unused at present -- best definition? */
+
+/*
+
+Standard C library for malloc() etc
+
+ */
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 0
+#endif
+
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE 1
+#endif
+
+#ifdef __EMX__
+#include <unistd.h>		/* should be re-include protected under EMX */
+#define getcwd _getcwd2
+#define chdir _chdir2
+#endif
+
+#ifdef vax
+#ifdef unix
+#define ultrix			/* Assume vax+unix=ultrix */
+#endif /* unix */
+#endif /* vax */
+
+#ifndef VMS
+#ifndef ultrix
+
+#ifdef NeXT
+#include <libc.h>		/* NeXT */
+#endif /* NeXT */
+
+#else /* ultrix: */
+
+#include <malloc.h>
+#include <memory.h>
+
+#endif /* !ultrix */
+#else /* VMS: */
+
+#include <unixlib.h>
+#if defined(VAXC) && !defined(__DECC)
+#define malloc	VAXC$MALLOC_OPT
+#define calloc	VAXC$CALLOC_OPT
+#define free	VAXC$FREE_OPT
+#define cfree	VAXC$CFREE_OPT
+#define realloc	VAXC$REALLOC_OPT
+#endif /* VAXC && !__DECC */
+
+#endif /* !VMS */
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+#define DeConst(p)   (void *)(intptr_t)(p)
+
+#define isEmpty(s)   ((s) == 0 || *(s) == 0)
+#define non_empty(s) !isEmpty(s)
+
+#define NonNull(s) (((s) != 0) ? s : "")
+#define NONNULL(s) (((s) != 0) ? s : "(null)")
+
+/* array/table size */
+#define	TABLESIZE(v)	(sizeof(v)/sizeof(v[0]))
+
+#define	typecalloc(cast)		(cast *)calloc((size_t)1, sizeof(cast))
+#define	typecallocn(cast,ntypes)	(cast *)calloc((size_t)(ntypes),sizeof(cast))
+
+#define typeRealloc(cast,ptr,ntypes)    (cast *)realloc(ptr, (size_t)(ntypes)*sizeof(cast))
+
+#define typeMalloc(cast)                (cast *)malloc(sizeof(cast))
+#define typeMallocn(cast,ntypes)        (cast *)malloc((size_t)(ntypes)*sizeof(cast))
+
+/*
+
+OFTEN USED INTEGER MACROS
+
+  Min and Max functions
+
+ */
+#ifndef HTMIN
+#define HTMIN(a,b) ((a) <= (b) ? (a) : (b))
+#define HTMAX(a,b) ((a) >= (b) ? (a) : (b))
+#endif
+/*
+
+Booleans
+
+ */
+/* Note: GOOD and BAD are already defined (differently) on RS6000 aix */
+/* #define GOOD(status) ((status)38;1)   VMS style status: test bit 0         */
+/* #define BAD(status)  (!GOOD(status))  Bit 0 set if OK, otherwise clear   */
+
+#ifndef _WINDOWS
+#ifndef BOOLEAN_DEFINED
+typedef char BOOLEAN;		/* Logical value */
+
+#ifndef CURSES
+#ifndef TRUE
+#define TRUE    (BOOLEAN)1
+#define FALSE   (BOOLEAN)0
+#endif
+#endif /*  CURSES  */
+#endif /*  BOOLEAN_DEFINED */
+#define BOOLEAN_DEFINED
+#endif /* _WINDOWS */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1300)
+/* it declares BOOL/BOOLEAN as BYTE/int */
+#else
+#ifndef BOOL
+#define BOOL BOOLEAN
+#endif
+#endif
+
+#ifndef YES
+#define YES (BOOLEAN)1
+#define NO (BOOLEAN)0
+#endif
+
+#define STRING1PTR const char *
+#define STRING2PTR const char * const *
+
+extern BOOL LYOutOfMemory;	/* Declared in LYexit.c - FM */
+
+#define TCP_PORT 80		/* Allocated to http by Jon Postel/ISI 24-Jan-92 */
+#define OLD_TCP_PORT 2784	/* Try the old one if no answer on 80 */
+#define DNP_OBJ 80		/* This one doesn't look busy, but we must check */
+			/* That one was for decnet */
+
+/*      Inline Function WHITE: Is character c white space? */
+/*      For speed, include all control characters */
+
+#define WHITE(c) ((UCH(TOASCII(c))) <= 32)
+
+/*     Inline Function LYIsASCII: Is character c a traditional ASCII
+ *     character (i.e. <128) after converting from host character set.  */
+
+#define LYIsASCII(c) (TOASCII(UCH(c)) < 128)
+
+/*
+
+Success (>=0) and failure (<0) codes
+
+Some of the values are chosen to be HTTP-like, but status return values
+are generally not the response status from any specific protocol.
+
+ */
+
+#define HT_PARSER_OTHER_CONTENT  701	/* tells SGML to change content model */
+#define HT_PARSER_REOPEN_ELT     700	/* tells SGML parser to keep tag open */
+#define HT_REDIRECTING           399
+#define HT_PARTIAL_CONTENT       206	/* Partial Content */
+#define HT_LOADED                200	/* Instead of a socket */
+
+#define HT_OK                      0	/* Generic success */
+
+#define HT_ERROR                  -1	/* Generic failure */
+#define HT_CANNOT_TRANSLATE       -4
+#define HT_BAD_EOF               -12	/* Premature EOF */
+#define HT_NO_CONNECTION         -99	/* ERR no connection available - */
+#define HT_NO_DATA              -204	/* OK but no data was loaded - */
+					/* possibly other app started or forked */
+#define HT_NO_ACCESS            -401	/* Access not available */
+#define HT_FORBIDDEN            -403	/* Access forbidden */
+#define HT_NOT_ACCEPTABLE       -406	/* Not Acceptable */
+#define HT_H_ERRNO_VALID        -800	/* see h_errno for resolver error */
+#define HT_INTERNAL             -900	/* Weird -- should never happen. */
+#define HT_INTERRUPTED        -29998
+#define HT_NOT_LOADED         -29999
+
+#ifndef va_arg
+#  include <stdarg.h>
+#endif
+
+#define LYva_start(ap,format) va_start(ap,format)
+
+/*
+ * GCC can be told that some functions are like printf (and do type-checking on
+ * their parameters).
+ */
+#ifndef GCC_PRINTFLIKE
+#if defined(GCC_PRINTF) && !defined(printf) && !defined(HAVE_LIBUTF8_H)
+#define GCC_PRINTFLIKE(fmt,var) __attribute__((format(printf,fmt,var)))
+#else
+#define GCC_PRINTFLIKE(fmt,var)	/*nothing */
+#endif
+#endif
+
+#include <HTString.h>		/* String utilities */
+
+/*
+
+Out Of Memory checking for malloc() return:
+
+ */
+#ifndef __FILE__
+#define __FILE__ ""
+#define __LINE__ ""
+#endif
+
+#include <LYexit.h>
+
+/*
+ * Upper- and Lowercase macros
+ *
+ * The problem here is that toupper(x) is not defined officially unless
+ * isupper(x) is.  These macros are CERTAINLY needed on #if defined(pyr) ||
+ * define(mips) or BDSI platforms.  For safefy, we make them mandatory.
+ *
+ * Note: Pyramid and Mips can't uppercase non-alpha.
+ */
+#include <ctype.h>
+#include <string.h>
+
+#ifndef TOLOWER
+
+#ifdef USE_ASCII_CTYPES
+
+#define TOLOWER(c) ascii_tolower(UCH(c))
+#define TOUPPER(c) ascii_toupper(UCH(c))
+#define ISUPPER(c) ascii_isupper(UCH(c))
+
+#else
+
+#define TOLOWER(c) (isupper(UCH(c)) ? tolower(UCH(c)) : UCH(c))
+#define TOUPPER(c) (islower(UCH(c)) ? toupper(UCH(c)) : UCH(c))
+#define ISUPPER(c) (isupper(UCH(c)))
+
+#endif
+
+#endif /* TOLOWER */
+
+#define FREE(x)    {if (x != 0) {free((char *)x); x = NULL;}}
+
+/*
+
+The local equivalents of CR and LF
+
+   We can check for these after net ascii text has been converted to the local
+   representation.  Similarly, we include them in strings to be sent as net ascii after
+   translation.
+
+ */
+#define LF   FROMASCII('\012')	/* ASCII line feed LOCAL EQUIVALENT */
+#define CR   FROMASCII('\015')	/* Will be converted to ^M for transmission */
+
+/*
+ * Debug message control.
+ */
+#ifdef NO_LYNX_TRACE
+#define WWW_TraceFlag   0
+#define WWW_TraceMask   0
+#define LYTraceLogFP    0
+#else
+extern BOOLEAN WWW_TraceFlag;
+extern int WWW_TraceMask;
+#endif
+
+#define TRACE           (WWW_TraceFlag)
+#define TRACE_bit(n)    (TRACE && (WWW_TraceMask & (1 << n)) != 0)
+#define TRACE_SGML      (TRACE_bit(0))
+#define TRACE_STYLE     (TRACE_bit(1))
+#define TRACE_TRST      (TRACE_bit(2))
+#define TRACE_CFG       (TRACE_bit(3))
+#define TRACE_BSTRING   (TRACE_bit(4))
+#define TRACE_COOKIES   (TRACE_bit(5))
+#define TRACE_CHARSETS  (TRACE_bit(6))
+#define TRACE_GRIDTEXT  (TRACE_bit(7))
+#define TRACE_TIMING    (TRACE_bit(8))
+#define TRACE_HTPARSE   (TRACE_bit(9))
+
+/*
+ * Get printing/scanning formats.
+ */
+#if defined(HAVE_INTTYPES_H)
+#include <inttypes.h>
+#endif
+
+#define DigitsOf(type)  (int)((sizeof(type)*8)/3)
+
+/*
+ * Printing/scanning-formats for "off_t", as well as cast needed to fit.
+ */
+#if defined(HAVE_LONG_LONG) && defined(HAVE_INTTYPES_H) && defined(SIZEOF_OFF_T)
+#if (SIZEOF_OFF_T == 8) && defined(PRId64) && defined(SCNd64)
+
+#define PRI_off_t	PRId64
+#define SCN_off_t	SCNd64
+#define CAST_off_t(n)	(int64_t)(n)
+
+#elif (SIZEOF_OFF_T == 4) && defined(PRId32)
+
+#define PRI_off_t	PRId32
+#define SCN_off_t	SCNd32
+
+#if (SIZEOF_INT == 4)
+#define CAST_off_t(n)	(int)(n)
+#elif (SIZEOF_LONG == 4)
+#define CAST_off_t(n)	(long)(n)
+#else
+#define CAST_off_t(n)	(int32_t)(n)
+#endif
+
+#endif
+#endif
+
+#ifndef PRI_off_t
+#define GUESS_PRI_off_t
+#if (SIZEOF_OFF_T == SIZEOF_LONG)
+#define PRI_off_t	"ld"
+#define SCN_off_t	"ld"
+#define CAST_off_t(n)	(long)(n)
+#elif defined(HAVE_LONG_LONG)
+#define PRI_off_t	"lld"
+#define SCN_off_t	"lld"
+#define CAST_off_t(n)	(long long)(n)
+#else
+#define PRI_off_t	"ld"
+/* SCN_off_t requires workaround */
+#define CAST_off_t(n)	(long)(n)
+#endif
+#endif
+
+/*
+ * MinGW-32 uses only 32-bit DLL, which limits printing.
+ */
+#if defined(__MINGW32__)
+#undef  PRI_off_t
+#undef  CAST_off_t
+#define PRI_off_t	"ld"
+#define CAST_off_t(n)	(long)(n)
+#endif
+
+/*
+ * Printing-format for "time_t", as well as cast needed to fit.
+ */
+#if defined(HAVE_LONG_LONG) && defined(HAVE_INTTYPES_H) && defined(SIZEOF_TIME_T)
+#if (SIZEOF_TIME_T == 8) && defined(PRId64)
+
+#define PRI_time_t	PRId64
+#define SCN_time_t	SCNd64
+#define CAST_time_t(n)	(int64_t)(n)
+
+#elif (SIZEOF_TIME_T == 4) && defined(PRId32)
+
+#define PRI_time_t	PRId32
+#define SCN_time_t	SCNd32
+
+#if (SIZEOF_INT == 4)
+#define CAST_time_t(n)	(int)(n)
+#elif (SIZEOF_LONG == 4)
+#define CAST_time_t(n)	(long)(n)
+#else
+#define CAST_time_t(n)	(int32_t)(n)
+#endif
+
+#endif
+#endif
+
+#ifndef PRI_time_t
+#if defined(HAVE_LONG_LONG) && (SIZEOF_TIME_T > SIZEOF_LONG)
+#define PRI_time_t	"lld"
+#define SCN_time_t	"lld"
+#define CAST_time_t(n)	(long long)(n)
+#else
+#define PRI_time_t	"ld"
+#define SCN_time_t	"ld"
+#define CAST_time_t(n)	(long)(n)
+#endif
+#endif
+
+/*
+ * Printing-format for "UCode_t".
+ */
+#define PRI_UCode_t	"lX"
+#define CAST_UCode_t(n)	(unsigned long)(n)
+
+/*
+ * Verbose-tracing.
+ */
+#if defined(USE_VERTRACE) && !defined(LY_TRACELINE)
+#define LY_TRACELINE __LINE__
+#endif
+
+#if defined(LY_TRACELINE)
+#define LY_SHOWWHERE fprintf( tfp, "%s: %d: ", __FILE__, LY_TRACELINE ),
+#else
+#define LY_SHOWWHERE		/* nothing */
+#endif
+
+#define CTRACE(p)         ((void)((TRACE) && ( LY_SHOWWHERE fprintf p )))
+#define CTRACE2(m,p)      ((void)((m)     && ( LY_SHOWWHERE fprintf p )))
+#define tfp TraceFP()
+#define CTRACE_SLEEP(secs) if (TRACE && LYTraceLogFP == 0) sleep((unsigned)secs)
+#define CTRACE_FLUSH(fp)   if (TRACE) fflush(fp)
+
+#include <www_tcp.h>
+
+/*
+ * We force this include-ordering since socks.h contains redefinitions of
+ * functions that probably are prototyped via other includes.  The socks.h
+ * definitions have to be included everywhere, since they're making wrappers
+ * for the stdio functions as well as the network functions.
+ */
+#if defined(USE_SOCKS5)
+#define SOCKS4TO5		/* turn on the Rxxxx definitions used in Lynx */
+#include <socks.h>
+
+/*
+ * The AIX- and SOCKS4-specific definitions in socks.h are inconsistent.
+ * Repair them so they're consistent (and usable).
+ */
+#if defined(_AIX) && !defined(USE_SOCKS4_PREFIX)
+#undef  Raccept
+#define Raccept       accept
+#undef  Rgetsockname
+#define Rgetsockname  getsockname
+#undef  Rgetpeername
+#define Rgetpeername  getpeername
+#endif
+
+/*
+ * Workaround for order-of-evaluation problem with gcc and socks5 headers
+ * which breaks the Rxxxx names by attaching the prefix twice:
+ */
+#ifdef INCLUDE_PROTOTYPES
+#undef  Raccept
+#undef  Rbind
+#undef  Rconnect
+#undef  Rlisten
+#undef  Rselect
+#undef  Rgetpeername
+#undef  Rgetsockname
+#define Raccept       accept
+#define Rbind         bind
+#define Rconnect      connect
+#define Rgetpeername  getpeername
+#define Rgetsockname  getsockname
+#define Rlisten       listen
+#define Rselect       select
+#endif
+
+#elif defined(SOCKS)
+#include <socks.h>
+#endif /* USE_SOCKS5 */
+
+#ifdef USE_SSL
+
+#define free_func free__func
+
+#ifdef USE_OPENSSL_INCL
+#include <openssl/ssl.h>
+#include <openssl/crypto.h>
+#include <openssl/rand.h>
+#include <openssl/err.h>
+
+#else
+
+#if defined(USE_GNUTLS_FUNCS)
+#include <tidy_tls.h>
+#define USE_GNUTLS_INCL 1	/* do this for the ".c" ifdef's */
+#elif defined(USE_GNUTLS_INCL)
+#include <gnutls/openssl.h>
+/*
+ * GNUTLS's implementation of OpenSSL is very incomplete and rudimentary.
+ * For a start, let's make it compile (TD - 2003/4/13).
+ */
+#ifndef SSL_VERIFY_PEER
+#define SSL_VERIFY_PEER			0x01
+#endif
+#else
+
+#ifdef USE_NSS_COMPAT_INCL
+#include <nss_compat_ossl/nss_compat_ossl.h>
+
+#else /* assume SSLeay */
+#include <ssl.h>
+#include <crypto.h>
+#include <rand.h>
+#include <err.h>
+#endif
+#endif
+#endif /* USE_OPENSSL_INCL */
+
+#undef free_func
+#endif /* USE_SSL */
+
+#ifdef HAVE_BSD_STDLIB_H
+#include <bsd/stdlib.h>		/* prototype for arc4random.h */
+#elif defined(HAVE_BSD_RANDOM_H)
+#include <bsd/random.h>		/* prototype for arc4random.h */
+#endif
+
+#ifdef HAVE_LIBDMALLOC
+#include <dmalloc.h>		/* Gray Watson's library */
+#define show_alloc() dmalloc_log_unfreed()
+#endif
+
+#ifdef HAVE_LIBDBMALLOC
+#include <dbmalloc.h>		/* Conor Cahill's library */
+#define show_alloc() malloc_dump(fileno(stderr))
+#endif
+
+#ifndef show_alloc
+#define show_alloc()		/* nothing */
+#endif
+
+#include <userdefs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifndef TOLOWER
+#ifdef USE_ASCII_CTYPES
+    extern int ascii_toupper(int);
+    extern int ascii_tolower(int);
+    extern int ascii_isupper(int);
+#endif
+#endif
+
+    extern FILE *TraceFP(void);
+
+    extern char *HTSkipToAt(char *host, int *gen_delims);
+    extern void strip_userid(char *host, int warn);
+
+#ifdef USE_SSL
+    extern SSL *HTGetSSLHandle(void);
+    extern void HTSSLInitPRNG(void);
+    extern int HTGetSSLCharacter(void *handle);
+#endif				/* USE_SSL */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTUTILS_H */
diff --git a/WWW/Library/Implementation/HTVMSUtils.c b/WWW/Library/Implementation/HTVMSUtils.c
new file mode 100644
index 0000000..38e583a
--- /dev/null
+++ b/WWW/Library/Implementation/HTVMSUtils.c
@@ -0,0 +1,1131 @@
+/*
+ * $LynxId: HTVMSUtils.c,v 1.40 2020/01/21 21:58:29 tom Exp $
+ *
+ * MODULE							HTVMSUtil.c
+ *		VMS Utility Routines
+ *
+ * AUTHORS:
+ *	MD	Mark Donszelmann    duns@vxdeop.cern.ch
+ *
+ * HISTORY:
+ *	14 Nov 93  MD	Written
+ *
+ * BUGS:
+ *
+ *
+ */
+
+#include <HTUtils.h>
+#ifdef VMS
+#include <HTFormat.h>
+#include <HTStream.h>
+#include <UCDefs.h>
+#include <UCMap.h>
+#include <UCAux.h>
+#include <HTFTP.h>
+#include <HTTCP.h>
+#include <HTVMSUtils.h>
+#include <ssdef.h>
+#include <jpidef.h>
+#include <prvdef.h>
+#include <acldef.h>
+#include <chpdef.h>
+#include <descrip.h>
+#include <lib$routines.h>
+#include <starlet.h>
+#include <rmsdef.h>
+
+#include <LYGlobalDefs.h>
+#include <LYUtils.h>
+#include <LYLeaks.h>
+#include <LYStrings.h>
+
+BOOL HTVMSFileVersions = FALSE;	/* Include version numbers in listing? */
+
+typedef struct {
+    unsigned long BufferLength:16;
+    unsigned long ItemCode:16;
+    unsigned long BufferAddress:32;
+    unsigned long ReturnLengthAddress:32;
+} ItemStruct;
+
+/* PUBLIC							HTVMS_authSysPrv()
+ *		CHECKS IF THIS PROCESS IS AUTHORIZED TO ENABLE SYSPRV
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *	returns	YES if SYSPRV is authorized
+ */
+BOOL HTVMS_authSysPrv(void)
+{
+    unsigned long Result;
+    ItemStruct ItemList[2];
+    unsigned long Length;
+    unsigned long Buffer[2];
+
+    /* fill Item */
+    ItemList[0].BufferLength = sizeof(Buffer);
+    ItemList[0].BufferAddress = (unsigned long) Buffer;
+    ItemList[0].ReturnLengthAddress = (unsigned long) &Length;
+    ItemList[0].ItemCode = JPI$_AUTHPRIV;
+
+    /* terminate list */
+    ItemList[1].ItemCode = 0;
+    ItemList[1].BufferLength = 0;
+
+    /* call system */
+    Result = sys$getjpiw(0, 0, 0, ItemList, 0, 0, 0);
+
+    if (Result != SS$_NORMAL)
+	return (NO);
+
+    if (Buffer[0] & PRV$M_SYSPRV)
+	return (YES);
+
+    return (NO);
+}
+
+/* PUBLIC							HTVMS_enableSysPrv()
+ *		ENABLES SYSPRV
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *
+ */
+void HTVMS_enableSysPrv(void)
+{
+    unsigned long Result;
+    unsigned long Prv[2], PreviousPrv[2];
+
+    Prv[0] = PRV$M_SYSPRV;
+    Prv[1] = 0;
+    Result = sys$setprv(1, &Prv, 0, &PreviousPrv);
+
+    if (Result == SS$_NORMAL) {
+	if (!(PreviousPrv[0] & PRV$M_SYSPRV)) {
+	    CTRACE((tfp, "HTVMS_enableSysPrv: Enabled SYSPRV\n"));
+	}
+    }
+}
+
+/* PUBLIC							HTVMS_disableSysPrv()
+ *		DISABLES SYSPRV
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *
+ */
+void HTVMS_disableSysPrv(void)
+{
+    unsigned long Result;
+    unsigned long Prv[2], PreviousPrv[2];
+
+    Prv[0] = PRV$M_SYSPRV;
+    Prv[1] = 0;
+    Result = sys$setprv(0, &Prv, 0, &PreviousPrv);
+
+    if (Result == SS$_NORMAL) {
+	if (PreviousPrv[0] & PRV$M_SYSPRV) {
+	    CTRACE((tfp, "HTVMS_disableSysPrv: Disabled SYSPRV\n"));
+	}
+    }
+}
+
+/* PUBLIC							HTVMS_checkAccess()
+ *		CHECKS ACCESS TO FILE FOR CERTAIN USER
+ * ON ENTRY:
+ *	FileName	The file to be accessed
+ *	UserName	Name of the user to check access for.
+ *			User nobody, represented by "" is given NO for an answer
+ *	Method		Name of the method to be checked
+ *
+ * ON EXIT:
+ *	returns YES if access is allowed
+ *
+ */
+BOOL HTVMS_checkAccess(const char *FileName,
+		       const char *UserName,
+		       const char *Method)
+{
+    unsigned long Result;
+    ItemStruct ItemList[2];
+    unsigned long Length;
+    unsigned long Buffer;
+    unsigned long ObjType;
+
+    char *VmsName;
+
+    struct dsc$descriptor_s FileNameDesc;
+    struct dsc$descriptor_s UserNameDesc;
+
+    char *colon;
+
+    /* user nobody should access as from account under which server is running */
+    if (0 == strcmp(UserName, ""))
+	return (NO);
+
+    /* check Filename and convert */
+    colon = StrChr(FileName, ':');
+    if (colon)
+	VmsName = HTVMS_name("", colon + 1);
+    else
+	VmsName = HTVMS_name("", FileName);
+
+    /* check for GET */
+    if (0 == strcmp(Method, "GET")) {
+	/* fill Item */
+	ItemList[0].BufferLength = sizeof(Buffer);
+	ItemList[0].BufferAddress = (unsigned long) &Buffer;
+	ItemList[0].ReturnLengthAddress = (unsigned long) &Length;
+	ItemList[0].ItemCode = CHP$_FLAGS;
+
+	/* terminate list */
+	ItemList[1].ItemCode = 0;
+	ItemList[1].BufferLength = 0;
+
+	/* fill input */
+	ObjType = ACL$C_FILE;
+	Buffer = CHP$M_READ;
+	UserNameDesc.dsc$w_length = strlen(UserName);
+	UserNameDesc.dsc$b_dtype = DSC$K_DTYPE_T;
+	UserNameDesc.dsc$b_class = DSC$K_CLASS_S;
+	UserNameDesc.dsc$a_pointer = (char *) UserName;
+	FileNameDesc.dsc$w_length = strlen(VmsName);
+	FileNameDesc.dsc$b_dtype = DSC$K_DTYPE_T;
+	FileNameDesc.dsc$b_class = DSC$K_CLASS_S;
+	FileNameDesc.dsc$a_pointer = VmsName;
+
+	/* call system */
+	Result = sys$check_access(&ObjType, &FileNameDesc, &UserNameDesc, ItemList);
+
+	if (Result == SS$_NORMAL)
+	    return (YES);
+	else
+	    return (NO);
+    }
+
+    return (NO);
+}
+
+/* PUBLIC							HTVMS_wwwName()
+ *		CONVERTS VMS Name into WWW Name
+ * ON ENTRY:
+ *	vmsname		VMS file specification (NO NODE)
+ *
+ * ON EXIT:
+ *	returns		www file specification
+ *
+ * EXAMPLES:
+ *	vmsname				wwwname
+ *	DISK$USER			disk$user
+ *	DISK$USER:			/disk$user/
+ *	DISK$USER:[DUNS]		/disk$user/duns
+ *	DISK$USER:[DUNS.ECHO]		/disk$user/duns/echo
+ *	[DUNS]				duns
+ *	[DUNS.ECHO]			duns/echo
+ *	[DUNS.ECHO.-.TRANS]		duns/echo/../trans
+ *	[DUNS.ECHO.--.TRANS]		duns/echo/../../trans
+ *	[.DUNS]				duns
+ *	[.DUNS.ECHO]			duns/echo
+ *	[.DUNS.ECHO]TEST.COM		duns/echo/test.com
+ *	TEST.COM			test.com
+ *
+ *
+ */
+const char *HTVMS_wwwName(const char *vmsname)
+{
+    static char wwwname[LY_MAXPATH];
+    const char *src;
+    char *dst;
+    int dir;
+
+    dst = wwwname;
+    src = vmsname;
+    dir = 0;
+    if (StrChr(src, ':'))
+	*(dst++) = '/';
+    for (; *src != '\0'; src++) {
+	switch (*src) {
+	case ':':
+	    *(dst++) = '/';
+	    break;
+	case '-':
+	    if (dir) {
+		if ((*(src - 1) == '[' ||
+		     *(src - 1) == '.' ||
+		     *(src - 1) == '-') &&
+		    (*(src + 1) == '.' ||
+		     *(src + 1) == '-')) {
+		    *(dst++) = '/';
+		    *(dst++) = '.';
+		    *(dst++) = '.';
+		} else
+		    *(dst++) = '-';
+	    } else {
+		if (*(src - 1) == ']')
+		    *(dst++) = '/';
+		*(dst++) = '-';
+	    }
+	    break;
+	case '.':
+	    if (dir) {
+		if (*(src - 1) != '[')
+		    *(dst++) = '/';
+	    } else {
+		if (*(src - 1) == ']')
+		    *(dst++) = '/';
+		*(dst++) = '.';
+	    }
+	    break;
+	case '[':
+	    dir = 1;
+	    break;
+	case ']':
+	    dir = 0;
+	    break;
+	default:
+	    if (*(src - 1) == ']')
+		*(dst++) = '/';
+	    *(dst++) = *src;
+	    break;
+	}
+    }
+    *(dst++) = '\0';
+    return (wwwname);
+}
+
+/*
+ *	The code below is for directory browsing by VMS Curses clients.
+ *	It is based on the newer WWWLib's HTDirBrw.c. - Foteos Macrides
+ */
+int HTStat(const char *filename,
+	   struct stat *info)
+{
+    /*
+       the following stuff does not work in VMS with a normal stat...
+       -->   /disk$user/duns/www if www is a directory
+       is statted like:  /disk$user/duns/www.dir
+       after a normal stat has failed
+       -->   /disk$user/duns     if duns is a toplevel directory
+       is statted like:  /disk$user/000000/duns.dir
+       -->   /disk$user since disk$user is a device
+       is statted like:  /disk$user/000000/000000.dir
+       -->   /
+       searches all devices, no solution yet...
+       -->   /vxcern!/disk$cr/wwwteam/login.com
+       is not statted but granted with fake information...
+     */
+    int Result;
+    int Len;
+    char *Ptr, *Ptr2;
+    static char *Name;
+
+    /* try normal stat... */
+    Result = stat((char *) filename, info);
+    if (Result == 0)
+	return (Result);
+
+    /* make local copy */
+    StrAllocCopy(Name, filename);
+
+    /* failed,so do device search in case root is requested */
+    if (!strcmp(Name, "/")) {	/* root requested */
+	return (-1);
+    }
+
+    /* failed so this might be a directory, add '.dir' */
+    Len = strlen(Name);
+    if (Name[Len - 1] == '/')
+	Name[Len - 1] = '\0';
+
+    /* fail in case of device */
+    Ptr = StrChr(Name + 1, '/');
+    if ((Ptr == NULL) && (Name[0] == '/')) {	/* device only... */
+	StrAllocCat(Name, "/000000/000000");
+    }
+
+    if (Ptr != NULL) {		/* correct filename in case of toplevel dir */
+	Ptr2 = StrChr(Ptr + 1, '/');
+	if ((Ptr2 == NULL) && (Name[0] == '/')) {
+	    char End[256];
+
+	    LYStrNCpy(End, Ptr, sizeof(End) - 1);
+	    *(Ptr + 1) = '\0';
+	    StrAllocCat(Name, "000000");
+	    StrAllocCat(Name, End);
+	}
+    }
+
+    /* try in case a file on toplevel directory or .DIR was already specified */
+    Result = stat(Name, info);
+    if (Result == 0)
+	return (Result);
+
+    /* add .DIR and try again */
+    StrAllocCat(Name, ".dir");
+    Result = stat(Name, info);
+    return (Result);
+}
+
+#ifndef	_POSIX_SOURCE
+#define	d_ino	d_fileno	/* compatibility */
+#ifndef	NULL
+#define	NULL	0
+#endif
+#endif /* !_POSIX_SOURCE */
+
+typedef struct __dirdesc {
+    long context;		/* context descriptor for LIB$FIND_FILE calls */
+    char dirname[255 + 1];	/* keeps the directory name, including *.* */
+    struct dsc$descriptor_s dirname_desc;	/* descriptor of dirname */
+} DIR;
+
+static DIR *HTVMSopendir(char *dirname);
+static struct dirent *HTVMSreaddir(DIR *dirp);
+static int HTVMSclosedir(DIR *dirp);
+
+/*** #include <sys_dirent.h> ***/
+/*** "sys_dirent.h" ***/
+struct dirent {
+    unsigned long d_fileno;	/* file number of entry */
+    unsigned short d_namlen;	/* length of string in d_name */
+    char d_name[255 + 1];	/* name (up to MAXNAMLEN + 1) */
+};
+
+#ifndef	_POSIX_SOURCE
+/*
+ * It's unlikely to change, but make sure that sizeof d_name above is
+ * at least MAXNAMLEN + 1 (more may be added for padding).
+ */
+#define	MAXNAMLEN	255
+/*
+ * The macro DIRSIZ(dp) gives the minimum amount of space required to represent
+ * a directory entry.  For any directory entry dp->d_reclen >= DIRSIZ(dp).
+ * Specific filesystem types may use this macro to construct the value
+ * for d_reclen.
+ */
+#undef	DIRSIZ
+#define	DIRSIZ(dp) \
+	(((sizeof(struct dirent) - (MAXNAMLEN+1) + ((dp)->d_namlen+1)) +3) & ~3)
+
+#endif /* !_POSIX_SOURCE */
+
+static DIR *HTVMSopendir(char *dirname)
+{
+    static DIR dir;
+    char *closebracket;
+    long status;
+    struct dsc$descriptor_s entryname_desc;
+    struct dsc$descriptor_s dirname_desc;
+    static char *DirEntry;
+    char Actual[256];
+    char VMSentry[256];
+    char UnixEntry[256];
+    int index;
+    char *dot;
+
+    /* check if directory exists */
+    /* dirname can look like /disk$user/duns/www/test/multi    */
+    /* or like               /disk$user/duns/www/test/multi/   */
+    /* DirEntry should look like     disk$user:[duns.www.test]multi in both cases */
+    /* dir.dirname should look like  disk$user:[duns.www.test.multi] */
+    sprintf(UnixEntry, "%.*s", sizeof(UnixEntry) - 2, dirname);
+    if (UnixEntry[strlen(UnixEntry) - 1] != '/')
+	strcat(UnixEntry, "/");
+
+    StrAllocCopy(DirEntry, HTVMS_name("", UnixEntry));
+    if (strlen(DirEntry) > sizeof(dir.dirname) - 1)
+	return (NULL);
+    strcpy(dir.dirname, DirEntry);
+    index = strlen(DirEntry) - 1;
+
+    if (DirEntry[index] == ']')
+	DirEntry[index] = '\0';
+
+    if ((dot = strrchr(DirEntry, '.')) == NULL) {	/* convert disk$user:[duns] into disk$user:[000000]duns.dir */
+	char *openbr = strrchr(DirEntry, '[');
+
+	if (!openbr) {		/* convert disk$user: into disk$user:[000000]000000.dir */
+	    if (strlen(dir.dirname) > sizeof(dir.dirname) - 10)
+		return (NULL);
+	    sprintf(dir.dirname, "%.*s[000000]", sizeof(dir.dirname) - 9, DirEntry);
+	    StrAllocCat(DirEntry, "[000000]000000.dir");
+	} else {
+	    char End[256];
+
+	    strcpy(End, openbr + 1);
+	    *(openbr + 1) = '\0';
+	    StrAllocCat(DirEntry, "000000]");
+	    StrAllocCat(DirEntry, End);
+	    StrAllocCat(DirEntry, ".dir");
+	}
+    } else {
+	*dot = ']';
+	StrAllocCat(DirEntry, ".dir");
+    }
+    /* lib$find_file needs a fixed-size buffer */
+    LYStrNCpy(Actual, DirEntry, sizeof(Actual) - 1);
+
+    dir.context = 0;
+    dirname_desc.dsc$w_length = strlen(Actual);
+    dirname_desc.dsc$b_dtype = DSC$K_DTYPE_T;
+    dirname_desc.dsc$b_class = DSC$K_CLASS_S;
+    dirname_desc.dsc$a_pointer = (char *) &(Actual);
+
+    /* look for the directory */
+    entryname_desc.dsc$w_length = 255;
+    entryname_desc.dsc$b_dtype = DSC$K_DTYPE_T;
+    entryname_desc.dsc$b_class = DSC$K_CLASS_S;
+    entryname_desc.dsc$a_pointer = VMSentry;
+
+    status = lib$find_file(&(dirname_desc),
+			   &entryname_desc,
+			   &(dir.context),
+			   0, 0, 0, 0);
+    if (!(status & 0x01)) {	/* directory not found */
+	return (NULL);
+    }
+
+    if (strlen(dir.dirname) > sizeof(dir.dirname) - 10)
+	return (NULL);
+    if (HTVMSFileVersions)
+	strcat(dir.dirname, "*.*;*");
+    else
+	strcat(dir.dirname, "*.*");
+    dir.context = 0;
+    dir.dirname_desc.dsc$w_length = strlen(dir.dirname);
+    dir.dirname_desc.dsc$b_dtype = DSC$K_DTYPE_T;
+    dir.dirname_desc.dsc$b_class = DSC$K_CLASS_S;
+    dir.dirname_desc.dsc$a_pointer = (char *) &(dir.dirname);
+    return (&dir);
+}
+
+static struct dirent *HTVMSreaddir(DIR *dirp)
+{
+    static struct dirent entry;
+    long status;
+    struct dsc$descriptor_s entryname_desc;
+    char *space, *slash;
+    char VMSentry[256];
+    const char *UnixEntry;
+
+    entryname_desc.dsc$w_length = 255;
+    entryname_desc.dsc$b_dtype = DSC$K_DTYPE_T;
+    entryname_desc.dsc$b_class = DSC$K_CLASS_S;
+    entryname_desc.dsc$a_pointer = VMSentry;
+
+    status = lib$find_file(&(dirp->dirname_desc),
+			   &entryname_desc,
+			   &(dirp->context),
+			   0, 0, 0, 0);
+    if (status == RMS$_NMF) {	/* no more files */
+	return (NULL);
+    } else {			/* ok */
+	if (!(status & 0x01))
+	    return (0);
+	if (HTVMSFileVersions)
+	    space = StrChr(VMSentry, ' ');
+	else
+	    space = StrChr(VMSentry, ';');
+	if (space)
+	    *space = '\0';
+
+	/* convert to unix style... */
+	UnixEntry = HTVMS_wwwName(VMSentry);
+	slash = strrchr(UnixEntry, '/') + 1;
+	strcpy(entry.d_name, slash);
+	entry.d_namlen = strlen(entry.d_name);
+	entry.d_fileno = 1;
+	return (&entry);
+    }
+}
+
+static int HTVMSclosedir(DIR *dirp)
+{
+    long status;
+
+    status = lib$find_file_end(&(dirp->context));
+    if (!(status & 0x01))
+	exit_immediately(status);
+    dirp->context = 0;
+    return (0);
+}
+
+#include <HTAnchor.h>
+#include <HTParse.h>
+#include <HTBTree.h>
+#include <HTFile.h>		/* For HTFileFormat() */
+#include <HTAlert.h>
+/*
+ *  Hypertext object building machinery.
+ */
+#include <HTML.h>
+#define PUTC(c) (*targetClass.put_character)(target, c)
+#define PUTS(s) (*targetClass.put_string)(target, s)
+#define START(e) (*targetClass.start_element)(target, e, 0, 0, -1, 0)
+#define END(e) (*targetClass.end_element)(target, e, 0)
+#define FREE_TARGET (*targetClass._free)(target)
+#define ABORT_TARGET (*targetClass._free)(target)
+struct _HTStructured {
+    const HTStructuredClass *isa;
+    /* ... */
+};
+
+#define STRUCT_DIRENT struct dirent
+
+static char *months[12] =
+{
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+};
+
+typedef struct _VMSEntryInfo {
+    char *filename;
+    char *type;
+    char *date;
+    unsigned int size;
+    BOOLEAN display;		/* show this entry? */
+} VMSEntryInfo;
+
+static void free_VMSEntryInfo_contents(VMSEntryInfo * entry_info)
+{
+    if (entry_info) {
+	FREE(entry_info->filename);
+	FREE(entry_info->type);
+	FREE(entry_info->date);
+    }
+    /* don't free the struct */
+}
+
+int compare_VMSEntryInfo_structs(VMSEntryInfo * entry1, VMSEntryInfo * entry2)
+{
+    int i, status;
+    char date1[16], date2[16], time1[8], time2[8], month[4];
+
+    switch (HTfileSortMethod) {
+    case FILE_BY_SIZE:
+	/* both equal or both 0 */
+	if (entry1->size == entry2->size)
+	    return (strcasecomp(entry1->filename,
+				entry2->filename));
+	else if (entry1->size > entry2->size)
+	    return (1);
+	else
+	    return (-1);
+    case FILE_BY_TYPE:
+	if (entry1->type && entry2->type) {
+	    status = strcasecomp(entry1->type, entry2->type);
+	    if (status)
+		return (status);
+	    /* else fall to filename comparison */
+	}
+	return (strcasecomp(entry1->filename,
+			    entry2->filename));
+    case FILE_BY_DATE:
+	if (entry1->date && entry2->date) {
+	    /*
+	     * Make sure we have the correct length. - FM
+	     */
+	    if (strlen(entry1->date) != 12 ||
+		strlen(entry2->date) != 12) {
+		return (strcasecomp(entry1->filename,
+				    entry2->filename));
+	    }
+	    /*
+	     * Set up for sorting in reverse
+	     * chronological order. - FM
+	     */
+	    if (entry1->date[7] != ' ') {
+		strcpy(date1, "9999");
+		strcpy(time1, (char *) &entry1->date[7]);
+	    } else {
+		strcpy(date1, (char *) &entry1->date[8]);
+		strcpy(time1, "00:00");
+	    }
+	    LYStrNCpy(month, entry1->date, 3);
+	    for (i = 0; i < 12; i++) {
+		if (!strcasecomp(month, months[i])) {
+		    break;
+		}
+	    }
+	    i++;
+	    sprintf(month, "%02d", i);
+	    strcat(date1, month);
+	    StrNCat(date1, (char *) &entry1->date[4], 2);
+	    date1[8] = '\0';
+	    if (date1[6] == ' ') {
+		date1[6] = '0';
+	    }
+	    strcat(date1, time1);
+	    if (entry2->date[7] != ' ') {
+		strcpy(date2, "9999");
+		strcpy(time2, (char *) &entry2->date[7]);
+	    } else {
+		strcpy(date2, (char *) &entry2->date[8]);
+		strcpy(time2, "00:00");
+	    }
+	    LYStrNCpy(month, entry2->date, 3);
+	    for (i = 0; i < 12; i++) {
+		if (!strcasecomp(month, months[i])) {
+		    break;
+		}
+	    }
+	    i++;
+	    sprintf(month, "%02d", i);
+	    strcat(date2, month);
+	    StrNCat(date2, (char *) &entry2->date[4], 2);
+	    date2[8] = '\0';
+	    if (date2[6] == ' ') {
+		date2[6] = '0';
+	    }
+	    strcat(date2, time2);
+	    /*
+	     * Do the comparison. - FM
+	     */
+	    status = strcasecomp(date2, date1);
+	    if (status)
+		return (status);
+	    /* else fall to filename comparison */
+	}
+	return (strcasecomp(entry1->filename,
+			    entry2->filename));
+    case FILE_BY_NAME:
+    default:
+	return (strcmp(entry1->filename,
+		       entry2->filename));
+    }
+}
+
+/*							HTVMSBrowseDir()
+ *
+ *	This function generates a directory listing as an HTML-object
+ *	for local file URL's.  It assumes the first two elements of
+ *	of the path are a device followed by a directory:
+ *
+ *		file://localhost/device/directory[/[foo]]
+ *
+ *	Will not accept 000000 as a directory name.
+ *	Will offer links to parent through the top directory, unless
+ *	a terminal slash was included in the calling URL.
+ *
+ *	Returns HT_LOADED on success, HTLoadError() messages on error.
+ *
+ *	Developed for Lynx by Foteos Macrides (macrides@sci.wfeb.edu).
+ */
+int HTVMSBrowseDir(const char *address,
+		   HTParentAnchor *anchor,
+		   HTFormat format_out,
+		   HTStream *sink)
+{
+    HTStructured *target;
+    HTStructuredClass targetClass;
+    char *pathname = HTParse(address, "", PARSE_PATH + PARSE_PUNCTUATION);
+    char *tail = NULL;
+    char *title = NULL;
+    char *header = NULL;
+    char *parent = NULL;
+    char *relative = NULL;
+    char *cp, *cp1;
+    int pathend, len;
+    DIR *dp;
+    struct stat file_info;
+    time_t NowTime;
+    static char ThisYear[8];
+    VMSEntryInfo *entry_info = 0;
+    char string_buffer[64];
+
+    HTUnEscape(pathname);
+    CTRACE((tfp, "HTVMSBrowseDir: Browsing `%s\'\n", pathname));
+
+    /*
+     * Require at least two elements (presumably a device and directory) and
+     * disallow the device root (000000 directory).  Symbolic paths (e.g.,
+     * sys$help) should have been translated and expanded (e.g., to
+     * /sys$sysroot/syshlp) before calling this routine.
+     */
+    if (((*pathname != '/') ||
+	 (cp = StrChr(pathname + 1, '/')) == NULL ||
+	 *(cp + 1) == '\0' ||
+	 0 == StrNCmp((cp + 1), "000000", 6)) ||
+	(dp = HTVMSopendir(pathname)) == NULL) {
+	FREE(pathname);
+	return HTLoadError(sink, 403, COULD_NOT_ACCESS_DIR);
+    }
+
+    /*
+     * Set up the output stream.
+     */
+    _HTProgress(BUILDING_DIR_LIST);
+    if (UCLYhndl_HTFile_for_unspec >= 0) {
+	HTAnchor_setUCInfoStage(anchor,
+				UCLYhndl_HTFile_for_unspec,
+				UCT_STAGE_PARSER,
+				UCT_SETBY_DEFAULT);
+    }
+    target = HTML_new(anchor, format_out, sink);
+    targetClass = *(target->isa);
+
+    /*
+     * Set up the offset string of the anchor reference, and strings for the
+     * title and header.
+     */
+    cp = strrchr(pathname, '/');	/* find lastslash */
+    StrAllocCopy(tail, (cp + 1));	/* take slash off the beginning */
+    if (*tail != '\0') {
+	StrAllocCopy(title, tail);
+	*cp = '\0';
+	if ((cp1 = strrchr(pathname, '/')) != NULL &&
+	    cp1 != pathname &&
+	    StrNCmp((cp1 + 1), "000000", 6))
+	    StrAllocCopy(parent, (cp1 + 1));
+	*cp = '/';
+    } else {
+	pathname[strlen(pathname) - 1] = '\0';
+	cp = strrchr(pathname, '/');
+	StrAllocCopy(title, (cp + 1));
+	pathname[strlen(pathname)] = '/';
+    }
+    StrAllocCopy(header, pathname);
+
+    /*
+     * Initialize path name for HTStat().
+     */
+    pathend = strlen(pathname);
+    if (*(pathname + pathend - 1) != '/') {
+	StrAllocCat(pathname, "/");
+	pathend++;
+    }
+
+    /*
+     * Output the title and header.
+     */
+    START(HTML_HTML);
+    PUTC('\n');
+    START(HTML_HEAD);
+    PUTC('\n');
+    HTUnEscape(title);
+    START(HTML_TITLE);
+    PUTS(title);
+    PUTS(" directory");
+    END(HTML_TITLE);
+    PUTC('\n');
+    FREE(title);
+    END(HTML_HEAD);
+    PUTC('\n');
+    START(HTML_BODY);
+    PUTC('\n');
+    HTUnEscape(header);
+    START(HTML_H1);
+    PUTS(header);
+    END(HTML_H1);
+    PUTC('\n');
+    if (HTDirReadme == HT_DIR_README_TOP) {
+	FILE *fp;
+
+	if (header[strlen(header) - 1] != '/')
+	    StrAllocCat(header, "/");
+	StrAllocCat(header, HT_DIR_README_FILE);
+	if ((fp = fopen(header, "r")) != NULL) {
+	    START(HTML_PRE);
+	    for (;;) {
+		char c = fgetc(fp);
+
+		if (c == (char) EOF)
+		    break;
+#ifdef NOTDEFINED
+		switch (c) {
+		case '&':
+		case '<':
+		case '>':
+		    PUTC('&');
+		    PUTC('#');
+		    PUTC((char) (c / 10));
+		    PUTC((char) (c % 10));
+		    PUTC(';');
+		    break;
+		default:
+		    PUTC(c);
+		}
+#else
+		PUTC(c);
+#endif /* NOTDEFINED */
+	    }
+	    END(HTML_PRE);
+	    fclose(fp);
+	}
+    }
+    FREE(header);
+    if (parent) {
+	HTSprintf0(&relative, "%s/..", tail);
+	HTStartAnchor(target, "", relative);
+	PUTS("Up to ");
+	HTUnEscape(parent);
+	PUTS(parent);
+	END(HTML_A);
+	START(HTML_P);
+	PUTC('\n');
+	FREE(relative);
+	FREE(parent);
+    }
+
+    /*
+     * Set up the date comparison.
+     */
+    NowTime = time(NULL);
+    strcpy(ThisYear, (char *) ctime(&NowTime) + 20);
+    ThisYear[4] = '\0';
+
+    /*
+     * Now, generate the Btree and put it out to the output stream.
+     */
+    {
+	char dottest = 2;	/* To avoid two strcmp() each time */
+	STRUCT_DIRENT *dirbuf;
+	HTBTree *bt;
+
+	/* Set up sort key and initialize BTree */
+	bt = HTBTree_new((HTComparer) compare_VMSEntryInfo_structs);
+
+	/* Build tree */
+	while ((dirbuf = HTVMSreaddir(dp))) {
+	    HTAtom *encoding = NULL;
+	    HTFormat format;
+
+	    /* Skip if not used */
+	    if (!dirbuf->d_ino) {
+		continue;
+	    }
+
+	    /* Current and parent directories are never shown in list */
+	    if (dottest && (!strcmp(dirbuf->d_name, ".") ||
+			    !strcmp(dirbuf->d_name, ".."))) {
+		dottest--;
+		continue;
+	    }
+
+	    /* Don't show the selective enabling file
+	     * unless version numbers are included */
+	    if (!strcasecomp(dirbuf->d_name, HT_DIR_ENABLE_FILE)) {
+		continue;
+	    }
+
+	    /* Skip files beginning with a dot? */
+	    if ((no_dotfiles || !show_dotfiles) && *dirbuf->d_name == '.') {
+		continue;
+	    }
+
+	    /* OK, make an lstat() and get a key ready. */
+	    *(pathname + pathend) = '\0';
+	    StrAllocCat(pathname, dirbuf->d_name);
+	    if (HTStat(pathname, &file_info)) {
+		/* for VMS the failure here means the file is not readable...
+		   we however continue to browse through the directory... */
+		continue;
+	    }
+	    entry_info = (VMSEntryInfo *) malloc(sizeof(VMSEntryInfo));
+	    if (entry_info == NULL)
+		outofmem(__FILE__, "HTVMSBrowseDir");
+	    entry_info->type = 0;
+	    entry_info->size = 0;
+	    entry_info->date = 0;
+	    entry_info->filename = 0;
+	    entry_info->display = TRUE;
+
+	    /* Get the type */
+	    format = HTFileFormat(dirbuf->d_name, &encoding,
+				  (const char **) &cp);
+	    if (!cp) {
+		if (!StrNCmp(HTAtom_name(format), "application", 11)) {
+		    cp = HTAtom_name(format) + 12;
+		    if (!StrNCmp(cp, "x-", 2))
+			cp += 2;
+		} else
+		    cp = HTAtom_name(format);
+	    }
+	    StrAllocCopy(entry_info->type, cp);
+
+	    StrAllocCopy(entry_info->filename, dirbuf->d_name);
+	    if (S_ISDIR(file_info.st_mode)) {
+		/* strip .DIR part... */
+		char *dot;
+
+		dot = strstr(entry_info->filename, ".DIR");
+		if (dot)
+		    *dot = '\0';
+		LYLowerCase(entry_info->filename);
+		StrAllocCopy(entry_info->type, "Directory");
+	    } else {
+		if ((cp = strstr(entry_info->filename, "READ")) == NULL) {
+		    cp = entry_info->filename;
+		} else {
+		    cp += 4;
+		    if (!StrNCmp(cp, "ME", 2)) {
+			cp += 2;
+			while (cp && *cp && *cp != '.') {
+			    cp++;
+			}
+		    } else if (!StrNCmp(cp, ".ME", 3)) {
+			cp = (entry_info->filename +
+			      strlen(entry_info->filename));
+		    } else {
+			cp = entry_info->filename;
+		    }
+		}
+		LYLowerCase(cp);
+		if (((len = strlen(entry_info->filename)) > 2) &&
+		    entry_info->filename[len - 1] == 'z') {
+		    if (entry_info->filename[len - 2] == '.' ||
+			entry_info->filename[len - 2] == '_')
+			entry_info->filename[len - 1] = 'Z';
+		}
+	    }
+
+	    /* Get the date */
+	    {
+		char *t = (char *) ctime((const time_t *) &file_info.st_ctime);
+
+		*(t + 24) = '\0';
+
+		StrAllocCopy(entry_info->date, (t + 4));
+		*((entry_info->date) + 7) = '\0';
+		if ((atoi((t + 19))) < atoi(ThisYear))
+		    StrAllocCat(entry_info->date, (t + 19));
+		else {
+		    StrAllocCat(entry_info->date, (t + 11));
+		    *((entry_info->date) + 12) = '\0';
+		}
+	    }
+
+	    /* Get the size */
+	    if (!S_ISDIR(file_info.st_mode))
+		entry_info->size = (unsigned int) file_info.st_size;
+	    else
+		entry_info->size = 0;
+
+	    /* Now, update the BTree etc. */
+	    if (entry_info->display) {
+		CTRACE((tfp, "Adding file to BTree: %s\n",
+			entry_info->filename));
+		HTBTree_add(bt, entry_info);
+	    }
+
+	}			/* End while HTVMSreaddir() */
+
+	FREE(pathname);
+	HTVMSclosedir(dp);
+
+	START(HTML_PRE);
+	/*
+	 * Run through the BTree printing out in order
+	 */
+	{
+	    HTBTElement *ele;
+	    int i;
+
+	    for (ele = HTBTree_next(bt, NULL);
+		 ele != NULL;
+		 ele = HTBTree_next(bt, ele)) {
+		entry_info = (VMSEntryInfo *) HTBTree_object(ele);
+
+		/* Output the date */
+		if (entry_info->date) {
+		    PUTS(entry_info->date);
+		    PUTS("  ");
+		} else
+		    PUTS("     * ");
+
+		/* Output the type */
+		if (entry_info->type) {
+		    for (i = 0; entry_info->type[i] != '\0' && i < 15; i++)
+			PUTC(entry_info->type[i]);
+		    for (; i < 17; i++)
+			PUTC(' ');
+
+		}
+
+		/* Output the link for the name */
+		HTDirEntry(target, tail, entry_info->filename);
+		PUTS(entry_info->filename);
+		END(HTML_A);
+
+		/* Output the size */
+		if (entry_info->size) {
+		    if (entry_info->size < 1024)
+			sprintf(string_buffer, "  %d bytes",
+				entry_info->size);
+		    else
+			sprintf(string_buffer, "  %dKb",
+				entry_info->size / 1024);
+		    PUTS(string_buffer);
+		}
+
+		PUTC('\n');	/* end of this entry */
+
+		free_VMSEntryInfo_contents(entry_info);
+	    }
+	}
+
+	HTBTreeAndObject_free(bt);
+
+    }				/* End of both BTree loops */
+
+    /*
+     * Complete the output stream.
+     */
+    END(HTML_PRE);
+    PUTC('\n');
+    END(HTML_BODY);
+    PUTC('\n');
+    END(HTML_HTML);
+    PUTC('\n');
+    FREE(tail);
+    FREE_TARGET;
+
+    return HT_LOADED;
+
+}				/* End of directory reading section */
+
+/*
+ * Remove all versions of the given file.  We assume there are no permissions
+ * problems, since we do this mainly for removing temporary files.
+ */
+int HTVMS_remove(char *filename)
+{
+    int code = remove(filename);	/* return the first status code */
+
+    while (remove(filename) == 0) ;
+    return code;
+}
+
+/*
+ * Remove all older versions of the given file.  We may fail to remove some
+ * version due to permissions -- the loop stops either at that point, or when
+ * we run out of older versions to remove.
+ */
+void HTVMS_purge(char *filename)
+{
+    char *older_file = 0;
+    char *oldest_file = 0;
+    struct stat sb;
+
+    StrAllocCopy(older_file, filename);
+    StrAllocCat(older_file, ";-1");
+
+    while (remove(older_file) == 0) ;
+    /*
+     * If we do not have any more older versions, it is safe to rename the
+     * current file to version #1.
+     */
+    if (stat(older_file, &sb) != 0) {
+	StrAllocCopy(oldest_file, filename);
+	StrAllocCat(oldest_file, ";1");
+	rename(older_file, oldest_file);
+	FREE(oldest_file);
+    }
+
+    FREE(older_file);
+}
+#endif /* VMS */
diff --git a/WWW/Library/Implementation/HTVMSUtils.h b/WWW/Library/Implementation/HTVMSUtils.h
new file mode 100644
index 0000000..d7efe8c
--- /dev/null
+++ b/WWW/Library/Implementation/HTVMSUtils.h
@@ -0,0 +1,101 @@
+/*             VMS specific routines
+
+ */
+
+#ifndef HTVMSUTIL_H
+#define HTVMSUTIL_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#include <HTAnchor.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern BOOL HTVMSFileVersions;	/* Include version numbers in listing? */
+
+/* PUBLIC							HTVMS_authSysPrv()
+ *		CHECKS IF THIS PROCESS IS AUTHORIZED TO ENABLE SYSPRV
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *	returns	YES if SYSPRV is authorized
+ */
+    extern BOOL HTVMS_authSysPrv(void);
+
+/* PUBLIC							HTVMS_enableSysPrv()
+ *		ENABLES SYSPRV
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *
+ */
+    extern void HTVMS_enableSysPrv(void);
+
+/* PUBLIC							HTVMS_disableSysPrv()
+ *		DISABLES SYSPRV
+ * ON ENTRY:
+ *	No arguments.
+ *
+ * ON EXIT:
+ *
+ */
+    extern void HTVMS_disableSysPrv(void);
+
+/* PUBLIC							HTVMS_checkAccess()
+ *		CHECKS ACCESS TO FILE FOR CERTAIN USER
+ * ON ENTRY:
+ *	FileName	The file to be accessed
+ *	UserName	Name of the user to check access for
+ *
+ * ON EXIT:
+ *	returns YES if access is allowed
+ *
+ */
+    extern BOOL HTVMS_checkAccess(const char *FileName,
+				  const char *UserName,
+				  const char *Method);
+
+/* PUBLIC							HTVMS_wwwName()
+ *		CONVERTS VMS Name into WWW Name
+ * ON ENTRY:
+ *	vmsname		VMS file specification (NO NODE)
+ *
+ * ON EXIT:
+ *	returns		www file specification
+ *
+ * EXAMPLES:
+ *	vmsname				wwwname
+ *	DISK$USER			disk$user
+ *	DISK$USER:			/disk$user/
+ *	DISK$USER:[DUNS]		/disk$user/duns
+ *	DISK$USER:[DUNS.ECHO]		/disk$user/duns/echo
+ *	[DUNS]				duns
+ *	[DUNS.ECHO]			duns/echo
+ *	[DUNS.ECHO.-.TRANS]		duns/echo/../trans
+ *	[DUNS.ECHO.--.TRANS]		duns/echo/../../trans
+ *	[.DUNS]				duns
+ *	[.DUNS.ECHO]			duns/echo
+ *	[.DUNS.ECHO]TEST.COM		duns/echo/test.com
+ *	TEST.COM			test.com
+ *
+ *
+ */
+    const extern char *HTVMS_wwwName(const char *vmsname);
+
+    extern int HTVMSBrowseDir(const char *address,
+			      HTParentAnchor *anchor,
+			      HTFormat format_out,
+			      HTStream *sink);
+
+    extern int HTVMS_remove(char *filename);
+    extern void HTVMS_purge(char *filename);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* not HTVMSUTIL_H */
diff --git a/WWW/Library/Implementation/HTVMS_WaisProt.c b/WWW/Library/Implementation/HTVMS_WaisProt.c
new file mode 100644
index 0000000..687c9df
--- /dev/null
+++ b/WWW/Library/Implementation/HTVMS_WaisProt.c
@@ -0,0 +1,2469 @@
+/*
+ * $LynxId: HTVMS_WaisProt.c,v 1.10 2020/01/21 22:10:03 tom Exp $
+ *
+ *							  HTVMS_WAISProt.c
+ *
+ *	Adaptation for Lynx by F.Macrides (macrides@sci.wfeb.edu)
+ *
+ *	31-May-1994 FM	Initial version.
+ *
+ *----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from WProt.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE:
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+
+ * 3.26.90	Harry Morris, morris@think.com
+ * 3.30.90  Harry Morris
+ * -	removed chunk code from WAISSearchAPDU,
+ * -	added makeWAISQueryType1Query() and readWAISType1Query() which replace
+ * makeWAISQueryTerms() and makeWAISQueryDocs().
+ * 4.11.90  HWM - generalized conditional includes (see c-dialect.h)
+ * - renamed makeWAISType1Query() to makeWAISTextQuery()
+ * renamed readWAISType1Query() to readWAISTextQuery()
+ * 5.29.90  TS - fixed bug in makeWAISQueryDocs
+ * added CSTFreeWAISFoo functions
+ */
+
+#define _C_WAIS_protocol_
+
+/*	This file implements the Z39.50 extensions required for WAIS
+*/
+
+#include <HTUtils.h>
+#include <HTVMS_WaisUI.h>
+#include <HTVMS_WaisProt.h>
+
+#include <LYLeaks.h>
+
+/* very rough estimates of the size of an object */
+#define DefWAISInitResponseSize		(size_t)200
+#define DefWAISSearchSize			(size_t)3000
+#define DefWAISSearchResponseSize	(size_t)6000
+#define DefWAISPresentSize			(size_t)1000
+#define DefWAISPresentResponseSize	(size_t)6000
+#define DefWAISDocHeaderSize		(size_t)500
+#define DefWAISShortHeaderSize		(size_t)200
+#define DefWAISLongHeaderSize		(size_t)800
+#define DefWAISDocTextSize			(size_t)6000
+#define DefWAISDocHeadlineSize		(size_t)500
+#define DefWAISDocCodeSize			(size_t)500
+
+#define RESERVE_SPACE_FOR_WAIS_HEADER(len)	\
+     if (*len > 0)				\
+	*len -= header_len;
+
+#define S_MALLOC(type) (type*)s_malloc(sizeof(type))
+#define S_MALLOC2(type) (type*)s_malloc(sizeof(type) * 2)
+
+#define S_REALLOC2(type, ptr, num) (type*)s_realloc((char*)ptr, (sizeof(type) * (num + 2)))
+
+/*----------------------------------------------------------------------*/
+
+static unsigned long userInfoTagSize(data_tag tag,
+				     unsigned long length)
+/* return the number of bytes required to write the user info tag and
+   length
+ */
+{
+    unsigned long size;
+
+    /* calculate bytes required to represent tag.  max tag is 16K */
+    size = writtenCompressedIntSize(tag);
+    size += writtenCompressedIntSize(length);
+
+    return (size);
+}
+
+/*----------------------------------------------------------------------*/
+
+static char *writeUserInfoHeader(data_tag tag,
+				 long infoSize,
+				 long estHeaderSize,
+				 char *buffer,
+				 long *len)
+/* write the tag and size, making sure the info fits.  return the true end
+   of the info (after adjustment) note that the argument infoSize includes
+   estHeaderSize.  Note that the argument len is the number of bytes remaining
+   in the buffer.  Since we write the tag and size at the beginning of the
+   buffer (in space that we reserved) we don't want to pass len the calls which
+   do that writing.
+ */
+{
+    long dummyLen = 100;	/* plenty of space for a tag and size */
+    char *buf = buffer;
+    long realSize = infoSize - estHeaderSize;
+    long realHeaderSize = userInfoTagSize(tag, realSize);
+
+    if (buffer == NULL || *len == 0)
+	return (NULL);
+
+    /* write the tag */
+    buf = writeTag(tag, buf, &dummyLen);
+
+    /* see if the if the header size was correct. if not,
+       we have to shift the info to fit the real header size */
+    if (estHeaderSize != realHeaderSize) {	/* make sure there is enough space */
+	CHECK_FOR_SPACE_LEFT(realHeaderSize - estHeaderSize, len);
+	memmove(buffer + realHeaderSize, buffer + estHeaderSize, (size_t) (realSize));
+    }
+
+    /* write the size */
+    writeCompressedInteger(realSize, buf, &dummyLen);
+
+    /* return the true end of buffer */
+    return (buffer + realHeaderSize + realSize);
+}
+
+/*----------------------------------------------------------------------*/
+
+static char *readUserInfoHeader(data_tag *tag,
+				unsigned long *num,
+				char *buffer)
+/* read the tag and size */
+{
+    char *buf = buffer;
+
+    buf = readTag(tag, buf);
+    buf = readCompressedInteger(num, buf);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISInitResponse *makeWAISInitResponse(long chunkCode,
+				       long chunkIDLen,
+				       char *chunkMarker,
+				       char *highlightMarker,
+				       char *deHighlightMarker,
+				       char *newLineChars)
+/* create a WAIS init response object */
+{
+    WAISInitResponse *init = S_MALLOC(WAISInitResponse);
+
+    init->ChunkCode = chunkCode;	/* note: none are copied! */
+    init->ChunkIDLength = chunkIDLen;
+    init->ChunkMarker = chunkMarker;
+    init->HighlightMarker = highlightMarker;
+    init->DeHighlightMarker = deHighlightMarker;
+    init->NewlineCharacters = newLineChars;
+
+    return (init);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISInitResponse(WAISInitResponse *init)
+/* free an object made with makeWAISInitResponse */
+{
+    s_free(init->ChunkMarker);
+    s_free(init->HighlightMarker);
+    s_free(init->DeHighlightMarker);
+    s_free(init->NewlineCharacters);
+    s_free(init);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeInitResponseInfo(InitResponseAPDU *init,
+			    char *buffer,
+			    long *len)
+/* write an init response object */
+{
+    unsigned long header_len = userInfoTagSize(DT_UserInformationLength,
+					       DefWAISInitResponseSize);
+    char *buf = buffer + header_len;
+    WAISInitResponse *info = (WAISInitResponse *) init->UserInformationField;
+    unsigned long size;
+
+    RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+    buf = writeNum(info->ChunkCode, DT_ChunkCode, buf, len);
+    buf = writeNum(info->ChunkIDLength, DT_ChunkIDLength, buf, len);
+    buf = writeString(info->ChunkMarker, DT_ChunkMarker, buf, len);
+    buf = writeString(info->HighlightMarker, DT_HighlightMarker, buf, len);
+    buf = writeString(info->DeHighlightMarker, DT_DeHighlightMarker, buf, len);
+    buf = writeString(info->NewlineCharacters, DT_NewlineCharacters, buf, len);
+
+    /* now write the header and size */
+    size = buf - buffer;
+    buf = writeUserInfoHeader(DT_UserInformationLength,
+			      size,
+			      header_len,
+			      buffer,
+			      len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readInitResponseInfo(void **info,
+			   char *buffer)
+/* read an init response object */
+{
+    char *buf = buffer;
+    unsigned long size;
+    unsigned long headerSize;
+    long chunkCode, chunkIDLen;
+    data_tag tag1;
+    char *chunkMarker = NULL;
+    char *highlightMarker = NULL;
+    char *deHighlightMarker = NULL;
+    char *newLineChars = NULL;
+
+    chunkCode = chunkIDLen = UNUSED;
+
+    buf = readUserInfoHeader(&tag1, &size, buf);
+    headerSize = buf - buffer;
+
+    while (buf < (buffer + size + headerSize)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_ChunkCode:
+	    buf = readNum(&chunkCode, buf);
+	    break;
+	case DT_ChunkIDLength:
+	    buf = readNum(&chunkIDLen, buf);
+	    break;
+	case DT_ChunkMarker:
+	    buf = readString(&chunkMarker, buf);
+	    break;
+	case DT_HighlightMarker:
+	    buf = readString(&highlightMarker, buf);
+	    break;
+	case DT_DeHighlightMarker:
+	    buf = readString(&deHighlightMarker, buf);
+	    break;
+	case DT_NewlineCharacters:
+	    buf = readString(&newLineChars, buf);
+	    break;
+	default:
+	    s_free(highlightMarker);
+	    s_free(deHighlightMarker);
+	    s_free(newLineChars);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    *info = (void *) makeWAISInitResponse(chunkCode, chunkIDLen, chunkMarker,
+					  highlightMarker, deHighlightMarker,
+					  newLineChars);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISSearch *makeWAISSearch(char *seedWords,
+			   DocObj **docs,
+			   char **textList,
+			   long dateFactor,
+			   char *beginDateRange,
+			   char *endDateRange,
+			   long maxDocsRetrieved)
+
+/* create a type 3 query object */
+{
+    WAISSearch *query = S_MALLOC(WAISSearch);
+
+    query->SeedWords = seedWords;	/* not copied! */
+    query->Docs = docs;		/* not copied! */
+    query->TextList = textList;	/* not copied! */
+    query->DateFactor = dateFactor;
+    query->BeginDateRange = beginDateRange;
+    query->EndDateRange = endDateRange;
+    query->MaxDocumentsRetrieved = maxDocsRetrieved;
+
+    return (query);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISSearch(WAISSearch *query)
+
+/* destroy an object made with makeWAISSearch() */
+{
+    void *ptr = NULL;
+    long i;
+
+    s_free(query->SeedWords);
+
+    if (query->Docs != NULL)
+	for (i = 0, ptr = (void *) query->Docs[i];
+	     ptr != NULL;
+	     ptr = (void *) query->Docs[++i])
+	    freeDocObj((DocObj *) ptr);
+    s_free(query->Docs);
+
+    if (query->TextList != NULL)	/* XXX revisit when textlist is fully defined */
+	for (i = 0, ptr = (void *) query->TextList[i];
+	     ptr != NULL;
+	     ptr = (void *) query->TextList[++i])
+	    s_free(ptr);
+    s_free(query->TextList);
+
+    s_free(query->BeginDateRange);
+    s_free(query->EndDateRange);
+    s_free(query);
+}
+
+/*----------------------------------------------------------------------*/
+
+DocObj *makeDocObjUsingWholeDocument(any *docID,
+				     char *type)
+
+/* construct a document object using byte chunks - only for use by
+   servers */
+{
+    DocObj *doc = S_MALLOC(DocObj);
+
+    doc->DocumentID = docID;	/* not copied! */
+    doc->Type = type;		/* not copied! */
+    doc->ChunkCode = CT_document;
+    return (doc);
+}
+
+/*----------------------------------------------------------------------*/
+
+DocObj *makeDocObjUsingLines(any *docID,
+			     char *type,
+			     long start,
+			     long end)
+
+/* construct a document object using line chunks - only for use by
+   servers */
+{
+    DocObj *doc = S_MALLOC(DocObj);
+
+    doc->ChunkCode = CT_line;
+    doc->DocumentID = docID;	/* not copied */
+    doc->Type = type;		/* not copied! */
+    doc->ChunkStart.Pos = start;
+    doc->ChunkEnd.Pos = end;
+    return (doc);
+}
+
+/*----------------------------------------------------------------------*/
+
+DocObj *makeDocObjUsingBytes(any *docID,
+			     char *type,
+			     long start,
+			     long end)
+
+/* construct a document object using byte chunks - only for use by
+   servers */
+{
+    DocObj *doc = S_MALLOC(DocObj);
+
+    doc->ChunkCode = CT_byte;
+    doc->DocumentID = docID;	/* not copied */
+    doc->Type = type;		/* not copied! */
+    doc->ChunkStart.Pos = start;
+    doc->ChunkEnd.Pos = end;
+    return (doc);
+}
+
+/*----------------------------------------------------------------------*/
+
+DocObj *makeDocObjUsingParagraphs(any *docID,
+				  char *type,
+				  any *start,
+				  any *end)
+
+/* construct a document object using byte chunks - only for use by
+   servers */
+{
+    DocObj *doc = S_MALLOC(DocObj);
+
+    doc->ChunkCode = CT_paragraph;
+    doc->DocumentID = docID;	/* not copied */
+    doc->Type = type;
+    doc->ChunkStart.ID = start;
+    doc->ChunkEnd.ID = end;
+    return (doc);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeDocObj(DocObj *doc)
+
+/* free a docObj */
+{
+    freeAny(doc->DocumentID);
+    s_free(doc->Type);
+    if (doc->ChunkCode == CT_paragraph) {
+	freeAny(doc->ChunkStart.ID);
+	freeAny(doc->ChunkEnd.ID);
+    }
+    s_free(doc);
+}
+
+/*----------------------------------------------------------------------*/
+
+static char *writeDocObj(DocObj *doc,
+			 char *buffer,
+			 long *len)
+
+/* write as little as we can about the doc obj */
+{
+    char *buf = buffer;
+
+    /* we always have to write the id, but its tag depends on if it's a chunk */
+    if (doc->ChunkCode == CT_document)
+	buf = writeAny(doc->DocumentID, DT_DocumentID, buf, len);
+    else
+	buf = writeAny(doc->DocumentID, DT_DocumentIDChunk, buf, len);
+
+    if (doc->Type != NULL)
+	buf = writeString(doc->Type, DT_TYPE, buf, len);
+
+    switch (doc->ChunkCode) {
+    case CT_document:
+	/* do nothing - there is no chunk data */
+	break;
+    case CT_byte:
+    case CT_line:
+	buf = writeNum(doc->ChunkCode, DT_ChunkCode, buf, len);
+	buf = writeNum(doc->ChunkStart.Pos, DT_ChunkStartID, buf, len);
+	buf = writeNum(doc->ChunkEnd.Pos, DT_ChunkEndID, buf, len);
+	break;
+    case CT_paragraph:
+	buf = writeNum(doc->ChunkCode, DT_ChunkCode, buf, len);
+	buf = writeAny(doc->ChunkStart.ID, DT_ChunkStartID, buf, len);
+	buf = writeAny(doc->ChunkEnd.ID, DT_ChunkEndID, buf, len);
+	break;
+    default:
+	panic("Implementation error: unknown chuck type %ld",
+	      doc->ChunkCode);
+	break;
+    }
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+static char *readDocObj(DocObj **doc,
+			char *buffer)
+
+/* read whatever we have about the new document */
+{
+    char *buf = buffer;
+    data_tag tag;
+
+    *doc = S_MALLOC(DocObj);
+
+    tag = peekTag(buf);
+    buf = readAny(&((*doc)->DocumentID), buf);
+
+    if (tag == DT_DocumentID) {
+	(*doc)->ChunkCode = CT_document;
+	tag = peekTag(buf);
+	if (tag == DT_TYPE)	/* XXX depends on DT_TYPE != what comes next */
+	    buf = readString(&((*doc)->Type), buf);
+	/* ChunkStart and ChunkEnd are undefined */
+    } else if (tag == DT_DocumentIDChunk) {
+	boolean readParagraphs = false;		/* for cleanup */
+
+	tag = peekTag(buf);
+	if (tag == DT_TYPE)	/* XXX depends on DT_TYPE != CT_FOO */
+	    buf = readString(&((*doc)->Type), buf);
+	buf = readNum(&((*doc)->ChunkCode), buf);
+	switch ((*doc)->ChunkCode) {
+	case CT_byte:
+	case CT_line:
+	    buf = readNum(&((*doc)->ChunkStart.Pos), buf);
+	    buf = readNum(&((*doc)->ChunkEnd.Pos), buf);
+	    break;
+	case CT_paragraph:
+	    buf = readAny(&((*doc)->ChunkStart.ID), buf);
+	    buf = readAny(&((*doc)->ChunkEnd.ID), buf);
+	    break;
+	default:
+	    freeAny((*doc)->DocumentID);
+	    if (readParagraphs) {
+		freeAny((*doc)->ChunkStart.ID);
+		freeAny((*doc)->ChunkEnd.ID);
+	    }
+	    s_free(doc);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    } else {
+	freeAny((*doc)->DocumentID);
+	s_free(*doc);
+	REPORT_READ_ERROR(buf);
+    }
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeSearchInfo(SearchAPDU *query,
+		      char *buffer,
+		      long *len)
+
+/* write out a WAIS query (type 1 or 3) */
+{
+    if (strcmp(query->QueryType, QT_TextRetrievalQuery) == 0) {
+	return (writeAny((any *) query->Query, DT_Query, buffer, len));
+    } else {
+	unsigned long header_len = userInfoTagSize(DT_UserInformationLength,
+						   DefWAISSearchSize);
+	char *buf = buffer + header_len;
+	WAISSearch *info = (WAISSearch *) query->Query;
+	unsigned long size;
+	long i;
+
+	RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+	buf = writeString(info->SeedWords, DT_SeedWords, buf, len);
+
+	if (info->Docs != NULL) {
+	    for (i = 0; info->Docs[i] != NULL; i++) {
+		buf = writeDocObj(info->Docs[i], buf, len);
+	    }
+	}
+
+	/* XXX text list */
+
+	buf = writeNum(info->DateFactor,
+		       DT_DateFactor,
+		       buf,
+		       len);
+	buf = writeString(info->BeginDateRange,
+			  DT_BeginDateRange,
+			  buf,
+			  len);
+	buf = writeString(info->EndDateRange,
+			  DT_EndDateRange,
+			  buf,
+			  len);
+	buf = writeNum(info->MaxDocumentsRetrieved,
+		       DT_MaxDocumentsRetrieved,
+		       buf,
+		       len);
+
+	/* now write the header and size */
+	size = buf - buffer;
+	buf = writeUserInfoHeader(DT_UserInformationLength,
+				  size,
+				  header_len,
+				  buffer,
+				  len);
+
+	return (buf);
+    }
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readSearchInfo(void **info,
+		     char *buffer)
+
+/* read a WAIS query (type 1 or 3) */
+{
+    data_tag type = peekTag(buffer);
+
+    if (type == DT_Query)	/* this is a type 1 query */
+    {
+	char *buf = buffer;
+	any *query = NULL;
+
+	buf = readAny(&query, buf);
+	*info = (void *) query;
+	return (buf);
+    } else {			/* a type 3 query */
+	char *buf = buffer;
+	unsigned long size;
+	unsigned long headerSize;
+	data_tag tag1;
+	char *seedWords = NULL;
+	char *beginDateRange = NULL;
+	char *endDateRange = NULL;
+	long dateFactor, maxDocsRetrieved;
+	char **textList = NULL;
+	DocObj **docIDs = NULL;
+	DocObj *doc = NULL;
+	long docs = 0;
+	long i;
+	void *ptr = NULL;
+
+	dateFactor = maxDocsRetrieved = UNUSED;
+
+	buf = readUserInfoHeader(&tag1, &size, buf);
+	headerSize = buf - buffer;
+
+	while (buf < (buffer + size + headerSize)) {
+	    data_tag tag = peekTag(buf);
+
+	    switch (tag) {
+	    case DT_SeedWords:
+		buf = readString(&seedWords, buf);
+		break;
+	    case DT_DocumentID:
+	    case DT_DocumentIDChunk:
+		if (docIDs == NULL)	/* create a new doc list */
+		{
+		    docIDs = S_MALLOC2(DocObj *);
+		} else {	/* grow the doc list */
+		    docIDs = S_REALLOC2(DocObj *, docIDs, docs);
+		}
+		buf = readDocObj(&doc, buf);
+		if (buf == NULL) {
+		    s_free(seedWords);
+		    s_free(beginDateRange);
+		    s_free(endDateRange);
+		    if (docIDs != NULL)
+			for (i = 0, ptr = (void *) docIDs[i];
+			     ptr != NULL;
+			     ptr = (void *) docIDs[++i])
+			    freeDocObj((DocObj *) ptr);
+		    s_free(docIDs);
+		    /* XXX should also free textlist when it is fully defined */
+		}
+		RETURN_ON_NULL(buf);
+		docIDs[docs++] = doc;	/* put it in the list */
+		docIDs[docs] = NULL;
+		break;
+	    case DT_TextList:
+		/* XXX */
+		break;
+	    case DT_DateFactor:
+		buf = readNum(&dateFactor, buf);
+		break;
+	    case DT_BeginDateRange:
+		buf = readString(&beginDateRange, buf);
+		break;
+	    case DT_EndDateRange:
+		buf = readString(&endDateRange, buf);
+		break;
+	    case DT_MaxDocumentsRetrieved:
+		buf = readNum(&maxDocsRetrieved, buf);
+		break;
+	    default:
+		s_free(seedWords);
+		s_free(beginDateRange);
+		s_free(endDateRange);
+		if (docIDs != NULL)
+		    for (i = 0, ptr = (void *) docIDs[i];
+			 ptr != NULL;
+			 ptr = (void *) docIDs[++i])
+			freeDocObj((DocObj *) ptr);
+		s_free(docIDs);
+		/* XXX should also free textlist when it is fully defined */
+		REPORT_READ_ERROR(buf);
+		break;
+	    }
+	}
+
+	*info = (void *) makeWAISSearch(seedWords, docIDs, textList,
+					dateFactor, beginDateRange, endDateRange,
+					maxDocsRetrieved);
+	return (buf);
+    }
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISDocumentHeader *makeWAISDocumentHeader(any *docID,
+					   long versionNumber,
+					   long score,
+					   long bestMatch,
+					   long docLen,
+					   long lines,
+					   char **types,
+					   char *source,
+					   char *date,
+					   char *headline,
+					   char *originCity)
+
+/* construct a standard document header, note that no fields are copied!
+   if the application needs to save these fields, it should copy them,
+   or set the field in this object to NULL before freeing it.
+ */
+{
+    WAISDocumentHeader *header = S_MALLOC(WAISDocumentHeader);
+
+    header->DocumentID = docID;
+    header->VersionNumber = versionNumber;
+    header->Score = score;
+    header->BestMatch = bestMatch;
+    header->DocumentLength = docLen;
+    header->Lines = lines;
+    header->Types = types;
+    header->Source = source;
+    header->Date = date;
+    header->Headline = headline;
+    header->OriginCity = originCity;
+
+    return (header);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISDocumentHeader(WAISDocumentHeader *header)
+{
+    freeAny(header->DocumentID);
+    doList((void **) header->Types, fs_free);	/* can't use the macro here ! */
+    s_free(header->Types);
+    s_free(header->Source);
+    s_free(header->Date);
+    s_free(header->Headline);
+    s_free(header->OriginCity);
+    s_free(header);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeWAISDocumentHeader(WAISDocumentHeader *header, char *buffer,
+			      long *len)
+{
+    unsigned long header_len = userInfoTagSize(DT_DocumentHeaderGroup,
+					       DefWAISDocHeaderSize);
+    char *buf = buffer + header_len;
+    unsigned long size1;
+
+    RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+    buf = writeAny(header->DocumentID, DT_DocumentID, buf, len);
+    buf = writeNum(header->VersionNumber, DT_VersionNumber, buf, len);
+    buf = writeNum(header->Score, DT_Score, buf, len);
+    buf = writeNum(header->BestMatch, DT_BestMatch, buf, len);
+    buf = writeNum(header->DocumentLength, DT_DocumentLength, buf, len);
+    buf = writeNum(header->Lines, DT_Lines, buf, len);
+    if (header->Types != NULL) {
+	long size;
+	char *ptr = NULL;
+	long i;
+
+	buf = writeTag(DT_TYPE_BLOCK, buf, len);
+	for (i = 0, size = 0, ptr = header->Types[i];
+	     ptr != NULL;
+	     ptr = header->Types[++i]) {
+	    long typeSize = strlen(ptr);
+
+	    size += writtenTagSize(DT_TYPE);
+	    size += writtenCompressedIntSize(typeSize);
+	    size += typeSize;
+	}
+	buf = writeCompressedInteger((unsigned long) size, buf, len);
+	for (i = 0, ptr = header->Types[i]; ptr != NULL; ptr = header->Types[++i])
+	    buf = writeString(ptr, DT_TYPE, buf, len);
+    }
+    buf = writeString(header->Source, DT_Source, buf, len);
+    buf = writeString(header->Date, DT_Date, buf, len);
+    buf = writeString(header->Headline, DT_Headline, buf, len);
+    buf = writeString(header->OriginCity, DT_OriginCity, buf, len);
+
+    /* now write the header and size */
+    size1 = buf - buffer;
+    buf = writeUserInfoHeader(DT_DocumentHeaderGroup,
+			      size1,
+			      header_len,
+			      buffer,
+			      len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readWAISDocumentHeader(WAISDocumentHeader **header, char *buffer)
+{
+    char *buf = buffer;
+    unsigned long size1;
+    unsigned long headerSize;
+    data_tag tag1;
+    any *docID = NULL;
+    long versionNumber, score, bestMatch, docLength, lines;
+    char **types = NULL;
+    char *source = NULL;
+    char *date = NULL;
+    char *headline = NULL;
+    char *originCity = NULL;
+
+    versionNumber = score = bestMatch = docLength = lines = UNUSED;
+
+    buf = readUserInfoHeader(&tag1, &size1, buf);
+    headerSize = buf - buffer;
+
+    while (buf < (buffer + size1 + headerSize)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_DocumentID:
+	    buf = readAny(&docID, buf);
+	    break;
+	case DT_VersionNumber:
+	    buf = readNum(&versionNumber, buf);
+	    break;
+	case DT_Score:
+	    buf = readNum(&score, buf);
+	    break;
+	case DT_BestMatch:
+	    buf = readNum(&bestMatch, buf);
+	    break;
+	case DT_DocumentLength:
+	    buf = readNum(&docLength, buf);
+	    break;
+	case DT_Lines:
+	    buf = readNum(&lines, buf);
+	    break;
+	case DT_TYPE_BLOCK:
+	    {
+		unsigned long size = -1;
+		long numTypes = 0;
+
+		buf = readTag(&tag, buf);
+		buf = readCompressedInteger(&size, buf);
+		while (size > 0) {
+		    char *type = NULL;
+		    char *originalBuf = buf;
+
+		    buf = readString(&type, buf);
+		    types = S_REALLOC2(char *, types, numTypes);
+
+		    types[numTypes++] = type;
+		    types[numTypes] = NULL;
+		    size -= (buf - originalBuf);
+		}
+	    }
+	    /* FALLTHRU */
+	case DT_Source:
+	    buf = readString(&source, buf);
+	    break;
+	case DT_Date:
+	    buf = readString(&date, buf);
+	    break;
+	case DT_Headline:
+	    buf = readString(&headline, buf);
+	    break;
+	case DT_OriginCity:
+	    buf = readString(&originCity, buf);
+	    break;
+	default:
+	    freeAny(docID);
+	    s_free(source);
+	    s_free(date);
+	    s_free(headline);
+	    s_free(originCity);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    *header = makeWAISDocumentHeader(docID, versionNumber, score, bestMatch,
+				     docLength, lines, types, source, date, headline,
+				     originCity);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISDocumentShortHeader *makeWAISDocumentShortHeader(any *docID,
+						     long versionNumber,
+						     long score,
+						     long bestMatch,
+						     long docLen,
+						     long lines)
+/* construct a short document header, note that no fields are copied!
+   if the application needs to save these fields, it should copy them,
+   or set the field in this object to NULL before freeing it.
+ */
+{
+    WAISDocumentShortHeader *header = S_MALLOC(WAISDocumentShortHeader);
+
+    header->DocumentID = docID;
+    header->VersionNumber = versionNumber;
+    header->Score = score;
+    header->BestMatch = bestMatch;
+    header->DocumentLength = docLen;
+    header->Lines = lines;
+
+    return (header);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISDocumentShortHeader(WAISDocumentShortHeader *header)
+{
+    freeAny(header->DocumentID);
+    s_free(header);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeWAISDocumentShortHeader(WAISDocumentShortHeader *header, char *buffer,
+				   long *len)
+{
+    unsigned long header_len = userInfoTagSize(DT_DocumentShortHeaderGroup,
+					       DefWAISShortHeaderSize);
+    char *buf = buffer + header_len;
+    unsigned long size;
+
+    RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+    buf = writeAny(header->DocumentID, DT_DocumentID, buf, len);
+    buf = writeNum(header->VersionNumber, DT_VersionNumber, buf, len);
+    buf = writeNum(header->Score, DT_Score, buf, len);
+    buf = writeNum(header->BestMatch, DT_BestMatch, buf, len);
+    buf = writeNum(header->DocumentLength, DT_DocumentLength, buf, len);
+    buf = writeNum(header->Lines, DT_Lines, buf, len);
+
+    /* now write the header and size */
+    size = buf - buffer;
+    buf = writeUserInfoHeader(DT_DocumentShortHeaderGroup,
+			      size,
+			      header_len,
+			      buffer,
+			      len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readWAISDocumentShortHeader(WAISDocumentShortHeader **header, char *buffer)
+{
+    char *buf = buffer;
+    unsigned long size;
+    unsigned long headerSize;
+    data_tag tag1;
+    any *docID = NULL;
+    long versionNumber, score, bestMatch, docLength, lines;
+
+    versionNumber = score = bestMatch = docLength = lines = UNUSED;
+
+    buf = readUserInfoHeader(&tag1, &size, buf);
+    headerSize = buf - buffer;
+
+    while (buf < (buffer + size + headerSize)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_DocumentID:
+	    buf = readAny(&docID, buf);
+	    break;
+	case DT_VersionNumber:
+	    buf = readNum(&versionNumber, buf);
+	    break;
+	case DT_Score:
+	    buf = readNum(&score, buf);
+	    break;
+	case DT_BestMatch:
+	    buf = readNum(&bestMatch, buf);
+	    break;
+	case DT_DocumentLength:
+	    buf = readNum(&docLength, buf);
+	    break;
+	case DT_Lines:
+	    buf = readNum(&lines, buf);
+	    break;
+	default:
+	    freeAny(docID);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    *header = makeWAISDocumentShortHeader(docID, versionNumber, score, bestMatch,
+					  docLength, lines);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISDocumentLongHeader *makeWAISDocumentLongHeader(any *docID,
+						   long versionNumber,
+						   long score,
+						   long bestMatch,
+						   long docLen,
+						   long lines,
+						   char **types,
+						   char *source,
+						   char *date,
+						   char *headline,
+						   char *originCity,
+						   char *stockCodes,
+						   char *companyCodes,
+						   char *industryCodes)
+/* construct a long document header, note that no fields are copied!
+   if the application needs to save these fields, it should copy them,
+   or set the field in this object to NULL before freeing it.
+ */
+{
+    WAISDocumentLongHeader *header = S_MALLOC(WAISDocumentLongHeader);
+
+    header->DocumentID = docID;
+    header->VersionNumber = versionNumber;
+    header->Score = score;
+    header->BestMatch = bestMatch;
+    header->DocumentLength = docLen;
+    header->Lines = lines;
+    header->Types = types;
+    header->Source = source;
+    header->Date = date;
+    header->Headline = headline;
+    header->OriginCity = originCity;
+    header->StockCodes = stockCodes;
+    header->CompanyCodes = companyCodes;
+    header->IndustryCodes = industryCodes;
+
+    return (header);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISDocumentLongHeader(WAISDocumentLongHeader *header)
+{
+    freeAny(header->DocumentID);
+    doList((void **) header->Types, fs_free);	/* can't use the macro here! */
+    s_free(header->Source);
+    s_free(header->Date);
+    s_free(header->Headline);
+    s_free(header->OriginCity);
+    s_free(header->StockCodes);
+    s_free(header->CompanyCodes);
+    s_free(header->IndustryCodes);
+    s_free(header);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeWAISDocumentLongHeader(WAISDocumentLongHeader *header, char *buffer,
+				  long *len)
+{
+    unsigned long header_len = userInfoTagSize(DT_DocumentLongHeaderGroup,
+					       DefWAISLongHeaderSize);
+    char *buf = buffer + header_len;
+    unsigned long size1;
+
+    RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+    buf = writeAny(header->DocumentID, DT_DocumentID, buf, len);
+    buf = writeNum(header->VersionNumber, DT_VersionNumber, buf, len);
+    buf = writeNum(header->Score, DT_Score, buf, len);
+    buf = writeNum(header->BestMatch, DT_BestMatch, buf, len);
+    buf = writeNum(header->DocumentLength, DT_DocumentLength, buf, len);
+    buf = writeNum(header->Lines, DT_Lines, buf, len);
+    if (header->Types != NULL) {
+	long size;
+	char *ptr = NULL;
+	long i;
+
+	buf = writeTag(DT_TYPE_BLOCK, buf, len);
+	for (i = 0, size = 0, ptr = header->Types[i];
+	     ptr != NULL;
+	     ptr = header->Types[++i]) {
+	    long typeSize = strlen(ptr);
+
+	    size += writtenTagSize(DT_TYPE);
+	    size += writtenCompressedIntSize(typeSize);
+	    size += typeSize;
+	}
+	buf = writeCompressedInteger((unsigned long) size, buf, len);
+	for (i = 0, ptr = header->Types[i]; ptr != NULL; ptr = header->Types[++i])
+	    buf = writeString(ptr, DT_TYPE, buf, len);
+    }
+    buf = writeString(header->Source, DT_Source, buf, len);
+    buf = writeString(header->Date, DT_Date, buf, len);
+    buf = writeString(header->Headline, DT_Headline, buf, len);
+    buf = writeString(header->OriginCity, DT_OriginCity, buf, len);
+    buf = writeString(header->StockCodes, DT_StockCodes, buf, len);
+    buf = writeString(header->CompanyCodes, DT_CompanyCodes, buf, len);
+    buf = writeString(header->IndustryCodes, DT_IndustryCodes, buf, len);
+
+    /* now write the header and size */
+    size1 = buf - buffer;
+    buf = writeUserInfoHeader(DT_DocumentLongHeaderGroup,
+			      size1,
+			      header_len,
+			      buffer,
+			      len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readWAISDocumentLongHeader(WAISDocumentLongHeader **header, char *buffer)
+{
+    char *buf = buffer;
+    unsigned long size1;
+    unsigned long headerSize;
+    data_tag tag1;
+    any *docID;
+    long versionNumber, score, bestMatch, docLength, lines;
+    char **types;
+    char *source, *date, *headline, *originCity, *stockCodes, *companyCodes, *industryCodes;
+
+    docID = NULL;
+    versionNumber =
+	score =
+	bestMatch =
+	docLength =
+	lines = UNUSED;
+    types = NULL;
+    source =
+	date =
+	headline =
+	originCity =
+	stockCodes =
+	companyCodes =
+	industryCodes = NULL;
+
+    buf = readUserInfoHeader(&tag1, &size1, buf);
+    headerSize = buf - buffer;
+
+    while (buf < (buffer + size1 + headerSize)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_DocumentID:
+	    buf = readAny(&docID, buf);
+	    break;
+	case DT_VersionNumber:
+	    buf = readNum(&versionNumber, buf);
+	    break;
+	case DT_Score:
+	    buf = readNum(&score, buf);
+	    break;
+	case DT_BestMatch:
+	    buf = readNum(&bestMatch, buf);
+	    break;
+	case DT_DocumentLength:
+	    buf = readNum(&docLength, buf);
+	    break;
+	case DT_Lines:
+	    buf = readNum(&lines, buf);
+	    break;
+	case DT_TYPE_BLOCK:
+	    {
+		unsigned long size = -1;
+		long numTypes = 0;
+
+		buf = readTag(&tag, buf);
+		readCompressedInteger(&size, buf);
+		while (size > 0) {
+		    char *type = NULL;
+		    char *originalBuf = buf;
+
+		    buf = readString(&type, buf);
+		    types = S_REALLOC2(char *, types, numTypes);
+
+		    types[numTypes++] = type;
+		    types[numTypes] = NULL;
+		    size -= (buf - originalBuf);
+		}
+	    }
+	    /* FALLTHRU */
+	case DT_Source:
+	    buf = readString(&source, buf);
+	    break;
+	case DT_Date:
+	    buf = readString(&date, buf);
+	    break;
+	case DT_Headline:
+	    buf = readString(&headline, buf);
+	    break;
+	case DT_OriginCity:
+	    buf = readString(&originCity, buf);
+	    break;
+	case DT_StockCodes:
+	    buf = readString(&stockCodes, buf);
+	    break;
+	case DT_CompanyCodes:
+	    buf = readString(&companyCodes, buf);
+	    break;
+	case DT_IndustryCodes:
+	    buf = readString(&industryCodes, buf);
+	    break;
+	default:
+	    freeAny(docID);
+	    s_free(source);
+	    s_free(date);
+	    s_free(headline);
+	    s_free(originCity);
+	    s_free(stockCodes);
+	    s_free(companyCodes);
+	    s_free(industryCodes);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    *header = makeWAISDocumentLongHeader(docID,
+					 versionNumber,
+					 score,
+					 bestMatch,
+					 docLength,
+					 lines,
+					 types,
+					 source,
+					 date,
+					 headline,
+					 originCity,
+					 stockCodes,
+					 companyCodes,
+					 industryCodes);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISSearchResponse *
+  makeWAISSearchResponse(
+			    char *seedWordsUsed,
+			    WAISDocumentHeader **docHeaders,
+			    WAISDocumentShortHeader **shortHeaders,
+			    WAISDocumentLongHeader **longHeaders,
+			    WAISDocumentText **text,
+			    WAISDocumentHeadlines **headlines,
+			    WAISDocumentCodes **codes,
+			    diagnosticRecord ** diagnostics)
+{
+    WAISSearchResponse *response = S_MALLOC(WAISSearchResponse);
+
+    response->SeedWordsUsed = seedWordsUsed;
+    response->DocHeaders = docHeaders;
+    response->ShortHeaders = shortHeaders;
+    response->LongHeaders = longHeaders;
+    response->Text = text;
+    response->Headlines = headlines;
+    response->Codes = codes;
+    response->Diagnostics = diagnostics;
+
+    return (response);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISSearchResponse(WAISSearchResponse * response)
+{
+    void *ptr = NULL;
+    long i;
+
+    s_free(response->SeedWordsUsed);
+
+    if (response->DocHeaders != NULL)
+	for (i = 0, ptr = (void *) response->DocHeaders[i];
+	     ptr != NULL;
+	     ptr = (void *) response->DocHeaders[++i])
+	    freeWAISDocumentHeader((WAISDocumentHeader *) ptr);
+    s_free(response->DocHeaders);
+
+    if (response->ShortHeaders != NULL)
+	for (i = 0, ptr = (void *) response->ShortHeaders[i];
+	     ptr != NULL;
+	     ptr = (void *) response->ShortHeaders[++i])
+	    freeWAISDocumentShortHeader((WAISDocumentShortHeader *) ptr);
+    s_free(response->ShortHeaders);
+
+    if (response->LongHeaders != NULL)
+	for (i = 0, ptr = (void *) response->LongHeaders[i];
+	     ptr != NULL;
+	     ptr = (void *) response->LongHeaders[++i])
+	    freeWAISDocumentLongHeader((WAISDocumentLongHeader *) ptr);
+    s_free(response->LongHeaders);
+
+    if (response->Text != NULL)
+	for (i = 0, ptr = (void *) response->Text[i];
+	     ptr != NULL;
+	     ptr = (void *) response->Text[++i])
+	    freeWAISDocumentText((WAISDocumentText *) ptr);
+    s_free(response->Text);
+
+    if (response->Headlines != NULL)
+	for (i = 0, ptr = (void *) response->Headlines[i];
+	     ptr != NULL;
+	     ptr = (void *) response->Headlines[++i])
+	    freeWAISDocumentHeadlines((WAISDocumentHeadlines *) ptr);
+    s_free(response->Headlines);
+
+    if (response->Codes != NULL)
+	for (i = 0, ptr = (void *) response->Codes[i];
+	     ptr != NULL;
+	     ptr = (void *) response->Codes[++i])
+	    freeWAISDocumentCodes((WAISDocumentCodes *) ptr);
+    s_free(response->Codes);
+
+    if (response->Diagnostics != NULL)
+	for (i = 0, ptr = (void *) response->Diagnostics[i];
+	     ptr != NULL;
+	     ptr = (void *) response->Diagnostics[++i])
+	    freeDiag((diagnosticRecord *) ptr);
+    s_free(response->Diagnostics);
+
+    s_free(response);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeSearchResponseInfo(SearchResponseAPDU *query,
+			      char *buffer,
+			      long *len)
+{
+    unsigned long header_len = userInfoTagSize(DT_UserInformationLength,
+					       DefWAISSearchResponseSize);
+    char *buf = buffer + header_len;
+    WAISSearchResponse *info = (WAISSearchResponse *) query->DatabaseDiagnosticRecords;
+    unsigned long size;
+    void *header = NULL;
+    long i;
+
+    RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+    buf = writeString(info->SeedWordsUsed, DT_SeedWordsUsed, buf, len);
+
+    /* write out all the headers */
+    if (info->DocHeaders != NULL) {
+	for (i = 0, header = (void *) info->DocHeaders[i];
+	     header != NULL;
+	     header = (void *) info->DocHeaders[++i])
+	    buf = writeWAISDocumentHeader((WAISDocumentHeader *) header, buf, len);
+    }
+
+    if (info->ShortHeaders != NULL) {
+	for (i = 0, header = (void *) info->ShortHeaders[i];
+	     header != NULL;
+	     header = (void *) info->ShortHeaders[++i])
+	    buf = writeWAISDocumentShortHeader((WAISDocumentShortHeader *) header,
+					       buf,
+					       len);
+    }
+
+    if (info->LongHeaders != NULL) {
+	for (i = 0, header = (void *) info->LongHeaders[i];
+	     header != NULL;
+	     header = (void *) info->LongHeaders[++i])
+	    buf = writeWAISDocumentLongHeader((WAISDocumentLongHeader *) header,
+					      buf,
+					      len);
+    }
+
+    if (info->Text != NULL) {
+	for (i = 0, header = (void *) info->Text[i];
+	     header != NULL;
+	     header = (void *) info->Text[++i])
+	    buf = writeWAISDocumentText((WAISDocumentText *) header, buf, len);
+    }
+
+    if (info->Headlines != NULL) {
+	for (i = 0, header = (void *) info->Headlines[i];
+	     header != NULL;
+	     header = (void *) info->Headlines[++i])
+	    buf = writeWAISDocumentHeadlines((WAISDocumentHeadlines *) header,
+					     buf,
+					     len);
+    }
+
+    if (info->Codes != NULL) {
+	for (i = 0, header = (void *) info->Codes[i];
+	     header != NULL;
+	     header = (void *) info->Codes[++i])
+	    buf = writeWAISDocumentCodes((WAISDocumentCodes *) header, buf, len);
+    }
+
+    if (info->Diagnostics != NULL) {
+	for (i = 0, header = (void *) info->Diagnostics[i];
+	     header != NULL;
+	     header = (void *) info->Diagnostics[++i])
+	    buf = writeDiag((diagnosticRecord *) header, buf, len);
+    }
+
+    /* now write the header and size */
+    size = buf - buffer;
+    buf = writeUserInfoHeader(DT_UserInformationLength,
+			      size,
+			      header_len,
+			      buffer,
+			      len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+static void cleanUpWaisSearchResponse(char *buf,
+				      char *seedWordsUsed,
+				      WAISDocumentHeader **docHeaders,
+				      WAISDocumentShortHeader **shortHeaders,
+				      WAISDocumentLongHeader **longHeaders,
+				      WAISDocumentText **text,
+				      WAISDocumentHeadlines **headlines,
+				      WAISDocumentCodes **codes,
+				      diagnosticRecord ** diags)
+/* if buf is NULL, we have just gotten a read error, and need to clean up
+   any state we have built.  If not, then everything is going fine, and
+   we should just hang loose
+ */
+{
+    void *ptr = NULL;
+    long i;
+
+    if (buf == NULL) {
+	s_free(seedWordsUsed);
+	if (docHeaders != NULL)
+	    for (i = 0, ptr = (void *) docHeaders[i]; ptr != NULL;
+		 ptr = (void *) docHeaders[++i])
+		freeWAISDocumentHeader((WAISDocumentHeader *) ptr);
+	s_free(docHeaders);
+	if (shortHeaders != NULL)
+	    for (i = 0, ptr = (void *) shortHeaders[i]; ptr != NULL;
+		 ptr = (void *) shortHeaders[++i])
+		freeWAISDocumentShortHeader((WAISDocumentShortHeader *) ptr);
+	s_free(shortHeaders);
+	if (longHeaders != NULL)
+	    for (i = 0, ptr = (void *) longHeaders[i]; ptr != NULL;
+		 ptr = (void *) longHeaders[++i])
+		freeWAISDocumentLongHeader((WAISDocumentLongHeader *) ptr);
+	s_free(longHeaders);
+	if (text != NULL)
+	    for (i = 0, ptr = (void *) text[i];
+		 ptr != NULL;
+		 ptr = (void *) text[++i])
+		freeWAISDocumentText((WAISDocumentText *) ptr);
+	s_free(text);
+	if (headlines != NULL)
+	    for (i = 0, ptr = (void *) headlines[i]; ptr != NULL;
+		 ptr = (void *) headlines[++i])
+		freeWAISDocumentHeadlines((WAISDocumentHeadlines *) ptr);
+	s_free(headlines);
+	if (codes != NULL)
+	    for (i = 0, ptr = (void *) codes[i]; ptr != NULL;
+		 ptr = (void *) codes[++i])
+		freeWAISDocumentCodes((WAISDocumentCodes *) ptr);
+	s_free(codes);
+	if (diags != NULL)
+	    for (i = 0, ptr = (void *) diags[i]; ptr != NULL;
+		 ptr = (void *) diags[++i])
+		freeDiag((diagnosticRecord *) ptr);
+	s_free(diags);
+    }
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readSearchResponseInfo(void **info,
+			     char *buffer)
+{
+    char *buf = buffer;
+    unsigned long size;
+    unsigned long headerSize;
+    data_tag tag1;
+    void *header = NULL;
+    WAISDocumentHeader **docHeaders = NULL;
+    WAISDocumentShortHeader **shortHeaders = NULL;
+    WAISDocumentLongHeader **longHeaders = NULL;
+    WAISDocumentText **text = NULL;
+    WAISDocumentHeadlines **headlines = NULL;
+    WAISDocumentCodes **codes = NULL;
+    long numDocHeaders, numLongHeaders, numShortHeaders, numText, numHeadlines;
+    long numCodes;
+    char *seedWordsUsed = NULL;
+    diagnosticRecord **diags = NULL;
+    diagnosticRecord *diag = NULL;
+    long numDiags = 0;
+
+    numDocHeaders =
+	numLongHeaders =
+	numShortHeaders =
+	numText =
+	numHeadlines =
+	numCodes = 0;
+
+    buf = readUserInfoHeader(&tag1, &size, buf);
+    headerSize = buf - buffer;
+
+    while (buf < (buffer + size + headerSize)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_SeedWordsUsed:
+	    buf = readString(&seedWordsUsed, buf);
+	    break;
+	case DT_DatabaseDiagnosticRecords:
+	    if (diags == NULL)	/* create a new diag list */
+	    {
+		diags = S_MALLOC2(diagnosticRecord *);
+	    } else {		/* grow the diag list */
+		diags = S_REALLOC2(diagnosticRecord *, diags, numDiags);
+	    }
+	    buf = readDiag(&diag, buf);
+	    diags[numDiags++] = diag;	/* put it in the list */
+	    diags[numDiags] = NULL;
+	    break;
+	case DT_DocumentHeaderGroup:
+	    if (docHeaders == NULL)	/* create a new header list */
+	    {
+		docHeaders = S_MALLOC2(WAISDocumentHeader *);
+	    } else {		/* grow the doc list */
+		docHeaders = S_REALLOC2(WAISDocumentHeader *, docHeaders, numDocHeaders);
+	    }
+	    buf = readWAISDocumentHeader((WAISDocumentHeader **) &header, buf);
+	    cleanUpWaisSearchResponse(buf,
+				      seedWordsUsed,
+				      docHeaders,
+				      shortHeaders,
+				      longHeaders,
+				      text,
+				      headlines,
+				      codes,
+				      diags);
+	    RETURN_ON_NULL(buf);
+	    docHeaders[numDocHeaders++] =
+		(WAISDocumentHeader *) header;	/* put it in the list */
+	    docHeaders[numDocHeaders] = NULL;
+	    break;
+	case DT_DocumentShortHeaderGroup:
+	    if (shortHeaders == NULL)	/* create a new header list */
+	    {
+		shortHeaders = S_MALLOC2(WAISDocumentShortHeader *);
+	    } else {		/* grow the doc list */
+		shortHeaders = S_REALLOC2(WAISDocumentShortHeader *,
+					  shortHeaders,
+					  numShortHeaders);
+	    }
+	    buf = readWAISDocumentShortHeader((WAISDocumentShortHeader **) &header,
+					      buf);
+	    cleanUpWaisSearchResponse(buf,
+				      seedWordsUsed,
+				      docHeaders,
+				      shortHeaders,
+				      longHeaders,
+				      text,
+				      headlines,
+				      codes,
+				      diags);
+	    RETURN_ON_NULL(buf);
+	    shortHeaders[numShortHeaders++] =
+		(WAISDocumentShortHeader *) header;	/* put it in the list */
+	    shortHeaders[numShortHeaders] = NULL;
+	    break;
+	case DT_DocumentLongHeaderGroup:
+	    if (longHeaders == NULL)	/* create a new header list */
+	    {
+		longHeaders = S_MALLOC2(WAISDocumentLongHeader *);
+	    } else {		/* grow the doc list */
+		longHeaders = S_REALLOC2(WAISDocumentLongHeader *,
+					 longHeaders,
+					 numLongHeaders);
+	    }
+	    buf = readWAISDocumentLongHeader((WAISDocumentLongHeader **) &header,
+					     buf);
+	    cleanUpWaisSearchResponse(buf,
+				      seedWordsUsed,
+				      docHeaders,
+				      shortHeaders,
+				      longHeaders,
+				      text,
+				      headlines,
+				      codes,
+				      diags);
+	    RETURN_ON_NULL(buf);
+	    longHeaders[numLongHeaders++] =
+		(WAISDocumentLongHeader *) header;	/* put it in the list */
+	    longHeaders[numLongHeaders] = NULL;
+	    break;
+	case DT_DocumentTextGroup:
+	    if (text == NULL)	/* create a new list */
+	    {
+		text = S_MALLOC2(WAISDocumentText *);
+	    } else {		/* grow the list */
+		text = S_REALLOC2(WAISDocumentText *, text, numText);
+	    }
+	    buf = readWAISDocumentText((WAISDocumentText **) &header, buf);
+	    cleanUpWaisSearchResponse(buf,
+				      seedWordsUsed,
+				      docHeaders,
+				      shortHeaders,
+				      longHeaders,
+				      text,
+				      headlines,
+				      codes,
+				      diags);
+	    RETURN_ON_NULL(buf);
+	    text[numText++] =
+		(WAISDocumentText *) header;	/* put it in the list */
+	    text[numText] = NULL;
+	    break;
+	case DT_DocumentHeadlineGroup:
+	    if (headlines == NULL)	/* create a new list */
+	    {
+		headlines = S_MALLOC2(WAISDocumentHeadlines *);
+	    } else {		/* grow the list */
+		headlines = S_REALLOC2(WAISDocumentHeadlines *, headlines, numHeadlines);
+	    }
+	    buf = readWAISDocumentHeadlines((WAISDocumentHeadlines **) &header,
+					    buf);
+	    cleanUpWaisSearchResponse(buf,
+				      seedWordsUsed,
+				      docHeaders,
+				      shortHeaders,
+				      longHeaders,
+				      text,
+				      headlines,
+				      codes,
+				      diags);
+	    RETURN_ON_NULL(buf);
+	    headlines[numHeadlines++] =
+		(WAISDocumentHeadlines *) header;	/* put it in the list */
+	    headlines[numHeadlines] = NULL;
+	    break;
+	case DT_DocumentCodeGroup:
+	    if (codes == NULL)	/* create a new list */
+	    {
+		codes = S_MALLOC2(WAISDocumentCodes *);
+	    } else {		/* grow the list */
+		codes = S_REALLOC2(WAISDocumentCodes *, codes, numCodes);
+	    }
+	    buf = readWAISDocumentCodes((WAISDocumentCodes **) &header, buf);
+	    cleanUpWaisSearchResponse(buf,
+				      seedWordsUsed,
+				      docHeaders,
+				      shortHeaders,
+				      longHeaders,
+				      text,
+				      headlines,
+				      codes,
+				      diags);
+	    RETURN_ON_NULL(buf);
+	    codes[numCodes++] =
+		(WAISDocumentCodes *) header;	/* put it in the list */
+	    codes[numCodes] = NULL;
+	    break;
+	default:
+	    cleanUpWaisSearchResponse(buf,
+				      seedWordsUsed,
+				      docHeaders,
+				      shortHeaders,
+				      longHeaders,
+				      text,
+				      headlines,
+				      codes,
+				      diags);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    *info = (void *) makeWAISSearchResponse(seedWordsUsed,
+					    docHeaders,
+					    shortHeaders,
+					    longHeaders,
+					    text,
+					    headlines,
+					    codes,
+					    diags);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISDocumentText *makeWAISDocumentText(any *docID,
+				       long versionNumber,
+				       any *documentText)
+{
+    WAISDocumentText *docText = S_MALLOC(WAISDocumentText);
+
+    docText->DocumentID = docID;
+    docText->VersionNumber = versionNumber;
+    docText->DocumentText = documentText;
+
+    return (docText);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISDocumentText(WAISDocumentText *docText)
+{
+    freeAny(docText->DocumentID);
+    freeAny(docText->DocumentText);
+    s_free(docText);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeWAISDocumentText(WAISDocumentText *docText, char *buffer,
+			    long *len)
+{
+    unsigned long header_len = userInfoTagSize(DT_DocumentTextGroup,
+					       DefWAISDocTextSize);
+    char *buf = buffer + header_len;
+    unsigned long size;
+
+    RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+    buf = writeAny(docText->DocumentID, DT_DocumentID, buf, len);
+    buf = writeNum(docText->VersionNumber, DT_VersionNumber, buf, len);
+    buf = writeAny(docText->DocumentText, DT_DocumentText, buf, len);
+
+    /* now write the header and size */
+    size = buf - buffer;
+    buf = writeUserInfoHeader(DT_DocumentTextGroup, size, header_len, buffer, len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readWAISDocumentText(WAISDocumentText **docText, char *buffer)
+{
+    char *buf = buffer;
+    unsigned long size;
+    unsigned long headerSize;
+    data_tag tag1;
+    any *docID, *documentText;
+    long versionNumber;
+
+    docID = documentText = NULL;
+    versionNumber = UNUSED;
+
+    buf = readUserInfoHeader(&tag1, &size, buf);
+    headerSize = buf - buffer;
+
+    while (buf < (buffer + size + headerSize)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_DocumentID:
+	    buf = readAny(&docID, buf);
+	    break;
+	case DT_VersionNumber:
+	    buf = readNum(&versionNumber, buf);
+	    break;
+	case DT_DocumentText:
+	    buf = readAny(&documentText, buf);
+	    break;
+	default:
+	    freeAny(docID);
+	    freeAny(documentText);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    *docText = makeWAISDocumentText(docID, versionNumber, documentText);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISDocumentHeadlines *makeWAISDocumentHeadlines(any *docID,
+						 long versionNumber,
+						 char *source,
+						 char *date,
+						 char *headline,
+						 char *originCity)
+{
+    WAISDocumentHeadlines *docHeadline = S_MALLOC(WAISDocumentHeadlines);
+
+    docHeadline->DocumentID = docID;
+    docHeadline->VersionNumber = versionNumber;
+    docHeadline->Source = source;
+    docHeadline->Date = date;
+    docHeadline->Headline = headline;
+    docHeadline->OriginCity = originCity;
+
+    return (docHeadline);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISDocumentHeadlines(WAISDocumentHeadlines *docHeadline)
+{
+    freeAny(docHeadline->DocumentID);
+    s_free(docHeadline->Source);
+    s_free(docHeadline->Date);
+    s_free(docHeadline->Headline);
+    s_free(docHeadline->OriginCity);
+    s_free(docHeadline);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeWAISDocumentHeadlines(WAISDocumentHeadlines *docHeadline, char *buffer,
+				 long *len)
+{
+    unsigned long header_len = userInfoTagSize(DT_DocumentHeadlineGroup,
+					       DefWAISDocHeadlineSize);
+    char *buf = buffer + header_len;
+    unsigned long size;
+
+    RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+    buf = writeAny(docHeadline->DocumentID, DT_DocumentID, buf, len);
+    buf = writeNum(docHeadline->VersionNumber, DT_VersionNumber, buf, len);
+    buf = writeString(docHeadline->Source, DT_Source, buf, len);
+    buf = writeString(docHeadline->Date, DT_Date, buf, len);
+    buf = writeString(docHeadline->Headline, DT_Headline, buf, len);
+    buf = writeString(docHeadline->OriginCity, DT_OriginCity, buf, len);
+
+    /* now write the header and size */
+    size = buf - buffer;
+    buf = writeUserInfoHeader(DT_DocumentHeadlineGroup,
+			      size,
+			      header_len,
+			      buffer,
+			      len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readWAISDocumentHeadlines(WAISDocumentHeadlines **docHeadline, char *buffer)
+{
+    char *buf = buffer;
+    unsigned long size;
+    unsigned long headerSize;
+    data_tag tag1;
+    any *docID;
+    long versionNumber;
+    char *source, *date, *headline, *originCity;
+
+    docID = NULL;
+    versionNumber = UNUSED;
+    source = date = headline = originCity = NULL;
+
+    buf = readUserInfoHeader(&tag1, &size, buf);
+    headerSize = buf - buffer;
+
+    while (buf < (buffer + size + headerSize)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_DocumentID:
+	    buf = readAny(&docID, buf);
+	    break;
+	case DT_VersionNumber:
+	    buf = readNum(&versionNumber, buf);
+	    break;
+	case DT_Source:
+	    buf = readString(&source, buf);
+	    break;
+	case DT_Date:
+	    buf = readString(&date, buf);
+	    break;
+	case DT_Headline:
+	    buf = readString(&headline, buf);
+	    break;
+	case DT_OriginCity:
+	    buf = readString(&originCity, buf);
+	    break;
+	default:
+	    freeAny(docID);
+	    s_free(source);
+	    s_free(date);
+	    s_free(headline);
+	    s_free(originCity);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    *docHeadline = makeWAISDocumentHeadlines(docID, versionNumber, source, date,
+					     headline, originCity);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+WAISDocumentCodes *makeWAISDocumentCodes(any *docID,
+					 long versionNumber,
+					 char *stockCodes,
+					 char *companyCodes,
+					 char *industryCodes)
+{
+    WAISDocumentCodes *docCodes = S_MALLOC(WAISDocumentCodes);
+
+    docCodes->DocumentID = docID;
+    docCodes->VersionNumber = versionNumber;
+    docCodes->StockCodes = stockCodes;
+    docCodes->CompanyCodes = companyCodes;
+    docCodes->IndustryCodes = industryCodes;
+
+    return (docCodes);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeWAISDocumentCodes(WAISDocumentCodes *docCodes)
+{
+    freeAny(docCodes->DocumentID);
+    s_free(docCodes->StockCodes);
+    s_free(docCodes->CompanyCodes);
+    s_free(docCodes->IndustryCodes);
+    s_free(docCodes);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeWAISDocumentCodes(WAISDocumentCodes *docCodes,
+			     char *buffer,
+			     long *len)
+{
+    unsigned long header_len = userInfoTagSize(DT_DocumentCodeGroup,
+					       DefWAISDocCodeSize);
+    char *buf = buffer + header_len;
+    unsigned long size;
+
+    RESERVE_SPACE_FOR_WAIS_HEADER(len);
+
+    buf = writeAny(docCodes->DocumentID, DT_DocumentID, buf, len);
+    buf = writeNum(docCodes->VersionNumber, DT_VersionNumber, buf, len);
+    buf = writeString(docCodes->StockCodes, DT_StockCodes, buf, len);
+    buf = writeString(docCodes->CompanyCodes, DT_CompanyCodes, buf, len);
+    buf = writeString(docCodes->IndustryCodes, DT_IndustryCodes, buf, len);
+
+    /* now write the header and size */
+    size = buf - buffer;
+    buf = writeUserInfoHeader(DT_DocumentCodeGroup, size, header_len, buffer, len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readWAISDocumentCodes(WAISDocumentCodes **docCodes,
+			    char *buffer)
+{
+    char *buf = buffer;
+    unsigned long size;
+    unsigned long headerSize;
+    data_tag tag1;
+    any *docID;
+    long versionNumber;
+    char *stockCodes, *companyCodes, *industryCodes;
+
+    docID = NULL;
+    versionNumber = UNUSED;
+    stockCodes = companyCodes = industryCodes = NULL;
+
+    buf = readUserInfoHeader(&tag1, &size, buf);
+    headerSize = buf - buffer;
+
+    while (buf < (buffer + size + headerSize)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_DocumentID:
+	    buf = readAny(&docID, buf);
+	    break;
+	case DT_VersionNumber:
+	    buf = readNum(&versionNumber, buf);
+	    break;
+	case DT_StockCodes:
+	    buf = readString(&stockCodes, buf);
+	    break;
+	case DT_CompanyCodes:
+	    buf = readString(&companyCodes, buf);
+	    break;
+	case DT_IndustryCodes:
+	    buf = readString(&industryCodes, buf);
+	    break;
+	default:
+	    freeAny(docID);
+	    s_free(stockCodes);
+	    s_free(companyCodes);
+	    s_free(industryCodes);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    *docCodes = makeWAISDocumentCodes(docID, versionNumber, stockCodes,
+				      companyCodes, industryCodes);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writePresentInfo(PresentAPDU * present GCC_UNUSED, char *buffer,
+		       long *len GCC_UNUSED)
+{
+    /* The WAIS protocol doesn't use present info */
+    return (buffer);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readPresentInfo(void **info,
+		      char *buffer)
+{
+    /* The WAIS protocol doesn't use present info */
+    *info = NULL;
+    return (buffer);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writePresentResponseInfo(PresentResponseAPDU * response GCC_UNUSED, char *buffer,
+			       long *len GCC_UNUSED)
+{
+    /* The WAIS protocol doesn't use presentResponse info */
+    return (buffer);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readPresentResponseInfo(void **info,
+			      char *buffer)
+{
+    /* The WAIS protocol doesn't use presentResponse info */
+    *info = NULL;
+    return (buffer);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* support for type 1 queries */
+
+/* new use values (for the chunk types) */
+#define	BYTE		"wb"
+#define	LINE		"wl"
+#define	PARAGRAPH	"wp"
+#define DATA_TYPE	"wt"
+
+/* WAIS supports the following semantics for type 1 queries:
+
+     1.  retrieve the header/codes from a document:
+
+	    System_Control_Number = docID
+	    Data Type = type (optional)
+	    And
+
+     2.  retrieve a fragment of the text of a document:
+
+	    System_Control_Number = docID
+	    Data Type = type (optional)
+	    And
+		Chunk >= start
+		And
+		Chunk < end
+		And
+
+		Information from multiple documents may be requested by using
+		groups of the above joined by:
+
+	    OR
+
+		( XXX does an OR come after every group but the first, or do they
+	      all come at the end? )
+
+	( XXX return type could be in the element set)
+*/
+
+static query_term **makeWAISQueryTerms(DocObj **docs)
+/* given a null terminated list of docObjs, construct the appropriate
+   query of the form given above
+ */
+{
+    query_term **terms = NULL;
+    long numTerms = 0;
+    DocObj *doc = NULL;
+    long i;
+
+    if (docs == NULL)
+	return ((query_term **) NULL);
+
+    terms = (query_term **) s_malloc((size_t) (sizeof(query_term *) * 1));
+
+    terms[numTerms] = NULL;
+
+    /* loop through the docs making terms for them all */
+    for (i = 0, doc = docs[i]; doc != NULL; doc = docs[++i]) {
+	any *type = NULL;
+
+	if (doc->Type != NULL)
+	    type = stringToAny(doc->Type);
+
+	if (doc->ChunkCode == CT_document)	/* a whole document */
+	{
+	    terms = S_REALLOC2(query_term *, terms, numTerms + 2);
+
+	    terms[numTerms++] = makeAttributeTerm(SYSTEM_CONTROL_NUMBER,
+						  EQUAL, IGNORE, IGNORE,
+						  IGNORE, IGNORE, doc->DocumentID);
+	    if (type != NULL) {
+		terms[numTerms++] = makeAttributeTerm(DATA_TYPE, EQUAL,
+						      IGNORE, IGNORE, IGNORE,
+						      IGNORE, type);
+		terms[numTerms++] = makeOperatorTerm(AND);
+	    }
+	    terms[numTerms] = NULL;
+	} else {		/* a document fragment */
+	    char chunk_att[ATTRIBUTE_SIZE];
+	    any *startChunk = NULL;
+	    any *endChunk = NULL;
+
+	    terms = S_REALLOC2(query_term *, terms, numTerms + 6);
+
+	    switch (doc->ChunkCode) {
+	    case CT_byte:
+	    case CT_line:
+		{
+		    char start[20], end[20];
+
+		    (doc->ChunkCode == CT_byte) ?
+			StrNCpy(chunk_att, BYTE, ATTRIBUTE_SIZE) :
+			StrNCpy(chunk_att, LINE, ATTRIBUTE_SIZE);
+		    sprintf(start, "%ld", doc->ChunkStart.Pos);
+		    startChunk = stringToAny(start);
+		    sprintf(end, "%ld", doc->ChunkEnd.Pos);
+		    endChunk = stringToAny(end);
+		}
+		break;
+	    case CT_paragraph:
+		StrNCpy(chunk_att, PARAGRAPH, ATTRIBUTE_SIZE);
+		startChunk = doc->ChunkStart.ID;
+		endChunk = doc->ChunkEnd.ID;
+		break;
+	    default:
+		/* error */
+		break;
+	    }
+
+	    terms[numTerms++] = makeAttributeTerm(SYSTEM_CONTROL_NUMBER,
+						  EQUAL, IGNORE, IGNORE,
+						  IGNORE,
+						  IGNORE, doc->DocumentID);
+	    if (type != NULL) {
+		terms[numTerms++] = makeAttributeTerm(DATA_TYPE, EQUAL, IGNORE,
+						      IGNORE, IGNORE, IGNORE,
+						      type);
+		terms[numTerms++] = makeOperatorTerm(AND);
+	    }
+	    terms[numTerms++] = makeAttributeTerm(chunk_att,
+						  GREATER_THAN_OR_EQUAL,
+						  IGNORE, IGNORE, IGNORE,
+						  IGNORE,
+						  startChunk);
+	    terms[numTerms++] = makeOperatorTerm(AND);
+	    terms[numTerms++] = makeAttributeTerm(chunk_att, LESS_THAN,
+						  IGNORE, IGNORE, IGNORE,
+						  IGNORE,
+						  endChunk);
+	    terms[numTerms++] = makeOperatorTerm(AND);
+	    terms[numTerms] = NULL;
+
+	    if (doc->ChunkCode == CT_byte || doc->ChunkCode == CT_line) {
+		freeAny(startChunk);
+		freeAny(endChunk);
+	    }
+	}
+
+	freeAny(type);
+
+	if (i != 0)		/* multiple independent queries, need a disjunction */
+	{
+	    terms = S_REALLOC2(query_term *, terms, numTerms);
+
+	    terms[numTerms++] = makeOperatorTerm(OR);
+	    terms[numTerms] = NULL;
+	}
+    }
+
+    return (terms);
+}
+
+/*----------------------------------------------------------------------*/
+
+static DocObj **makeWAISQueryDocs(query_term **terms)
+/* given a list of terms in the form given above, convert them to
+   DocObjs.
+ */
+{
+    query_term *docTerm = NULL;
+    query_term *fragmentTerm = NULL;
+    DocObj **docs = NULL;
+    DocObj *doc = NULL;
+    long docNum, termNum;
+
+    docNum = termNum = 0;
+
+    docs = S_MALLOC(DocObj *);
+
+    docs[docNum] = NULL;
+
+    /* translate the terms into DocObjs */
+    while (true) {
+	query_term *typeTerm = NULL;
+	char *type = NULL;
+	long startTermOffset;
+
+	docTerm = terms[termNum];
+
+	if (docTerm == NULL)
+	    break;		/* we're done converting */
+
+	typeTerm = terms[termNum + 1];	/* get the lead Term if it exists */
+
+	if (strcmp(typeTerm->Use, DATA_TYPE) == 0)	/* we do have a type */
+	{
+	    startTermOffset = 3;
+	    type = anyToString(typeTerm->Term);
+	} else {		/* no type */
+	    startTermOffset = 1;
+	    typeTerm = NULL;
+	    type = NULL;
+	}
+
+	/* grow the doc list */
+	docs = S_REALLOC2(DocObj *, docs, docNum);
+
+	/* figure out what kind of docObj to build - and build it */
+	fragmentTerm = terms[termNum + startTermOffset];
+	if (fragmentTerm != NULL && fragmentTerm->TermType == TT_Attribute) {	/* build a document fragment */
+	    query_term *startTerm = fragmentTerm;
+	    query_term *endTerm = terms[termNum + startTermOffset + 2];
+
+	    if (strcmp(startTerm->Use, BYTE) == 0) {	/* a byte chunk */
+		doc = makeDocObjUsingBytes(duplicateAny(docTerm->Term),
+					   type,
+					   anyToLong(startTerm->Term),
+					   anyToLong(endTerm->Term));
+		log_write("byte");
+	    } else if (strcmp(startTerm->Use, LINE) == 0) {	/* a line chunk */
+		doc = makeDocObjUsingLines(duplicateAny(docTerm->Term),
+					   type,
+					   anyToLong(startTerm->Term),
+					   anyToLong(endTerm->Term));
+		log_write("line");
+	    } else {
+		log_write("chunk");	/* a paragraph chunk */
+		doc = makeDocObjUsingParagraphs(duplicateAny(docTerm->Term),
+						type,
+						duplicateAny(startTerm->Term),
+						duplicateAny(endTerm->Term));
+	    }
+	    termNum += (startTermOffset + 4);	/* point to next term */
+	} else {		/* build a full document */
+	    doc = makeDocObjUsingWholeDocument(duplicateAny(docTerm->Term),
+					       type);
+	    log_write("whole doc");
+	    termNum += startTermOffset;		/* point to next term */
+	}
+
+	docs[docNum++] = doc;	/* insert the new document */
+
+	docs[docNum] = NULL;	/* keep the doc list terminated */
+
+	if (terms[termNum] != NULL)
+	    termNum++;		/* skip the OR operator it necessary */
+	else
+	    break;		/* we are done */
+    }
+
+    return (docs);
+}
+
+/*----------------------------------------------------------------------*/
+
+any *makeWAISTextQuery(DocObj **docs)
+/* given a list of DocObjs, return an any whose contents is the corresponding
+   type 1 query
+ */
+{
+    any *buf = NULL;
+    query_term **terms = NULL;
+
+    terms = makeWAISQueryTerms(docs);
+    buf = writeQuery(terms);
+
+    doList((void **) terms, freeTerm);
+    s_free(terms);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+DocObj **readWAISTextQuery(any *buf)
+/* given an any whose contents are type 1 queries of the WAIS sort,
+   construct a list of the corresponding DocObjs
+ */
+{
+    query_term **terms = NULL;
+    DocObj **docs = NULL;
+
+    terms = readQuery(buf);
+    docs = makeWAISQueryDocs(terms);
+
+    doList((void **) terms, freeTerm);
+    s_free(terms);
+
+    return (docs);
+}
+
+/*----------------------------------------------------------------------*/
+/* Customized free WAIS object routines:                                */
+/*                                                                      */
+/*   This set of procedures is for applications to free a WAIS object   */
+/*   which was made with makeWAISFOO.                                   */
+/*   Each procedure frees only the memory that was allocated in its     */
+/*   associated makeWAISFOO routine, thus it's not necessary for the    */
+/*   caller to assign nulls to the pointer fields of the WAIS object.  */
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISInitResponse(WAISInitResponse *init)
+/* free an object made with makeWAISInitResponse */
+{
+    s_free(init);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISSearch(WAISSearch *query)
+/* destroy an object made with makeWAISSearch() */
+{
+    s_free(query);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeDocObj(DocObj *doc)
+/* free a docObj */
+{
+    s_free(doc);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISDocumentHeader(WAISDocumentHeader *header)
+{
+    s_free(header);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISDocumentShortHeader(WAISDocumentShortHeader *header)
+{
+    s_free(header);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISDocumentLongHeader(WAISDocumentLongHeader *header)
+{
+    s_free(header);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISSearchResponse(WAISSearchResponse * response)
+{
+    s_free(response);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISDocumentText(WAISDocumentText *docText)
+{
+    s_free(docText);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISDocHeadlines(WAISDocumentHeadlines *docHeadline)
+{
+    s_free(docHeadline);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISDocumentCodes(WAISDocumentCodes *docCodes)
+{
+    s_free(docCodes);
+}
+
+/*----------------------------------------------------------------------*/
+
+void CSTFreeWAISTextQuery(any *query)
+{
+    freeAny(query);
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from WMessage.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ * 3.26.90
+ */
+
+/* This file is for reading and writing the wais packet header.
+ * Morris@think.com
+ */
+
+/* to do:
+ *  add check sum
+ *  what do you do when checksum is wrong?
+ */
+
+/*---------------------------------------------------------------------*/
+
+void readWAISPacketHeader(char *msgBuffer,
+			  WAISMessage * header_struct)
+{
+    /* msgBuffer is a string containing at least HEADER_LENGTH bytes. */
+
+    memmove(header_struct->msg_len, msgBuffer, (size_t) 10);
+    header_struct->msg_type = char_downcase((unsigned long) msgBuffer[10]);
+    header_struct->hdr_vers = char_downcase((unsigned long) msgBuffer[11]);
+    memmove(header_struct->server, (void *) (msgBuffer + 12), (size_t) 10);
+    header_struct->compression = char_downcase((unsigned long) msgBuffer[22]);
+    header_struct->encoding = char_downcase((unsigned long) msgBuffer[23]);
+    header_struct->msg_checksum = char_downcase((unsigned long) msgBuffer[24]);
+}
+
+/*---------------------------------------------------------------------*/
+
+/* this modifies the header argument.  See wais-message.h for the different
+ * options for the arguments.
+ */
+
+void writeWAISPacketHeader(char *header,
+			   long dataLen,
+			   long type,
+			   char *server,
+			   long compression,
+			   long encoding,
+			   long version)
+/* Puts together the new wais before-the-z39-packet header. */
+{
+    char lengthBuf[11];
+    char serverBuf[11];
+
+    long serverLen = strlen(server);
+
+    if (serverLen > 10)
+	serverLen = 10;
+
+    sprintf(lengthBuf, "%010ld", dataLen);
+    StrNCpy(header, lengthBuf, 10);
+
+    header[10] = type & 0xFF;
+    header[11] = version & 0xFF;
+
+    StrNCpy(serverBuf, server, serverLen);
+    StrNCpy((char *) (header + 12), serverBuf, serverLen);
+
+    header[22] = compression & 0xFF;
+    header[23] = encoding & 0xFF;
+    header[24] = '0';		/* checkSum(header + HEADER_LENGTH,dataLen);   XXX the result must be ascii */
+}
+
+/*---------------------------------------------------------------------*/
diff --git a/WWW/Library/Implementation/HTVMS_WaisProt.h b/WWW/Library/Implementation/HTVMS_WaisProt.h
new file mode 100644
index 0000000..cea2a32
--- /dev/null
+++ b/WWW/Library/Implementation/HTVMS_WaisProt.h
@@ -0,0 +1,425 @@
+/*							HTVMS_WAISProt.h
+ *
+ *	Adaptation for Lynx by F.Macrides (macrides@sci.wfeb.edu)
+ *
+ *	31-May-1994 FM	Initial version.
+ *
+ *----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from WProt.h -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE:
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ *
+ *  3.26.90	Harry Morris, morris@think.com
+ *  3.30.90  Harry Morris
+ *			-	removed chunk code from WAISSearchAPDU,
+ *			-	added makeWAISQueryType1Query() and readWAISType1Query() which
+ *				replace makeWAISQueryTerms() and makeWAISQueryDocs().
+ *  4.11.90  HWM - added definitions of wais element set names
+ *  4.14.90  HWM - changed symbol for relevance feedback query from QT_3 to
+ *				  QT_RelevanceFeedbackQuery added QT_TextRetrievalQuery as a
+ *				  synonym for QT_BooleanQuery
+ *				- renamed makeWAISType1Query() to makeWAISTextQuery()
+ *				  renamed readWAISType1Query() to readWAISTextQuery()
+ *  5.29.90  TS - added CSTFreeWAISFoo functions
+ */
+
+#ifndef _H_WAIS_protocol_
+#define _H_WAIS_protocol_
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#include <HTVMS_WaisUI.h>
+
+/*----------------------------------------------------------------------*/
+/* Data types / constants */
+
+/* date factor constants */
+#define	DF_INDEPENDENT		1
+#define DF_LATER		2
+#define DF_EARLIER		3
+#define DF_SPECIFIED_RANGE	4
+
+/* chunk types */
+#define CT_document		0
+#define CT_byte			1
+#define CT_line			2
+#define CT_paragraph	3
+
+/* relevance feedback query */
+#define QT_RelevanceFeedbackQuery	"3"
+#define QT_TextRetrievalQuery		QT_BooleanQuery
+
+/* new data tags */
+#define DT_UserInformationLength	(data_tag)99
+#define	DT_ChunkCode			(data_tag)100
+#define	DT_ChunkIDLength		(data_tag)101
+#define	DT_ChunkMarker			(data_tag)102
+#define	DT_HighlightMarker		(data_tag)103
+#define	DT_DeHighlightMarker		(data_tag)104
+#define	DT_NewlineCharacters		(data_tag)105
+#define	DT_SeedWords			(data_tag)106
+#define	DT_DocumentIDChunk		(data_tag)107
+#define	DT_ChunkStartID			(data_tag)108
+#define	DT_ChunkEndID			(data_tag)109
+#define	DT_TextList			(data_tag)110
+#define	DT_DateFactor			(data_tag)111
+#define	DT_BeginDateRange		(data_tag)112
+#define	DT_EndDateRange			(data_tag)113
+#define	DT_MaxDocumentsRetrieved	(data_tag)114
+#define	DT_SeedWordsUsed		(data_tag)115
+#define	DT_DocumentID			(data_tag)116
+#define	DT_VersionNumber		(data_tag)117
+#define	DT_Score			(data_tag)118
+#define	DT_BestMatch			(data_tag)119
+#define	DT_DocumentLength		(data_tag)120
+#define	DT_Source			(data_tag)121
+#define	DT_Date				(data_tag)122
+#define	DT_Headline			(data_tag)123
+#define	DT_OriginCity			(data_tag)124
+#define	DT_PresentStartByte		(data_tag)125
+#define	DT_TextLength			(data_tag)126
+#define	DT_DocumentText			(data_tag)127
+#define	DT_StockCodes			(data_tag)128
+#define	DT_CompanyCodes			(data_tag)129
+#define	DT_IndustryCodes		(data_tag)130
+
+/* added by harry */
+#define DT_DocumentHeaderGroup		(data_tag)150
+#define DT_DocumentShortHeaderGroup	(data_tag)151
+#define DT_DocumentLongHeaderGroup	(data_tag)152
+#define DT_DocumentTextGroup		(data_tag)153
+#define DT_DocumentHeadlineGroup	(data_tag)154
+#define DT_DocumentCodeGroup		(data_tag)155
+#define DT_Lines			(data_tag)131
+#define	DT_TYPE_BLOCK			(data_tag)132
+#define DT_TYPE				(data_tag)133
+
+/* wais element sets */
+#define ES_DocumentHeader		"Document Header"
+#define ES_DocumentShortHeader		"Document Short Header"
+#define ES_DocumentLongHeader		"Document Long Header"
+#define ES_DocumentText			"Document Text"
+#define ES_DocumentHeadline		"Document Headline"
+#define ES_DocumentCodes		"Document Codes"
+
+typedef struct DocObj {		/* specifies a section of a document */
+    any *DocumentID;
+    char *Type;
+    long ChunkCode;
+    union {
+	long Pos;
+	any *ID;
+    } ChunkStart;
+    union {
+	long Pos;
+	any *ID;
+    } ChunkEnd;
+} DocObj;
+
+/*----------------------------------------------------------------------*/
+/* WAIS APDU extensions */
+
+typedef struct WAISInitResponse {
+    long ChunkCode;
+    long ChunkIDLength;
+    char *ChunkMarker;
+    char *HighlightMarker;
+    char *DeHighlightMarker;
+    char *NewlineCharacters;
+    /* XXX  need to add UpdateFrequency and Update Time */
+} WAISInitResponse;
+
+typedef struct WAISSearch {
+    char *SeedWords;
+    DocObj **Docs;
+    char **TextList;
+    long DateFactor;
+    char *BeginDateRange;
+    char *EndDateRange;
+    long MaxDocumentsRetrieved;
+} WAISSearch;
+
+typedef struct WAISDocumentHeader {
+    any *DocumentID;
+    long VersionNumber;
+    long Score;
+    long BestMatch;
+    long DocumentLength;
+    long Lines;
+    char **Types;
+    char *Source;
+    char *Date;
+    char *Headline;
+    char *OriginCity;
+} WAISDocumentHeader;
+
+typedef struct WAISDocumentShortHeader {
+    any *DocumentID;
+    long VersionNumber;
+    long Score;
+    long BestMatch;
+    long DocumentLength;
+    long Lines;
+} WAISDocumentShortHeader;
+
+typedef struct WAISDocumentLongHeader {
+    any *DocumentID;
+    long VersionNumber;
+    long Score;
+    long BestMatch;
+    long DocumentLength;
+    long Lines;
+    char **Types;
+    char *Source;
+    char *Date;
+    char *Headline;
+    char *OriginCity;
+    char *StockCodes;
+    char *CompanyCodes;
+    char *IndustryCodes;
+} WAISDocumentLongHeader;
+
+typedef struct WAISDocumentText {
+    any *DocumentID;
+    long VersionNumber;
+    any *DocumentText;
+} WAISDocumentText;
+
+typedef struct WAISDocumentHeadlines {
+    any *DocumentID;
+    long VersionNumber;
+    char *Source;
+    char *Date;
+    char *Headline;
+    char *OriginCity;
+} WAISDocumentHeadlines;
+
+typedef struct WAISDocumentCodes {
+    any *DocumentID;
+    long VersionNumber;
+    char *StockCodes;
+    char *CompanyCodes;
+    char *IndustryCodes;
+} WAISDocumentCodes;
+
+typedef struct WAISSearchResponse {
+    char *SeedWordsUsed;
+    WAISDocumentHeader **DocHeaders;
+    WAISDocumentShortHeader **ShortHeaders;
+    WAISDocumentLongHeader **LongHeaders;
+    WAISDocumentText **Text;
+    WAISDocumentHeadlines **Headlines;
+    WAISDocumentCodes **Codes;
+    diagnosticRecord **Diagnostics;
+} WAISSearchResponse;
+
+/*----------------------------------------------------------------------*/
+/* Functions */
+
+char *generate_search_apdu(char *buff,	/* buffer to hold the apdu */
+			   long *buff_len,	/* number of bytes written to the buffer */
+			   char *seed_words,	/* string of the seed words */
+			   char *database_name,
+			   DocObj **docobjs,
+			   long maxDocsRetrieved);
+
+DocObj *makeDocObjUsingWholeDocument(any *aDocID, char *type);
+DocObj *makeDocObjUsingBytes(any *aDocID, char *type, long start, long end);
+DocObj *makeDocObjUsingLines(any *aDocID, char *type, long start, long end);
+DocObj *makeDocObjUsingParagraphs(any *aDocID, char *type, any *start, any *end);
+void freeDocObj(DocObj *doc);
+
+WAISInitResponse *makeWAISInitResponse(long chunkCode, long chunkIDLen,
+				       char *chunkMarker, char *highlightMarker,
+				       char *deHighlightMarker, char *newLineChars);
+void freeWAISInitResponse(WAISInitResponse *init);
+
+WAISSearch *makeWAISSearch(char *seedWords,
+			   DocObj **docs,
+			   char **textList,
+			   long dateFactor,
+			   char *beginDateRange,
+			   char *endDateRange,
+			   long maxDocsRetrieved);
+void freeWAISSearch(WAISSearch *query);
+
+WAISDocumentHeader *makeWAISDocumentHeader(any *aDocID,
+					   long versionNumber,
+					   long score,
+					   long bestMatch,
+					   long docLen,
+					   long lines,
+					   char **types,
+					   char *source,
+					   char *date,
+					   char *headline,
+					   char *originCity);
+void freeWAISDocumentHeader(WAISDocumentHeader *header);
+char *writeWAISDocumentHeader(WAISDocumentHeader *header, char *buffer, long *len);
+char *readWAISDocumentHeader(WAISDocumentHeader **header, char *buffer);
+
+WAISDocumentShortHeader *makeWAISDocumentShortHeader(any *aDocID,
+						     long versionNumber,
+						     long score,
+						     long bestMatch,
+						     long docLen,
+						     long lines);
+void freeWAISDocumentShortHeader(WAISDocumentShortHeader *header);
+char *writeWAISDocumentShortHeader(WAISDocumentShortHeader *header,
+				   char *buffer, long *len);
+char *readWAISDocumentShortHeader(WAISDocumentShortHeader **header, char *buffer);
+
+WAISDocumentLongHeader *makeWAISDocumentLongHeader(any *aDocID,
+						   long versionNumber,
+						   long score,
+						   long bestMatch,
+						   long docLen,
+						   long lines,
+						   char **types,
+						   char *source,
+						   char *date, char *headline,
+						   char *originCity,
+						   char *stockCodes,
+						   char *companyCodes,
+						   char *industryCodes);
+void freeWAISDocumentLongHeader(WAISDocumentLongHeader *header);
+char *writeWAISDocumentLongHeader(WAISDocumentLongHeader *header,
+				  char *buffer,
+				  long *len);
+char *readWAISDocumentLongHeader(WAISDocumentLongHeader **header, char *buffer);
+
+WAISSearchResponse *makeWAISSearchResponse(char *seedWordsUsed,
+					   WAISDocumentHeader **docHeaders,
+					   WAISDocumentShortHeader **shortHeaders,
+					   WAISDocumentLongHeader **longHeaders,
+					   WAISDocumentText **text, WAISDocumentHeadlines **headlines,
+					   WAISDocumentCodes **codes,
+					   diagnosticRecord ** diagnostics);
+void freeWAISSearchResponse(WAISSearchResponse * response);
+
+WAISDocumentText *makeWAISDocumentText(any *aDocID, long versionNumber,
+				       any *documentText);
+void freeWAISDocumentText(WAISDocumentText *docText);
+char *writeWAISDocumentText(WAISDocumentText *docText, char *buffer, long *len);
+char *readWAISDocumentText(WAISDocumentText **docText, char *buffer);
+
+WAISDocumentHeadlines *makeWAISDocumentHeadlines(any *aDocID,
+						 long versionNumber,
+						 char *source,
+						 char *date,
+						 char *headline,
+						 char *originCity);
+void freeWAISDocumentHeadlines(WAISDocumentHeadlines *docHeadline);
+char *writeWAISDocumentHeadlines(WAISDocumentHeadlines *docHeadline,
+				 char *buffer,
+				 long *len);
+char *readWAISDocumentHeadlines(WAISDocumentHeadlines **docHeadline, char *buffer);
+
+WAISDocumentCodes *makeWAISDocumentCodes(any *aDocID,
+					 long versionNumber,
+					 char *stockCodes,
+					 char *companyCodes,
+					 char *industryCodes);
+void freeWAISDocumentCodes(WAISDocumentCodes *docCodes);
+char *writeWAISDocumentCodes(WAISDocumentCodes *docCodes, char *buffer, long *len);
+char *readWAISDocumentCodes(WAISDocumentCodes **docCodes, char *buffer);
+
+any *makeWAISTextQuery(DocObj **docs);
+DocObj **readWAISTextQuery(any *terms);
+
+void CSTFreeWAISInitResponse(WAISInitResponse *init);
+void CSTFreeWAISSearch(WAISSearch *query);
+void CSTFreeDocObj(DocObj *doc);
+void CSTFreeWAISDocumentHeader(WAISDocumentHeader *header);
+void CSTFreeWAISDocumentShortHeader(WAISDocumentShortHeader *header);
+void CSTFreeWAISDocumentLongHeader(WAISDocumentLongHeader *header);
+void CSTFreeWAISSearchResponse(WAISSearchResponse * response);
+void CSTFreeWAISDocumentText(WAISDocumentText *docText);
+void CSTFreeWAISDocHeadlines(WAISDocumentHeadlines *docHeadline);
+void CSTFreeWAISDocumentCodes(WAISDocumentCodes *docCodes);
+void CSTFreeWAISTextQuery(any *query);
+
+/*----------------------------------------------------------------------*/
+
+#endif /* ndef _H_WAIS_protocol_ */
+
+/*
+ *	Routines originally from WMessage.h -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ * 3.26.90
+ */
+
+/* wais-message.h
+ *
+ * This is the header outside of WAIS Z39.50 messages.  The header will be
+ * printable ascii, so as to be transportable.  This header will precede each
+ * Z39.50 APDU, or zero-length message if it is an ACK or NACK.  Be sure to
+ * change hdr_vers current value if you change the structure of the header.
+ *
+ * The characters in the header are case insensitive so that the systems from
+ * the past that only handle one case can at least read the header.
+ *
+ * 7.5.90 HWM - added constants
+ * 7/5/90 brewster added function prototypes and comments
+ * 11/30/90 HWM - went to version 2 (inits and typed retrieval)
+ */
+
+#ifndef WMESSAGE_H
+#define WMESSAGE_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#include <HTVMS_WaisUI.h>
+
+typedef struct wais_header {
+    char msg_len[10];		/* length in bytes of following message */
+    char msg_type;		/* type of message: 'z'=Z39.50 APDU,
+				   'a'=ACK, 'n'=NACK */
+    char hdr_vers;		/* version of this header, currently = '2' */
+    char server[10];		/* name or address of server */
+    char compression;		/* <sp>=no compression, 'u'=unix compress */
+    char encoding;		/* <sp>=no encoding, 'h'=hexize,
+				   'u'=uuencode */
+    char msg_checksum;		/* XOR of every byte of message */
+} WAISMessage;
+
+#define HEADER_LENGTH	25	/* number of bytes needed to write a
+				   wais-header (not sizeof(wais_header)) */
+
+#define HEADER_VERSION	(long)'2'
+
+/* message type */
+#define Z3950			'z'
+#define ACK			'a'
+#define	NAK			'n'
+
+/* compression */
+#define NO_COMPRESSION		' '
+#define UNIX_COMPRESSION	'u'
+
+/* encoding */
+#define NO_ENCODING		' '
+#define HEX_ENCODING		'h'	/* Swartz 4/3 encoding */
+#define IBM_HEXCODING		'i'	/* same as h but uses characters acceptable for IBM mainframes */
+#define UUENCODE		'u'
+
+void readWAISPacketHeader(char *msgBuffer, WAISMessage * header_struct);
+long getWAISPacketLength(WAISMessage * header);
+void writeWAISPacketHeader(char *header, long dataLen, long type,
+			   char *server, long compression,
+			   long encoding, long version);
+
+#endif /* ndef WMESSAGE_H */
diff --git a/WWW/Library/Implementation/HTVMS_WaisUI.c b/WWW/Library/Implementation/HTVMS_WaisUI.c
new file mode 100644
index 0000000..716bbbb
--- /dev/null
+++ b/WWW/Library/Implementation/HTVMS_WaisUI.c
@@ -0,0 +1,2279 @@
+/*
+ * $LynxId: HTVMS_WaisUI.c,v 1.21 2020/01/21 22:00:50 tom Exp $
+ *								HTVMS_WAISUI.c
+ *
+ *	Adaptation for Lynx by F.Macrides (macrides@sci.wfeb.edu)
+ *
+ *	30-May-1994 FM	Initial version.
+ *
+ *----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from UI.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE:
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ *
+ * Brewster@think.com
+ */
+
+/*
+ * this is a simple ui toolkit for building other ui's on top.
+ * -brewster
+ *
+ * top level functions:
+ *   generate_search_apdu
+ *   generate_retrieval_apdu
+ *   interpret_message
+ *
+ */
+
+/* to do:
+ *   generate multiple queries for long documents.
+ *     this will crash if the file being retrieved is larger than 100k.
+ *   do log_write()
+ *
+ */
+
+#include <HTUtils.h>
+
+#ifdef VMS
+#include <HTVMS_WaisUI.h>
+#include <HTVMS_WaisProt.h>
+#include <HTTCP.h>
+
+#undef MAXINT			/* we don't need it here, and www_tcp.h may conflict */
+#include <math.h>
+
+#include <LYexit.h>
+#include <LYLeaks.h>
+
+void log_write(char *s GCC_UNUSED)
+{
+    return;
+}
+
+/*----------------------------------------------------------------------*/
+
+/* returns a pointer in the buffer of the first free byte.
+   if it overflows, then NULL is returned
+ */
+char *generate_search_apdu(char *buff,	/* buffer to hold the apdu */
+			   long *buff_len,	/* length of the buffer changed to reflect new data written */
+			   char *seed_words,	/* string of the seed words */
+			   char *database_name,
+			   DocObj **docobjs,
+			   long maxDocsRetrieved)
+{
+    /* local variables */
+
+    SearchAPDU *search3;
+    char *end_ptr;
+    static char *database_names[2] =
+    {"", 0};
+    any refID;
+    WAISSearch *query;
+
+    refID.size = 1;
+    refID.bytes = "3";
+
+    database_names[0] = database_name;
+    query = makeWAISSearch(seed_words,
+			   docobjs,	/* DocObjsPtr */
+			   0,
+			   1,	/* DateFactor */
+			   0,	/* BeginDateRange */
+			   0,	/* EndDateRange */
+			   maxDocsRetrieved
+	);
+
+    search3 = makeSearchAPDU(30,
+			     5000,	/* should be large */
+			     30,
+			     1,	/* replace indicator */
+			     "",	/* result set name */
+			     database_names,	/* database name */
+			     QT_RelevanceFeedbackQuery,		/* query_type */
+			     0,	/* element name */
+			     NULL,	/* reference ID */
+			     query);
+
+    end_ptr = writeSearchAPDU(search3, buff, buff_len);
+
+    CSTFreeWAISSearch(query);
+    freeSearchAPDU(search3);
+    return (end_ptr);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* returns a pointer into the buffer of the next free byte.
+   if it overflowed, then NULL is returned
+ */
+
+char *generate_retrieval_apdu(char *buff,
+			      long *buff_len,	/* length of the buffer changed to reflect new data written */
+			      any *docID,
+			      long chunk_type,
+			      long start,
+			      long end,
+			      char *type,
+			      char *database_name)
+{
+    SearchAPDU *search;
+    char *end_ptr;
+
+    static char *database_names[2];
+    static char *element_names[3];
+    any refID;
+
+    DocObj *DocObjs[2];
+    any *query;			/* changed from char* by brewster */
+
+    if (NULL == type)
+	type = s_strdup("TEXT");
+
+    database_names[0] = database_name;
+    database_names[1] = NULL;
+
+    element_names[0] = " ";
+    element_names[1] = ES_DocumentText;
+    element_names[2] = NULL;
+
+    refID.size = 1;
+    refID.bytes = "3";
+
+    switch (chunk_type) {
+    case CT_line:
+	DocObjs[0] = makeDocObjUsingLines(docID, type, start, end);
+	break;
+    case CT_byte:
+	DocObjs[0] = makeDocObjUsingBytes(docID, type, start, end);
+	break;
+    }
+    DocObjs[1] = NULL;
+
+    query = makeWAISTextQuery(DocObjs);
+    search = makeSearchAPDU(10, 16, 15,
+			    1,	/* replace indicator */
+			    "FOO",	/* result set name */
+			    database_names,	/* database name */
+			    QT_TextRetrievalQuery,	/* query_type */
+			    element_names,	/* element name */
+			    &refID,	/* reference ID */
+			    query);
+    end_ptr = writeSearchAPDU(search, buff, buff_len);
+    CSTFreeWAISTextQuery(query);
+    freeSearchAPDU(search);
+    return (end_ptr);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* this is a safe version of unix 'read' it does all the checking
+ * and looping necessary
+ * to those trying to modify the transport code to use non-UNIX streams:
+ *  This is the function to modify!
+ */
+static long read_from_stream(int d, char *buf, long nbytes)
+{
+    long didRead;
+    long toRead = nbytes;
+    long totalRead = 0;		/* paranoia */
+
+    while (toRead > 0) {
+	didRead = NETREAD(d, buf, (int) toRead);
+	if (didRead == HT_INTERRUPTED)
+	    return (HT_INTERRUPTED);
+	if (didRead == -1)	/* error */
+	    return (-1);
+	if (didRead == 0)	/* eof */
+	    return (-2);	/* maybe this should return 0? */
+	toRead -= didRead;
+	buf += didRead;
+	totalRead += didRead;
+    }
+    if (totalRead != nbytes)	/* we overread for some reason */
+	return (-totalRead);	/* bad news */
+    return (totalRead);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* returns the length of the response, 0 if an error */
+
+static long transport_message(long connection,
+			      char *request_message,
+			      long request_length,
+			      char *response_message,
+			      long response_buffer_length)
+{
+    WAISMessage header;
+    long response_length;
+    int rv;
+
+    /* Write out message.  Read back header.  Figure out response length. */
+
+    if (request_length + HEADER_LENGTH !=
+	NETWRITE(connection, request_message,
+		 (int) (request_length + HEADER_LENGTH)))
+	return 0;
+
+    /* read for the first '0' */
+
+    while (1) {
+	rv = read_from_stream(connection, response_message, 1);
+	if (rv == HT_INTERRUPTED)
+	    return HT_INTERRUPTED;
+	if (rv < 0)
+	    return 0;
+	if ('0' == response_message[0])
+	    break;
+    }
+
+    rv = read_from_stream(connection, response_message + 1, HEADER_LENGTH - 1);
+    if (rv == HT_INTERRUPTED)
+	return HT_INTERRUPTED;
+    if (rv < 0)
+	return 0;
+
+    readWAISPacketHeader(response_message, &header);
+    {
+	char length_array[11];
+
+	LYStrNCpy(length_array, header.msg_len, 10);
+	response_length = atol(length_array);
+	/*
+	   if(verbose){
+	   printf("WAIS header: '%s' length_array: '%s'\n",
+	   response_message, length_array);
+	   }
+	 */
+	if (response_length > response_buffer_length) {
+	    /* we got a message that is too long, therefore empty the message out,
+	       and return 0 */
+	    long i;
+
+	    for (i = 0; i < response_length; i++) {
+		rv = read_from_stream(connection,
+				      response_message + HEADER_LENGTH,
+				      1);
+		if (rv == HT_INTERRUPTED)
+		    return HT_INTERRUPTED;
+		if (rv < 0)
+		    return 0;
+	    }
+	    return (0);
+	}
+    }
+    rv = read_from_stream(connection,
+			  response_message + HEADER_LENGTH,
+			  response_length);
+    if (rv == HT_INTERRUPTED)
+	return HT_INTERRUPTED;
+    if (rv < 0)
+	return 0;
+    return (response_length);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* returns the number of bytes written.  0 if an error */
+long interpret_message(char *request_message,
+		       long request_length,	/* length of the buffer */
+		       char *response_message,
+		       long response_buffer_length,
+		       long connection,
+		       boolean verbose GCC_UNUSED)
+{
+    long response_length;
+
+    /* ?
+       if(verbose){
+       printf ("sending");
+       if(hostname_internal && strlen(hostname_internal) > 0)
+       printf(" to host %s", hostname_internal);
+       if(service_name && strlen(service_name) > 0)
+       printf(" for service %s", service_name);
+       printf("\n");
+       twais_dsply_rsp_apdu(request_message + HEADER_LENGTH,
+       request_length);
+       }
+
+     */
+
+    writeWAISPacketHeader(request_message,
+			  request_length,
+			  (long) 'z',	/* Z39.50 */
+			  "wais      ",		/* server name */
+			  (long) NO_COMPRESSION,	/* no compression */
+			  (long) NO_ENCODING, (long) HEADER_VERSION);
+    if (connection != 0) {
+	response_length = transport_message(connection, request_message,
+					    request_length,
+					    response_message,
+					    response_buffer_length);
+	if (response_length == HT_INTERRUPTED)
+	    return (HT_INTERRUPTED);
+    } else
+	return (0);
+
+    return (response_length);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* modifies the string to exclude all seeker codes. sets length to
+   the new length. */
+static char *delete_seeker_codes(char *string, long *length)
+{
+    long original_count;	/* index into the original string */
+    long new_count = 0;		/* index into the collapsed string */
+
+    for (original_count = 0; original_count < *length; original_count++) {
+	if (27 == string[original_count]) {
+	    /* then we have an escape code */
+	    /* if the next letter is '(' or ')', then ignore two letters */
+	    if ('(' == string[original_count + 1] ||
+		')' == string[original_count + 1])
+		original_count += 1;	/* it is a term marker */
+	    else
+		original_count += 4;	/* it is a paragraph marker */
+	} else
+	    string[new_count++] = string[original_count];
+    }
+    *length = new_count;
+    return (string);
+}
+
+/*----------------------------------------------------------------------*/
+
+#if defined(VMS) && defined(__GNUC__)	/* 10-AUG-1995 [pr] */
+/*
+  Workaround for an obscure bug in gcc's 2.6.[123] and 2.7.0 vax/vms port;
+  sometimes global variables will end up not being defined properly,
+  causing first gas to assume they're routines, then the linker to complain
+  about unresolved symbols, and finally the program to reference the wrong
+  objects (provoking ACCVIO).  It's triggered by the specific ordering of
+  variable usage in the source code, hence rarely appears.  This bug is
+  fixed in gcc 2.7.1, and was not present in 2.6.0 and earlier.
+
+   Make a reference to VAXCRTL's _ctype_[], and also one to this dummy
+   variable itself to prevent any "defined but not used" warning.
+ */
+static __const void *__const ctype_dummy[] =
+{&_ctype_, &ctype_dummy};
+#endif /* VMS && __GNUC__ */
+
+/* returns a pointer to a string with good stuff */
+char *trim_junk(char *headline)
+{
+    long length = strlen(headline) + 1;		/* include the trailing null */
+    size_t i;
+
+    headline = delete_seeker_codes(headline, &length);
+    /* delete leading spaces */
+    for (i = 0; i < strlen(headline); i++) {
+	if (isprint(headline[i])) {
+	    break;
+	}
+    }
+    headline = headline + i;
+    /* delete trailing stuff */
+    for (i = strlen(headline) - 1; i > 0; i--) {
+	if (isprint(headline[i])) {
+	    break;
+	}
+	headline[i] = '\0';
+    }
+    return (headline);
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from ZProt.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE:`
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ *
+ * 3.26.90	Harry Morris, morris@think.com
+ * 3.30.90  Harry Morris - Changed any->bits to any->bytes
+ * 4.11.90  HWM - generalized conditional includes (see c-dialect.h)
+ */
+
+#define RESERVE_SPACE_FOR_HEADER(spaceLeft)		\
+	*spaceLeft -= HEADER_LEN;
+
+#define RELEASE_HEADER_SPACE(spaceLeft)			\
+	if (*spaceLeft > 0)				\
+	  *spaceLeft += HEADER_LEN;
+
+/*----------------------------------------------------------------------*/
+
+InitResponseAPDU *makeInitResponseAPDU(boolean result,
+				       boolean search,
+				       boolean present,
+				       boolean deleteIt,
+				       boolean accessControl,
+				       boolean resourceControl,
+				       long prefSize,
+				       long maxMsgSize,
+				       char *auth,
+				       char *id,
+				       char *name,
+				       char *version,
+				       any *refID,
+				       void *userInfo)
+/* build an initResponse APDU with user specified information */
+{
+    InitResponseAPDU *init = (InitResponseAPDU *) s_malloc((size_t) sizeof(InitResponseAPDU));
+
+    init->PDUType = initResponseAPDU;
+    init->Result = result;
+    init->willSearch = search;
+    init->willPresent = present;
+    init->willDelete = deleteIt;
+    init->supportAccessControl = accessControl;
+    init->supportResourceControl = resourceControl;
+    init->PreferredMessageSize = prefSize;
+    init->MaximumRecordSize = maxMsgSize;
+    init->IDAuthentication = s_strdup(auth);
+    init->ImplementationID = s_strdup(id);
+    init->ImplementationName = s_strdup(name);
+    init->ImplementationVersion = s_strdup(version);
+    init->ReferenceID = duplicateAny(refID);
+    init->UserInformationField = userInfo;	/* not copied! */
+
+    return (init);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeInitResponseAPDU(InitResponseAPDU *init)
+/* free an initAPDU */
+{
+    s_free(init->IDAuthentication);
+    s_free(init->ImplementationID);
+    s_free(init->ImplementationName);
+    s_free(init->ImplementationVersion);
+    freeAny(init->ReferenceID);
+    s_free(init);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeInitResponseAPDU(InitResponseAPDU *init, char *buffer, long *len)
+/* write the initResponse to a buffer, adding system information */
+{
+    char *buf = buffer + HEADER_LEN;	/* leave room for the header-length-indicator */
+    long size;
+    bit_map *optionsBM = NULL;
+
+    RESERVE_SPACE_FOR_HEADER(len);
+
+    buf = writePDUType(init->PDUType, buf, len);
+    buf = writeBoolean(init->Result, buf, len);
+    buf = writeProtocolVersion(buf, len);
+
+    optionsBM = makeBitMap((unsigned long) 5, init->willSearch, init->willPresent,
+			   init->willDelete, init->supportAccessControl,
+			   init->supportResourceControl);
+    buf = writeBitMap(optionsBM, DT_Options, buf, len);
+    freeBitMap(optionsBM);
+
+    buf = writeNum(init->PreferredMessageSize,
+		   DT_PreferredMessageSize,
+		   buf,
+		   len);
+    buf = writeNum(init->MaximumRecordSize,
+		   DT_MaximumRecordSize,
+		   buf,
+		   len);
+    buf = writeString(init->IDAuthentication,
+		      DT_IDAuthentication,
+		      buf,
+		      len);
+    buf = writeString(init->ImplementationID,
+		      DT_ImplementationID,
+		      buf,
+		      len);
+    buf = writeString(init->ImplementationName,
+		      DT_ImplementationName,
+		      buf,
+		      len);
+    buf = writeString(init->ImplementationVersion,
+		      DT_ImplementationVersion,
+		      buf,
+		      len);
+    buf = writeAny(init->ReferenceID,
+		   DT_ReferenceID,
+		   buf,
+		   len);
+
+    /* go back and write the header-length-indicator */
+    RELEASE_HEADER_SPACE(len);
+    size = buf - buffer - HEADER_LEN;
+    writeBinaryInteger(size, HEADER_LEN, buffer, len);
+
+    if (init->UserInformationField != NULL)
+	buf = writeInitResponseInfo(init, buf, len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readInitResponseAPDU(InitResponseAPDU **init, char *buffer)
+{
+    char *buf = buffer;
+    boolean search, present, delete, accessControl, resourceControl;
+    long prefSize, maxMsgSize;
+    char *auth, *id, *name, *version;
+    long size;
+    pdu_type pduType;
+    bit_map *versionBM = NULL;
+    bit_map *optionsBM = NULL;
+    boolean result;
+    any *refID = NULL;
+    void *userInfo = NULL;
+
+    auth = id = name = version = NULL;
+    refID = NULL;
+
+    /* read required part */
+    buf = readBinaryInteger(&size, HEADER_LEN, buf);
+    buf = readPDUType(&pduType, buf);
+    buf = readBoolean(&result, buf);
+    buf = readBitMap(&versionBM, buf);
+    buf = readBitMap(&optionsBM, buf);
+    buf = readNum(&prefSize, buf);
+    buf = readNum(&maxMsgSize, buf);
+
+    /* decode optionsBM */
+    search = bitAtPos(0, optionsBM);
+    present = bitAtPos(1, optionsBM);
+    delete = bitAtPos(2, optionsBM);
+    accessControl = bitAtPos(3, optionsBM);
+    resourceControl = bitAtPos(4, optionsBM);
+
+    /* read optional part */
+    while (buf < (buffer + size + HEADER_LEN)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_IDAuthentication:
+	    buf = readString(&auth, buf);
+	    break;
+	case DT_ImplementationID:
+	    buf = readString(&id, buf);
+	    break;
+	case DT_ImplementationName:
+	    buf = readString(&name, buf);
+	    break;
+	case DT_ImplementationVersion:
+	    buf = readString(&version, buf);
+	    break;
+	case DT_ReferenceID:
+	    buf = readAny(&refID, buf);
+	    break;
+	default:
+	    freeBitMap(versionBM);
+	    freeBitMap(optionsBM);
+	    s_free(auth);
+	    s_free(id);
+	    s_free(name);
+	    s_free(version);
+	    freeAny(refID);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    buf = readInitResponseInfo(&userInfo, buf);
+    if (buf == NULL) {
+	freeBitMap(versionBM);
+	freeBitMap(optionsBM);
+	s_free(auth);
+	s_free(id);
+	s_free(name);
+	s_free(version);
+	freeAny(refID);
+    }
+    RETURN_ON_NULL(buf);
+
+    /* construct the basic init object */
+    *init = makeInitResponseAPDU(result,
+				 search,
+				 present,
+				 delete,
+				 accessControl,
+				 resourceControl,
+				 prefSize,
+				 maxMsgSize,
+				 auth,
+				 id,
+				 name,
+				 version,
+				 refID,
+				 userInfo);
+
+    freeBitMap(versionBM);
+    freeBitMap(optionsBM);
+    s_free(auth);
+    s_free(id);
+    s_free(name);
+    s_free(version);
+    freeAny(refID);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+InitResponseAPDU *replyToInitAPDU(InitAPDU * init, boolean result, void *userInfo)
+/* respond to an init message in the default way - echoing back
+   the init info
+ */
+{
+    InitResponseAPDU *initResp;
+
+    initResp = makeInitResponseAPDU(result,
+				    init->willSearch,
+				    init->willPresent,
+				    init->willDelete,
+				    init->supportAccessControl,
+				    init->supportResourceControl,
+				    init->PreferredMessageSize,
+				    init->MaximumRecordSize,
+				    init->IDAuthentication,
+				    defaultImplementationID(),
+				    defaultImplementationName(),
+				    defaultImplementationVersion(),
+				    init->ReferenceID,
+				    userInfo);
+    return (initResp);
+}
+
+/*----------------------------------------------------------------------*/
+
+SearchAPDU *makeSearchAPDU(long small,
+			   long large,
+			   long medium,
+			   boolean replace,
+			   char *name,
+			   char **databases,
+			   char *type,
+			   char **elements,
+			   any *refID,
+			   void *queryInfo)
+{
+    char *ptr = NULL;
+    long i;
+    SearchAPDU *query = (SearchAPDU *) s_malloc((size_t) sizeof(SearchAPDU));
+
+    query->PDUType = searchAPDU;
+    query->SmallSetUpperBound = small;
+    query->LargeSetLowerBound = large;
+    query->MediumSetPresentNumber = medium;
+    query->ReplaceIndicator = replace;
+    query->ResultSetName = s_strdup(name);
+    query->DatabaseNames = NULL;
+    if (databases != NULL) {
+	for (i = 0, ptr = databases[i]; ptr != NULL; ptr = databases[++i]) {
+	    if (query->DatabaseNames == NULL)
+		query->DatabaseNames = (char **) s_malloc((size_t) (sizeof(char
+									   *)
+								    * 2));
+
+	    else
+		query->DatabaseNames = (char **) s_realloc((char *) query->DatabaseNames,
+							   (size_t) (sizeof(char
+									    *) *
+								     (i + 2)));
+
+	    query->DatabaseNames[i] = s_strdup(ptr);
+	    query->DatabaseNames[i + 1] = NULL;
+	}
+    }
+    query->QueryType = s_strdup(type);
+    query->ElementSetNames = NULL;
+    if (elements != NULL) {
+	for (i = 0, ptr = elements[i]; ptr != NULL; ptr = elements[++i]) {
+	    if (query->ElementSetNames == NULL)
+		query->ElementSetNames =
+		    (char **) s_malloc((size_t) (sizeof(char *) * 2));
+
+	    else
+		query->ElementSetNames = (char **) s_realloc((char *) query->ElementSetNames,
+							     (size_t) (sizeof(char
+									      *) *
+								       (i + 2)));
+
+	    query->ElementSetNames[i] = s_strdup(ptr);
+	    query->ElementSetNames[i + 1] = NULL;
+	}
+    }
+    query->ReferenceID = duplicateAny(refID);
+    query->Query = queryInfo;	/* not copied! */
+    return (query);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeSearchAPDU(SearchAPDU *query)
+{
+    s_free(query->ResultSetName);
+    s_free(query->QueryType);
+    doList((void **) query->DatabaseNames, fs_free);	/* can't use the macro here ! */
+    s_free(query->DatabaseNames);
+    doList((void **) query->ElementSetNames, fs_free);	/* can't use the macro here ! */
+    s_free(query->ElementSetNames);
+    freeAny(query->ReferenceID);
+    s_free(query);
+}
+
+/*----------------------------------------------------------------------*/
+
+#define DB_DELIMITER	"\037"	/* hex 1F occurs between each database name */
+#define ES_DELIMITER_1	"\037"	/* separates database name from element name */
+#define ES_DELIMITER_2	"\036"	/* hex 1E separates <db,es> groups from one another */
+
+char *writeSearchAPDU(SearchAPDU *query, char *buffer, long *len)
+{
+    char *buf = buffer + HEADER_LEN;	/* leave room for the header-length-indicator */
+    long size, i;
+    char *ptr = NULL;
+    char *scratch = NULL;
+
+    RESERVE_SPACE_FOR_HEADER(len);
+
+    buf = writePDUType(query->PDUType, buf, len);
+    buf = writeBinaryInteger(query->SmallSetUpperBound, (size_t) 3, buf, len);
+    buf = writeBinaryInteger(query->LargeSetLowerBound, (size_t) 3, buf, len);
+    buf = writeBinaryInteger(query->MediumSetPresentNumber, (size_t) 3, buf, len);
+    buf = writeBoolean(query->ReplaceIndicator, buf, len);
+    buf = writeString(query->ResultSetName, DT_ResultSetName, buf, len);
+    /* write database names */
+    if (query->DatabaseNames != NULL) {
+	for (i = 0, scratch = NULL, ptr = query->DatabaseNames[i]; ptr != NULL;
+	     ptr = query->DatabaseNames[++i]) {
+	    if (scratch == NULL)
+		scratch = s_strdup(ptr);
+	    else {
+		size_t newScratchSize = (size_t) (strlen(scratch) +
+						  strlen(ptr) + 2);
+
+		scratch = (char *) s_realloc(scratch, newScratchSize);
+		s_strncat(scratch, DB_DELIMITER, 2, newScratchSize);
+		s_strncat(scratch, ptr, strlen(ptr) + 1, newScratchSize);
+	    }
+	}
+	buf = writeString(scratch, DT_DatabaseNames, buf, len);
+	s_free(scratch);
+    }
+    buf = writeString(query->QueryType, DT_QueryType, buf, len);
+    /* write element set names */
+    if (query->ElementSetNames != NULL) {
+	for (i = 0, scratch = NULL, ptr = query->ElementSetNames[i];
+	     ptr != NULL;
+	     ptr = query->ElementSetNames[++i]) {
+	    if (scratch == NULL) {
+		if (query->ElementSetNames[i + 1] == NULL)	/* there is a single element set name */
+		{
+		    scratch = (char *) s_malloc((size_t) strlen(ptr) + 2);
+		    StrNCpy(scratch, ES_DELIMITER_1, 2);
+		    s_strncat(scratch, ptr, strlen(ptr) + 1, strlen(ptr) + 2);
+		} else {	/* this is the first of a series of element set names */
+		    size_t newScratchSize = (size_t) (strlen(ptr) +
+						      strlen(query->ElementSetNames[i
+										    + 1])
+						      + 2);
+
+		    scratch = s_strdup(ptr);	/* the database name */
+		    ptr = query->ElementSetNames[++i];	/* the element set name */
+		    scratch = (char *) s_realloc(scratch, newScratchSize);
+		    s_strncat(scratch, ES_DELIMITER_1, 2, newScratchSize);
+		    s_strncat(scratch, ptr, strlen(ptr) + 1, newScratchSize);
+		}
+	    } else {
+		char *esPtr = query->ElementSetNames[++i];	/* the element set name */
+		size_t newScratchSize = (size_t) (strlen(scratch) +
+						  strlen(ptr) +
+						  strlen(esPtr) +
+						  3);
+
+		scratch = (char *) s_realloc(scratch, newScratchSize);
+		s_strncat(scratch, ES_DELIMITER_2, 2, newScratchSize);
+		s_strncat(scratch, ptr, strlen(ptr) + 1, newScratchSize);
+		s_strncat(scratch, ES_DELIMITER_1, 2, newScratchSize);
+		s_strncat(scratch, esPtr, strlen(esPtr) + 1, newScratchSize);
+	    }
+	}
+	buf = writeString(scratch, DT_ElementSetNames, buf, len);
+	s_free(scratch);
+    }
+    buf = writeAny(query->ReferenceID, DT_ReferenceID, buf, len);
+
+    /* go back and write the header-length-indicator */
+    RELEASE_HEADER_SPACE(len);
+    size = buf - buffer - HEADER_LEN;
+    writeBinaryInteger(size, HEADER_LEN, buffer, len);
+
+    if (query->Query != NULL)
+	buf = writeSearchInfo(query, buf, len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+SearchResponseAPDU *makeSearchResponseAPDU(long result,
+					   long count,
+					   long recordsReturned,
+					   long nextPos,
+					   long resultStatus,
+					   long presentStatus,
+					   any *refID,
+					   void *records)
+{
+    SearchResponseAPDU *query =
+    (SearchResponseAPDU *) s_malloc((size_t) sizeof(SearchResponseAPDU));
+
+    query->PDUType = searchResponseAPDU;
+    query->SearchStatus = result;
+    query->ResultCount = count;
+    query->NumberOfRecordsReturned = recordsReturned;
+    query->NextResultSetPosition = nextPos;
+    query->ResultSetStatus = resultStatus;
+    query->PresentStatus = presentStatus;
+    query->ReferenceID = duplicateAny(refID);
+    query->DatabaseDiagnosticRecords = records;
+    return (query);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeSearchResponseAPDU(SearchResponseAPDU *queryResponse)
+{
+    freeAny(queryResponse->ReferenceID);
+    s_free(queryResponse);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeSearchResponseAPDU(SearchResponseAPDU *queryResponse, char *buffer,
+			      long *len)
+{
+    char *buf = buffer + HEADER_LEN;	/* leave room for the header-length-indicator */
+    long size;
+
+    RESERVE_SPACE_FOR_HEADER(len);
+
+    buf = writePDUType(queryResponse->PDUType,
+		       buf,
+		       len);
+    buf = writeBinaryInteger(queryResponse->SearchStatus,
+			     (size_t) 1,
+			     buf,
+			     len);
+    buf = writeBinaryInteger(queryResponse->ResultCount,
+			     (size_t) 3,
+			     buf,
+			     len);
+    buf = writeBinaryInteger(queryResponse->NumberOfRecordsReturned,
+			     (size_t) 3,
+			     buf,
+			     len);
+    buf = writeBinaryInteger(queryResponse->NextResultSetPosition,
+			     (size_t) 3,
+			     buf,
+			     len);
+    buf = writeNum(queryResponse->ResultSetStatus,
+		   DT_ResultSetStatus,
+		   buf,
+		   len);
+    buf = writeNum(queryResponse->PresentStatus,
+		   DT_PresentStatus,
+		   buf,
+		   len);
+    buf = writeAny(queryResponse->ReferenceID,
+		   DT_ReferenceID,
+		   buf,
+		   len);
+
+    /* go back and write the header-length-indicator */
+    RELEASE_HEADER_SPACE(len);
+    size = buf - buffer - HEADER_LEN;
+    writeBinaryInteger(size, HEADER_LEN, buffer, len);
+
+    if (queryResponse->DatabaseDiagnosticRecords != NULL)
+	buf = writeSearchResponseInfo(queryResponse, buf, len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readSearchResponseAPDU(SearchResponseAPDU **queryResponse, char *buffer)
+{
+    char *buf = buffer;
+    long size;
+    pdu_type pduType;
+    long result, count, recordsReturned, nextPos;
+    long resultStatus, presentStatus;
+    any *refID = NULL;
+    void *userInfo = NULL;
+
+    /* read required part */
+    buf = readBinaryInteger(&size, HEADER_LEN, buf);
+    buf = readPDUType(&pduType, buf);
+    buf = readBinaryInteger(&result, (size_t) 1, buf);
+    buf = readBinaryInteger(&count, (size_t) 3, buf);
+    buf = readBinaryInteger(&recordsReturned, (size_t) 3, buf);
+    buf = readBinaryInteger(&nextPos, (size_t) 3, buf);
+
+    resultStatus = presentStatus = UNUSED;
+    refID = NULL;
+
+    /* read optional part */
+    while (buf < (buffer + size + HEADER_LEN)) {
+	data_tag tag = peekTag(buf);
+
+	switch (tag) {
+	case DT_ResultSetStatus:
+	    buf = readNum(&resultStatus, buf);
+	    break;
+	case DT_PresentStatus:
+	    buf = readNum(&presentStatus, buf);
+	    break;
+	case DT_ReferenceID:
+	    buf = readAny(&refID, buf);
+	    break;
+	default:
+	    freeAny(refID);
+	    REPORT_READ_ERROR(buf);
+	    break;
+	}
+    }
+
+    buf = readSearchResponseInfo(&userInfo, buf);
+    if (buf == NULL)
+	freeAny(refID);
+    RETURN_ON_NULL(buf);
+
+    /* construct the search object */
+    *queryResponse = makeSearchResponseAPDU(result,
+					    count,
+					    recordsReturned,
+					    nextPos,
+					    (long) resultStatus,
+					    (long) presentStatus,
+					    refID,
+					    userInfo);
+
+    freeAny(refID);
+
+    return (buf);
+}
+
+/*
+ *	Routines originally from ZUtil.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE:
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ *
+ * 3.26.90	Harry Morris, morris@think.com
+ * 3.30.90  Harry Morris - Changed any->bits to any->bytes
+ * 4.11.90  HWM - fixed include file names, changed
+ *		- writeCompressedIntegerWithPadding() to
+ *		  writeCompressedIntWithPadding()
+ *		- generalized conditional includes (see c-dialect.h)
+ * 3.7.91   Jonny Goldman.  Replaced "short" in makeBitMap with "int" line 632.
+ */
+
+char *readErrorPosition = NULL;	/* pos where buf stopped making sense */
+
+/*----------------------------------------------------------------------*/
+/* A note on error handling
+   read - these are low level routines, they do not check the type tags
+   which (sometimes) precede the data (this is done by the higher
+   level functions which call these functions).  There is no
+   attempt made to check that the reading does not exceed the read
+   buffer.  Such cases should be very rare and usually will be
+   caught by the calling functions. (note - it is unlikely that
+   a series of low level reads will go far off the edge without
+   triggering a type error.  However, it is possible for a single
+   bad read in an array function (eg. readAny) to attempt to read a
+   large amount, possibly causing a segmentation violation or out
+   of memory condition.
+ */
+/*----------------------------------------------------------------------*/
+
+diagnosticRecord *makeDiag(boolean surrogate, char *code, char *addInfo)
+{
+    diagnosticRecord *diag =
+    (diagnosticRecord *) s_malloc((size_t) sizeof(diagnosticRecord));
+
+    diag->SURROGATE = surrogate;
+    MemCpy(diag->DIAG, code, DIAGNOSTIC_CODE_SIZE);
+    diag->ADDINFO = s_strdup(addInfo);
+
+    return (diag);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeDiag(diagnosticRecord * diag)
+{
+    if (diag != NULL) {
+	if (diag->ADDINFO != NULL)
+	    s_free(diag->ADDINFO);
+	s_free(diag);
+    }
+}
+
+/*----------------------------------------------------------------------*/
+
+#define END_OF_RECORD	0x1D
+
+char *writeDiag(diagnosticRecord * diag, char *buffer, long *len)
+/* diagnostics (as per Appendix D) have a very weird format - this changes
+   in SR-1
+ */
+{
+    char *buf = buffer;
+    long length;
+
+    if (diag == NULL)		/* handle unspecified optional args */
+	return (buf);
+
+    buf = writeTag(DT_DatabaseDiagnosticRecords, buf, len);
+    CHECK_FOR_SPACE_LEFT(0, len);
+
+    length = 3;
+    if (diag->ADDINFO != NULL)
+	length += strlen(diag->ADDINFO);
+
+    if (length >= 0xFFFF)	/* make sure the length is reasonable */
+    {
+	length = 0xFFFF - 1;
+	diag->ADDINFO[0xFFFF - 3 - 1] = '\0';
+    }
+
+    buf = writeBinaryInteger(length, 2, buf, len);
+
+    CHECK_FOR_SPACE_LEFT(1, len);
+    buf[0] = diag->DIAG[0];
+    buf++;
+
+    CHECK_FOR_SPACE_LEFT(1, len);
+    buf[0] = diag->DIAG[1];
+    buf++;
+
+    if (length > 3) {
+	CHECK_FOR_SPACE_LEFT(3, len);
+	MemCpy(buf, diag->ADDINFO, length - 3);
+	buf += length - 3;
+    }
+
+    CHECK_FOR_SPACE_LEFT(1, len);
+    buf[0] = diag->SURROGATE;
+    buf++;
+
+    CHECK_FOR_SPACE_LEFT(1, len);
+    buf[0] = END_OF_RECORD;
+    buf++;
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readDiag(diagnosticRecord ** diag, char *buffer)
+{
+    char *buf = buffer;
+    diagnosticRecord *d = (diagnosticRecord *) s_malloc((size_t) sizeof(diagnosticRecord));
+    data_tag tag;
+    long len;
+
+    buf = readTag(&tag, buf);
+
+    buf = readBinaryInteger(&len, 2, buf);
+
+    d->DIAG[0] = buf[0];
+    d->DIAG[1] = buf[1];
+    d->DIAG[2] = '\0';
+
+    if (len > 3) {
+	d->ADDINFO = (char *) s_malloc((size_t) (len - 3 + 1));
+	MemCpy(d->ADDINFO, (char *) (buf + 2), len - 3);
+	d->ADDINFO[len - 3] = '\0';
+    } else
+	d->ADDINFO = NULL;
+
+    d->SURROGATE = buf[len - 1];
+
+    *diag = d;
+
+    return (buf + len + 1);
+}
+
+/*----------------------------------------------------------------------*/
+
+#define continueBit	0x80
+#define dataMask	0x7F
+#define dataBits	7
+
+char *writeCompressedInteger(unsigned long num, char *buf, long *len)
+/* write a binary integer in the format described on p. 40.
+   this might be sped up
+*/
+{
+    char byte;
+    unsigned long i;
+    unsigned long size;
+
+    size = writtenCompressedIntSize(num);
+    CHECK_FOR_SPACE_LEFT(size, len);
+
+    for (i = size - 1; i != 0; i--) {
+	byte = num & dataMask;
+	if (i != (size - 1))	/* turn on continue bit */
+	    byte = (char) (byte | continueBit);
+	buf[i] = byte;
+	num = num >> dataBits;	/* don't and here */
+    }
+
+    return (buf + size);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readCompressedInteger(unsigned long *num, char *buf)
+/* read a binary integer in the format described on p. 40.
+   this might be sped up
+*/
+{
+    long i = 0;
+    unsigned char byte;
+
+    *num = 0;
+
+    do {
+	byte = buf[i++];
+	*num = *num << dataBits;
+	*num += (byte & dataMask);
+    }
+    while (byte & continueBit);
+
+    return (buf + i);
+}
+
+/*----------------------------------------------------------------------*/
+
+#define pad	128		/* high bit is set */
+
+char *writeCompressedIntWithPadding(unsigned long num,
+				    unsigned long size,
+				    char *buffer,
+				    long *len)
+/* Like writeCompressedInteger, except writes padding (128) to make
+   sure that size bytes are used.  This can be read correctly by
+   readCompressedInteger()
+*/
+{
+    char *buf = buffer;
+    unsigned long needed, padding;
+    long i;
+
+    CHECK_FOR_SPACE_LEFT(size, len);
+
+    needed = writtenCompressedIntSize(num);
+    padding = size - needed;
+    i = padding - 1;
+
+    for (i = padding - 1; i >= 0; i--) {
+	buf[i] = pad;
+    }
+
+    buf = writeCompressedInteger(num, buf + padding, len);
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+unsigned long writtenCompressedIntSize(unsigned long num)
+/* return the number of bytes needed to represent the value num in
+   compressed format.  currently limited to 4 bytes
+ */
+{
+    if (num < CompressedInt1Byte)
+	return (1);
+    else if (num < CompressedInt2Byte)
+	return (2);
+    else if (num < CompressedInt3Byte)
+	return (3);
+    else
+	return (4);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeTag(data_tag tag, char *buf, long *len)
+/* write out a data tag */
+{
+    return (writeCompressedInteger(tag, buf, len));
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readTag(data_tag *tag, char *buf)
+/* read a data tag */
+{
+    return (readCompressedInteger(tag, buf));
+}
+
+/*----------------------------------------------------------------------*/
+
+unsigned long writtenTagSize(data_tag tag)
+{
+    return (writtenCompressedIntSize(tag));
+}
+
+/*----------------------------------------------------------------------*/
+
+data_tag peekTag(char *buf)
+/* read a data tag without advancing the buffer */
+{
+    data_tag tag;
+
+    readTag(&tag, buf);
+    return (tag);
+}
+
+/*----------------------------------------------------------------------*/
+
+any *makeAny(unsigned long size, char *data)
+{
+    any *a = (any *) s_malloc((size_t) sizeof(any));
+
+    a->size = size;
+    a->bytes = data;
+    return (a);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeAny(any *a)
+/* destroy an any and its associated data.  Assumes a->bytes was
+   allocated using the s_malloc family of libraries
+ */
+{
+    if (a != NULL) {
+	if (a->bytes != NULL)
+	    s_free(a->bytes);
+	s_free(a);
+    }
+}
+
+/*----------------------------------------------------------------------*/
+
+any *duplicateAny(any *a)
+{
+    any *copy = NULL;
+
+    if (a == NULL)
+	return (NULL);
+
+    copy = (any *) s_malloc((size_t) sizeof(any));
+
+    copy->size = a->size;
+    if (a->bytes == NULL)
+	copy->bytes = NULL;
+    else {
+	copy->bytes = (char *) s_malloc((size_t) copy->size);
+	MemCpy(copy->bytes, a->bytes, copy->size);
+    }
+    return (copy);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeAny(any *a, data_tag tag, char *buffer, long *len)
+/* write an any + tag and size info */
+{
+    char *buf = buffer;
+
+    if (a == NULL)		/* handle unspecified optional args */
+	return (buf);
+
+    /* write the tags */
+    buf = writeTag(tag, buf, len);
+    buf = writeCompressedInteger(a->size, buf, len);
+
+    /* write the bytes */
+    CHECK_FOR_SPACE_LEFT(a->size, len);
+    MemCpy(buf, a->bytes, a->size);
+
+    return (buf + a->size);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readAny(any **anAny, char *buffer)
+/* read an any + tag and size info */
+{
+    char *buf;
+    any *a;
+    data_tag tag;
+
+    a = (any *) s_malloc((size_t) sizeof(any));
+
+    buf = buffer;
+
+    buf = readTag(&tag, buf);
+
+    buf = readCompressedInteger(&a->size, buf);
+
+    /* now simply copy the bytes */
+    a->bytes = (char *) s_malloc((size_t) a->size);
+    MemCpy(a->bytes, buf, a->size);
+    *anAny = a;
+
+    return (buf + a->size);
+}
+
+/*----------------------------------------------------------------------*/
+
+unsigned long writtenAnySize(data_tag tag, any *a)
+{
+    unsigned long size;
+
+    if (a == NULL)
+	return (0);
+
+    size = writtenTagSize(tag);
+    size += writtenCompressedIntSize(a->size);
+    size += a->size;
+    return (size);
+}
+
+/*----------------------------------------------------------------------*/
+
+any *stringToAny(char *s)
+{
+    any *a = NULL;
+
+    if (s == NULL)
+	return (NULL);
+
+    a = (any *) s_malloc((size_t) sizeof(any));
+
+    a->size = strlen(s);
+    a->bytes = (char *) s_malloc((size_t) a->size);
+    MemCpy(a->bytes, s, a->size);
+    return (a);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *anyToString(any *a)
+{
+    char *s = NULL;
+
+    if (a == NULL)
+	return (NULL);
+
+    s = s_malloc((size_t) (a->size + 1));
+    MemCpy(s, a->bytes, a->size);
+    s[a->size] = '\0';
+    return (s);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeString(char *s, data_tag tag, char *buffer, long *len)
+/* Write a C style string.  The terminating null is not written.
+   This function is not part of the Z39.50 spec.  It is provided
+   for the convenience of those wishing to pass C strings in
+   the place of an any.
+ */
+{
+    char *buf = buffer;
+    any *data = NULL;
+
+    if (s == NULL)
+	return (buffer);	/* handle unused optional item before making an any */
+    data = (any *) s_malloc((size_t) sizeof(any));
+
+    data->size = strlen(s);
+    data->bytes = s;		/* save a copy here by not using stringToAny() */
+    buf = writeAny(data, tag, buf, len);
+    s_free(data);		/* don't use freeAny() since it will free s too */
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readString(char **s, char *buffer)
+/* Read an any and convert it into a C style string.
+   This function is not part of the Z39.50 spec.  It is provided
+   for the convenience of those wishing to pass C strings in
+   the place of an any.
+ */
+{
+    any *data = NULL;
+    char *buf = readAny(&data, buffer);
+
+    *s = anyToString(data);
+    freeAny(data);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+unsigned long writtenStringSize(data_tag tag, char *s)
+{
+    unsigned long size;
+
+    if (s == NULL)
+	return (0);
+
+    size = writtenTagSize(tag);
+    size += writtenCompressedIntSize(size);
+    size += strlen(s);
+    return (size);
+}
+
+/*----------------------------------------------------------------------*/
+
+any *longToAny(long num)
+/* a convenience function */
+{
+    char s[40];
+
+    sprintf(s, "%ld", num);
+
+    return (stringToAny(s));
+}
+
+/*----------------------------------------------------------------------*/
+
+long anyToLong(any *a)
+/* a convenience function */
+{
+    long num;
+    char *str = NULL;
+
+    str = anyToString(a);
+    sscanf(str, "%ld", &num);	/* could check the result and return
+				   an error */
+    s_free(str);
+    return (num);
+}
+
+/*----------------------------------------------------------------------*/
+
+#define bitsPerByte	8
+
+bit_map *makeBitMap(unsigned long numBits, ...)
+/* construct and return a bitmap with numBits elements */
+{
+    va_list ap;
+    unsigned long i, j;
+    bit_map *bm = NULL;
+
+    LYva_start(ap, numBits);
+
+    bm = (bit_map *) s_malloc((size_t) sizeof(bit_map));
+
+    bm->size = (unsigned long) (ceil((double) numBits / bitsPerByte));
+    bm->bytes = (char *) s_malloc((size_t) bm->size);
+
+    /* fill up the bits */
+    for (i = 0; i < bm->size; i++)	/* iterate over bytes */
+    {
+	char byte = 0;
+
+	for (j = 0; j < bitsPerByte; j++)	/* iterate over bits */
+	{
+	    if ((i * bitsPerByte + j) < numBits) {
+		boolean bit = false;
+
+		bit = (boolean) va_arg(ap, boolean);
+
+		if (bit) {
+		    byte = byte | (1 << (bitsPerByte - j - 1));
+		}
+	    }
+	}
+	bm->bytes[i] = byte;
+    }
+
+    va_end(ap);
+    return (bm);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeBitMap(bit_map *bm)
+/* destroy a bit map created by makeBitMap() */
+{
+    s_free(bm->bytes);
+    s_free(bm);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* use this routine to interpret a bit map.  pos specifies the bit
+   number.  bit 0 is the Leftmost bit of the first byte.
+   Could do bounds checking.
+ */
+
+boolean bitAtPos(unsigned long pos, bit_map *bm)
+{
+    if (pos > bm->size * bitsPerByte)
+	return false;
+    else
+	return ((bm->bytes[(pos / bitsPerByte)] &
+		 (0x80 >> (pos % bitsPerByte))) ?
+		true : false);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeBitMap(bit_map *bm, data_tag tag, char *buffer, long *len)
+/* write a bitmap + type and size info */
+{
+    return (writeAny((any *) bm, tag, buffer, len));
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readBitMap(bit_map **bm, char *buffer)
+/* read a bitmap + type and size info */
+{
+    char *c;
+
+    c = readAny((any **) bm, buffer);
+    return (c);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeByte(unsigned long byte, char *buf, long *len)
+{
+    CHECK_FOR_SPACE_LEFT(1, len);
+    buf[0] = byte & 0xFF;	/* we really only want the first byte */
+    return (buf + 1);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readByte(unsigned char *byte, char *buf)
+{
+    *byte = buf[0];
+    return (buf + 1);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeBoolean(boolean flag, char *buf, long *len)
+{
+    return (writeByte(flag, buf, len));
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readBoolean(boolean *flag, char *buffer)
+{
+    unsigned char byte;
+    char *buf = readByte(&byte, buffer);
+
+    *flag = (byte == true) ? true : false;
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writePDUType(pdu_type pduType, char *buf, long *len)
+/* PDUType is a single byte */
+{
+    return (writeBinaryInteger((long) pduType, (unsigned long) 1, buf, len));
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readPDUType(pdu_type *pduType, char *buf)
+/* PDUType is a single byte */
+{
+    return (readBinaryInteger((long *) pduType, (unsigned long) 1, buf));
+}
+
+/*----------------------------------------------------------------------*/
+
+pdu_type peekPDUType(char *buf)
+/* read the next pdu without advancing the buffer, Note that this
+   function is to be used on a buffer that is known to contain an
+   APDU.  The pdu_type is written HEADER_LEN bytes into the buffer
+ */
+{
+    pdu_type pdu;
+
+    readPDUType(&pdu, buf + HEADER_LEN);
+    return (pdu);
+}
+
+/*----------------------------------------------------------------------*/
+
+#define BINARY_INTEGER_BYTES	sizeof(long)	/* the number of bytes used by
+						   a "binary integer" */
+char *writeBinaryInteger(long num, unsigned long size, char *buf, long *len)
+/* write out first size bytes of num - no type info
+  XXX should this take unsigned longs instead ???  */
+{
+    long i;
+    char byte;
+
+    if (size < 1 || size > BINARY_INTEGER_BYTES)
+	return (NULL);		/* error */
+
+    CHECK_FOR_SPACE_LEFT(size, len);
+
+    for (i = size - 1; i >= 0; i--) {
+	byte = (char) (num & 255);
+	buf[i] = byte;
+	num = num >> bitsPerByte;	/* don't and here */
+    }
+
+    return (buf + size);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readBinaryInteger(long *num, unsigned long size, char *buf)
+/* read in first size bytes of num - no type info
+  XXX this should take unsigned longs instead !!! */
+{
+    unsigned long i;
+    unsigned char byte;
+
+    if (size < 1 || size > BINARY_INTEGER_BYTES)
+	return (buf);		/* error */
+    *num = 0;
+
+    for (i = 0; i < size; i++) {
+	byte = buf[i];
+	*num = *num << bitsPerByte;
+	*num += byte;
+    }
+
+    return (buf + size);
+}
+
+/*----------------------------------------------------------------------*/
+
+unsigned long writtenCompressedBinIntSize(long num)
+/* return the number of bytes needed to represent the value num.
+   currently limited to max of 4 bytes
+   Only compresses for positive nums - negatives get whole 4 bytes
+ */
+{
+    if (num < 0L)
+	return (4);
+    else if (num < 256L)	/* 2**8 */
+	return (1);
+    else if (num < 65536L)	/* 2**16 */
+	return (2);
+    else if (num < 16777216L)	/* 2**24 */
+	return (3);
+    else
+	return (4);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeNum(long num, data_tag tag, char *buffer, long *len)
+/* write a binary integer + size and tag info */
+{
+    char *buf = buffer;
+    long size = writtenCompressedBinIntSize(num);
+
+    if (num == UNUSED)
+	return (buffer);
+
+    buf = writeTag(tag, buf, len);
+    buf = writeCompressedInteger(size, buf, len);
+    buf = writeBinaryInteger(num, (unsigned long) size, buf, len);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readNum(long *num, char *buffer)
+/* read a binary integer + size and tag info */
+{
+    char *buf = buffer;
+    data_tag tag;
+    unsigned long size;
+    unsigned long val;
+
+    buf = readTag(&tag, buf);
+    buf = readCompressedInteger(&val, buf);
+    size = (unsigned long) val;
+    buf = readBinaryInteger(num, size, buf);
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+unsigned long writtenNumSize(data_tag tag, long num)
+{
+    long dataSize = writtenCompressedBinIntSize(num);
+    long size;
+
+    size = writtenTagSize(tag);	/* space for the tag */
+    size += writtenCompressedIntSize(dataSize);		/* space for the size */
+    size += dataSize;		/* space for the data */
+
+    return (size);
+}
+
+/*----------------------------------------------------------------------*/
+
+typedef void (voidfunc) (void *);
+
+void doList(void **list, voidfunc * func)
+/* call func on each element of the NULL terminated list of pointers */
+{
+    register long i;
+    register void *ptr = NULL;
+
+    if (list == NULL)
+	return;
+    for (i = 0, ptr = list[i]; ptr != NULL; ptr = list[++i])
+	(*func) (ptr);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *writeProtocolVersion(char *buf, long *len)
+/* write a bitmap describing the protocols available */
+{
+    static bit_map *version = NULL;
+
+    if (version == NULL) {
+	version = makeBitMap((unsigned long) 1, true);	/* version 1! */
+    }
+
+    return (writeBitMap(version, DT_ProtocolVersion, buf, len));
+}
+
+/*----------------------------------------------------------------------*/
+
+char *defaultImplementationID(void)
+{
+    static char ImplementationID[] = "TMC";
+
+    return (ImplementationID);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *defaultImplementationName(void)
+{
+    static char ImplementationName[] = "Thinking Machines Corporation Z39.50";
+
+    return (ImplementationName);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *defaultImplementationVersion(void)
+{
+    static char ImplementationVersion[] = "2.0A";
+
+    return (ImplementationVersion);
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from ZType1.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE:
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ *
+ * 3.26.90	Harry Morris, morris@think.com
+ * 4.11.90  HWM - generalized conditional includes (see c-dialect.h)
+ */
+/*----------------------------------------------------------------------*/
+
+query_term *makeAttributeTerm(char *use,
+			      char *relation,
+			      char *position,
+			      char *structure,
+			      char *truncation,
+			      char *completeness,
+			      any *term)
+{
+    query_term *qt = (query_term *) s_malloc((size_t) sizeof(query_term));
+
+    qt->TermType = TT_Attribute;
+
+    /* copy in the attributes */
+    LYStrNCpy(qt->Use, use, ATTRIBUTE_SIZE);
+    LYStrNCpy(qt->Relation, relation, ATTRIBUTE_SIZE);
+    LYStrNCpy(qt->Position, position, ATTRIBUTE_SIZE);
+    LYStrNCpy(qt->Structure, structure, ATTRIBUTE_SIZE);
+    LYStrNCpy(qt->Truncation, truncation, ATTRIBUTE_SIZE);
+    LYStrNCpy(qt->Completeness, completeness, ATTRIBUTE_SIZE);
+
+    qt->Term = duplicateAny(term);
+
+    qt->ResultSetID = NULL;
+
+    return (qt);
+}
+
+/*----------------------------------------------------------------------*/
+
+query_term *makeResultSetTerm(any *resultSet)
+{
+    query_term *qt = (query_term *) s_malloc((size_t) sizeof(query_term));
+
+    qt->TermType = TT_ResultSetID;
+
+    qt->ResultSetID = duplicateAny(resultSet);
+
+    qt->Term = NULL;
+
+    return (qt);
+}
+
+/*----------------------------------------------------------------------*/
+
+query_term *makeOperatorTerm(char *operatorCode)
+{
+    query_term *qt = (query_term *) s_malloc((size_t) sizeof(query_term));
+
+    qt->TermType = TT_Operator;
+
+    LYStrNCpy(qt->Operator, operatorCode, OPERATOR_SIZE);
+
+    qt->Term = NULL;
+    qt->ResultSetID = NULL;
+
+    return (qt);
+}
+
+/*----------------------------------------------------------------------*/
+
+void freeTerm(void *param)
+{
+    query_term *qt = (query_term *) param;
+
+    switch (qt->TermType) {
+    case TT_Attribute:
+	freeAny(qt->Term);
+	break;
+    case TT_ResultSetID:
+	freeAny(qt->ResultSetID);
+	break;
+    case TT_Operator:
+	/* do nothing */
+	break;
+    default:
+	panic("Implementation error: Unknown term type %ld",
+	      qt->TermType);
+	break;
+    }
+    s_free(qt);
+}
+
+/*----------------------------------------------------------------------*/
+
+#define ATTRIBUTE_LIST_SIZE	ATTRIBUTE_SIZE * 6
+#define AT_DELIMITER	" "
+
+char *writeQueryTerm(query_term *qt, char *buffer, long *len)
+{
+    char *buf = buffer;
+    char attributes[ATTRIBUTE_LIST_SIZE];
+
+    switch (qt->TermType) {
+    case TT_Attribute:
+	LYStrNCpy(attributes, qt->Use, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, AT_DELIMITER, sizeof(AT_DELIMITER) + 1, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, qt->Relation, ATTRIBUTE_SIZE, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, AT_DELIMITER, sizeof(AT_DELIMITER) + 1, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, qt->Position, ATTRIBUTE_SIZE, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, AT_DELIMITER, sizeof(AT_DELIMITER) + 1, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, qt->Structure, ATTRIBUTE_SIZE, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, AT_DELIMITER, sizeof(AT_DELIMITER) + 1, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, qt->Truncation, ATTRIBUTE_SIZE, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, AT_DELIMITER, sizeof(AT_DELIMITER) + 1, ATTRIBUTE_LIST_SIZE);
+	s_strncat(attributes, qt->Completeness, ATTRIBUTE_SIZE, ATTRIBUTE_LIST_SIZE);
+	buf = writeString(attributes, DT_AttributeList, buf, len);
+	buf = writeAny(qt->Term, DT_Term, buf, len);
+	break;
+    case TT_ResultSetID:
+	buf = writeAny(qt->ResultSetID, DT_ResultSetID, buf, len);
+	break;
+    case TT_Operator:
+	buf = writeString(qt->Operator, DT_Operator, buf, len);
+	break;
+    default:
+	panic("Implementation error: Unknown term type %ld",
+	      qt->TermType);
+	break;
+    }
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *readQueryTerm(query_term **qt, char *buffer)
+{
+    char *buf = buffer;
+    char *attributeList = NULL;
+    char *operator = NULL;
+    any *term;
+    char *use = NULL;
+    char *relation = NULL;
+    char *position = NULL;
+    char *structure = NULL;
+    char *truncation = NULL;
+    char *completeness;
+    any *resultSetID = NULL;
+    data_tag tag;
+
+    tag = peekTag(buffer);
+
+    switch (tag) {
+    case DT_AttributeList:
+	buf = readString(&attributeList, buf);
+	buf = readAny(&term, buf);
+	use = strtok(attributeList, AT_DELIMITER);
+	relation = strtok(NULL, AT_DELIMITER);
+	position = strtok(NULL, AT_DELIMITER);
+	structure = strtok(NULL, AT_DELIMITER);
+	truncation = strtok(NULL, AT_DELIMITER);
+	completeness = strtok(NULL, AT_DELIMITER);
+	*qt = makeAttributeTerm(use, relation, position, structure,
+				truncation, completeness, term);
+	s_free(attributeList);
+	freeAny(term);
+	break;
+    case DT_ResultSetID:
+	buf = readAny(&resultSetID, buf);
+	*qt = makeResultSetTerm(resultSetID);
+	freeAny(resultSetID);
+	break;
+    case DT_Operator:
+	buf = readString(&operator, buf);
+	*qt = makeOperatorTerm(operator);
+	s_free(operator);
+	break;
+    default:
+	REPORT_READ_ERROR(buf);
+	break;
+    }
+
+    return (buf);
+}
+
+/*----------------------------------------------------------------------*/
+
+static unsigned long getQueryTermSize(query_term *qt);
+
+static unsigned long getQueryTermSize(query_term *qt)
+/* figure out how many bytes it will take to write this query */
+{
+    unsigned long size = 0;
+    static char attributes[] = "11 22 33 44 55 66";	/* we just need this to
+
+							   calculate its written
+							   size */
+
+    switch (qt->TermType) {
+    case TT_Attribute:
+	size = writtenStringSize(DT_AttributeList, attributes);
+	size += writtenAnySize(DT_Term, qt->Term);
+	break;
+    case TT_ResultSetID:
+	size = writtenAnySize(DT_ResultSetID, qt->ResultSetID);
+	break;
+    case TT_Operator:
+	size = writtenStringSize(DT_Operator, qt->Operator);
+	break;
+    default:
+	panic("Implementation error: Unknown term type %ld",
+	      qt->TermType);
+	break;
+    }
+
+    return (size);
+}
+
+/*----------------------------------------------------------------------*/
+
+/* A query is simply a null terminated list of query terms.  For
+   transmission, a query is written into an any which is sent as
+   the user information field. */
+
+any *writeQuery(query_term **terms)
+{
+    any *info = NULL;
+    char *writePos = NULL;
+    char *data = NULL;
+    unsigned long size = 0;
+    long remaining = 0;
+    long i;
+    query_term *qt = NULL;
+
+    if (terms == NULL)
+	return (NULL);
+
+    /* calculate the size of write buffer */
+    for (i = 0, qt = terms[i]; qt != NULL; qt = terms[++i])
+	size += getQueryTermSize(qt);
+
+    data = (char *) s_malloc((size_t) size);
+
+    /* write the terms */
+    writePos = data;
+    remaining = size;
+    for (i = 0, qt = terms[i]; qt != NULL; qt = terms[++i])
+	writePos = writeQueryTerm(qt, writePos, &remaining);
+
+    info = makeAny(size, data);
+
+    return (info);
+}
+
+/*----------------------------------------------------------------------*/
+
+query_term **readQuery(any *info)
+{
+    char *readPos = info->bytes;
+    query_term **terms = NULL;
+    query_term *qt = NULL;
+    long numTerms = 0L;
+    char tmp[100];
+
+    sprintf(tmp, "readquery: bytes: %ld", info->size);
+    log_write(tmp);
+
+    while (readPos < info->bytes + info->size) {
+	readPos = readQueryTerm(&qt, readPos);
+
+	if (terms == NULL) {
+	    terms = (query_term **) s_malloc((size_t) (sizeof(query_term *) * 2));
+	} else {
+	    terms =
+		(query_term **) s_realloc((char *) terms,
+					  (size_t) (sizeof(query_term *) *
+						      (numTerms + 2)));
+	}
+	if (qt == NULL)
+	    log_write("qt = null");
+	terms[numTerms++] = qt;
+	terms[numTerms] = NULL;
+    }
+
+    return (terms);
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from panic.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* WIDE AREA INFORMATION SERVER SOFTWARE:
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ *
+ * Morris@think.com
+ */
+
+/* panic is an error system interface.  On the Mac, it will pop
+ * up a little window to explain the problem.
+ * On a unix box, it will print out the error and call perror()
+ */
+
+/*----------------------------------------------------------------------*/
+
+static void exitAction(long error);
+
+static void exitAction(long error GCC_UNUSED)
+{
+    exit_immediately(EXIT_SUCCESS);
+}
+
+/*----------------------------------------------------------------------*/
+
+#define PANIC_HEADER "Fatal Error:  "
+
+void panic(char *format, ...)
+{
+    va_list ap;			/* the variable arguments */
+
+    fprintf(stderr, PANIC_HEADER);
+    LYva_start(ap, format);	/* init ap */
+    vfprintf(stderr, format, ap);	/* print the contents */
+    va_end(ap);			/* free ap */
+    fflush(stderr);
+
+    exitAction(0);
+}
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from cutil.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+/* Wide AREA INFORMATION SERVER SOFTWARE
+ * No guarantees or restrictions.  See the readme file for the full standard
+ * disclaimer.
+ *
+ * 3.26.90	Harry Morris, morris@think.com
+ * 4.11.90  HWM - generalized conditional includes (see c-dialect.h)
+ */
+
+/*----------------------------------------------------------------------*/
+
+void fs_checkPtr(void *ptr)
+/* If the ptr is NULL, give an error */
+{
+    if (ptr == NULL)
+	panic("checkPtr found a NULL pointer");
+}
+
+/*----------------------------------------------------------------------*/
+
+void *fs_malloc(size_t size)
+/* does safety checks and optional accounting */
+{
+    register void *ptr = NULL;
+
+    ptr = (void *) calloc((size_t) size, (size_t) 1);
+    s_checkPtr(ptr);
+
+    return (ptr);
+}
+
+/*----------------------------------------------------------------------*/
+
+void *fs_realloc(void *ptr, size_t size)
+/* does safety checks and optional accounting
+   note - we don't know how big ptr's memory is, so we can't ensure
+   that any new memory allocated is NULLed!
+ */
+{
+    register void *nptr = NULL;
+
+    if (ptr == NULL)		/* this is really a malloc */
+	return (s_malloc(size));
+
+    nptr = (void *) realloc(ptr, size);
+    s_checkPtr(ptr);
+
+    return (nptr);
+}
+
+/*----------------------------------------------------------------------*/
+
+void fs_free(void *ptr)
+/* does safety checks and optional accounting */
+{
+    if (ptr != NULL)		/* some non-ansi compilers/os's can't handle freeing null */
+    {				/* if we knew the size of this block of memory, we could clear it - oh well */
+	free(ptr);
+	ptr = NULL;
+    }
+}
+
+/*----------------------------------------------------------------------*/
+
+char *s_strdup(char *s)
+
+/* return a copy of s.  This is identical to the standard library routine
+   strdup(), except that it is safe.  If s == NULL or malloc fails,
+   appropriate action is taken.
+ */
+{
+    unsigned long len;
+    char *copy = NULL;
+
+    if (s == NULL)		/* safety check to postpone stupid errors */
+	return (NULL);
+
+    len = strlen(s);		/* length of string - terminator */
+    copy = (char *) s_malloc((size_t) (sizeof(char) * (len + 1)));
+
+    StrNCpy(copy, s, len + 1);
+    return (copy);
+}
+
+/*----------------------------------------------------------------------*/
+
+char *fs_strncat(char *dst, char *src, size_t maxToAdd, size_t maxTotal)
+
+/* like strncat, except the fourth argument limits the maximum total
+   length of the resulting string
+ */
+{
+    size_t dstSize = strlen(dst);
+    size_t srcSize = strlen(src);
+
+    if (dstSize + srcSize < maxTotal)	/* use regular old strncat */
+	return (StrNCat(dst, src, maxToAdd));
+    else {
+	size_t truncateTo = maxTotal - dstSize - 1;
+	char saveChar = src[truncateTo];
+	char *result = NULL;
+
+	src[truncateTo] = '\0';
+	result = StrNCat(dst, src, maxToAdd);
+	src[truncateTo] = saveChar;
+	return (result);
+    }
+}
+
+/*----------------------------------------------------------------------*/
+
+char char_downcase(unsigned long long_ch)
+{
+    unsigned char ch = long_ch & 0xFF;	/* just want one byte */
+
+    /* when ansi is the way of the world, this can be tolower */
+    return (((ch >= 'A') && (ch <= 'Z')) ? (ch + 'a' - 'A') : ch);
+}
+
+char *string_downcase(char *word)
+{
+    long i = 0;
+
+    while (word[i] != '\0') {
+	word[i] = char_downcase((unsigned long) word[i]);
+	i++;
+    }
+    return (word);
+}
+
+/*----------------------------------------------------------------------*/
+#endif /* VMS */
diff --git a/WWW/Library/Implementation/HTVMS_WaisUI.h b/WWW/Library/Implementation/HTVMS_WaisUI.h
new file mode 100644
index 0000000..4b5b06d
--- /dev/null
+++ b/WWW/Library/Implementation/HTVMS_WaisUI.h
@@ -0,0 +1,664 @@
+/*							HTVMS_WAISUI.h
+ *
+ *	Adaptation for Lynx by F.Macrides (macrides@sci.wfeb.edu)
+ *
+ *	31-May-1994 FM	Initial version.
+ */
+
+#ifndef HTVMSWAIS_H
+#define HTVMSWAIS_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    void log_write(char *);
+
+/*
+ *	Routines originally from Panic.h -- FM
+ *
+ *----------------------------------------------------------------------*/
+
+    void panic(char *format, ...);
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from CUtil.h -- FM
+ *
+ *----------------------------------------------------------------------*/
+
+/* types and constants */
+
+#ifndef boolean
+#define boolean unsigned long
+#endif				/* boolean */
+
+#ifndef true
+#define true	(boolean)1L
+#endif				/* true */
+
+#ifndef false
+#define false	(boolean)0L	/* used to be (!true), but broke
+				   some compilers */
+#endif				/* false */
+
+#ifndef TRUE
+#define TRUE	true
+#endif				/* TRUE */
+
+#ifndef FALSE
+#define FALSE	false
+#endif				/* FALSE */
+
+/*----------------------------------------------------------------------*/
+/* functions */
+
+/* enhanced memory handling functions - don't call them directly, use the
+   macros below */
+    void fs_checkPtr(void *ptr);
+    void *fs_malloc(size_t size);
+    void *fs_realloc(void *ptr, size_t size);
+    void fs_free(void *ptr);
+    char *fs_strncat(char *dst, char *src, size_t maxToAdd, size_t maxTotal);
+
+/* macros for memory functions.  call these in your program.  */
+#define s_checkPtr(ptr)		fs_checkPtr(ptr)
+#define s_malloc(size)		fs_malloc(size)
+#define s_realloc(ptr,size)	fs_realloc((ptr),(size))
+#define s_free(ptr)		{ fs_free((char*)ptr); ptr = NULL; }
+#define s_strncat(dst,src,maxToAdd,maxTotal)	fs_strncat((dst),(src),(maxToAdd),(maxTotal))
+
+    char *s_strdup(char *s);
+
+#define IS_DELIMITER	1
+#define	NOT_DELIMITER	!IS_DELIMITER
+
+    char char_downcase(unsigned long ch);
+    char *string_downcase(char *word);
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from ZUtil.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+
+/* Data types / constants */
+
+/* bytes to leave for the header size info */
+#define HEADER_LEN	(size_t)2
+
+    typedef long pdu_type;
+
+#define	initAPDU			(pdu_type)20
+#define	initResponseAPDU		(pdu_type)21
+#define	searchAPDU			(pdu_type)22
+#define	searchResponseAPDU		(pdu_type)23
+#define	presentAPDU			(pdu_type)24
+#define	presentResponseAPDU		(pdu_type)25
+#define	deteteAPDU			(pdu_type)26
+#define	deleteResponseAPDU		(pdu_type)27
+#define	accessControlAPDU		(pdu_type)28
+#define	accessControlResponseAPDU	(pdu_type)29
+#define	resourceControlAPDU		(pdu_type)30
+#define	resourceControlResponseAPDU	(pdu_type)31
+
+    typedef struct any {	/* an any is a non-ascii string of characters */
+	unsigned long size;
+	char *bytes;
+    } any;
+
+    typedef any bit_map;	/* a bit_map is a group of packed bits */
+
+    typedef unsigned long data_tag;
+
+#define DT_PDUType			(data_tag)1
+#define	DT_ReferenceID			(data_tag)2
+#define	DT_ProtocolVersion		(data_tag)3
+#define	DT_Options			(data_tag)4
+#define	DT_PreferredMessageSize		(data_tag)5
+#define	DT_MaximumRecordSize		(data_tag)6
+#define	DT_IDAuthentication		(data_tag)7
+#define	DT_ImplementationID		(data_tag)8
+#define	DT_ImplementationName		(data_tag)9
+#define	DT_ImplementationVersion	(data_tag)10
+#define	DT_UserInformationField		(data_tag)11
+#define	DT_Result			(data_tag)12
+#define	DT_SmallSetUpperBound		(data_tag)13
+#define	DT_LargeSetLowerBound		(data_tag)14
+#define	DT_MediumSetPresentNumber	(data_tag)15
+#define	DT_ReplaceIndicator		(data_tag)16
+#define	DT_ResultSetName		(data_tag)17
+#define	DT_DatabaseNames		(data_tag)18
+#define DT_ElementSetNames		(data_tag)19
+#define	DT_QueryType			(data_tag)20
+#define	DT_Query			(data_tag)21
+#define	DT_SearchStatus			(data_tag)22
+#define	DT_ResultCount			(data_tag)23
+#define	DT_NumberOfRecordsReturned	(data_tag)24
+#define	DT_NextResultSetPosition	(data_tag)25
+#define	DT_ResultSetStatus		(data_tag)26
+#define	DT_PresentStatus		(data_tag)27
+#define	DT_DatabaseDiagnosticRecords	(data_tag)28
+#define	DT_NumberOfRecordsRequested	(data_tag)29
+#define	DT_ResultSetStartPosition	(data_tag)30
+#define	DT_ResultSetID			(data_tag)31
+#define	DT_DeleteOperation		(data_tag)32
+#define	DT_DeleteStatus			(data_tag)33
+#define	DT_NumberNotDeleted		(data_tag)34
+#define	DT_BulkStatuses			(data_tag)35
+#define	DT_DeleteMSG			(data_tag)36
+#define	DT_SecurityChallenge		(data_tag)37
+#define	DT_SecurityChallengeResponse	(data_tag)38
+#define	DT_SuspendedFlag		(data_tag)39
+#define	DT_ResourceReport		(data_tag)40
+#define	DT_PartialResultsAvailable	(data_tag)41
+#define	DT_ContinueFlag			(data_tag)42
+#define	DT_ResultSetWanted		(data_tag)43
+
+#define UNUSED	-1
+
+/* number of bytes required to represent the following sizes in compressed
+   integer format
+ */
+#define CompressedInt1Byte	128	/* 2 ^ 7 */
+#define CompressedInt2Byte	16384	/* 2 ^ 14 */
+#define CompressedInt3Byte	2097152		/* 2 ^ 21 */
+/* others may follow ... */
+
+/* types of query */
+#define QT_0	"0"		/* query whose non-standard format has been agreed upon
+				   client and server */
+/* values for InitAPDU option element */
+#define	WILL_USE		TRUE
+#define WILL_NOT_USE		FALSE
+#define WILL_SUPPORT		TRUE
+#define WILL_NOT_SUPPORT	FALSE
+
+/* values for InitResponseAPDU result element */
+#define ACCEPT	TRUE
+#define REJECT	FALSE
+
+/* values for SearchResponseAPDU search status element */
+#define	SUCCESS	0		/* intuitive huh? */
+#define FAILURE	1
+
+/* values for SearchResponseAPDU result set status element */
+#define	SUBSET	1
+#define INTERIM	2
+#define NONE	3
+
+/* values for SearchResponseAPDU present status element */
+/* SUCCESS already defined */
+#define PARTIAL_1	1
+#define PARTIAL_2	2
+#define PARTIAL_3	3
+#define PARTIAL_4	4
+#define PS_NONE		5	/* can't use NONE since it was used by result
+				   set status */
+
+#define DIAGNOSTIC_CODE_SIZE	(size_t)3
+
+    typedef struct diagnosticRecord {
+	boolean SURROGATE;
+	char DIAG[DIAGNOSTIC_CODE_SIZE];
+	char *ADDINFO;
+    } diagnosticRecord;
+
+#define D_PermanentSystemError	       "S1"
+#define D_TemporarySystemError         "S2"
+#define D_UnsupportedSearch            "S3"
+#define D_TermsOnlyStopWords           "S5"
+#define D_TooManyArgumentWords         "S6"
+#define D_TooManyBooleanOperators      "S7"
+#define D_TooManyTruncatedWords        "S8"
+#define D_TooMany IncompleteSubfields  "S9"
+#define D_TruncatedWordsTooShort       "SA"
+#define D_InvalidFormatForRecordNumber "SB"
+#define D_TooManyCharactersInSearch    "SC"
+#define D_TooManyRecordsRetrieved      "SD"
+#define D_PresentRequestOutOfRange     "SF"
+#define D_SystemErrorInPresentRecords  "SG"
+#define D_RecordNotAuthorizedToBeSent  "SH"
+#define D_RecordExceedsPrefMessageSize "SI"
+#define D_RecordExceedsMaxRecordSize   "SJ"
+#define D_ResultSetNotSuppAsSearchTerm "SK"
+#define D_OnlyOneRsltSetAsSrchTermSupp "SL"
+#define D_OnlyANDingOfASnglRsltSetSupp "SM"
+#define D_RsltSetExistsNoReplace       "SN"
+#define D_ResultSetNamingNotSupported  "SO"
+#define D_CombinationDatabasesNotSupp  "SP"
+#define D_ElementSetNamesNotSupported  "SQ"
+#define D_ElementSetNameNotValid       "SR"
+#define D_OnlyASingleElmntSetNameSupp  "SS"
+#define D_ResultSetDeletedByTarget     "ST"
+#define D_ResultSetIsInUse             "SU"
+#define D_DatabasesIsLocked            "SV"
+#define D_TerminatedByNoContinueResp   "SW"
+#define D_ResultSetDoesNotExist        "SX"
+#define D_ResExNoResultsAvailable      "SY"
+#define D_ResExUnpredictableResults    "SZ"
+#define D_ResExValidSubsetOfResults    "T1"
+#define D_AccessControlFailure         "T2"
+#define D_SecurityNotIssuedReqTerm     "T3"
+#define D_SecurityNotBeIssuedRecNotInc "T4"
+
+/*----------------------------------------------------------------------*/
+
+/* for internal error handling */
+
+    extern char *readErrorPosition;	/* pos where buf stopped making sense */
+
+/* the following are macros so that they can return OUT of the function
+   which calls them
+ */
+
+#define RETURN_ON_NULL(var)					\
+	if (var == NULL)					\
+	  return(NULL);		/* jump out of caller */
+
+#define REPORT_READ_ERROR(pos)					\
+	{ readErrorPosition = (pos);				\
+	  return(NULL); /* jump out of caller */		\
+    }
+
+#define CHECK_FOR_SPACE_LEFT(spaceNeeded,spaceLeft)		\
+	{ if (*spaceLeft >= spaceNeeded)			\
+	    (*spaceLeft) -= spaceNeeded;			\
+	  else							\
+	   { *spaceLeft = 0;					\
+	     return(NULL); /* jump out of the caller */		\
+	   }							\
+	}
+
+/*----------------------------------------------------------------------*/
+
+    diagnosticRecord *makeDiag(boolean surrogate, char *code, char *addInfo);
+    void freeDiag(diagnosticRecord * diag);
+    char *writeDiag(diagnosticRecord * diag, char *buffer, long *len);
+    char *readDiag(diagnosticRecord ** diag, char *buffer);
+
+    char *writeCompressedInteger(unsigned long num, char *buf, long *len);
+    char *readCompressedInteger(unsigned long *num, char *buf);
+    char *writeCompressedIntWithPadding(unsigned long num, unsigned long size,
+					char *buffer, long *len);
+    unsigned long writtenCompressedIntSize(unsigned long num);
+
+    char *writeTag(data_tag tag, char *buf, long *len);
+    char *readTag(data_tag *tag, char *buf);
+    data_tag peekTag(char *buf);
+    unsigned long writtenTagSize(data_tag tag);
+
+    any *makeAny(unsigned long size, char *data);
+    void freeAny(any *a);
+    any *duplicateAny(any *a);
+    char *writeAny(any *a, data_tag tag, char *buffer, long *len);
+    char *readAny(any **anAny, char *buffer);
+    unsigned long writtenAnySize(data_tag tag, any *a);
+
+    any *stringToAny(char *s);
+    char *anyToString(any *a);
+    unsigned long writtenStringSize(data_tag tag, char *s);
+
+    any *longToAny(long Num);
+    long anyToLong(any *a);
+
+    char *writeString(char *s, data_tag tag, char *buffer, long *len);
+    char *readString(char **s, char *buffer);
+
+    bit_map *makeBitMap(unsigned long numBits, ...);
+
+    void freeBitMap(bit_map *bm);
+    boolean bitAtPos(unsigned long pos, bit_map *bm);
+    char *writeBitMap(bit_map *bm, data_tag tag, char *buffer, long *len);
+    char *readBitMap(bit_map **bm, char *buffer);
+
+    char *writeByte(unsigned long byte, char *buf, long *len);
+    char *readByte(unsigned char *byte, char *buf);
+
+    char *writeBoolean(boolean flag, char *buf, long *len);
+    char *readBoolean(boolean *flag, char *buf);
+
+    char *writePDUType(pdu_type pduType, char *buf, long *len);
+    char *readPDUType(pdu_type *pduType, char *buf);
+    pdu_type peekPDUType(char *buf);
+
+    char *writeBinaryInteger(long num, unsigned long size,
+			     char *buf, long *len);
+    char *readBinaryInteger(long *num, unsigned long size, char *buf);
+    unsigned long writtenCompressedBinIntSize(long num);
+
+    char *writeNum(long num, data_tag tag, char *buffer, long *len);
+    char *readNum(long *num, char *buffer);
+    unsigned long writtenNumSize(data_tag tag, long num);
+
+    void doList(void **list, void (*func) (void *));
+
+    char *writeProtocolVersion(char *buf, long *len);
+    char *defaultImplementationID(void);
+    char *defaultImplementationName(void);
+    char *defaultImplementationVersion(void);
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from ZType1.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+
+/* This file implements the type 1 query defined in appendices B & C
+   of the SR 1 spec.
+ */
+
+/*----------------------------------------------------------------------*/
+/* types and constants */
+
+/* new data tags */
+#define	DT_AttributeList	(data_tag)44
+#define DT_Term			(data_tag)45
+#define DT_Operator		(data_tag)46
+
+#define QT_BooleanQuery	"1"	/* standard boolean query */
+
+/* general attribute code - use in place of any attribute */
+#define IGNORE			"ig"
+
+/* use value codes */
+#define	UV_ISBN			"ub"
+#define	CORPORATE_NAME		"uc"
+#define	ISSN			"us"
+#define	PERSONAL_NAME		"up"
+#define	SUBJECT			"uj"
+#define	TITLE			"ut"
+#define	GEOGRAPHIC_NAME		"ug"
+#define	CODEN			"ud"
+#define	SUBJECT_SUBDIVISION	"ue"
+#define	SERIES_TITLE		"uf"
+#define	MICROFORM_GENERATION	"uh"
+#define	PLACE_OF_PUBLICATION	"ui"
+#define	NUC_CODE		"uk"
+#define	LANGUAGE		"ul"
+#define	COMBINATION_OF_USE_VALUES	"um"
+#define	SYSTEM_CONTROL_NUMBER	"un"
+#define	DATE			"uo"
+#define	LC_CONTROL_NUMBER	"ur"
+#define	MUSIC_PUBLISHERS_NUMBER	"uu"
+#define	GOVERNMENT_DOCUMENTS_NUMBER	"uv"
+#define	SUBJECT_CLASSIFICATION	"uw"
+#define	RECORD_TYPE		"uy"
+
+/* relation value codes */
+#define	EQUAL			"re"
+#define	GREATER_THAN		"rg"
+#define	GREATER_THAN_OR_EQUAL	"ro"
+#define	LESS_THAN		"rl"
+#define	LESS_THAN_OR_EQUAL	"rp"
+#define	NOT_EQUAL		"rn"
+
+/* position value codes */
+#define	FIRST_IN_FIELD		"pf"
+#define	FIRST_IN_SUBFIELD	"ps"
+#define	FIRST_IN_A_SUBFIELD	"pa"
+#define	FIRST_IN_NOT_A_SUBFIELD	"pt"
+#define	ANY_POSITION_IN_FIELD	"py"
+
+/* structure value codes */
+#define	PHRASE			"sp"
+#define	WORD			"sw"
+#define	KEY			"sk"
+#define	WORD_LIST		"sl"
+
+/* truncation value codes */
+#define	NO_TRUNCATION		"tn"
+#define	RIGHT_TRUNCATION	"tr"
+#define	PROC_NUM_INCLUDED_IN_SEARCH_ARG	"ti"
+
+/* completeness value codes */
+#define	INCOMPLETE_SUBFIELD	"ci"
+#define	COMPLETE_SUBFIELD	"cs"
+#define	COMPLETEFIELD		"cf"
+
+/* operator codes */
+#define AND	"a"
+#define OR	"o"
+#define AND_NOT	"n"
+
+/* term types */
+#define TT_Attribute		1
+#define	TT_ResultSetID		2
+#define	TT_Operator		3
+
+#define ATTRIBUTE_SIZE		3
+#define OPERATOR_SIZE		2
+
+    typedef struct query_term {
+	/* type */
+	long TermType;
+	/* for term */
+	char Use[ATTRIBUTE_SIZE + 1];
+	char Relation[ATTRIBUTE_SIZE + 1];
+	char Position[ATTRIBUTE_SIZE + 1];
+	char Structure[ATTRIBUTE_SIZE + 1];
+	char Truncation[ATTRIBUTE_SIZE + 1];
+	char Completeness[ATTRIBUTE_SIZE + 1];
+	any *Term;
+	/* for result set */
+	any *ResultSetID;
+	/* for operator */
+	char Operator[OPERATOR_SIZE];
+    } query_term;
+
+/*----------------------------------------------------------------------*/
+/* functions */
+
+    query_term *makeAttributeTerm(char *use, char *relation, char *position, char *structure,
+				  char *truncation, char *completeness, any *term);
+    query_term *makeResultSetTerm(any *resultSet);
+    query_term *makeOperatorTerm(char *operatorCode);
+    void freeTerm(void *qt);
+    char *writeQueryTerm(query_term *qt, char *buffer, long *len);
+    char *readQueryTerm(query_term **qt, char *buffer);
+    any *writeQuery(query_term **terms);
+    query_term **readQuery(any *info);
+
+/*----------------------------------------------------------------------*/
+
+/*
+ *	Routines originally from UI.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+
+    char *generate_retrieval_apdu(char *buff,
+				  long *buff_len,
+				  any *docID,
+				  long chunk_type,
+				  long start_line, long end_line,
+				  char *type,
+				  char *database_name);
+
+    long interpret_message(char *request_message,
+			   long request_length,
+			   char *response_message,
+			   long response_buffer_length,		/* length of the buffer (modified) */
+			   long connection,
+			   boolean verbose);
+
+    char *trim_junk(char *headline);
+
+/*
+ *	Routines originally from ZProt.c -- FM
+ *
+ *----------------------------------------------------------------------*/
+
+/* APDU types */
+
+    typedef struct InitAPDU {
+	pdu_type PDUType;
+	boolean willSearch, willPresent, willDelete;
+	boolean supportAccessControl, supportResourceControl;
+	long PreferredMessageSize;
+	long MaximumRecordSize;
+	char *IDAuthentication;
+	char *ImplementationID;
+	char *ImplementationName;
+	char *ImplementationVersion;
+	any *ReferenceID;
+	void *UserInformationField;
+    } InitAPDU;
+
+    typedef struct InitResponseAPDU {
+	pdu_type PDUType;
+	boolean Result;
+	boolean willSearch, willPresent, willDelete;
+	boolean supportAccessControl, supportResourceControl;
+	long PreferredMessageSize;
+	long MaximumRecordSize;
+	char *IDAuthentication;
+	char *ImplementationID;
+	char *ImplementationName;
+	char *ImplementationVersion;
+	any *ReferenceID;
+	void *UserInformationField;
+    } InitResponseAPDU;
+
+    typedef struct SearchAPDU {
+	pdu_type PDUType;
+	long SmallSetUpperBound;
+	long LargeSetLowerBound;
+	long MediumSetPresentNumber;
+	boolean ReplaceIndicator;
+	char *ResultSetName;
+	char **DatabaseNames;
+	char *QueryType;
+	char **ElementSetNames;
+	any *ReferenceID;
+	void *Query;
+    } SearchAPDU;
+
+    typedef struct SearchResponseAPDU {
+	pdu_type PDUType;
+	long SearchStatus;
+	long ResultCount;
+	long NumberOfRecordsReturned;
+	long NextResultSetPosition;
+	long ResultSetStatus;
+	long PresentStatus;
+	any *ReferenceID;
+	void *DatabaseDiagnosticRecords;
+    } SearchResponseAPDU;
+
+    typedef struct PresentAPDU {
+	pdu_type PDUType;
+	long NumberOfRecordsRequested;
+	long ResultSetStartPosition;
+	char *ResultSetID;
+	char *ElementSetNames;
+	any *ReferenceID;
+	void *PresentInfo;
+    } PresentAPDU;
+
+    typedef struct PresentResponseAPDU {
+	pdu_type PDUType;
+	boolean PresentStatus;
+	long NumberOfRecordsReturned;
+	long NextResultSetPosition;
+	any *ReferenceID;
+	void *DatabaseDiagnosticRecords;
+    } PresentResponseAPDU;
+
+/*----------------------------------------------------------------------*/
+/* Functions */
+
+    InitAPDU *makeInitAPDU(boolean search, boolean present, boolean deleteIt,
+			   boolean accessControl, boolean resourceControl, long prefMsgSize,
+			   long maxMsgSize,
+			   char *auth,
+			   char *id,
+			   char *name,
+			   char *version,
+			   any *refID,
+			   void *userInfo);
+    void freeInitAPDU(InitAPDU * init);
+    char *writeInitAPDU(InitAPDU * init, char *buffer, long *len);
+    char *readInitAPDU(InitAPDU ** init, char *buffer);
+
+    InitResponseAPDU *makeInitResponseAPDU(boolean result,
+					   boolean search,
+					   boolean present,
+					   boolean deleteIt,
+					   boolean accessControl,
+					   boolean resourceControl,
+					   long prefMsgSize,
+					   long maxMsgSize,
+					   char *auth,
+					   char *id,
+					   char *name,
+					   char *version,
+					   any *refID,
+					   void *userInfo);
+    void freeInitResponseAPDU(InitResponseAPDU *init);
+    char *writeInitResponseAPDU(InitResponseAPDU *init, char *buffer, long *len);
+    char *readInitResponseAPDU(InitResponseAPDU **init, char *buffer);
+    InitResponseAPDU *replyToInitAPDU(InitAPDU * init, boolean result, void *userInfo);
+
+    SearchAPDU *makeSearchAPDU(long small, long large, long medium,
+			       boolean replace, char *name, char **databases,
+			       char *type, char **elements, any *refID, void *queryInfo);
+    void freeSearchAPDU(SearchAPDU *query);
+    char *writeSearchAPDU(SearchAPDU *query, char *buffer, long *len);
+    char *readSearchAPDU(SearchAPDU **query, char *buffer);
+
+    SearchResponseAPDU *makeSearchResponseAPDU(long result, long count,
+					       long recordsReturned, long nextPos,
+					       long resultStatus, long presentStatus,
+					       any *refID, void *records);
+    void freeSearchResponseAPDU(SearchResponseAPDU *queryResponse);
+    char *writeSearchResponseAPDU(SearchResponseAPDU *queryResponse, char
+				  *buffer, long *len);
+    char *readSearchResponseAPDU(SearchResponseAPDU **queryResponse, char *buffer);
+
+    PresentAPDU *makePresentAPDU(long recsReq, long startPos,
+				 char *resultID, any *refID, void *info);
+    void freePresentAPDU(PresentAPDU * present);
+    char *writePresentAPDU(PresentAPDU * present, char *buffer, long *len);
+    char *readPresentAPDU(PresentAPDU ** present, char *buffer);
+
+    PresentResponseAPDU *makePresentResponseAPDU(boolean status, long recsRet,
+						 long nextPos, any *refID,
+						 void *records);
+    void freePresentResponseAPDU(PresentResponseAPDU * present);
+    char *writePresentResponseAPDU(PresentResponseAPDU * present, char
+				   *buffer, long *len);
+    char *readPresentResponseAPDU(PresentResponseAPDU ** present, char *buffer);
+
+/*----------------------------------------------------------------------*/
+/* user extension hooks: */
+
+    extern char *writeInitInfo(InitAPDU * init, char *buffer, long *len);
+    extern char *readInitInfo(void **info, char *buffer);
+
+    extern char *writeInitResponseInfo(InitResponseAPDU *init, char *buffer, long *len);
+    extern char *readInitResponseInfo(void **info, char *buffer);
+
+    extern char *writeSearchInfo(SearchAPDU *query, char *buffer, long *len);
+    extern char *readSearchInfo(void **info, char *buffer);
+
+    extern char *writeSearchResponseInfo(SearchResponseAPDU *query, char
+					 *buffer, long *len);
+    extern char *readSearchResponseInfo(void **info, char *buffer);
+
+    extern char *writePresentInfo(PresentAPDU * present, char *buffer, long *len);
+    extern char *readPresentInfo(void **info, char *buffer);
+
+    extern char *writePresentResponseInfo(PresentResponseAPDU * present, char
+					  *buffer, long *len);
+    extern char *readPresentResponseInfo(void **info, char *buffer);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTVMSWAIS_H */
diff --git a/WWW/Library/Implementation/HTWAIS.c b/WWW/Library/Implementation/HTWAIS.c
new file mode 100644
index 0000000..3c9fb0a
--- /dev/null
+++ b/WWW/Library/Implementation/HTWAIS.c
@@ -0,0 +1,1078 @@
+/*
+ * $LynxId: HTWAIS.c,v 1.40 2020/01/21 22:22:15 tom Exp $
+ *
+ *	WorldWideWeb - Wide Area Information Server Access	HTWAIS.c
+ *	==================================================
+ *
+ *	This module allows a WWW server or client to read data from a
+ *	remote	WAIS
+ *  server, and provide that data to a WWW client in hypertext form.
+ *  Source files, once retrieved, are stored and used to provide
+ *  information about the index when that is acessed.
+ *
+ *  Authors
+ *	BK	Brewster Kahle, Thinking Machines, <Brewster@think.com>
+ *	TBL	Tim Berners-Lee, CERN <timbl@info.cern.ch>
+ *	FM	Foteos Macrides, WFEB <macrides@sci.wfeb.edu>
+ *
+ *  History
+ *	   Sep 91	TBL adapted shell-ui.c (BK) with HTRetrieve.c from WWW.
+ *	   Feb 91	TBL Generated HTML cleaned up a bit (quotes, escaping)
+ *			    Refers to lists of sources.
+ *	   Mar 93	TBL Lib 2.0 compatible module made.
+ *	   May 94	FM  Added DIRECT_WAIS support for VMS.
+ *
+ *  Bugs
+ *	Uses C stream i/o to read and write sockets, which won't work
+ *	on VMS TCP systems.
+ *
+ *	Should cache connections.
+ *
+ *	ANSI C only as written
+ *
+ *  Bugs fixed
+ *	NT Nathan Torkington (Nathan.Torkington@vuw.ac.nz)
+ *
+ *  WAIS comments:
+ *
+ *	1.	Separate directories for different system's .o would help
+ *	2.	Document ids are rather long!
+ *
+ * W WW Address mapping convention:
+ *
+ *	/servername/database/type/length/document-id
+ *
+ *	/servername/database?word+word+word
+ */
+/* WIDE AREA INFORMATION SERVER SOFTWARE:
+   No guarantees or restrictions.  See the readme file for the full standard
+   disclaimer.
+
+   Brewster@think.com
+*/
+
+#include <HTUtils.h>
+#include <HTParse.h>
+#include <HTAccess.h>		/* We implement a protocol */
+#include <HTML.h>		/* The object we will generate */
+#include <HTWSRC.h>
+#include <HTTCP.h>
+#include <HTCJK.h>
+#include <HTAlert.h>
+#include <LYStrings.h>
+
+#undef lines			/* term.h conflict with wais.h */
+#undef alloca			/* alloca.h conflict with wais.h */
+
+/*			From WAIS
+ *			---------
+ */
+#ifdef VMS
+#include <HTVMS_WaisUI.h>
+#include <HTVMS_WaisProt.h>
+#elif defined(HAVE_WAIS_H)
+#include <wais.h>
+#else
+#include <ui.h>
+#endif /* VMS */
+
+#define MAX_MESSAGE_LEN 100000
+#define CHARS_PER_PAGE 10000	/* number of chars retrieved in each request */
+
+#define WAISSEARCH_DATE "Fri Jul 19 1991"
+
+/*			FROM WWW
+ *			--------
+ */
+#include <LYUtils.h>
+#include <LYLeaks.h>
+
+#define DIRECTORY "/cnidr.org:210/directory-of-servers"
+/* #define DIRECTORY "/quake.think.com:210/directory-of-servers" */
+
+#define BIG 1024		/* identifier size limit  @@@@@ */
+
+#define BUFFER_SIZE 4096	/* Arbitrary size for efficiency */
+
+#define HEX_ESCAPE '%'
+
+static BOOL as_gate;		/* Client is using us as gateway */
+
+static char line[2048];		/* For building strings to display */
+
+				/* Must be able to take id */
+
+#define PUTC(c) (*target->isa->put_character)(target, c)
+#define PUTS(s) (*target->isa->put_string)(target, s)
+#define START(e) (*target->isa->start_element)(target, e, 0, 0, -1, 0)
+#define END(e) (*target->isa->end_element)(target, e, 0)
+#define MAYBE_END(e) if (HTML_dtd.tags[e].contents != SGML_EMPTY) \
+			(*target->isa->end_element)(target, e, 0)
+#define FREE_TARGET (*target->isa->_free)(target)
+
+struct _HTStructured {
+    const HTStructuredClass *isa;
+    /* ... */
+};
+
+/* ------------------------------------------------------------------------ */
+/* ---------------- Local copy of connect_to_server calls ----------------- */
+/* ------------------------------------------------------------------------ */
+/* Returns 1 on success, 0 on fail, -1 on interrupt. */
+static int fd_mosaic_connect_to_server(char *host_name,
+				       long port,
+				       long *fd)
+{
+    char *dummy = NULL;
+    int status;
+    int result;
+
+    HTSprintf0(&dummy, "%s//%s:%ld/", STR_WAIS_URL, host_name, port);
+
+    status = HTDoConnect(dummy, "WAIS", 210, (int *) fd);
+    if (status == HT_INTERRUPTED) {
+	result = -1;
+    } else if (status < 0) {
+	result = 0;
+    } else {
+	result = 1;
+    }
+    FREE(dummy);
+    return result;
+}
+
+/* Returns 1 on success, 0 on fail, -1 on interrupt. */
+#ifdef VMS
+static int mosaic_connect_to_server(char *host_name,
+				    long port,
+				    long *fdp)
+#else
+static int mosaic_connect_to_server(char *host_name,
+				    long port,
+				    FILE **fp)
+#endif				/* VMS */
+{
+#ifndef VMS
+    FILE *file;
+#endif /* VMS */
+    long fd;
+    int rv;
+
+    rv = fd_mosaic_connect_to_server(host_name, port, &fd);
+    if (rv == 0) {
+	HTAlert(gettext("Could not connect to WAIS server."));
+	return 0;
+    } else if (rv == -1) {
+	HTAlert(CONNECTION_INTERRUPTED);
+	return -1;
+    }
+#ifndef VMS
+    if ((file = fdopen(fd, "r+")) == NULL) {
+	HTAlert(gettext("Could not open WAIS connection for reading."));
+	return 0;
+    }
+
+    *fp = file;
+#else
+    *fdp = fd;
+#endif /* VMS */
+    return 1;
+}
+/* ------------------------------------------------------------------------ */
+/* ------------------------------------------------------------------------ */
+
+/*								showDiags
+*/
+/* modified from Jonny G's version in ui/question.c */
+static void showDiags(HTStream *target, diagnosticRecord ** d)
+{
+    long i;
+
+    for (i = 0; d[i] != NULL; i++) {
+	if (d[i]->ADDINFO != NULL) {
+	    PUTS(gettext("Diagnostic code is "));
+	    PUTS(d[i]->DIAG);
+	    PUTC(' ');
+	    PUTS(d[i]->ADDINFO);
+	    PUTC('\n');
+	}
+    }
+}
+
+/*	Matrix of allowed characters in filenames
+ *	-----------------------------------------
+ */
+
+static BOOL acceptable[256];
+static BOOL acceptable_inited = NO;
+
+static void init_acceptable(void)
+{
+    unsigned int i;
+    char *good =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./-_$";
+
+    for (i = 0; i < 256; i++)
+	acceptable[i] = NO;
+    for (; *good; good++)
+	acceptable[(unsigned int) *good] = YES;
+    acceptable_inited = YES;
+}
+
+/*	Transform file identifier into WWW address
+ *	------------------------------------------
+ *
+ *
+ * On exit,
+ *	returns		nil if error
+ *			pointer to malloced string (must be freed) if ok
+ */
+static char *WWW_from_archie(char *file)
+{
+    char *end;
+    char *result;
+    char *colon;
+
+    for (end = file; *end > ' '; end++) ;	/* assumes ASCII encoding */
+    result = (char *) malloc(10 + (end - file));
+    if (!result)
+	return result;		/* Malloc error */
+    strcpy(result, "file://");
+    StrNCat(result, file, end - file);
+    colon = StrChr(result + 7, ':');	/* Expect colon after host */
+    if (colon) {
+	for (; colon[0]; colon[0] = colon[1], colon++) ;	/* move down */
+    }
+    return result;
+}				/* WWW_from_archie */
+
+/*	Transform document identifier into URL
+ *	--------------------------------------
+ *
+ *  Bugs: A static buffer of finite size is used!
+ *	The format of the docid MUST be good!
+ *
+ *  On exit,
+ *	returns		nil if error
+ *			pointer to malloced string (must be freed) if ok
+ */
+static char hex[17] = "0123456789ABCDEF";
+
+static char *WWW_from_WAIS(any *docid)
+{
+    static char buf[BIG];
+    char *q = buf;
+    char *p = (docid->bytes);
+    char *result = NULL;
+    int i, l;
+
+    if (TRACE) {
+	char *p2;
+
+	fprintf(tfp, "WAIS id (%d bytes) is ", (int) docid->size);
+	for (p2 = docid->bytes; p2 < docid->bytes + docid->size; p2++) {
+	    if ((*p2 >= ' ') && (*p2 <= '~'))	/* Assume ASCII! */
+		fprintf(tfp, "%c", *p2);
+	    else
+		fprintf(tfp, "<%x>", (unsigned) *p2);
+	}
+	fprintf(tfp, "\n");
+    }
+    for (p = docid->bytes;
+	 (p < docid->bytes + docid->size) && (q < &buf[BIG]);) {
+	CTRACE((tfp, "    Record type %d, length %d\n", p[0], p[1]));
+	if (*p > 10) {
+	    CTRACE((tfp, "Eh?  DOCID record type of %d!\n", *p));
+	    return 0;
+	} {			/* Bug fix -- allow any byte value 15 Apr 93 */
+	    unsigned int i2 = (unsigned) *p++;
+
+	    if (i2 > 99) {
+		*q++ = (i2 / 100) + '0';
+		i2 = i2 % 100;
+	    }
+	    if (i2 > 9) {
+		*q++ = (i2 / 10) + '0';
+		i2 = i2 % 10;
+	    }
+	    *q++ = i2 + '0';	/* Record type */
+	}
+	*q++ = '=';		/* Separate */
+	l = *p++;		/* Length */
+	for (i = 0; i < l; i++, p++) {
+	    if (!acceptable[UCH(*p)]) {
+		*q++ = HEX_ESCAPE;	/* Means hex coming */
+		*q++ = hex[(*p) >> 4];
+		*q++ = hex[(*p) & 15];
+	    } else
+		*q++ = *p;
+	}
+	*q++ = ';';		/* Terminate field */
+    }
+    *q++ = 0;			/* Terminate string */
+    CTRACE((tfp, "WWW form of id: %s\n", buf));
+    StrAllocCopy(result, buf);
+    return result;
+}				/* WWW_from_WAIS */
+
+/*	Transform URL into WAIS document identifier
+ *	-------------------------------------------
+ *
+ *  On entry,
+ *	docname		points to valid name produced originally by
+ *			WWW_from_WAIS
+ *  On exit,
+ *	docid->size	is valid
+ *	docid->bytes	is malloced and must later be freed.
+ */
+static any *WAIS_from_WWW(any *docid, char *docname)
+{
+    char *z;			/* Output pointer */
+    char *sor;			/* Start of record - points to size field. */
+    char *p;			/* Input pointer */
+    char *q;			/* Poisition of "=" */
+    char *s;			/* Position of semicolon */
+    int n;			/* size */
+
+    CTRACE((tfp, "WWW id (to become WAIS id): %s\n", docname));
+    for (n = 0, p = docname; *p; p++) {		/* Count sizes of strings */
+	n++;
+	if (*p == ';')
+	    n--;		/* Not converted */
+	else if (*p == HEX_ESCAPE)
+	    n = n - 2;		/* Save two bytes */
+	docid->size = n;
+    }
+
+    if (!(docid->bytes = (char *) malloc(docid->size)))		/* result record */
+	outofmem(__FILE__, "WAIS_from_WWW");
+    z = docid->bytes;
+
+    for (p = docname; *p;) {	/* Convert of strings */
+	/* Record type */
+
+	*z = 0;			/* Initialize record type */
+	while (*p >= '0' && *p <= '9') {
+	    *z = *z * 10 + (*p++ - '0');	/* Decode decimal record type */
+	}
+	z++;
+	if (*p != '=')
+	    return 0;
+	q = p;
+
+	s = StrChr(q, ';');	/* (Check only) */
+	if (!s)
+	    return 0;		/* Bad! No ';'; */
+	sor = z;		/* Remember where the size field was */
+	z++;			/* Skip record size for now     */
+	for (p = q + 1; *p != ';';) {
+	    if (*p == HEX_ESCAPE) {
+		char c;
+		unsigned int b;
+
+		p++;
+		c = *p++;
+		b = from_hex(c);
+		c = *p++;
+		if (!c)
+		    break;	/* Odd number of chars! */
+		*z++ = (b << 4) + from_hex(c);
+	    } else {
+		*z++ = *p++;	/* Record */
+	    }
+	}
+	*sor = (z - sor - 1);	/* Fill in size -- not counting size itself */
+	p++;			/* After semicolon: start of next record */
+    }
+
+    if (TRACE) {
+	char *p2;
+
+	fprintf(tfp, "WAIS id (%d bytes) is ", (int) docid->size);
+	for (p2 = docid->bytes; p2 < docid->bytes + docid->size; p2++) {
+	    if ((*p2 >= ' ') && (*p2 <= '~'))	/* Assume ASCII! */
+		fprintf(tfp, "%c", *p2);
+	    else
+		fprintf(tfp, "<%x>", (unsigned) *p2);
+	}
+	fprintf(tfp, "\n");
+    }
+    return docid;		/* Ok */
+
+}				/* WAIS_from_WWW */
+
+/*	Send a plain text record to the client		output_text_record()
+ *	--------------------------------------
+ */
+static void output_text_record(HTStream *target,
+			       WAISDocumentText *record,
+			       boolean binary)
+{
+    unsigned long count;
+
+    /* printf(" Text\n");
+       print_any("     DocumentID:  ", record->DocumentID);
+       printf("     VersionNumber:  %d\n", record->VersionNumber);
+     */
+
+    if (binary) {
+	(*target->isa->put_block) (target,
+				   record->DocumentText->bytes,
+				   record->DocumentText->size);
+	return;
+    }
+
+    for (count = 0; count < record->DocumentText->size; count++) {
+	long ch = (unsigned char) record->DocumentText->bytes[count];
+
+	if (ch == 27) {		/* What is this in for?  Tim */
+	    /* then we have an escape code */
+	    /* if the next letter is '(' or ')', then ignore two letters */
+	    if ('(' == record->DocumentText->bytes[count + 1] ||
+		')' == record->DocumentText->bytes[count + 1])
+		count += 1;	/* it is a term marker */
+	    else
+		count += 4;	/* it is a paragraph marker */
+	} else if (ch == '\n' || ch == '\r') {
+	    PUTC('\n');
+	} else if (IS_CJK_TTY || ch == '\t' || isprint(ch)) {
+	    PUTC(ch);
+	}
+    }
+}				/* output text record */
+
+/*	Format A Search response for the client		display_search_response
+ *	---------------------------------------
+ */
+/* modified from tracy shen's version in wutil.c
+ * displays either a text record or a set of headlines.
+ */
+static void display_search_response(HTStructured * target, SearchResponseAPDU *response,
+				    char *the_database,
+				    char *keywords)
+{
+    WAISSearchResponse *info;
+    long i, k;
+
+    BOOL archie = strstr(the_database, "archie") != 0;	/* Special handling */
+
+    CTRACE((tfp, "HTWAIS: Displaying search response\n"));
+    PUTS(gettext("Index "));
+    START(HTML_EM);
+    PUTS(the_database);
+    END(HTML_EM);
+    sprintf(line, gettext(" contains the following %d item%s relevant to \""),
+	    (int) (response->NumberOfRecordsReturned),
+	    response->NumberOfRecordsReturned == 1 ? "" : "s");
+    PUTS(line);
+    START(HTML_EM);
+    PUTS(keywords);
+    END(HTML_EM);
+    PUTS("\".\n");
+    PUTS(gettext("The first figure after each entry is its relative score, "));
+    PUTS(gettext("the second is the number of lines in the item."));
+    START(HTML_BR);
+    START(HTML_BR);
+    PUTC('\n');
+    START(HTML_OL);
+
+    if (response->DatabaseDiagnosticRecords != 0) {
+	info = (WAISSearchResponse *) response->DatabaseDiagnosticRecords;
+	i = 0;
+
+	if (info->Diagnostics != NULL)
+	    showDiags((HTStream *) target, info->Diagnostics);
+
+	if (info->DocHeaders != 0) {
+	    for (k = 0; info->DocHeaders[k] != 0; k++) {
+		WAISDocumentHeader *head = info->DocHeaders[k];
+		char *headline = trim_junk(head->Headline);
+		any *docid = head->DocumentID;
+		char *docname;	/* printable version of docid */
+
+		i++;
+		/*
+		 * Make a printable string out of the document id.
+		 */
+		CTRACE((tfp, "HTWAIS:  %2ld: Score: %4ld, lines:%4ld '%s'\n",
+			i,
+			(long int) (info->DocHeaders[k]->Score),
+			(long int) (info->DocHeaders[k]->Lines),
+			headline));
+
+		START(HTML_LI);
+
+		if (archie) {
+		    char *www_name = WWW_from_archie(headline);
+
+		    if (www_name) {
+			HTStartAnchor(target, NULL, www_name);
+			PUTS(headline);
+			END(HTML_A);
+			FREE(www_name);
+		    } else {
+			PUTS(headline);
+			PUTS(gettext(" (bad file name)"));
+		    }
+		} else {	/* Not archie */
+		    docname = WWW_from_WAIS(docid);
+		    if (docname) {
+			if ((head->Types) &&
+			    (!strcmp(head->Types[0], "URL"))) {
+			    HTStartAnchor(target, NULL, headline);
+			} else {
+			    char *dbname = HTEscape(the_database, URL_XPALPHAS);
+			    char *w3_address = NULL;
+
+			    HTSprintf0(&w3_address,
+				       "/%s/%s/%d/%s",
+				       dbname,
+				       head->Types ? head->Types[0] : "TEXT",
+				       (int) (head->DocumentLength),
+				       docname);
+			    HTStartAnchor(target, NULL, w3_address);
+			    FREE(w3_address);
+			    FREE(dbname);
+			}
+			PUTS(headline);
+			END(HTML_A);
+			FREE(docname);
+		    } else {
+			PUTS(gettext("(bad doc id)"));
+		    }
+		}
+
+		sprintf(line, "%5ld  %5ld  ",
+			head->Score,
+			head->Lines);
+		PUTS(line);
+		MAYBE_END(HTML_LI);
+	    }			/* next document header */
+	}
+	/* if there were any document headers */
+	if (info->ShortHeaders != 0) {
+	    k = 0;
+	    while (info->ShortHeaders[k] != 0) {
+		i++;
+		PUTS(gettext("(Short Header record, can't display)"));
+	    }
+	}
+	if (info->LongHeaders != 0) {
+	    k = 0;
+	    while (info->LongHeaders[k] != 0) {
+		i++;
+		PUTS(gettext("\nLong Header record, can't display\n"));
+	    }
+	}
+	if (info->Text != 0) {
+	    k = 0;
+	    while (info->Text[k] != 0) {
+		i++;
+		PUTS(gettext("\nText record\n"));
+		output_text_record((HTStream *) target,
+				   info->Text[k++], false);
+	    }
+	}
+	if (info->Headlines != 0) {
+	    k = 0;
+	    while (info->Headlines[k] != 0) {
+		i++;
+		PUTS(gettext("\nHeadline record, can't display\n"));
+		/* dsply_headline_record( info->Headlines[k++]); */
+	    }
+	}
+	if (info->Codes != 0) {
+	    k = 0;
+	    while (info->Codes[k] != 0) {
+		i++;
+		PUTS(gettext("\nCode record, can't display\n"));
+		/* dsply_code_record( info->Codes[k++]); */
+	    }
+	}
+    }				/* Loop: display user info */
+    END(HTML_OL);
+    PUTC('\n');
+}
+
+/*		Load by name					HTLoadWAIS
+ *		============
+ *
+ *  This renders any object or search as required.
+ */
+int HTLoadWAIS(const char *arg,
+	       HTParentAnchor *anAnchor,
+	       HTFormat format_out,
+	       HTStream *sink)
+#define MAX_KEYWORDS_LENGTH 1000
+#define MAX_SERVER_LENGTH 1000
+#define MAX_DATABASE_LENGTH 1000
+#define MAX_SERVICE_LENGTH 1000
+#define MAXDOCS 200
+
+{
+    char *key;			/* pointer to keywords in URL */
+    char *request_message = NULL;	/* arbitrary message limit */
+    char *response_message = NULL;	/* arbitrary message limit */
+    long request_buffer_length;	/* how of the request is left */
+    SearchResponseAPDU *retrieval_response = 0;
+    char keywords[MAX_KEYWORDS_LENGTH + 1];
+    char *the_server_name;
+    char *wais_database = NULL;	/* name of current database */
+    char *www_database;		/* Same name escaped */
+    char *service;
+    char *doctype;
+    char *doclength;
+    long document_length = 0;
+    char *docname = 0;
+
+#ifdef VMS
+    long connection = 0;
+
+#else
+    FILE *connection = NULL;
+#endif /* VMS */
+    char *names;		/* Copy of arg to be hacked up */
+    BOOL ok = NO;
+    int return_status = HT_LOADED;
+    int rv;
+
+    if (!acceptable_inited)
+	init_acceptable();
+
+    /* Decipher and check syntax of WWW address:
+     * ----------------------------------------
+     *
+     * First we remove the "wais:" if it was specified.  920110
+     */
+    names = HTParse(arg, "", PARSE_HOST | PARSE_PATH | PARSE_PUNCTUATION);
+    key = StrChr(names, '?');
+
+    if (key) {
+	char *p;
+
+	*key++ = 0;		/* Split off keywords */
+	for (p = key; *p; p++)
+	    if (*p == '+')
+		*p = ' ';
+	HTUnEscape(key);
+    }
+    if (names[0] == '/') {
+	the_server_name = names + 1;
+	if ((as_gate = (*the_server_name == '/')) != 0)
+	    the_server_name++;	/* Accept one or two */
+	www_database = StrChr(the_server_name, '/');
+	if (www_database) {
+	    *www_database++ = 0;	/* Separate database name */
+	    doctype = StrChr(www_database, '/');
+	    if (key)
+		ok = YES;	/* Don't need doc details */
+	    else if (doctype) {	/* If not search parse doc details */
+		*doctype++ = 0;	/* Separate rest of doc address */
+		doclength = StrChr(doctype, '/');
+		if (doclength) {
+		    *doclength++ = 0;
+		    document_length = atol(doclength);
+		    if (document_length) {
+			docname = StrChr(doclength, '/');
+			if (docname) {
+			    *docname++ = 0;
+			    ok = YES;	/* To avoid a goto! */
+			}	/* if docname */
+		    }		/* if document_length valid */
+		}		/* if doclength */
+	    } else {		/* no doctype?  Assume index required */
+		if (!key)
+		    key = "";
+		ok = YES;
+	    }			/* if doctype */
+	}			/* if database */
+    }
+
+    if (!ok)
+	return HTLoadError(sink, 500, gettext("Syntax error in WAIS URL"));
+
+    CTRACE((tfp, "HTWAIS: Parsed OK\n"));
+
+    service = StrChr(names, ':');
+    if (service)
+	*service++ = 0;
+    else
+	service = "210";
+
+    if (the_server_name[0] == 0) {
+#ifdef VMS
+	connection = 0;
+#else
+	connection = NULL;
+#endif /* VMS */
+
+    } else if (!(key && !*key)) {
+	int status;
+
+	CTRACE((tfp, "===WAIS=== calling mosaic_connect_to_server\n"));
+	status = mosaic_connect_to_server(the_server_name,
+					  atoi(service),
+					  &connection);
+	if (status == 0) {
+	    CTRACE((tfp, "===WAIS=== connection failed\n"));
+	    FREE(names);
+	    return HT_NOT_LOADED;
+	} else if (status == -1) {
+	    CTRACE((tfp, "===WAIS=== connection interrupted\n"));
+	    FREE(names);
+	    return HT_NOT_LOADED;
+	}
+    }
+
+    StrAllocCopy(wais_database, www_database);
+    HTUnEscape(wais_database);
+
+    /*
+     * This below fixed size stuff is terrible.
+     */
+#ifdef VMS
+    if ((request_message = typecallocn(char, MAX_MESSAGE_LEN)) == 0)
+	  outofmem(__FILE__, "HTLoadWAIS");
+    if ((response_message = typecallocn(char, MAX_MESSAGE_LEN)) == 0)
+	  outofmem(__FILE__, "HTLoadWAIS");
+
+#else
+    request_message = (char *) s_malloc((size_t) MAX_MESSAGE_LEN * sizeof(char));
+    response_message = (char *) s_malloc((size_t) MAX_MESSAGE_LEN * sizeof(char));
+#endif /* VMS */
+
+    /*
+     * If keyword search is performed but there are no keywords, the user has
+     * followed a link to the index itself.  It would be appropriate at this
+     * point to send him the .SRC file - how?
+     */
+    if (key && !*key) {		/* I N D E X */
+#ifdef CACHE_FILE_PREFIX
+	char *filename = NULL;
+	FILE *fp;
+#endif
+	HTStructured *target = HTML_new(anAnchor, format_out, sink);
+
+	START(HTML_HEAD);
+	PUTC('\n');
+	HTStartIsIndex(target, HTWAIS_SOLICIT_QUERY, NULL);
+	PUTC('\n');
+
+	{
+	    START(HTML_TITLE);
+	    PUTS(wais_database);
+	    PUTS(gettext(" (WAIS Index)"));
+	    END(HTML_TITLE);
+	    PUTC('\n');
+	    END(HTML_HEAD);
+	    PUTC('\n');
+
+	    START(HTML_H1);
+	    PUTS(gettext("WAIS Index: "));
+	    START(HTML_EM);
+	    PUTS(wais_database);
+	    END(HTML_EM);
+	    END(HTML_H1);
+	    PUTC('\n');
+	    PUTS(gettext("This is a link for searching the "));
+	    START(HTML_EM);
+	    PUTS(wais_database);
+	    END(HTML_EM);
+	    PUTS(gettext(" WAIS Index.\n"));
+
+	}
+	/*
+	 * If we have seen a source file for this database, use that.
+	 */
+#ifdef CACHE_FILE_PREFIX
+	HTSprintf0(&filename, "%sWSRC-%s:%s:%.100s.txt",
+		   CACHE_FILE_PREFIX,
+		   the_server_name, service, www_database);
+
+	fp = fopen(filename, "r");	/* Have we found this already? */
+	CTRACE((tfp, "HTWAIS: Description of server %s %s.\n",
+		filename,
+		fp ? "exists already" : "does NOT exist!"));
+
+	if (fp) {
+	    char c;
+
+	    START(HTML_PRE);	/* Preformatted description */
+	    PUTC('\n');
+	    while ((c = getc(fp)) != EOF)
+		PUTC(c);	/* Transfer file */
+	    END(HTML_PRE);
+	    fclose(fp);
+	}
+	FREE(filename);
+#endif
+	START(HTML_P);
+	PUTS(gettext("\nEnter the 's'earch command and then specify search words.\n"));
+
+	FREE_TARGET;
+    } else if (key) {		/* S E A R C H */
+	char *p;
+	HTStructured *target;
+
+	LYStrNCpy(keywords, key, MAX_KEYWORDS_LENGTH);
+	while ((p = StrChr(keywords, '+')) != 0)
+	    *p = ' ';
+
+	/*
+	 * Send advance title to get something fast to the other end.
+	 */
+	target = HTML_new(anAnchor, format_out, sink);
+
+	START(HTML_HEAD);
+	PUTC('\n');
+	HTStartIsIndex(target, HTWAIS_SOLICIT_QUERY, NULL);
+	PUTC('\n');
+	START(HTML_TITLE);
+	PUTS(keywords);
+	PUTS(gettext(" (in "));
+	PUTS(wais_database);
+	PUTC(')');
+	END(HTML_TITLE);
+	PUTC('\n');
+	END(HTML_HEAD);
+	PUTC('\n');
+
+	START(HTML_H1);
+	PUTS(gettext("WAIS Search of \""));
+	START(HTML_EM);
+	PUTS(keywords);
+	END(HTML_EM);
+	PUTS(gettext("\" in: "));
+	START(HTML_EM);
+	PUTS(wais_database);
+	END(HTML_EM);
+	END(HTML_H1);
+	PUTC('\n');
+
+	request_buffer_length = MAX_MESSAGE_LEN;	/* Amount left */
+	CTRACE((tfp, "HTWAIS: Search for `%s' in `%s'\n",
+		keywords, wais_database));
+	if (NULL ==
+	    generate_search_apdu(request_message + HEADER_LENGTH,
+				 &request_buffer_length,
+				 keywords, wais_database, NULL, MAXDOCS)) {
+#ifdef VMS
+	    HTAlert(gettext("HTWAIS: Request too large."));
+	    return_status = HT_NOT_LOADED;
+	    FREE_TARGET;
+	    goto CleanUp;
+#else
+	    panic("request too large");
+#endif /* VMS */
+	}
+
+	HTProgress(gettext("Searching WAIS database..."));
+	rv = interpret_message(request_message,
+			       MAX_MESSAGE_LEN - request_buffer_length,
+			       response_message,
+			       MAX_MESSAGE_LEN,
+			       connection,
+			       false	/* true verbose */
+	    );
+
+	if (rv == HT_INTERRUPTED) {
+	    HTAlert(gettext("Search interrupted."));
+	    return_status = HT_INTERRUPTED;
+	    FREE_TARGET;
+	    goto CleanUp;
+	} else if (!rv) {
+#ifdef VMS
+	    HTAlert(HTWAIS_MESSAGE_TOO_BIG);
+	    return_status = HT_NOT_LOADED;
+	    FREE_TARGET;
+	    goto CleanUp;
+#else
+	    panic("returned message too large");
+#endif /* VMS */
+	} else {		/* returned message ok */
+	    SearchResponseAPDU *query_response = 0;
+
+	    readSearchResponseAPDU(&query_response,
+				   response_message + HEADER_LENGTH);
+	    display_search_response(target,
+				    query_response, wais_database, keywords);
+	    if (query_response->DatabaseDiagnosticRecords)
+		freeWAISSearchResponse(query_response->DatabaseDiagnosticRecords);
+	    freeSearchResponseAPDU(query_response);
+	}			/* returned message not too large */
+	FREE_TARGET;
+    } else {			/* D O C U M E N T    F E T C H */
+	HTFormat format_in;
+	boolean binary;		/* how to transfer stuff coming over */
+	HTStream *target;
+	long count;
+	any doc_chunk;
+	any *docid = &doc_chunk;
+
+	CTRACE((tfp,
+		"HTWAIS: Retrieve document id `%s' type `%s' length %ld\n",
+		NonNull(docname), doctype, document_length));
+
+	format_in =
+	    !strcmp(doctype, "WSRC") ? HTAtom_for("application/x-wais-source") :
+	    !strcmp(doctype, "TEXT") ? HTAtom_for(STR_PLAINTEXT) :
+	    !strcmp(doctype, "HTML") ? HTAtom_for(STR_HTML) :
+	    !strcmp(doctype, "GIF") ? HTAtom_for("image/gif") :
+	    HTAtom_for(STR_BINARY);
+	binary =
+	    0 != strcmp(doctype, "WSRC") &&
+	    0 != strcmp(doctype, "TEXT") &&
+	    0 != strcmp(doctype, "HTML");
+
+	target = HTStreamStack(format_in, format_out, sink, anAnchor);
+	if (!target)
+	    return HTLoadError(sink, 500,
+			       gettext("Can't convert format of WAIS document"));
+	/*
+	 * Decode hex or literal format for document ID.
+	 */
+	WAIS_from_WWW(docid, docname);
+
+	/*
+	 * Loop over slices of the document.
+	 */
+	for (count = 0;
+	     count * CHARS_PER_PAGE < document_length;
+	     count++) {
+#ifdef VMS
+	    char *type = NULL;
+
+	    StrAllocCopy(type, doctype);
+#else
+	    char *type = s_strdup(doctype);	/* Gets freed I guess */
+#endif /* VMS */
+	    request_buffer_length = MAX_MESSAGE_LEN;	/* Amount left */
+	    CTRACE((tfp, "HTWAIS: Slice number %ld\n", count));
+
+	    if (HTCheckForInterrupt()) {
+		HTAlert(TRANSFER_INTERRUPTED);
+		(*target->isa->_abort) (target, NULL);
+#ifdef VMS
+		FREE(type);
+#endif /* VMS */
+		return_status = HT_NOT_LOADED;
+		goto CleanUp;
+	    }
+
+	    if (0 ==
+		generate_retrieval_apdu(request_message + HEADER_LENGTH,
+					&request_buffer_length,
+					docid,
+					CT_byte,
+					count * CHARS_PER_PAGE,
+					(((count + 1) * CHARS_PER_PAGE <= document_length)
+					 ? (count + 1) * CHARS_PER_PAGE
+					 : document_length),
+					type,
+					wais_database)) {
+#ifdef VMS
+		HTAlert(gettext("HTWAIS: Request too long."));
+		return_status = HT_NOT_LOADED;
+		FREE_TARGET;
+		FREE(type);
+		FREE(docid->bytes);
+		goto CleanUp;
+#else
+		panic("request too long");
+#endif /* VMS */
+	    }
+
+	    /*
+	     * Actually do the transaction given by request_message.
+	     */
+	    HTProgress(gettext("Fetching WAIS document..."));
+	    rv = interpret_message(request_message,
+				   MAX_MESSAGE_LEN - request_buffer_length,
+				   response_message,
+				   MAX_MESSAGE_LEN,
+				   connection,
+				   false	/* true verbose */
+		);
+	    if (rv == HT_INTERRUPTED) {
+		HTAlert(TRANSFER_INTERRUPTED);
+		return_status = HT_INTERRUPTED;
+		FREE_TARGET;
+		FREE(type);
+		FREE(docid->bytes);
+		goto CleanUp;
+	    } else if (!rv) {
+#ifdef VMS
+		HTAlert(HTWAIS_MESSAGE_TOO_BIG);
+		return_status = HT_NOT_LOADED;
+		FREE_TARGET;
+		FREE(type);
+		FREE(docid->bytes);
+		goto CleanUp;
+#else
+		panic("Returned message too large");
+#endif /* VMS */
+	    }
+
+	    /*
+	     * Parse the result which came back into memory.
+	     */
+	    readSearchResponseAPDU(&retrieval_response,
+				   response_message + HEADER_LENGTH);
+
+	    if (NULL ==
+		((WAISSearchResponse *)
+		 retrieval_response->DatabaseDiagnosticRecords)->Text) {
+		/* display_search_response(target, retrieval_response,
+		   wais_database, keywords); */
+		PUTS(gettext("No text was returned!\n"));
+		/* panic("No text was returned"); */
+	    } else {
+		output_text_record(target,
+				   ((WAISSearchResponse *)
+				    retrieval_response->DatabaseDiagnosticRecords)->Text[0],
+				   binary);
+	    }			/* If text existed */
+
+#ifdef VMS
+	    FREE(type);
+#endif /* VMS */
+	}			/* Loop over slices */
+
+	FREE_TARGET;
+	FREE(docid->bytes);
+
+	freeWAISSearchResponse(retrieval_response->DatabaseDiagnosticRecords);
+	freeSearchResponseAPDU(retrieval_response);
+
+    }				/* If document rather than search */
+
+  CleanUp:
+    /*
+     * (This postponed until later, after a timeout:)
+     */
+#ifdef VMS
+    if (connection)
+	NETCLOSE((int) connection);
+#else
+    if (connection)
+	fclose(connection);
+#endif /* VMS */
+    FREE(wais_database);
+#ifdef VMS
+    FREE(request_message);
+    FREE(response_message);
+#else
+    s_free(request_message);
+    s_free(response_message);
+#endif /* VMS */
+    FREE(names);
+    return (return_status);
+}
+
+#ifdef GLOBALDEF_IS_MACRO
+#define _HTWAIS_C_1_INIT { "wais", HTLoadWAIS, NULL }
+GLOBALDEF(HTProtocol, HTWAIS, _HTWAIS_C_1_INIT);
+#else
+GLOBALDEF HTProtocol HTWAIS =
+{"wais", HTLoadWAIS, NULL};
+#endif /* GLOBALDEF_IS_MACRO */
diff --git a/WWW/Library/Implementation/HTWAIS.h b/WWW/Library/Implementation/HTWAIS.h
new file mode 100644
index 0000000..4ba6f67
--- /dev/null
+++ b/WWW/Library/Implementation/HTWAIS.h
@@ -0,0 +1,43 @@
+/*                                                    WAIS protocol module for the W3 library
+                                 WAIS PROTOCOL INTERFACE
+
+   This module does not actually perform the WAIS protocol directly, but it does using one
+   or more libraries of the freeWAIS distribution.  The ui.a library came with the old free
+   WAIS from TMC,  the client.a and wais.a libraries are needed from the freeWAIS from
+   CNIDR.
+
+   If you include this module in the library, you must also
+
+      Register the HTWAIS protocol at initialisation (e.g., HTInit or HTSInit) by compiling
+      it with -DDIRECT_WAIS
+
+      Link with the WAIS libraries
+
+   The wais source files are parsed by a separate and independent module, HTWSRC .   You
+   can include HTWSRC without including direct wais using this module, and your WWW code
+   will be able to read source files, and access WAIS indexes through a gateway.
+
+   A WAIS-WWW gateway is just a normal W3 server with a libwww compiled with this module.
+
+   Anyways, this interface won't change much:
+
+ */
+#ifndef HTWAIS_H
+#define HTWAIS_H
+
+#include <HTAccess.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef GLOBALREF_IS_MACRO
+    extern GLOBALREF (HTProtocol, HTWAIS);
+
+#else
+    GLOBALREF HTProtocol HTWAIS;
+#endif				/* GLOBALDEF_IS_MACRO */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTWAIS_H */
diff --git a/WWW/Library/Implementation/HTWSRC.c b/WWW/Library/Implementation/HTWSRC.c
new file mode 100644
index 0000000..ba12cc7
--- /dev/null
+++ b/WWW/Library/Implementation/HTWSRC.c
@@ -0,0 +1,486 @@
+/*
+ * $LynxId: HTWSRC.c,v 1.31 2020/01/21 22:05:46 tom Exp $
+ *
+ *			Parse WAIS Source file			HTWSRC.c
+ *			======================
+ *
+ *	This module parses a stream with WAIS source file
+ *	format information on it and creates a structured stream.
+ *	That structured stream is then converted into whatever.
+ *
+ *	3 June 93	Bug fix: Won't crash if no description
+ */
+
+#define HTSTREAM_INTERNAL 1
+
+#include <HTUtils.h>
+
+#include <HTWSRC.h>
+#include <LYUtils.h>
+
+#include <HTML.h>
+#include <HTParse.h>
+
+#include <LYLeaks.h>
+
+#define BIG 10000		/* Arbitrary limit to value length */
+#define PARAM_MAX BIG
+#define CACHE_PERIOD (7*86400)	/* Time to keep .src file in seconds */
+
+struct _HTStructured {
+    const HTStructuredClass *isa;
+    /* ... */
+};
+
+#define PUTC(c) (*me->target->isa->put_character)(me->target, c)
+#define PUTS(s) (*me->target->isa->put_string)(me->target, s)
+#define START(e) (*me->target->isa->start_element)(me->target, e, 0, 0, -1, 0)
+#define END(e) (*me->target->isa->end_element)(me->target, e, 0)
+#define MAYBE_END(e) if (HTML_dtd.tags[e].contents != SGML_EMPTY) \
+			(*me->target->isa->end_element)(me->target, e, 0)
+
+/*	Here are the parameters which can be specified in a  source file
+*/
+static const char *par_name[] =
+{
+    "version",
+    "ip-address",
+#define PAR_IP_NAME 2
+    "ip-name",
+#define PAR_TCP_PORT 3
+    "tcp-port",
+#define PAR_DATABASE_NAME 4
+    "database-name",
+#define PAR_COST 5
+    "cost",
+#define PAR_COST_UNIT 6
+    "cost-unit",
+#define PAR_FREE 7
+    "free",
+#define PAR_MAINTAINER 8
+    "maintainer",
+#define PAR_DESCRIPTION 9
+    "description",
+    "keyword-list",
+    "source",
+    "window-geometry",
+    "configuration",
+    "script",
+    "update-time",
+    "contact-at",
+    "last-contacted",
+    "confidence",
+    "num-docs-to-request",
+    "font",
+    "font-size",
+#define PAR_UNKNOWN 22
+    "unknown",
+    0,				/* Terminate list */
+#define PAR_COUNT 23
+};
+
+enum tokenstate {
+    beginning,
+    before_tag,
+    colon,
+    before_value,
+    value,
+    bracketed_value,
+    quoted_value,
+    escape_in_quoted,
+    done
+};
+
+/*		Stream Object
+ *		------------
+ *
+ *	The target is the structured stream down which the
+ *	parsed results will go.
+ *
+ *	all the static stuff below should go in here to make it reentrant
+ */
+
+struct _HTStream {
+    const HTStreamClass *isa;
+    HTStructured *target;
+    char *par_value[PAR_COUNT];
+    enum tokenstate state;
+    char param[BIG + 1];
+    int param_number;
+    int param_count;
+};
+
+/*	Decode one hex character
+*/
+char from_hex(char c)
+{
+    return (char) ((c >= '0') && (c <= '9') ? c - '0'
+		   : (c >= 'A') && (c <= 'F') ? c - 'A' + 10
+		   : (c >= 'a') && (c <= 'f') ? c - 'a' + 10
+		   : 0);
+}
+
+/*			State machine
+ *			-------------
+ *
+ * On entry,
+ *	me->state	is a valid state (see WSRC_init)
+ *	c		is the next character
+ * On exit,
+ *	returns 1	Done with file
+ *		0	Continue. me->state is updated if necessary.
+ *		-1	Syntax error error
+ */
+
+/*		Treat One Character
+ *		-------------------
+ */
+static void WSRCParser_put_character(HTStream *me, int c)
+{
+    switch (me->state) {
+    case beginning:
+	if (c == '(')
+	    me->state = before_tag;
+	break;
+
+    case before_tag:
+	if (c == ')') {
+	    me->state = done;
+	    return;		/* Done with input file */
+	} else if (c == ':') {
+	    me->param_count = 0;
+	    me->state = colon;
+	}			/* Ignore other text */
+	break;
+
+    case colon:
+	if (WHITE(c)) {
+	    me->param[me->param_count++] = 0;	/* Terminate */
+	    for (me->param_number = 0;
+		 par_name[me->param_number];
+		 me->param_number++) {
+		if (0 == strcmp(par_name[me->param_number], me->param)) {
+		    break;
+		}
+	    }
+	    if (!par_name[me->param_number]) {	/* Unknown field */
+		CTRACE((tfp, "HTWSRC: Unknown field `%s' in source file\n",
+			me->param));
+		me->param_number = PAR_UNKNOWN;
+		me->state = before_value;	/* Could be better ignore */
+		return;
+	    }
+	    me->state = before_value;
+	} else {
+	    if (me->param_count < PARAM_MAX)
+		me->param[me->param_count++] = (char) c;
+	}
+	break;
+
+    case before_value:
+	if (c == ')') {
+	    me->state = done;
+	    return;		/* Done with input file */
+	}
+	if (WHITE(c))
+	    return;		/* Skip white space */
+	me->param_count = 0;
+	if (c == '"') {
+	    me->state = quoted_value;
+	} else {
+	    me->state = ((c == '(')
+			 ? bracketed_value
+			 : value);
+	    me->param[me->param_count++] = (char) c;	/* Don't miss first character */
+	}
+	break;
+
+    case value:
+	if (WHITE(c)) {
+	    me->param[me->param_count] = 0;
+	    StrAllocCopy(me->par_value[me->param_number], me->param);
+	    me->state = before_tag;
+	} else {
+	    if (me->param_count < PARAM_MAX)
+		me->param[me->param_count++] = (char) c;
+	}
+	break;
+
+    case bracketed_value:
+	if (c == ')') {
+	    me->param[me->param_count] = 0;
+	    StrAllocCopy(me->par_value[me->param_number], me->param);
+	    me->state = before_tag;
+	    break;
+	}
+	if (me->param_count < PARAM_MAX)
+	    me->param[me->param_count++] = (char) c;
+	break;
+
+    case quoted_value:
+	if (c == '"') {
+	    me->param[me->param_count] = 0;
+	    StrAllocCopy(me->par_value[me->param_number], me->param);
+	    me->state = before_tag;
+	    break;
+	}
+
+	if (c == '\\') {	/* Ignore escape but switch state */
+	    me->state = escape_in_quoted;
+	    break;
+	}
+	/* Fall through! */
+
+    case escape_in_quoted:
+	if (me->param_count < PARAM_MAX)
+	    me->param[me->param_count++] = (char) c;
+	me->state = quoted_value;
+	break;
+
+    case done:			/* Ignore anything after EOF */
+	return;
+
+    }				/* switch me->state */
+}
+
+/*			Open Cache file
+ *			===============
+ *
+ *   Bugs: Maybe for filesystem-challenged platforms (MSDOS for example) we
+ *   should make a hash code for the filename.
+ */
+
+#ifdef CACHE_FILE_PREFIX
+static BOOL write_cache(HTStream *me)
+{
+    FILE *fp;
+    char *cache_file_name = NULL;
+    char *www_database;
+    int result = NO;
+
+    if (!me->par_value[PAR_DATABASE_NAME]
+	|| !me->par_value[PAR_IP_NAME]
+	)
+	return NO;
+
+    www_database = HTEscape(me->par_value[PAR_DATABASE_NAME], URL_XALPHAS);
+    HTSprintf0(&cache_file_name, "%sWSRC-%s:%s:%.100s.txt",
+	       CACHE_FILE_PREFIX,
+	       me->par_value[PAR_IP_NAME],
+	       (me->par_value[PAR_TCP_PORT]
+		? me->par_value[PAR_TCP_PORT]
+		: "210"),
+	       www_database);
+
+    if ((fp = fopen(cache_file_name, TXT_W)) != 0) {
+	result = YES;
+	if (me->par_value[PAR_DESCRIPTION])
+	    fputs(me->par_value[PAR_DESCRIPTION], fp);
+	else
+	    fputs("Description not available\n", fp);
+	fclose(fp);
+    }
+    FREE(www_database);
+    FREE(cache_file_name);
+    return result;
+}
+#endif
+
+/*			Output equivalent HTML
+ *			----------------------
+ *
+ */
+
+static void give_parameter(HTStream *me, int p)
+{
+    PUTS(par_name[p]);
+    if (me->par_value[p]) {
+	PUTS(": ");
+	PUTS(me->par_value[p]);
+	PUTS("; ");
+    } else {
+	PUTS(gettext(" NOT GIVEN in source file; "));
+    }
+}
+
+/*			Generate Output
+ *			===============
+ */
+static void WSRC_gen_html(HTStream *me, int source_file)
+{
+    if (me->par_value[PAR_DATABASE_NAME]) {
+	char *shortname = 0;
+	int l;
+
+	StrAllocCopy(shortname, me->par_value[PAR_DATABASE_NAME]);
+	l = (int) strlen(shortname);
+	if (l > 4 && !strcasecomp(shortname + l - 4, ".src")) {
+	    shortname[l - 4] = 0;	/* Chop of .src -- boring! */
+	}
+
+	START(HTML_HEAD);
+	PUTC('\n');
+	START(HTML_TITLE);
+	PUTS(shortname);
+	PUTS(source_file ? gettext(" WAIS source file") : INDEX_SEGMENT);
+	END(HTML_TITLE);
+	PUTC('\n');
+	END(HTML_HEAD);
+
+	START(HTML_H1);
+	PUTS(shortname);
+	PUTS(source_file ? gettext(" description") : INDEX_SEGMENT);
+	END(HTML_H1);
+	PUTC('\n');
+	FREE(shortname);
+    }
+
+    START(HTML_DL);		/* Definition list of details */
+
+    if (source_file) {
+	START(HTML_DT);
+	PUTS(gettext("Access links"));
+	MAYBE_END(HTML_DT);
+	START(HTML_DD);
+	if (me->par_value[PAR_IP_NAME] &&
+	    me->par_value[PAR_DATABASE_NAME]) {
+
+	    char *WSRC_address = NULL;
+	    char *www_database;
+
+	    www_database = HTEscape(me->par_value[PAR_DATABASE_NAME],
+				    URL_XALPHAS);
+	    HTSprintf0(&WSRC_address, "%s//%s%s%s/%s",
+		       STR_WAIS_URL,
+		       me->par_value[PAR_IP_NAME],
+		       me->par_value[PAR_TCP_PORT] ? ":" : "",
+		       (me->par_value[PAR_TCP_PORT]
+			? me->par_value[PAR_TCP_PORT]
+			: ""),
+		       www_database);
+
+	    HTStartAnchor(me->target, NULL, WSRC_address);
+	    PUTS(gettext("Direct access"));
+	    END(HTML_A);
+	    /** Proxy will be used if defined, so let user know that - FM **/
+	    PUTS(gettext(" (or via proxy server, if defined)"));
+
+	    FREE(www_database);
+	    FREE(WSRC_address);
+
+	} else {
+	    give_parameter(me, PAR_IP_NAME);
+	    give_parameter(me, PAR_DATABASE_NAME);
+	}
+	MAYBE_END(HTML_DD);
+
+    }
+    /* end if source_file */
+    if (me->par_value[PAR_MAINTAINER]) {
+	START(HTML_DT);
+	PUTS(gettext("Maintainer"));
+	MAYBE_END(HTML_DT);
+	START(HTML_DD);
+	PUTS(me->par_value[PAR_MAINTAINER]);
+	MAYBE_END(HTML_DD);
+    }
+    if (me->par_value[PAR_IP_NAME]) {
+	START(HTML_DT);
+	PUTS(gettext("Host"));
+	MAYBE_END(HTML_DT);
+	START(HTML_DD);
+	PUTS(me->par_value[PAR_IP_NAME]);
+	MAYBE_END(HTML_DD);
+    }
+
+    END(HTML_DL);
+
+    if (me->par_value[PAR_DESCRIPTION]) {
+	START(HTML_PRE);	/* Preformatted description */
+	PUTS(me->par_value[PAR_DESCRIPTION]);
+	END(HTML_PRE);
+    }
+
+    (*me->target->isa->_free) (me->target);
+
+    return;
+}				/* generate html */
+
+static void WSRCParser_put_string(HTStream *context, const char *str)
+{
+    const char *p;
+
+    for (p = str; *p; p++)
+	WSRCParser_put_character(context, *p);
+}
+
+static void WSRCParser_write(HTStream *context, const char *str,
+			     int l)
+{
+    const char *p;
+    const char *e = str + l;
+
+    for (p = str; p < e; p++)
+	WSRCParser_put_character(context, *p);
+}
+
+static void WSRCParser_free(HTStream *me)
+{
+    WSRC_gen_html(me, YES);
+#ifdef CACHE_FILE_PREFIX
+    write_cache(me);
+#endif
+    {
+	int p;
+
+	for (p = 0; par_name[p]; p++) {		/* Clear out old values */
+	    FREE(me->par_value[p]);
+	}
+    }
+    FREE(me);
+}
+
+static void WSRCParser_abort(HTStream *me, HTError e GCC_UNUSED)
+{
+    WSRCParser_free(me);
+}
+
+/*		Stream subclass		-- method routines
+ *		---------------
+ */
+
+static HTStreamClass WSRCParserClass =
+{
+    "WSRCParser",
+    WSRCParser_free,
+    WSRCParser_abort,
+    WSRCParser_put_character,
+    WSRCParser_put_string,
+    WSRCParser_write
+};
+
+/*		Converter from WAIS Source to whatever
+ *		--------------------------------------
+ */
+HTStream *HTWSRCConvert(HTPresentation *pres, HTParentAnchor *anchor,
+			HTStream *sink)
+{
+    HTStream *me = (HTStream *) malloc(sizeof(*me));
+
+    if (!me)
+	outofmem(__FILE__, "HTWSRCConvert");
+
+    me->isa = &WSRCParserClass;
+    me->target = HTML_new(anchor, pres->rep_out, sink);
+
+    {
+	int p;
+
+	for (p = 0; p < PAR_COUNT; p++) {	/* Clear out parameter values */
+	    me->par_value[p] = 0;
+	}
+    }
+    me->state = beginning;
+
+    return me;
+}
diff --git a/WWW/Library/Implementation/HTWSRC.h b/WWW/Library/Implementation/HTWSRC.h
new file mode 100644
index 0000000..6c81132
--- /dev/null
+++ b/WWW/Library/Implementation/HTWSRC.h
@@ -0,0 +1,43 @@
+/*                                                             A parser for WAIS source files
+                                 WAIS SOURCE FILE PARSER
+
+   This converter returns a stream object into which a WAIS source file can be
+   written.  The result is put via a structured stream into whatever format was
+   required for the output stream.
+
+   See also:  HTWAIS protocol interface module
+
+ */
+#ifndef HTWSRC_H
+#define HTWSRC_H
+
+#include <HTFormat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern char from_hex(char c);
+
+    extern HTStream *HTWSRCConvert(HTPresentation *pres,
+				   HTParentAnchor *anchor,
+				   HTStream *sink);
+
+/*
+
+Escaping Strings
+
+   HTDeSlash takes out the invalid characters in a URL path ELEMENT by
+   converting them into hex-escaped characters.  HTEnSlash does the reverse.
+
+   Each returns a pointer to a newly allocated string which must eventually be
+   freed by the caller.
+
+ */
+    extern char *HTDeSlash(const char *str);
+
+    extern char *HTEnSlash(const char *str);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTWSRC_H */
diff --git a/WWW/Library/Implementation/HText.h b/WWW/Library/Implementation/HText.h
new file mode 100644
index 0000000..93ff4a6
--- /dev/null
+++ b/WWW/Library/Implementation/HText.h
@@ -0,0 +1,219 @@
+/*
+ * $LynxId: HText.h,v 1.17 2020/01/21 22:08:07 tom Exp $
+ *                                                           Rich Hypertext object for libWWW
+ *                                RICH HYPERTEXT OBJECT
+ *
+ * This is the C interface to the Objective-C (or whatever) Style-oriented
+ * HyperText class.  It is used when a style-oriented text object is available
+ * or craeted in order to display hypertext.
+ */
+#ifndef HTEXT_H
+#define HTEXT_H
+
+#include <HTAnchor.h>
+#include <HTStyle.h>
+#include <HTStream.h>
+#include <SGML.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifndef THINK_C
+#ifndef HyperText		/* Objective C version defined HyperText */
+    typedef struct _HText HText;	/* Normal Library */
+#endif
+#else
+    class CHyperText;		/* Mac Think-C browser hook */
+    typedef CHyperText HText;
+#endif
+
+    extern HText *HTMainText;	/* Pointer to current main text */
+    extern HTParentAnchor *HTMainAnchor;	/* Pointer to current text's anchor */
+
+    extern const char *HTAppName;	/* Application name */
+    extern const char *HTAppVersion;	/* Application version */
+
+/*
+
+Creation and deletion
+
+  HTEXT_NEW: CREATE HYPERTEXT OBJECT
+
+   There are several methods depending on how much you want to specify.  The
+   output stream is used with objects which need to output the hypertext to a
+   stream.  The structure is for objects which need to refer to the structure
+   which is kep by the creating stream.
+
+ */
+    extern HText *HText_new(HTParentAnchor *anchor);
+
+    extern HText *HText_new2(HTParentAnchor *anchor,
+			     HTStream *output_stream);
+
+    extern HText *HText_new3(HTParentAnchor *anchor,
+			     HTStream *output_stream,
+			     HTStructured * structure);
+
+/*
+
+  FREE HYPERTEXT OBJECT
+
+ */
+    extern void HText_free(HText *me);
+
+/*
+
+Object Building methods
+
+   These are used by a parser to build the text in an object HText_beginAppend
+   must be called, then any combination of other append calls, then
+   HText_endAppend.  This allows optimised handling using buffers and caches
+   which are flushed at the end.
+
+ */
+    extern void HText_beginAppend(HText *text);
+
+    extern void HText_endAppend(HText *text);
+
+/*
+
+  SET THE STYLE FOR FUTURE TEXT
+
+ */
+
+    extern void HText_setStyle(HText *text, HTStyle *style);
+
+/*
+
+  ADD ONE CHARACTER
+
+ */
+    extern void HText_appendCharacter(HText *text, int ch);
+
+/*
+
+  ADD A ZERO-TERMINATED STRING
+
+ */
+
+    extern void HText_appendText(HText *text, const char *str);
+
+/*
+
+  NEW PARAGRAPH
+
+   and similar things
+
+ */
+    extern void HText_appendParagraph(HText *text);
+
+    extern void HText_appendLineBreak(HText *text);
+
+    extern void HText_appendHorizontalRule(HText *text);
+
+/*
+
+  START/END SENSITIVE TEXT
+
+ */
+
+/*
+
+   The anchor object is created and passed to HText_beginAnchor.  The sensitive
+   text is added to the text object, and then HText_endAnchor is called. 
+   Anchors may not be nested.
+
+ */
+    extern int HText_beginAnchor(HText *text, int underline,
+				 HTChildAnchor *anc);
+    extern void HText_endAnchor(HText *text, int number);
+    extern BOOL HText_isAnchorBlank(HText *text, int number);
+
+/*
+
+  APPEND AN INLINE IMAGE
+
+   The image is handled by the creation of an anchor whose destination is the
+   image document to be included.  The semantics is the intended inline display
+   of the image.
+
+   An alternative implementation could be, for example, to begin an anchor,
+   append the alternative text or "IMAGE", then end the anchor.  This would
+   simply generate some text linked to the image itself as a separate document.
+
+ */
+    extern void HText_appendImage(HText *text, HTChildAnchor *anc,
+				  const char *alternative_text,
+				  int alignment,
+				  int isMap);
+
+/*
+
+  RETURN THE ANCHOR ASSOCIATED WITH THIS NODE
+
+ */
+    extern HTParentAnchor *HText_nodeAnchor(HText *me);
+
+/*
+
+Browsing functions
+
+ */
+
+/*
+
+  BRING TO FRONT AND HIGHLIGHT IT
+
+ */
+
+    extern BOOL HText_select(HText *text);
+    extern BOOL HText_selectAnchor(HText *text, HTChildAnchor *anchor);
+
+/*
+
+Editing functions
+
+   These are called from the application.  There are many more functions not
+   included here from the original text object.  These functions NEED NOT BE
+   IMPLEMENTED in a browser which cannot edit.
+
+ */
+/*      Style handling:
+*/
+/*      Apply this style to the selection
+*/
+    extern void HText_applyStyle(HText *me, HTStyle *style);
+
+/*      Update all text with changed style.
+*/
+    extern void HText_updateStyle(HText *me, HTStyle *style);
+
+/*      Return style of  selection
+*/
+    extern HTStyle *HText_selectionStyle(HText *me, HTStyleSheet *sheet);
+
+/*      Paste in styled text
+*/
+    extern void HText_replaceSel(HText *me, const char *aString,
+				 HTStyle *aStyle);
+
+/*      Apply this style to the selection and all similarly formatted text
+ *      (style recovery only)
+ */
+    extern void HTextApplyToSimilar(HText *me, HTStyle *style);
+
+/*      Select the first unstyled run.
+ *      (style recovery only)
+ */
+    extern void HTextSelectUnstyled(HText *me, HTStyleSheet *sheet);
+
+/*      Anchor handling:
+*/
+    extern void HText_unlinkSelection(HText *me);
+    extern HTAnchor *HText_referenceSelected(HText *me);
+    extern HTAnchor *HText_linkSelTo(HText *me, HTAnchor * anchor);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* HTEXT_H */
diff --git a/WWW/Library/Implementation/HTioctl.h b/WWW/Library/Implementation/HTioctl.h
new file mode 100644
index 0000000..99f8632
--- /dev/null
+++ b/WWW/Library/Implementation/HTioctl.h
@@ -0,0 +1,11 @@
+/*
+ *  A routine to mimic the ioctl function for UCX.
+ *  Bjorn S. Nilsson, 25-Nov-1993. Based on an example in the UCX manual.
+ */
+#include <iodef.h>
+#define IOC_OUT (int)0x40000000
+extern int vaxc$get_sdc(), sys$qiow();
+
+#ifndef UCX$C_IOCTL
+#define UCX$C_IOCTL TCPIP$C_IOCTL
+#endif
diff --git a/WWW/Library/Implementation/LYLeaks.h b/WWW/Library/Implementation/LYLeaks.h
new file mode 100644
index 0000000..a47b962
--- /dev/null
+++ b/WWW/Library/Implementation/LYLeaks.h
@@ -0,0 +1,309 @@
+/*
+ * $LynxId: LYLeaks.h,v 1.19 2020/01/21 22:05:46 tom Exp $
+ */
+#ifndef __LYLEAKS_H
+/*
+ *	Avoid include redundancy
+ *	Include only if finding memory leaks.
+ */
+#define __LYLEAKS_H
+
+/*
+ *  Copyright (c) 1994, University of Kansas, All Rights Reserved
+ *
+ *  Include File:	LYLeaks.h
+ *  Purpose:		Header to convert requests for allocation to Lynx
+ *			custom functions to track memory leaks.
+ *  Remarks/Portability/Dependencies/Restrictions:
+ *	For the stdlib.h allocation functions to be overridden by the
+ *		Lynx memory tracking functions all modules allocating,
+ *		freeing, or resizing memory must have LY_FIND_LEAKS
+ *		defined before including this file.
+ *	This header file should be included in every source file which
+ *		does any memory manipulation through use of the
+ *		stdlib.h memory functions.
+ *	For proper reporting of memory leaks, the function LYLeaks
+ *		should be registered for execution by atexit as the
+ *		very first executable statement in main.
+ *	This code is slow and should not be used except in debugging
+ *		circumstances (don't define LY_FIND_LEAKS).
+ *	If you are using LY_FIND_LEAKS and don't want the LYLeak*
+ *		memory functions to be used in a certain file,
+ *		define NO_MEMORY_TRACKING before including this file.
+ *	The only safe way to call the LYLeak* functions is to use
+ *		the below macros because they depend on the static
+ *		string created by __FILE__ to not be dynamic in
+ *		nature (don't free it and assume will exist at all
+ *		times during execution).
+ *	If you are using LY_FIND_LEAKS and LY_FIND_LEAKS_EXTENDED and
+ *		want only normal memory tracking (not extended for
+ *		HTSprintf/HTSprintf0) to be used in a certain file,
+ *		define NO_EXTENDED_MEMORY_TRACKING and don't define
+ *		NO_MEMORY_TRACKING before including this file.
+ *  Revision History:
+ *	05-26-94	created for Lynx 2-3-1, Garrett Arch Blythe
+ *	10-30-97	modified to handle StrAllocCopy() and
+ *			StrAllocCat(). - KW & FM
+ *	1999-10-17	modified to handle HTSprintf0 and HTSprintf(),
+ *			and to provide mark_malloced, if
+ *			LY_FIND_LEAKS_EXTENDED is defined. - kw
+ *	2003-01-22	add sequence-id for counting mallocs/frees -TD
+ *	2004-04-27	ANSIfy'd -TD
+ *	2012-02-09	add bstring interfaces -TD
+ */
+
+/* Undefine this to get no improved HTSprintf0/HTSprintf tracking: */
+#define LY_FIND_LEAKS_EXTENDED
+
+/*
+ *  Required includes
+ */
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ *	Constant defines
+ */
+#define MAX_CONTENT_LENGTH 50
+#ifdef VMS
+#define LEAKAGE_SINK "sys$login:Lynx.leaks"
+#else
+#define LEAKAGE_SINK "Lynx.leaks"
+#endif				/* VMS */
+/*
+ * Data structures
+ */
+    typedef struct SourceLocation_tag {
+	/*
+	 * The file name and line number of where an event took place.
+	 */
+	const char *cp_FileName;
+	short ssi_LineNumber;
+    } SourceLocation;
+
+    typedef struct AllocationList_tag {
+	/*
+	 * A singly linked list.
+	 */
+	struct AllocationList_tag *ALp_Next;
+
+	/*
+	 * Count the number of mallocs.
+	 */
+	long st_Sequence;
+
+	/*
+	 * The memory pointer allocated.  If set to NULL, then an invalid request
+	 * was made.  The invalid pointer also.
+	 */
+	void *vp_Alloced;
+	void *vp_BadRequest;
+
+	/*
+	 * The size in bytes of the allocated memory.
+	 */
+	size_t st_Bytes;
+
+	/*
+	 * The source location of specific event (calloc, malloc, free).  realloc
+	 * kept separate since will track last realloc on pointer.
+	 */
+	SourceLocation SL_memory;
+	SourceLocation SL_realloc;
+    } AllocationList;
+
+/*
+ *  Global variable declarations
+ */
+    extern char LYLeaksPath[];
+
+/*
+ *  Macros
+ */
+#if defined(LY_FIND_LEAKS) && !defined(NO_MEMORY_TRACKING)
+/*
+ * Only use these macros if we are to track memory allocations.  The reason for
+ * using a macro instead of a define is that we want to track where the initial
+ * allocation took place or where the last reallocation took place.  Track
+ * where the allocation took place by the __FILE__ and __LINE__ defines which
+ * are automatic to the compiler.
+ */
+#ifdef malloc
+#undef malloc
+#endif				/* malloc */
+#define malloc(st_bytes) LYLeakMalloc(st_bytes, __FILE__, __LINE__)
+
+#ifdef calloc
+#undef calloc
+#endif				/* calloc */
+#define calloc(st_number, st_bytes) LYLeakCalloc(st_number, st_bytes, \
+	__FILE__, __LINE__)
+
+#ifdef realloc
+#undef realloc
+#endif				/* realloc */
+#define realloc(vp_alloced, st_newbytes) LYLeakRealloc(vp_alloced, \
+	st_newbytes, __FILE__, __LINE__)
+
+#ifdef free
+#undef free
+#endif				/* free */
+#define free(vp_alloced) LYLeakFree(vp_alloced, __FILE__, __LINE__)
+
+#ifdef strdup
+#undef strdup
+#endif				/* free */
+#define strdup(vp_alloced) LYLeakStrdup(vp_alloced, __FILE__, __LINE__)
+
+/*
+ * Added the following two defines to track Lynx's frequent use of those
+ * macros.  - KW 1997-10-12
+ */
+#ifdef StrAllocCopy
+#undef StrAllocCopy
+#endif				/* StrAllocCopy */
+#define StrAllocCopy(dest, src) LYLeakSACopy(&(dest), src, __FILE__, __LINE__)
+
+#ifdef StrAllocCat
+#undef StrAllocCat
+#endif				/* StrAllocCat */
+#define StrAllocCat(dest, src)  LYLeakSACat(&(dest), src, __FILE__, __LINE__)
+
+#ifdef BStrAlloc
+#undef BStrAlloc
+#endif
+#define BStrAlloc(d,n)   LYLeakSABAlloc( &(d), n, __FILE__, __LINE__)
+
+#ifdef BStrCopy
+#undef BStrCopy
+#endif
+#define BStrCopy(d,s)  LYLeakSABCopy( &(d), BStrData(s), BStrLen(s), __FILE__, __LINE__)
+
+#ifdef BStrCopy0
+#undef BStrCopy0
+#endif
+#define BStrCopy0(d,s)  LYLeakSABCopy0( &(d), s, __FILE__, __LINE__)
+
+#ifdef BStrCat
+#undef BStrCat
+#endif
+#define BStrCat(d,s)  LYLeakSABCat( &(d), BStrData(s), BStrLen(s), __FILE__, __LINE__)
+
+#ifdef BStrCat0
+#undef BStrCat0
+#endif
+#define BStrCat0(d,s)  LYLeakSABCat0( &(d), s, __FILE__, __LINE__)
+
+#define mark_malloced(a,size) LYLeak_mark_malloced(a,size, __FILE__, __LINE__)
+
+#if defined(LY_FIND_LEAKS_EXTENDED) && !defined(NO_EXTENDED_MEMORY_TRACKING)
+
+#ifdef HTSprintf0
+#undef HTSprintf0
+#endif				/* HTSprintf0 */
+#define HTSprintf0 (Get_htsprintf0_fn(__FILE__,__LINE__))
+
+#ifdef HTSprintf
+#undef HTSprintf
+#endif				/* HTSprintf */
+#define HTSprintf (Get_htsprintf_fn(__FILE__,__LINE__))
+
+#endif				/* LY_FIND_LEAKS_EXTENDED and not NO_EXTENDED_MEMORY_TRACKING */
+
+#else				/* LY_FIND_LEAKS && !NO_MEMORY_TRACKING */
+
+#define mark_malloced(a,size)	/* no-op */
+#define LYLeakSequence() (-1)
+
+#endif				/* LY_FIND_LEAKS && !NO_MEMORY_TRACKING */
+
+#if defined(LY_FIND_LEAKS)
+#define PUBLIC_IF_FIND_LEAKS	/* nothing */
+#else
+#define PUBLIC_IF_FIND_LEAKS static
+#endif
+
+/*
+ * Function declarations.
+ * See the appropriate source file for usage.
+ */
+#ifndef LYLeakSequence
+    extern long LYLeakSequence(void);
+#endif
+    extern void LYLeaks(void);
+
+#ifdef LY_FIND_LEAKS_EXTENDED
+    extern AllocationList *LYLeak_mark_malloced(void *vp_alloced,
+						size_t st_bytes,
+						const char *cp_File,
+						const short ssi_Line);
+#endif				/* LY_FIND_LEAKS_EXTENDED */
+    extern void *LYLeakMalloc(size_t st_bytes, const char *cp_File,
+			      const short ssi_Line);
+    extern void *LYLeakCalloc(size_t st_number, size_t st_bytes, const char *cp_File,
+			      const short ssi_Line);
+    extern void *LYLeakRealloc(void *vp_alloced,
+			       size_t st_newbytes,
+			       const char *cp_File,
+			       const short ssi_Line);
+    extern void LYLeakFree(void *vp_alloced,
+			   const char *cp_File,
+			   const short ssi_Line);
+    extern char *LYLeakStrdup(const char *src,
+			      const char *cp_File,
+			      const short ssi_Line);
+    extern char *LYLeakSACopy(char **dest,
+			      const char *src,
+			      const char *cp_File,
+			      const short ssi_Line);
+    extern char *LYLeakSACat(char **dest,
+			     const char *src,
+			     const char *cp_File,
+			     const short ssi_Line);
+    extern void LYLeakSABAlloc(bstring **dest,
+			       int len,
+			       const char *cp_File,
+			       const short ssi_Line);
+    extern void LYLeakSABCopy(bstring **dest,
+			      const char *src,
+			      int len,
+			      const char *cp_File,
+			      const short ssi_Line);
+    extern void LYLeakSABCopy0(bstring **dest,
+			       const char *src,
+			       const char *cp_File,
+			       const short ssi_Line);
+    extern void LYLeakSABCat(bstring **dest,
+			     const char *src,
+			     int len,
+			     const char *cp_File,
+			     const short ssi_Line);
+    extern void LYLeakSABCat0(bstring **dest,
+			      const char *src,
+			      const char *cp_File,
+			      const short ssi_Line);
+    extern void LYLeakSABFree(bstring **ptr,
+			      const char *cp_File,
+			      const short ssi_Line);
+
+#ifdef LY_FIND_LEAKS_EXTENDED
+/*
+ * Trick to get tracking of var arg functions without relying on var arg
+ * preprocessor macros:
+ */
+    typedef char *HTSprintflike(char **, const char *, ...);
+    extern HTSprintflike *Get_htsprintf_fn(const char *cp_File,
+					   const short ssi_Line);
+    extern HTSprintflike *Get_htsprintf0_fn(const char *cp_File,
+					    const short ssi_Line);
+#endif				/* LY_FIND_LEAKS_EXTENDED */
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* __LYLEAKS_H */
diff --git a/WWW/Library/Implementation/LYexit.h b/WWW/Library/Implementation/LYexit.h
new file mode 100644
index 0000000..dd4b0e6
--- /dev/null
+++ b/WWW/Library/Implementation/LYexit.h
@@ -0,0 +1,67 @@
+#ifndef __LYEXIT_H
+/*
+ *	Avoid include redundancy
+ */
+#define __LYEXIT_H
+
+/*
+ *	Copyright (c) 1994, University of Kansas, All Rights Reserved
+ *
+ *	Include File:	LYexit.h
+ *	Purpose:	Provide an atexit function for libraries without such.
+ *	Remarks/Portability/Dependencies/Restrictions:
+ *		Include this header in every file that you have an exit or
+ *			atexit statement.
+ *	Revision History:
+ *		06-15-94	created Lynx 2-3-1 Garrett Arch Blythe
+ */
+
+/*
+ *	Required includes
+ */
+#ifdef _WINDOWS
+#include <process.h>		/* declares exit() */
+#endif
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ *	Constant defines
+ */
+#ifdef exit
+#undef exit
+#endif
+#define exit(code) LYexit(code)
+#define atexit LYatexit
+#define ATEXITSIZE 50
+
+/*
+ *	Data structures
+ */
+
+/*
+ * Global variable declarations
+ */
+
+/*
+ * Macros
+ */
+
+/*
+ * Function declarations
+ */
+    extern GCC_NORETURN void outofmem(const char *fname, const char *func);
+    extern void reset_signals(void);
+    extern GCC_NORETURN void exit_immediately(int status);
+    extern GCC_NORETURN void LYexit(int status);
+    extern int LYatexit(void (*function) (void));
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* __LYEXIT_H */
diff --git a/WWW/Library/Implementation/SGML.c b/WWW/Library/Implementation/SGML.c
new file mode 100644
index 0000000..2534606
--- /dev/null
+++ b/WWW/Library/Implementation/SGML.c
@@ -0,0 +1,5159 @@
+/*
+ * $LynxId: SGML.c,v 1.183 2022/06/13 00:20:50 tom Exp $
+ *
+ *			General SGML Parser code		SGML.c
+ *			========================
+ *
+ *	This module implements an HTStream object.  To parse an
+ *	SGML file, create this object which is a parser.  The object
+ *	is (currently) created by being passed a DTD structure,
+ *	and a target HTStructured object at which to throw the parsed stuff.
+ *
+ *	 6 Feb 93  Binary searches used. Interface modified.
+ */
+
+#define HTSTREAM_INTERNAL 1
+
+#include <HTUtils.h>
+
+#include <SGML.h>
+#include <HTMLDTD.h>
+#include <HTAccess.h>
+#include <UCAux.h>
+
+#include <HTChunk.h>
+#include <HTUtils.h>
+
+#include <LYCharSets.h>
+#include <LYCharVals.h>		/* S/390 -- gil -- 0635 */
+#include <LYGlobalDefs.h>
+#include <LYStrings.h>
+#include <LYLeaks.h>
+#include <LYUtils.h>
+
+#ifdef USE_COLOR_STYLE
+# include <LYStyle.h>
+#endif
+#ifdef USE_PRETTYSRC
+# include <LYPrettySrc.h>
+#endif
+
+/* a global variable doesn't work with info-stages which convert encoding */
+#if defined(EXP_CHINESEUTF8_SUPPORT)
+#undef IS_CJK_TTY
+#define IS_CJK_TTY me->T.do_cjk
+#endif
+
+#define AssumeCP1252(me) \
+	(((me)->inUCLYhndl == LATIN1 \
+	  || (me)->inUCLYhndl == US_ASCII) \
+	 && html5_charsets)
+
+#define INVALID (-1)
+
+static int sgml_offset;
+
+#ifdef USE_PRETTYSRC
+
+static char *entity_string;	/* this is used for printing entity name.
+
+				   Unconditionally added since redundant assignments don't hurt much */
+
+static void fake_put_character(HTStream *p GCC_UNUSED,
+			       int c GCC_UNUSED)
+{
+}
+
+#define START TRUE
+#define STOP FALSE
+
+#define PUTS_TR(x) psrc_convert_string = TRUE; PUTS(x)
+
+#endif
+
+/* my_casecomp() - optimized by the first character, NOT_ASCII ok */
+#define my_casecomp(a,b)  ((TOUPPER(*a) == TOUPPER(*b)) ? \
+			AS_casecomp(a,b) : \
+			(TOASCII(TOUPPER(*a)) - TOASCII(TOUPPER(*b))))
+
+/* ...used for comments and attributes value like href... */
+#define HTChunkPutUtf8Char(ch,x) \
+    { \
+    if ((TOASCII(x) < 128)  && (ch->size < ch->allocated)) \
+	ch->data[ch->size++] = (char)x; \
+    else \
+	(HTChunkPutUtf8Char)(ch,x); \
+    }
+
+#define PUTS(str) ((*me->actions->put_string)(me->target, str))
+#define PUTC(ch)  ((*me->actions->put_character)(me->target, (char) ch))
+#define PUTUTF8(code) (UCPutUtf8_charstring((HTStream *)me->target, \
+		      (putc_func_t*)(me->actions->put_character), code))
+
+#ifdef USE_PRETTYSRC
+#define PRETTYSRC_PUTC(c) if (psrc_view) PUTC(c)
+#else
+#define PRETTYSRC_PUTC(c)	/* nothing */
+#endif
+
+/*the following macros are used for pretty source view. */
+#define IS_C(attr) (attr.type == HTMLA_CLASS)
+
+#if defined(USE_JAPANESEUTF8_SUPPORT)
+# define UTF8_TTY_ISO2022JP (me->T.output_utf8)
+#else
+# define UTF8_TTY_ISO2022JP 0
+#endif
+
+HTCJKlang HTCJK = NOCJK;	/* CJK enum value.              */
+BOOL HTPassEightBitRaw = FALSE;	/* Pass 161-172,174-255 raw.    */
+BOOL HTPassEightBitNum = FALSE;	/* Pass ^ numeric entities raw. */
+BOOL HTPassHighCtrlRaw = FALSE;	/* Pass 127-160,173,&#127; raw. */
+BOOL HTPassHighCtrlNum = FALSE;	/* Pass &#128;-&#159; raw.      */
+
+/*	The State (context) of the parser
+ *
+ *	This is passed with each call to make the parser reentrant
+ */
+
+#define MAX_ATTRIBUTES 36	/* Max number of attributes per element */
+
+/*		Element Stack
+ *		-------------
+ *	This allows us to return down the stack reselecting styles.
+ *	As we return, attribute values will be garbage in general.
+ */
+typedef struct _HTElement HTElement;
+struct _HTElement {
+    HTElement *next;		/* Previously nested element or 0 */
+    HTTag *tag;			/* The tag at this level  */
+};
+
+typedef enum {
+    S_text = 0
+    ,S_attr
+    ,S_attr_gap
+    ,S_comment
+    ,S_cro
+    ,S_doctype
+    ,S_dollar
+    ,S_dollar_dq
+    ,S_dollar_paren
+    ,S_dollar_paren_dq
+    ,S_dollar_paren_sq
+    ,S_dollar_sq
+    ,S_dquoted
+    ,S_end
+    ,S_entity
+    ,S_equals
+    ,S_ero
+    ,S_esc
+    ,S_esc_dq
+    ,S_esc_sq
+    ,S_exclamation
+    ,S_in_kanji
+    ,S_incro
+    ,S_junk_tag
+    ,S_litteral
+    ,S_marked
+    ,S_nonascii_text
+    ,S_nonascii_text_dq
+    ,S_nonascii_text_sq
+    ,S_paren
+    ,S_paren_dq
+    ,S_paren_sq
+    ,S_pcdata
+    ,S_pi
+    ,S_script
+    ,S_sgmlatt
+    ,S_sgmlele
+    ,S_sgmlent
+    ,S_squoted
+    ,S_tag
+    ,S_tag_gap
+    ,S_tagname_slash
+    ,S_value
+} sgml_state;
+
+/*	Internal Context Data Structure
+ *	-------------------------------
+ */
+struct _HTStream {
+
+    const HTStreamClass *isa;	/* inherited from HTStream */
+
+    const SGML_dtd *dtd;
+    const HTStructuredClass *actions;	/* target class  */
+    HTStructured *target;	/* target object */
+
+    HTTag *current_tag;
+    HTTag *slashedtag;
+    const HTTag *unknown_tag;
+    BOOL extended_html;		/* xhtml */
+    BOOL strict_xml;		/* xml */
+    BOOL inSELECT;
+    BOOL no_lynx_specialcodes;
+    int current_attribute_number;
+    HTChunk *string;
+    int leading_spaces;
+    int trailing_spaces;
+    HTElement *element_stack;
+    sgml_state state;
+    unsigned char kanji_buf;
+#ifdef CALLERDATA
+    void *callerData;
+#endif				/* CALLERDATA */
+    BOOL present[MAX_ATTRIBUTES];	/* Flags: attribute is present? */
+    char *value[MAX_ATTRIBUTES];	/* NULL, or strings alloc'd with StrAllocCopy_extra() */
+
+    BOOL lead_exclamation;
+    BOOL first_dash;
+    BOOL end_comment;
+    BOOL doctype_bracket;
+    BOOL first_bracket;
+    BOOL second_bracket;
+    BOOL isHex;
+
+    HTParentAnchor *node_anchor;
+    LYUCcharset *inUCI;		/* pointer to anchor UCInfo */
+    int inUCLYhndl;		/* charset we are fed       */
+    LYUCcharset *outUCI;	/* anchor UCInfo for target */
+    int outUCLYhndl;		/* charset for target       */
+    UTFDecodeState U;
+    UCTransParams T;
+    int current_tag_charset;	/* charset to pass attributes */
+
+    char *recover;
+    int recover_index;
+    char *include;
+    char *active_include;
+    int include_index;
+    char *url;
+    char *csi;
+    int csi_index;
+#ifdef USE_PRETTYSRC
+    BOOL cur_attr_is_href;
+    BOOL cur_attr_is_name;
+#endif
+};
+
+#ifdef NO_LYNX_TRACE
+#define state_name(n) "state"
+#else
+static const char *state_name(sgml_state n)
+{
+    const char *result = "?";
+    /* *INDENT-OFF* */
+    switch (n) {
+    case S_attr:                result = "S_attr";              break;
+    case S_attr_gap:            result = "S_attr_gap";          break;
+    case S_comment:             result = "S_comment";           break;
+    case S_cro:                 result = "S_cro";               break;
+    case S_doctype:             result = "S_doctype";           break;
+    case S_dollar:              result = "S_dollar";            break;
+    case S_dollar_dq:           result = "S_dollar_dq";         break;
+    case S_dollar_paren:        result = "S_dollar_paren";      break;
+    case S_dollar_paren_dq:     result = "S_dollar_paren_dq";   break;
+    case S_dollar_paren_sq:     result = "S_dollar_paren_sq";   break;
+    case S_dollar_sq:           result = "S_dollar_sq";         break;
+    case S_dquoted:             result = "S_dquoted";           break;
+    case S_end:                 result = "S_end";               break;
+    case S_entity:              result = "S_entity";            break;
+    case S_equals:              result = "S_equals";            break;
+    case S_ero:                 result = "S_ero";               break;
+    case S_esc:                 result = "S_esc";               break;
+    case S_esc_dq:              result = "S_esc_dq";            break;
+    case S_esc_sq:              result = "S_esc_sq";            break;
+    case S_exclamation:         result = "S_exclamation";       break;
+    case S_in_kanji:            result = "S_in_kanji";          break;
+    case S_incro:               result = "S_incro";             break;
+    case S_pi:                  result = "S_pi";                break;
+    case S_junk_tag:            result = "S_junk_tag";          break;
+    case S_litteral:            result = "S_litteral";          break;
+    case S_marked:              result = "S_marked";            break;
+    case S_nonascii_text:       result = "S_nonascii_text";     break;
+    case S_nonascii_text_dq:    result = "S_nonascii_text_dq";  break;
+    case S_nonascii_text_sq:    result = "S_nonascii_text_sq";  break;
+    case S_paren:               result = "S_paren";             break;
+    case S_paren_dq:            result = "S_paren_dq";          break;
+    case S_paren_sq:            result = "S_paren_sq";          break;
+    case S_pcdata:              result = "S_pcdata";            break;
+    case S_script:              result = "S_script";            break;
+    case S_sgmlatt:             result = "S_sgmlatt";           break;
+    case S_sgmlele:             result = "S_sgmlele";           break;
+    case S_sgmlent:             result = "S_sgmlent";           break;
+    case S_squoted:             result = "S_squoted";           break;
+    case S_tag:                 result = "S_tag";               break;
+    case S_tag_gap:             result = "S_tag_gap";           break;
+    case S_tagname_slash:       result = "S_tagname_slash";     break;
+    case S_text:                result = "S_text";              break;
+    case S_value:               result = "S_value";             break;
+    }
+    /* *INDENT-ON* */
+
+    return result;
+}
+#endif
+
+/* storage for Element Stack */
+#define DEPTH 10
+static HTElement pool[DEPTH];
+static int depth = 0;
+
+static HTElement *pool_alloc(void)
+{
+    depth++;
+    if (depth > DEPTH)
+	return (HTElement *) malloc(sizeof(HTElement));
+    return (pool + depth - 1);
+}
+
+static void pool_free(HTElement * e)
+{
+    if (depth > DEPTH)
+	FREE(e);
+    depth--;
+    return;
+}
+
+#ifdef USE_PRETTYSRC
+
+static void HTMLSRC_apply_markup(HTStream *me,
+				 HTlexeme lexeme,
+				 int start)
+{
+    HT_tagspec *ts = *((start ? lexeme_start : lexeme_end) + lexeme);
+
+    while (ts) {
+#ifdef USE_COLOR_STYLE
+	if (ts->start) {
+	    current_tag_style = ts->style;
+	    force_current_tag_style = TRUE;
+	    forced_classname = ts->class_name;
+	    force_classname = TRUE;
+	}
+#endif
+	CTRACE((tfp, ts->start ? "SRCSTART %d\n" : "SRCSTOP %d\n", (int) lexeme));
+	if (ts->start)
+	    (*me->actions->start_element) (me->target,
+					   (int) ts->element,
+					   ts->present,
+					   (STRING2PTR) ts->value,
+					   me->current_tag_charset,
+					   &me->include);
+	else
+	    (*me->actions->end_element) (me->target,
+					 (int) ts->element,
+					 &me->include);
+	ts = ts->next;
+    }
+}
+
+#define PSRCSTART(x)	HTMLSRC_apply_markup(me,HTL_##x,START)
+#define PSRCSTOP(x)   HTMLSRC_apply_markup(me,HTL_##x,STOP)
+
+#define attr_is_href me->cur_attr_is_href
+#define attr_is_name me->cur_attr_is_name
+#endif
+
+static void set_chartrans_handling(HTStream *me,
+				   HTParentAnchor *anchor,
+				   int chndl)
+{
+    if (chndl < 0) {
+	/*
+	 * Nothing was set for the parser in earlier stages, so the HTML
+	 * parser's UCLYhndl should still be its default.  - FM
+	 */
+	chndl = HTAnchor_getUCLYhndl(anchor, UCT_STAGE_STRUCTURED);
+	if (chndl < 0)
+	    /*
+	     * That wasn't set either, so seek the HText default.  - FM
+	     */
+	    chndl = HTAnchor_getUCLYhndl(anchor, UCT_STAGE_HTEXT);
+	if (chndl < 0)
+	    /*
+	     * That wasn't set either, so assume the current display character
+	     * set.  - FM
+	     */
+	    chndl = current_char_set;
+	/*
+	 * Try to set the HText and HTML stages' chartrans info with the
+	 * default lock level (will not be changed if it was set previously
+	 * with a higher lock level).  - FM
+	 */
+	HTAnchor_setUCInfoStage(anchor, chndl,
+				UCT_STAGE_HTEXT,
+				UCT_SETBY_DEFAULT);
+	HTAnchor_setUCInfoStage(anchor, chndl,
+				UCT_STAGE_STRUCTURED,
+				UCT_SETBY_DEFAULT);
+	/*
+	 * Get the chartrans info for output to the HTML parser.  - FM
+	 */
+	me->outUCI = HTAnchor_getUCInfoStage(anchor,
+					     UCT_STAGE_STRUCTURED);
+	me->outUCLYhndl = HTAnchor_getUCLYhndl(me->node_anchor,
+					       UCT_STAGE_STRUCTURED);
+    }
+    /*
+     * Set the in->out transformation parameters.  - FM
+     */
+    UCSetTransParams(&me->T,
+		     me->inUCLYhndl, me->inUCI,
+		     me->outUCLYhndl, me->outUCI);
+    /*
+     * This is intended for passing the SGML parser's input charset as an
+     * argument in each call to the HTML parser's start tag function, but it
+     * would be better to call a Lynx_HTML_parser function to set an element in
+     * its HTStructured object, itself, if this were needed.  - FM
+     */
+#ifndef USE_JAPANESEUTF8_SUPPORT
+    if (IS_CJK_TTY) {
+	me->current_tag_charset = -1;
+    } else
+#endif
+    if (me->T.transp) {
+	me->current_tag_charset = me->inUCLYhndl;
+    } else if (me->T.decode_utf8) {
+	me->current_tag_charset = me->inUCLYhndl;
+    } else if (me->T.do_8bitraw ||
+	       me->T.use_raw_char_in) {
+	me->current_tag_charset = me->inUCLYhndl;
+    } else if (me->T.output_utf8 ||
+	       me->T.trans_from_uni) {
+	me->current_tag_charset = UCGetLYhndl_byMIME("utf-8");
+    } else {
+	me->current_tag_charset = LATIN1;
+    }
+}
+
+static void change_chartrans_handling(HTStream *me)
+{
+    int new_LYhndl = HTAnchor_getUCLYhndl(me->node_anchor,
+					  UCT_STAGE_PARSER);
+
+    if (new_LYhndl != me->inUCLYhndl &&
+	new_LYhndl >= 0) {
+	/*
+	 * Something changed.  but ignore if a META wants an unknown charset.
+	 */
+	LYUCcharset *new_UCI = HTAnchor_getUCInfoStage(me->node_anchor,
+						       UCT_STAGE_PARSER);
+
+	if (new_UCI) {
+	    LYUCcharset *next_UCI = HTAnchor_getUCInfoStage(me->node_anchor,
+							    UCT_STAGE_STRUCTURED);
+	    int next_LYhndl = HTAnchor_getUCLYhndl(me->node_anchor, UCT_STAGE_STRUCTURED);
+
+	    me->inUCI = new_UCI;
+	    me->inUCLYhndl = new_LYhndl;
+	    me->outUCI = next_UCI;
+	    me->outUCLYhndl = next_LYhndl;
+	    set_chartrans_handling(me,
+				   me->node_anchor, next_LYhndl);
+	}
+    }
+}
+
+#ifdef USE_COLOR_STYLE
+#include <AttrList.h>
+static int current_is_class = 0;
+#endif
+
+/*	Handle Attribute
+ *	----------------
+ */
+/* PUBLIC const char * SGML_default = "";   ?? */
+
+static void handle_attribute_name(HTStream *me, const char *s)
+{
+    HTTag *tag = me->current_tag;
+    const attr *attributes = tag->attributes;
+    int high, low, i, diff;
+
+#ifdef USE_PRETTYSRC
+    if (psrc_view) {
+	attr_is_href = FALSE;
+	attr_is_name = FALSE;
+    }
+#endif
+    /*
+     * Ignore unknown tag.  - KW
+     */
+    if (tag == me->unknown_tag) {
+#ifdef USE_PRETTYSRC
+	if (psrc_view)
+	    me->current_attribute_number = 1;	/* anything !=INVALID */
+#endif
+	return;
+    }
+
+    /*
+     * Binary search for attribute name.
+     */
+    for (low = 0, high = tag->number_of_attributes;
+	 high > low;
+	 diff < 0 ? (low = i + 1) : (high = i)) {
+	i = (low + (high - low) / 2);
+	diff = my_casecomp(attributes[i].name, s);
+	if (diff == 0) {	/* success: found it */
+	    me->current_attribute_number = i;
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		attr_is_name = (BOOL) (attributes[i].type == HTMLA_ANAME);
+		attr_is_href = (BOOL) (attributes[i].type == HTMLA_HREF);
+	    } else
+#endif
+	    {
+		me->present[i] = YES;
+		Clear_extra(me->value[i]);
+#ifdef USE_COLOR_STYLE
+#   ifdef USE_PRETTYSRC
+		current_is_class = IS_C(attributes[i]);
+#   else
+		current_is_class = (!strcasecomp("class", s));
+#   endif
+		CTRACE((tfp, "SGML: found attribute %s, %d\n", s, current_is_class));
+#endif
+	    }
+	    return;
+	}
+	/* if */
+    }				/* for */
+
+    CTRACE((tfp, "SGML: Unknown attribute %s for tag %s\n",
+	    s, NonNull(me->current_tag->name)));
+    me->current_attribute_number = INVALID;	/* Invalid */
+}
+
+/*	Handle attribute value
+ *	----------------------
+ */
+static void handle_attribute_value(HTStream *me, const char *s)
+{
+    if (me->current_attribute_number != INVALID) {
+	StrAllocCopy_extra(me->value[me->current_attribute_number], s);
+#ifdef USE_COLOR_STYLE
+	if (current_is_class) {
+	    StrNCpy(class_string, s, TEMPSTRINGSIZE);
+	    CTRACE((tfp, "SGML: class is '%s'\n", s));
+	} else {
+	    CTRACE((tfp, "SGML: attribute value is '%s'\n", s));
+	}
+#endif
+    } else {
+	CTRACE((tfp, "SGML: Attribute value %s ***ignored\n", s));
+    }
+    me->current_attribute_number = INVALID;	/* can't have two assignments! */
+}
+
+/*
+ *  Translate some Unicodes to Lynx special codes and output them.
+ *  Special codes - ones those output depend on parsing.
+ *
+ *  Additional issue, like handling bidirectional text if necessary
+ *  may be called from here:  zwnj (8204), zwj (8205), lrm (8206), rlm (8207)
+ *  - currently they are ignored in SGML.c and LYCharUtils.c
+ *  but also in UCdomap.c because they are non printable...
+ *
+ */
+static BOOL put_special_unicodes(HTStream *me, UCode_t code)
+{
+    /* (Tgf_nolyspcl) */
+    if (me->no_lynx_specialcodes) {
+	/*
+	 * We were asked by a "DTD" flag to not generate lynx specials.  - kw
+	 */
+	return NO;
+    }
+
+    if (code == CH_NBSP) {	/* S/390 -- gil -- 0657 */
+	/*
+	 * Use Lynx special character for nbsp.
+	 */
+#ifdef USE_PRETTYSRC
+	if (!psrc_view)
+#endif
+	    PUTC(HT_NON_BREAK_SPACE);
+    } else if (code == CH_SHY) {
+	/*
+	 * Use Lynx special character for shy.
+	 */
+#ifdef USE_PRETTYSRC
+	if (!psrc_view)
+#endif
+	    PUTC(LY_SOFT_HYPHEN);
+    } else if (code == 8194 || code == 8201) {
+	/*
+	 * Use Lynx special character for ensp or thinsp.
+	 *
+	 * Originally, Lynx use space '32' as word delimiter and omits this
+	 * space at end of line if word is wrapped to the next line.  There are
+	 * several other spaces in the Unicode repertoire and we should teach
+	 * Lynx to understand them, not only as regular characters but in the
+	 * context of line wrapping.  Unfortunately, if we use HT_EN_SPACE we
+	 * override the chartrans tables for those spaces with a single '32'
+	 * for all (but do line wrapping more fancy).
+	 *
+	 * We may treat emsp as one or two ensp (below).
+	 */
+#ifdef USE_PRETTYSRC
+	if (!psrc_view)
+#endif
+	    PUTC(HT_EN_SPACE);
+    } else if (code == 8195) {
+	/*
+	 * Use Lynx special character for emsp.
+	 */
+#ifdef USE_PRETTYSRC
+	if (!psrc_view) {
+#endif
+	    /* PUTC(HT_EN_SPACE);  let's stay with a single space :) */
+	    PUTC(HT_EN_SPACE);
+#ifdef USE_PRETTYSRC
+	}
+#endif
+    } else {
+	/*
+	 * Return NO if nothing done.
+	 */
+	return NO;
+    }
+    /*
+     * We have handled it.
+     */
+    return YES;
+}
+
+#ifdef USE_PRETTYSRC
+static void put_pretty_entity(HTStream *me, int term)
+{
+    PSRCSTART(entity);
+    PUTC('&');
+    PUTS(entity_string);
+    if (term)
+	PUTC((char) term);
+    PSRCSTOP(entity);
+}
+
+static void put_pretty_number(HTStream *me)
+{
+    PSRCSTART(entity);
+    PUTS((me->isHex ? "&#x" : "&#"));
+    PUTS(entity_string);
+    PUTC(';');
+    PSRCSTOP(entity);
+}
+#endif /* USE_PRETTYSRC */
+
+/*	Handle entity
+ *	-------------
+ *
+ * On entry,
+ *	s	contains the entity name zero terminated
+ * Bugs:
+ *	If the entity name is unknown, the terminator is treated as
+ *	a printable non-special character in all cases, even if it is '<'
+ * Bug-fix:
+ *	Modified SGML_character() so we only come here with terminator
+ *	as '\0' and check a FoundEntity flag. -- Foteos Macrides
+ *
+ * Modified more (for use with Lynx character translation code):
+ */
+static char replace_buf[64];	/* buffer for replacement strings */
+static BOOL FoundEntity = FALSE;
+
+static void handle_entity(HTStream *me, int term)
+{
+    UCode_t code;
+    long uck = -1;
+    const char *s = me->string->data;
+
+    /*
+     * Handle all entities normally.  - FM
+     */
+    FoundEntity = FALSE;
+    if ((code = HTMLGetEntityUCValue(s)) != 0) {
+	/*
+	 * We got a Unicode value for the entity name.  Check for special
+	 * Unicodes.  - FM
+	 */
+	if (put_special_unicodes(me, code)) {
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		put_pretty_entity(me, term);
+	    }
+#endif
+	    FoundEntity = TRUE;
+	    return;
+	}
+	/*
+	 * Seek a translation from the chartrans tables.
+	 */
+	if ((uck = UCTransUniChar(code, me->outUCLYhndl)) >= 32 &&
+/* =============== work in ASCII below here ===============  S/390 -- gil -- 0672 */
+	    uck < 256 &&
+	    (uck < 127 ||
+	     uck >= LYlowest_eightbit[me->outUCLYhndl])) {
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		put_pretty_entity(me, term);
+	    } else
+#endif
+		PUTC(FROMASCII((char) uck));
+	    FoundEntity = TRUE;
+	    return;
+	} else if ((uck == -4 ||
+		    (me->T.repl_translated_C0 &&
+		     uck > 0 && uck < 32)) &&
+	    /*
+	     * Not found; look for replacement string.
+	     */
+		   (uck = UCTransUniCharStr(replace_buf, 60, code,
+					    me->outUCLYhndl, 0) >= 0)) {
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		put_pretty_entity(me, term);
+	    } else
+#endif
+		PUTS(replace_buf);
+	    FoundEntity = TRUE;
+	    return;
+	}
+	/*
+	 * If we're displaying UTF-8, try that now.  - FM
+	 */
+#ifndef USE_PRETTYSRC
+	if (me->T.output_utf8 && PUTUTF8(code)) {
+	    FoundEntity = TRUE;
+	    return;
+	}
+#else
+	if (me->T.output_utf8 && (psrc_view
+				  ? (UCPutUtf8_charstring((HTStream *) me->target,
+							  (putc_func_t *) (fake_put_character),
+							  code))
+				  : PUTUTF8(code))) {
+
+	    if (psrc_view) {
+		put_pretty_entity(me, term);
+	    }
+
+	    FoundEntity = TRUE;
+	    return;
+	}
+#endif
+	/*
+	 * If it's safe ASCII, use it.  - FM
+	 */
+	if (code >= 32 && code < 127) {
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		put_pretty_entity(me, term);
+	    } else
+#endif
+
+		PUTC(FROMASCII((char) code));
+	    FoundEntity = TRUE;
+	    return;
+	}
+/* =============== work in ASCII above here ===============  S/390 -- gil -- 0682 */
+	/*
+	 * Ignore zwnj (8204) and zwj (8205), if we get to here.  Note that
+	 * zwnj may have been handled as <WBR> by the calling function.  - FM
+	 */
+	if (!strcmp(s, "zwnj") ||
+	    !strcmp(s, "zwj")) {
+	    CTRACE((tfp, "handle_entity: Ignoring '%s'.\n", s));
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		put_pretty_entity(me, term);
+	    }
+#endif
+	    FoundEntity = TRUE;
+	    return;
+	}
+	/*
+	 * Ignore lrm (8206), and rln (8207), if we get to here.  - FM
+	 */
+	if (!strcmp(s, "lrm") ||
+	    !strcmp(s, "rlm")) {
+	    CTRACE((tfp, "handle_entity: Ignoring '%s'.\n", s));
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		put_pretty_entity(me, term);
+	    }
+#endif
+	    FoundEntity = TRUE;
+	    return;
+	}
+    }
+
+    /*
+     * If entity string not found, display as text.
+     */
+#ifdef USE_PRETTYSRC
+    if (psrc_view)
+	PSRCSTART(badseq);
+#endif
+    /* S/390 -- gil -- 0695 */
+    CTRACE((tfp, "SGML: Unknown entity '%s' %" PRI_UCode_t " %ld\n", s, code, uck));
+    PUTC('&');
+    PUTS(s);
+    if (term != '\0')
+	PUTC(term);
+#ifdef USE_PRETTYSRC
+    if (psrc_view)
+	PSRCSTOP(badseq);
+#endif
+}
+
+/*	Handle comment
+ *	--------------
+ */
+static void handle_comment(HTStream *me)
+{
+    const char *s = me->string->data;
+
+    CTRACE((tfp, "SGML Comment:\n<%s>\n", s));
+
+    if (me->csi == NULL &&
+	StrNCmp(s, "!--#", 4) == 0 &&
+	LYCheckForCSI(me->node_anchor, &me->url) == TRUE) {
+	LYDoCSI(me->url, s, &me->csi);
+    } else {
+	LYCommentHacks(me->node_anchor, me->string->data);
+    }
+
+    return;
+}
+
+/*	Handle identifier
+ *	-----------------
+ */
+static void handle_identifier(HTStream *me)
+{
+    const char *s = me->string->data;
+
+    CTRACE((tfp, "SGML Identifier:\n<%s>\n", s));
+
+    return;
+}
+
+/*	Handle doctype
+ *	--------------
+ */
+static void handle_doctype(HTStream *me)
+{
+    const char *s = me->string->data;
+
+    CTRACE((tfp, "SGML Doctype:\n<%s>\n", s));
+    if (strstr(s, "DTD XHTML ") != 0) {
+	CTRACE((tfp, "...processing extended HTML\n"));
+	me->extended_html = TRUE;
+    }
+
+    return;
+}
+
+/*	Handle marked
+ *	-------------
+ */
+static void handle_marked(HTStream *me)
+{
+    const char *s = me->string->data;
+
+    CTRACE((tfp, "SGML Marked Section:\n<%s>\n", s));
+
+    if (!StrNCmp(me->string->data, "![INCLUDE[", 10)) {
+	me->string->data[me->string->size - 3] = '\0';
+	StrAllocCat(me->include, me->string->data + 10);
+	/* @@@ This needs to take charset into account! @@@
+	   the wrong assumptions will be made about the data's
+	   charset once it is in include - kw */
+
+    } else if (!StrNCmp(me->string->data, "![CDATA[", 8)) {
+	(*me->actions->put_block) (me->target,
+				   me->string->data + 8,
+				   me->string->size - 11);
+
+    }
+    return;
+}
+
+/*	Handle processing instruction
+ *	-----------------------------
+ */
+static void handle_processing_instruction(HTStream *me)
+{
+    const char *s = me->string->data;
+
+    CTRACE((tfp, "SGML Processing instruction:\n<%s>\n", s));
+
+    if (!StrNCmp(s, "?xml ", 5)) {
+	int flag = me->T.decode_utf8;
+
+	me->strict_xml = TRUE;
+	/*
+	 * Switch to UTF-8 if the encoding is explicitly "utf-8".
+	 */
+	if (!flag) {
+	    char *t = strstr(s, "encoding=");
+
+	    if (t != 0) {
+		t += 9;
+		if (*t == '"')
+		    ++t;
+		flag = !StrNCmp(t, "utf-8", 5);
+	    }
+	    if (flag) {
+		CTRACE((tfp, "...Use UTF-8 for XML\n"));
+		me->T.decode_utf8 = TRUE;
+	    }
+	}
+    }
+
+    return;
+}
+
+/*	Handle sgmlent
+ *	--------------
+ */
+static void handle_sgmlent(HTStream *me)
+{
+    const char *s = me->string->data;
+
+    CTRACE((tfp, "SGML Entity Declaration:\n<%s>\n", s));
+
+    return;
+}
+
+/*	Handle sgmlent
+ *	--------------
+ */
+static void handle_sgmlele(HTStream *me)
+{
+    const char *s = me->string->data;
+
+    CTRACE((tfp, "SGML Element Declaration:\n<%s>\n", s));
+
+    return;
+}
+
+/*	Handle sgmlatt
+ *	--------------
+ */
+static void handle_sgmlatt(HTStream *me)
+{
+    const char *s = me->string->data;
+
+    CTRACE((tfp, "SGML Attribute Declaration:\n<%s>\n", s));
+
+    return;
+}
+
+/*
+ * Convenience macros - tags (elements) are identified sometimes by an int or
+ * enum value ('TAGNUM'), sometimes by a pointer to HTTag ('TAGP').  - kw
+ */
+#define TAGNUM_OF_TAGP(t) (HTMLElement) (t - me->dtd->tags)
+#define TAGP_OF_TAGNUM(e) (me->dtd->tags + e)
+
+/*
+ * The following implement special knowledge about OBJECT.  As long as
+ * HTML_OBJECT is the only tag for which an alternative variant exist, they can
+ * be simple macros.  - kw
+ */
+/* does 'TAGNUM' e have an alternative (variant) parsing mode? */
+#define HAS_ALT_TAGNUM(e) (e == HTML_OBJECT)
+
+/* return 'TAGNUM' of the alternative mode for 'TAGNUM' e, if any. */
+#define ALT_TAGNUM(e) ((e == HTML_OBJECT) ? HTML_ALT_OBJECT : e)
+
+/* return 'TAGNUM' of the normal mode for 'TAGNUM' e which may be alt. */
+#define NORMAL_TAGNUM(e) (((int)(e) >= HTML_ELEMENTS) ? HTML_OBJECT : (HTMLElement)e)
+
+/* More convenience stuff. - kw */
+#define ALT_TAGP_OF_TAGNUM(e) TAGP_OF_TAGNUM(ALT_TAGNUM(e))
+#define NORMAL_TAGP_OF_TAGNUM(e) TAGP_OF_TAGNUM(NORMAL_TAGNUM(e))
+
+#define ALT_TAGP(t) ALT_TAGP_OF_TAGNUM(TAGNUM_OF_TAGP(t))
+#define NORMAL_TAGP(t) NORMAL_TAGP_OF_TAGNUM(TAGNUM_OF_TAGP(t))
+
+#define IsTagAlias(a,b) (((a) == (b)) || ((a) - (a)->alias == (b) - (b)->alias))
+
+static BOOL element_valid_within(HTTag * new_tag, HTTag * stacked_tag, int direct)
+{
+    BOOL result = YES;
+    TagClass usecontains, usecontained;
+
+    if (stacked_tag && new_tag) {
+	usecontains = (direct ? stacked_tag->contains : stacked_tag->icontains);
+	usecontained = (direct ? new_tag->contained : new_tag->icontained);
+	if (IsTagAlias(new_tag, stacked_tag)) {
+	    result = (BOOL) ((Tgc_same & usecontains) &&
+			     (Tgc_same & usecontained));
+	} else {
+	    result = (BOOL) ((new_tag->tagclass & usecontains) &&
+			     (stacked_tag->tagclass & usecontained));
+	}
+    }
+    return result;
+}
+
+static BOOL element_really_within(HTTag * new_tag, HTTag * stacked_tag, int direct)
+{
+    BOOL result = YES;
+    TagClass usecontains, usecontained;
+
+    if (stacked_tag && new_tag) {
+	usecontains = (direct ? stacked_tag->contains : stacked_tag->icontains);
+	usecontained = (direct ? new_tag->contained : new_tag->icontained);
+	if (IsTagAlias(new_tag, stacked_tag)) {
+	    result = (BOOL) ((Tgc_same & usecontains) &&
+			     (Tgc_same & usecontained));
+	} else {
+	    result = (BOOL) ((new_tag->tagclass & usecontains) ==
+			     new_tag->tagclass &&
+			     (stacked_tag->tagclass & usecontained) == stacked_tag->tagclass);
+	}
+    }
+    return result;
+}
+
+typedef enum {
+    close_NO = 0,
+    close_error = 1,
+    close_valid = 2
+} canclose_t;
+
+static canclose_t can_close(HTTag * new_tag, HTTag * stacked_tag)
+{
+    canclose_t result;
+
+    if (!stacked_tag) {
+	result = close_NO;
+    } else if (stacked_tag->flags & Tgf_endO) {
+	result = close_valid;
+    } else if (IsTagAlias(new_tag, stacked_tag)) {
+	result = ((Tgc_same & new_tag->canclose)
+		  ? close_error
+		  : close_NO);
+    } else {
+	result = ((stacked_tag->tagclass & new_tag->canclose)
+		  ? close_error
+		  : close_NO);
+    }
+    return result;
+}
+
+static void do_close_stacked(HTStream *me)
+{
+    HTElement *stacked = me->element_stack;
+    HTMLElement e;
+
+    if (!stacked)
+	return;			/* stack was empty */
+    if (me->inSELECT && !strcasecomp(stacked->tag->name, "SELECT")) {
+	me->inSELECT = FALSE;
+    }
+    e = NORMAL_TAGNUM(TAGNUM_OF_TAGP(stacked->tag));
+#ifdef USE_PRETTYSRC
+    if (!psrc_view)		/* Don't actually pass call on if viewing psrc - kw */
+#endif
+	(*me->actions->end_element) (me->target,
+				     (int) e,
+				     &me->include);
+    me->element_stack = stacked->next;
+    pool_free(stacked);
+    me->no_lynx_specialcodes =
+	(BOOL) (me->element_stack
+		? (me->element_stack->tag->flags & Tgf_nolyspcl)
+		: NO);
+}
+
+static int is_on_stack(HTStream *me, HTTag * old_tag)
+{
+    HTElement *stacked = me->element_stack;
+    int i = 1;
+
+    for (; stacked; stacked = stacked->next, i++) {
+	if (IsTagAlias(stacked->tag, old_tag) ||
+	    stacked->tag == ALT_TAGP(old_tag))
+	    return i;
+    }
+    return 0;
+}
+
+/*	End element
+ *	-----------
+ */
+static void end_element(HTStream *me, HTTag * old_tag)
+{
+    BOOL extra_action_taken = NO;
+    canclose_t canclose_check = close_valid;
+    int stackpos = is_on_stack(me, old_tag);
+    BOOL direct_container = YES;
+
+    if (!Old_DTD) {
+	if (old_tag->aliases) {
+	    if (me->element_stack) {
+		if (!element_really_within(old_tag,
+					   me->element_stack->tag,
+					   direct_container) &&
+		    element_really_within(old_tag + 1,
+					  me->element_stack->tag,
+					  direct_container)) {
+		    ++old_tag;
+		}
+	    }
+	}
+	while (canclose_check != close_NO &&
+	       me->element_stack &&
+	       (stackpos > 1 || (!extra_action_taken && stackpos == 0))) {
+	    if (stackpos == 0 && (old_tag->flags & Tgf_startO) &&
+		element_valid_within(old_tag, me->element_stack->tag, YES)) {
+		CTRACE((tfp, "SGML: </%s> ignored\n", old_tag->name));
+		return;
+	    }
+	    canclose_check = can_close(old_tag, me->element_stack->tag);
+	    if (canclose_check != close_NO) {
+		CTRACE((tfp, "SGML: End </%s> \t<- %s end </%s>\n",
+			me->element_stack->tag->name,
+			((canclose_check == close_valid)
+			 ? "supplied,"
+			 : "***forced by"),
+			old_tag->name));
+		do_close_stacked(me);
+		extra_action_taken = YES;
+		stackpos = is_on_stack(me, old_tag);
+	    }
+	}
+
+	if (stackpos == 0 && old_tag->contents != SGML_EMPTY) {
+	    CTRACE((tfp, "SGML: Still open %s, ***no open %s for </%s>\n",
+		    me->element_stack ?
+		    me->element_stack->tag->name : "none",
+		    old_tag->name,
+		    old_tag->name));
+	    return;
+	}
+	if (stackpos > 1) {
+	    CTRACE((tfp,
+		    "SGML: Nesting <%s>...<%s> \t<- ***invalid end </%s>\n",
+		    old_tag->name,
+		    me->element_stack ?
+		    me->element_stack->tag->name : "none",
+		    old_tag->name));
+	    return;
+	}
+    }
+    /* Now let the non-extended code deal with the rest. - kw */
+
+    /*
+     * If we are in a SELECT block, ignore anything but a SELECT end tag.  - FM
+     */
+    if (me->inSELECT) {
+	if (!strcasecomp(old_tag->name, "SELECT")) {
+	    /*
+	     * Turn off the inSELECT flag and fall through.  - FM
+	     */
+	    me->inSELECT = FALSE;
+	} else {
+	    /*
+	     * Ignore the end tag.  - FM
+	     */
+	    CTRACE((tfp, "SGML: ***Ignoring end tag </%s> in SELECT block.\n",
+		    old_tag->name));
+	    return;
+	}
+    }
+    /*
+     * Handle the end tag.  - FM
+     */
+    CTRACE((tfp, "SGML: End </%s>\n", old_tag->name));
+    if (old_tag->contents == SGML_EMPTY) {
+	CTRACE((tfp, "SGML: ***Illegal end tag </%s> found.\n",
+		old_tag->name));
+	return;
+    }
+#ifdef WIND_DOWN_STACK
+    while (me->element_stack)	/* Loop is error path only */
+#else
+    if (me->element_stack)	/* Substitute and remove one stack element */
+#endif /* WIND_DOWN_STACK */
+    {
+	int status = HT_OK;
+	HTMLElement e;
+	HTElement *N = me->element_stack;
+	HTTag *t = (N->tag != old_tag) ? NORMAL_TAGP(N->tag) : N->tag;
+
+	if (old_tag != t) {	/* Mismatch: syntax error */
+	    if (me->element_stack->next) {	/* This is not the last level */
+		CTRACE((tfp,
+			"SGML: Found </%s> when expecting </%s>. </%s> ***assumed.\n",
+			old_tag->name, t->name, t->name));
+	    } else {		/* last level */
+		CTRACE((tfp,
+			"SGML: Found </%s> when expecting </%s>. </%s> ***Ignored.\n",
+			old_tag->name, t->name, old_tag->name));
+		return;		/* Ignore */
+	    }
+	}
+
+	e = NORMAL_TAGNUM(TAGNUM_OF_TAGP(t));
+	CTRACE2(TRACE_SGML, (tfp, "tagnum(%p) = %d\n", (void *) t, (int) e));
+#ifdef USE_PRETTYSRC
+	if (!psrc_view)		/* Don't actually pass call on if viewing psrc - kw */
+#endif
+	    status = (*me->actions->end_element) (me->target,
+						  (int) e,
+						  &me->include);
+	if (status == HT_PARSER_REOPEN_ELT) {
+	    CTRACE((tfp, "SGML: Restart <%s>\n", t->name));
+	    (*me->actions->start_element) (me->target,
+					   (int) e,
+					   NULL,
+					   NULL,
+					   me->current_tag_charset,
+					   &me->include);
+	} else if (status == HT_PARSER_OTHER_CONTENT) {
+	    CTRACE((tfp, "SGML: Continue with other content model for <%s>\n", t->name));
+	    me->element_stack->tag = ALT_TAGP_OF_TAGNUM(e);
+	} else {
+	    me->element_stack = N->next;	/* Remove from stack */
+	    pool_free(N);
+	}
+	me->no_lynx_specialcodes =
+	    (BOOL) (me->element_stack
+		    ? (me->element_stack->tag->flags & Tgf_nolyspcl)
+		    : NO);
+#ifdef WIND_DOWN_STACK
+	if (IsTagAlias(old_tag, t))
+	    return;		/* Correct sequence */
+#else
+	return;
+#endif /* WIND_DOWN_STACK */
+
+	/* Syntax error path only */
+
+    }
+    CTRACE((tfp, "SGML: Extra end tag </%s> found and ignored.\n",
+	    old_tag->name));
+}
+
+/*	Start a element
+*/
+static void start_element(HTStream *me)
+{
+    int status;
+    HTTag *new_tag = me->current_tag;
+    HTMLElement e = TAGNUM_OF_TAGP(new_tag);
+    BOOL ok = FALSE;
+
+    BOOL valid = YES;
+    BOOL direct_container = YES;
+    BOOL extra_action_taken = NO;
+    canclose_t canclose_check = close_valid;
+
+    if (!Old_DTD) {
+	if (new_tag->aliases) {
+	    if (me->element_stack) {
+		if (!element_really_within(new_tag,
+					   me->element_stack->tag,
+					   direct_container) &&
+		    element_really_within(new_tag + 1,
+					  me->element_stack->tag,
+					  direct_container)) {
+		    ++new_tag;
+		}
+	    }
+	}
+	while (me->element_stack &&
+	       (canclose_check == close_valid ||
+		(canclose_check == close_error &&
+		 IsTagAlias(new_tag, me->element_stack->tag))) &&
+	       !(valid = element_valid_within(new_tag,
+					      me->element_stack->tag,
+					      direct_container))) {
+	    canclose_check = can_close(new_tag, me->element_stack->tag);
+	    if (canclose_check != close_NO) {
+		CTRACE((tfp, "SGML: End </%s> \t<- %s start <%s>\n",
+			me->element_stack->tag->name,
+			((canclose_check == close_valid)
+			 ? "supplied,"
+			 : "***forced by"),
+			new_tag->name));
+		do_close_stacked(me);
+		extra_action_taken = YES;
+		if (canclose_check == close_error)
+		    direct_container = NO;
+	    } else {
+		CTRACE((tfp,
+			"SGML: Still open %s \t<- ***invalid start <%s>\n",
+			me->element_stack->tag->name,
+			new_tag->name));
+	    }
+	}
+	if (me->element_stack && !valid &&
+	    (me->element_stack->tag->flags & Tgf_strict) &&
+	    !(valid = element_valid_within(new_tag,
+					   me->element_stack->tag,
+					   direct_container))) {
+	    CTRACE((tfp, "SGML: Still open %s \t<- ***ignoring start <%s>\n",
+		    me->element_stack->tag->name,
+		    new_tag->name));
+	    return;
+	}
+
+	if (me->element_stack &&
+	    !extra_action_taken &&
+	    (canclose_check == close_NO) &&
+	    !valid && (new_tag->flags & Tgf_mafse)) {
+	    BOOL has_attributes = NO;
+	    int i = 0;
+
+	    for (; i < new_tag->number_of_attributes && !has_attributes; i++)
+		has_attributes = me->present[i];
+	    if (!has_attributes) {
+		CTRACE((tfp,
+			"SGML: Still open %s, ***converting invalid <%s> to </%s>\n",
+			me->element_stack->tag->name,
+			new_tag->name,
+			new_tag->name));
+		end_element(me, new_tag);
+		return;
+	    }
+	}
+
+	if (me->element_stack &&
+	    (canclose_check == close_error) &&
+	    !element_valid_within(new_tag,
+				  me->element_stack->tag,
+				  direct_container)) {
+	    CTRACE((tfp, "SGML: Still open %s \t<- ***invalid start <%s>\n",
+		    me->element_stack->tag->name,
+		    new_tag->name));
+	}
+    }
+    /* Fall through to the non-extended code - kw */
+
+    /*
+     * If we are not in a SELECT block, check if this is a SELECT start tag. 
+     * Otherwise (i.e., we are in a SELECT block) accept only OPTION as valid,
+     * terminate the SELECT block if it is any other form-related element, and
+     * otherwise ignore it.  - FM
+     */
+    if (!me->inSELECT) {
+	/*
+	 * We are not in a SELECT block, so check if this starts one.  - FM
+	 * (frequent case!)
+	 */
+	/* my_casecomp() - optimized by the first character */
+	if (!my_casecomp(new_tag->name, "SELECT")) {
+	    /*
+	     * Set the inSELECT flag and fall through.  - FM
+	     */
+	    me->inSELECT = TRUE;
+	}
+    } else {
+	/*
+	 * We are in a SELECT block.  - FM
+	 */
+	if (strcasecomp(new_tag->name, "OPTION")) {
+	    /*
+	     * Ugh, it is not an OPTION.  - FM
+	     */
+	    switch (e) {
+	    case HTML_INPUT:
+	    case HTML_TEXTAREA:
+	    case HTML_SELECT:
+	    case HTML_BUTTON:
+	    case HTML_FIELDSET:
+	    case HTML_LABEL:
+	    case HTML_LEGEND:
+	    case HTML_FORM:
+		ok = TRUE;
+		break;
+	    default:
+		break;
+	    }
+	    if (ok) {
+		/*
+		 * It is another form-related start tag, so terminate the
+		 * current SELECT block and fall through.  - FM
+		 */
+		CTRACE((tfp,
+			"SGML: ***Faking SELECT end tag before <%s> start tag.\n",
+			new_tag->name));
+		end_element(me, SGMLFindTag(me->dtd, "SELECT"));
+	    } else {
+		/*
+		 * Ignore the start tag.  - FM
+		 */
+		CTRACE((tfp,
+			"SGML: ***Ignoring start tag <%s> in SELECT block.\n",
+			new_tag->name));
+		return;
+	    }
+	}
+    }
+    /*
+     * Handle the start tag.  - FM
+     */
+    CTRACE((tfp, "SGML: Start <%s>\n", new_tag->name));
+    status = (*me->actions->start_element) (me->target,
+					    (int) TAGNUM_OF_TAGP(new_tag),
+					    me->present,
+					    (STRING2PTR) me->value,	/* coerce type for think c */
+					    me->current_tag_charset,
+					    &me->include);
+    if (status == HT_PARSER_OTHER_CONTENT)
+	new_tag = ALT_TAGP(new_tag);	/* this is only returned for OBJECT */
+    if (new_tag->contents != SGML_EMPTY) {	/* i.e., tag not empty */
+	HTElement *N = pool_alloc();
+
+	if (N == NULL)
+	    outofmem(__FILE__, "start_element");
+
+	N->next = me->element_stack;
+	N->tag = new_tag;
+	me->element_stack = N;
+	me->no_lynx_specialcodes = (BOOLEAN) (new_tag->flags & Tgf_nolyspcl);
+
+    } else if (e == HTML_META) {
+	/*
+	 * Check for result of META tag.  - KW & FM
+	 */
+	change_chartrans_handling(me);
+    }
+}
+
+/*		Find Tag in DTD tag list
+ *		------------------------
+ *
+ * On entry,
+ *	dtd	points to dtd structure including valid tag list
+ *	string	points to name of tag in question
+ *
+ * On exit,
+ *	returns:
+ *		NULL		tag not found
+ *		else		address of tag structure in dtd
+ */
+HTTag *SGMLFindTag(const SGML_dtd * dtd,
+		   const char *s)
+{
+    int high, low, i, diff;
+    static HTTag *last[64] =
+    {NULL};			/*optimize using the previous results */
+    HTTag **res = last + (UCH(*s) % 64);	/*pointer arithmetic */
+
+    if (*res) {
+	if ((*res)->name == NULL)
+	    return NULL;
+	if (!strcasecomp((*res)->name, s))
+	    return *res;
+    }
+
+    for (low = 0, high = dtd->number_of_tags;
+	 high > low;
+	 diff < 0 ? (low = i + 1) : (high = i)) {	/* Binary search */
+	i = (low + (high - low) / 2);
+	/* my_casecomp() - optimized by the first character, NOT_ASCII ok */
+	diff = my_casecomp(dtd->tags[i].name, s);	/* Case insensitive */
+	if (diff == 0) {	/* success: found it */
+	    i -= dtd->tags[i].alias;
+	    *res = &dtd->tags[i];
+	    return *res;
+	}
+    }
+    if (IsNmStart(*s)) {
+	/*
+	 * Unrecognized, but may be valid.  - KW
+	 */
+	return &HTTag_unrecognized;
+    }
+    return NULL;
+}
+
+/*________________________________________________________________________
+ *			Public Methods
+ */
+
+/*	Could check that we are back to bottom of stack! @@  */
+/*	Do check! - FM					     */
+/*							     */
+static void SGML_free(HTStream *me)
+{
+    int i;
+    HTElement *cur;
+    HTTag *t;
+
+    /*
+     * Free the buffers.  - FM
+     */
+    FREE(me->recover);
+    FREE(me->url);
+    FREE(me->csi);
+    FREE(me->include);
+    FREE(me->active_include);
+
+    /*
+     * Wind down stack if any elements are open.  - FM
+     */
+    while (me->element_stack) {
+	cur = me->element_stack;
+	t = cur->tag;
+	me->element_stack = cur->next;	/* Remove from stack */
+	pool_free(cur);
+#ifdef USE_PRETTYSRC
+	if (!psrc_view)		/* Don't actually call on target if viewing psrc - kw */
+#endif
+	    (*me->actions->end_element)
+		(me->target,
+		 (int) NORMAL_TAGNUM(TAGNUM_OF_TAGP(t)),
+		 &me->include);
+	FREE(me->include);
+    }
+
+    /*
+     * Finish off the target.  - FM
+     */
+    (*me->actions->_free) (me->target);
+
+    /*
+     * Free the strings and context structure.  - FM
+     */
+    HTChunkFree(me->string);
+    for (i = 0; i < MAX_ATTRIBUTES; i++)
+	FREE_extra(me->value[i]);
+    FREE(me);
+
+#ifdef USE_PRETTYSRC
+    sgml_in_psrc_was_initialized = FALSE;
+#endif
+}
+
+static void SGML_abort(HTStream *me, HTError e)
+{
+    int i;
+    HTElement *cur;
+
+    /*
+     * Abort the target.  - FM
+     */
+    (*me->actions->_abort) (me->target, e);
+
+    /*
+     * Free the buffers.  - FM
+     */
+    FREE(me->recover);
+    FREE(me->include);
+    FREE(me->active_include);
+    FREE(me->url);
+    FREE(me->csi);
+
+    /*
+     * Free stack memory if any elements were left open.  - KW
+     */
+    while (me->element_stack) {
+	cur = me->element_stack;
+	me->element_stack = cur->next;	/* Remove from stack */
+	pool_free(cur);
+    }
+
+    /*
+     * Free the strings and context structure.  - FM
+     */
+    HTChunkFree(me->string);
+    for (i = 0; i < MAX_ATTRIBUTES; i++)
+	FREE_extra(me->value[i]);
+    FREE(me);
+
+#ifdef USE_PRETTYSRC
+    sgml_in_psrc_was_initialized = FALSE;
+#endif
+}
+
+/*	Read and write user callback handle
+ *	-----------------------------------
+ *
+ *   The callbacks from the SGML parser have an SGML context parameter.
+ *   These calls allow the caller to associate his own context with a
+ *   particular SGML context.
+ */
+
+#ifdef CALLERDATA
+void *SGML_callerData(HTStream *me)
+{
+    return me->callerData;
+}
+
+void SGML_setCallerData(HTStream *me, void *data)
+{
+    me->callerData = data;
+}
+#endif /* CALLERDATA */
+
+#ifdef USE_PRETTYSRC
+static void transform_tag(HTStream *me, HTChunk *string)
+{
+    if (!me->strict_xml) {
+	if (tagname_transform != 1) {
+	    if (tagname_transform == 0)
+		LYLowerCase(string->data);
+	    else
+		LYUpperCase(string->data);
+	}
+    }
+}
+#endif /* USE_PRETTYSRC */
+
+static BOOL ignore_when_empty(HTTag * tag)
+{
+    BOOL result = FALSE;
+
+    if (!LYPreparsedSource
+	&& LYxhtml_parsing
+	&& tag->name != 0
+	&& !(tag->flags & Tgf_mafse)
+	&& tag->contents != SGML_EMPTY
+	&& tag->tagclass != Tgc_Plike
+	&& (tag->tagclass == Tgc_APPLETlike
+	    || tag->tagclass == Tgc_SELECTlike
+	    || (tag->contains && tag->icontains))) {
+	result = TRUE;
+    }
+    CTRACE((tfp, "SGML Do%s ignore_when_empty:%s\n",
+	    result ? "" : " not",
+	    NonNull(tag->name)));
+    return result;
+}
+
+static void discard_empty(HTStream *me)
+{
+    static HTTag empty_tag;
+
+    CTRACE((tfp, "SGML discarding empty %s\n",
+	    NonNull(me->current_tag->name)));
+    CTRACE_FLUSH(tfp);
+
+    memset(&empty_tag, 0, sizeof(empty_tag));
+    me->current_tag = &empty_tag;
+    me->string->size = 0;
+
+    /* do not call end_element() if start_element() was not called */
+}
+
+#ifdef USE_PRETTYSRC
+static BOOL end_if_prettysrc(HTStream *me, HTChunk *string, int end_ch)
+{
+    BOOL result = psrc_view;
+
+    if (psrc_view) {
+	if (attr_is_name) {
+	    HTStartAnchor(me->target, string->data, NULL);
+	    (*me->actions->end_element) (me->target,
+					 HTML_A,
+					 &me->include);
+	} else if (attr_is_href) {
+	    PSRCSTART(href);
+	    HTStartAnchor(me->target, NULL, string->data);
+	}
+	PUTS_TR(string->data);
+	if (attr_is_href) {
+	    (*me->actions->end_element) (me->target,
+					 HTML_A,
+					 &me->include);
+	    PSRCSTOP(href);
+	}
+	if (end_ch)
+	    PUTC(end_ch);
+	PSRCSTOP(attrval);
+    }
+    return result;
+}
+#endif
+
+static void SGML_character(HTStream *me, int c_in)
+{
+    const SGML_dtd *dtd = me->dtd;
+    HTChunk *string = me->string;
+    const char *EntityName;
+    HTTag *testtag = NULL;
+    BOOLEAN chk;		/* Helps (?) walk through all the else ifs... */
+    UCode_t clong, uck = 0;	/* Enough bits for UCS4 ... */
+    int testlast;
+
+    unsigned char c;
+    unsigned char saved_char_in = '\0';
+
+    ++sgml_offset;
+
+    c = UCH(c_in);
+    clong = UCH(c);
+
+    if (me->T.decode_utf8) {
+	switch (HTDecodeUTF8(&(me->U), &c_in, &clong)) {
+	case dUTF8_ok:
+	    if (clong < 256) {
+		c_in = FROMASCII(UCH(clong));
+	    }
+	    break;
+	case dUTF8_err:
+	    clong = UCS_REPL;
+	    strcpy(me->U.utf_buf, "\357\277\275");
+	    me->U.utf_buf_p = (me->U.utf_buf + 3);
+	    break;
+	case dUTF8_more:
+	    return;
+	}
+
+	c = UCH(c_in);
+	if ((me->U.utf_buf_p - me->U.utf_buf) > 1) {
+	    goto top1;
+	}
+    }
+
+    /*
+     * If we want the raw input converted to Unicode, try that now.  - FM
+     */
+#ifdef USE_JAPANESEUTF8_SUPPORT
+    /* Convert ISO-2022-JP to Unicode (charset=iso-2022-jp is unrecognized) */
+#define IS_JIS7_HILO(c) (0x20<(c)&&(c)<0x7F)
+    if (UTF8_TTY_ISO2022JP && (me->state == S_nonascii_text
+			       || me->state == S_nonascii_text_sq
+			       || me->state == S_nonascii_text_dq)) {
+	/* end of ISO-2022-JP? || not in ISO-2022-JP range */
+	if (TOASCII(c) == '\033' || !IS_JIS7_HILO(c)) {
+	    me->kanji_buf = '\0';
+	    goto top1;
+	}
+	if (me->kanji_buf == '\t') {	/* flag for single byte kana in "ESC(I" */
+	    if (conv_jisx0201kana) {
+		JISx0201TO0208_SJIS(c | 0200,
+				    (unsigned char *) me->U.utf_buf,
+				    (unsigned char *) me->U.utf_buf + 1);
+		clong = UCTransJPToUni(me->U.utf_buf, 2,
+				       UCGetLYhndl_byMIME("shift_jis"));
+	    } else {
+		clong = UCTransToUni(c | 0200, UCGetLYhndl_byMIME("shift_jis"));
+	    }
+	} else if (me->kanji_buf) {
+	    me->U.utf_buf[0] = (char) (me->kanji_buf | 0200);	/* to EUC-JP */
+	    me->U.utf_buf[1] = (char) (c | 0200);
+	    clong = UCTransJPToUni(me->U.utf_buf, 2,
+				   UCGetLYhndl_byMIME("euc-jp"));
+	    me->kanji_buf = '\0';
+	} else {
+	    me->kanji_buf = c;
+	    clong = ucNeedMore;
+	}
+	goto top1;
+    }
+#endif /* USE_JAPANESEUTF8_SUPPORT */
+#ifdef USE_JAPANESEUTF8_SUPPORT
+    if (me->T.trans_to_uni &&
+	((strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "euc-jp") == 0) ||
+	 (strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "shift_jis") == 0))) {
+	if (strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "shift_jis") == 0) {
+	    if (me->U.utf_count == 0) {
+		if (IS_SJIS_HI1(c) ||
+		    IS_SJIS_HI2(c)) {
+		    me->U.utf_buf[0] = (char) c;
+		    me->U.utf_count = 1;
+		    clong = ucCannotConvert;
+		} else if (IS_SJIS_X0201KANA(c)) {
+		    if (conv_jisx0201kana) {
+			JISx0201TO0208_SJIS(c,
+					    (unsigned char *) me->U.utf_buf,
+					    (unsigned char *) me->U.utf_buf + 1);
+			clong = UCTransJPToUni(me->U.utf_buf, 2, me->inUCLYhndl);
+		    } else {
+			clong = UCTransToUni(c, me->inUCLYhndl);
+		    }
+		}
+	    } else {
+		if (IS_SJIS_LO(c)) {
+		    me->U.utf_buf[1] = (char) c;
+		    clong = UCTransJPToUni(me->U.utf_buf, 2, me->inUCLYhndl);
+		}
+		me->U.utf_count = 0;
+	    }
+	} else {
+	    if (me->U.utf_count == 0) {
+		if (IS_EUC_HI(c) || c == 0x8E) {
+		    me->U.utf_buf[0] = (char) c;
+		    me->U.utf_count = 1;
+		    clong = ucCannotConvert;
+		}
+	    } else {
+		if (IS_EUC_LOX(c)) {
+		    me->U.utf_buf[1] = (char) c;
+		    clong = UCTransJPToUni(me->U.utf_buf, 2, me->inUCLYhndl);
+		}
+		me->U.utf_count = 0;
+	    }
+	}
+	goto top1;
+    } else
+#endif /* USE_JAPANESEUTF8_SUPPORT */
+#ifdef EXP_CHINESEUTF8_SUPPORT
+	if (me->T.trans_to_uni &&
+	    ((strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "euc-cn") == 0))) {
+	if (me->U.utf_count == 0) {
+	    if (IS_GBK_HI(c)) {
+		me->U.utf_buf[0] = (char) c;
+		me->U.utf_count = 1;
+		clong = ucCannotConvert;
+		CTRACE((tfp, "Get EUC-CN: 0x%02X\n", UCH(c)));
+	    }
+	} else {
+	    if (IS_GBK_LO(c)) {
+		me->U.utf_buf[1] = (char) c;
+		clong = UCTransJPToUni(me->U.utf_buf, 2, me->inUCLYhndl);
+		if (clong > 0) {
+		    CTRACE((tfp, "... second: [%02X%02X] U+%04lX\n",
+			    UCH(me->U.utf_buf[0]),
+			    UCH(me->U.utf_buf[1]),
+			    clong));
+		} else {
+		    CTRACE((tfp, "... second: [%02X%02X] %ld\n",
+			    UCH(me->U.utf_buf[0]),
+			    UCH(me->U.utf_buf[1]),
+			    clong));
+		}
+	    }
+	    me->U.utf_count = 0;
+	}
+	goto top1;
+    } else
+#endif /* EXP_CHINESEUTF8_SUPPORT */
+#ifdef EXP_CHINESEUTF8_SUPPORT
+	if (me->T.trans_to_uni &&
+	    ((strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "euc-kr") == 0))) {
+	if (me->U.utf_count == 0) {
+	    if (IS_EUC_HI(c)) {
+		me->U.utf_buf[0] = (char) c;
+		me->U.utf_count = 1;
+		clong = ucCannotConvert;
+		CTRACE((tfp, "Get EUC-KR: 0x%02X\n", UCH(c)));
+	    }
+	} else {
+	    if (IS_EUC_LOS(c) ||
+		IS_EUC_LOX(c)) {
+		me->U.utf_buf[1] = (char) c;
+		clong = UCTransJPToUni(me->U.utf_buf, 2, me->inUCLYhndl);
+		if (clong > 0) {
+		    CTRACE((tfp, "... second: [%02X%02X] U+%04lX\n",
+			    UCH(me->U.utf_buf[0]),
+			    UCH(me->U.utf_buf[1]),
+			    clong));
+		} else {
+		    CTRACE((tfp, "... second: [%02X%02X] %ld\n",
+			    UCH(me->U.utf_buf[0]),
+			    UCH(me->U.utf_buf[1]),
+			    clong));
+		}
+	    }
+	    me->U.utf_count = 0;
+	}
+	goto top1;
+    } else
+#endif /* EXP_CHINESEUTF8_SUPPORT */
+#ifdef EXP_CHINESEUTF8_SUPPORT
+	if (me->T.trans_to_uni &&
+	    ((strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "big5") == 0))) {
+	if (me->U.utf_count == 0) {
+	    if (IS_BIG5_HI(c)) {
+		me->U.utf_buf[0] = (char) c;
+		me->U.utf_count = 1;
+		clong = ucCannotConvert;
+		CTRACE((tfp, "Get BIG5: 0x%02X\n", UCH(c)));
+	    }
+	} else {
+	    if (IS_BIG5_LOS(c) ||
+		IS_BIG5_LOX(c)) {
+		me->U.utf_buf[1] = (char) c;
+		clong = UCTransJPToUni(me->U.utf_buf, 2, me->inUCLYhndl);
+		if (clong > 0) {
+		    CTRACE((tfp, "... second: [%02X%02X] U+%04lX\n",
+			    UCH(me->U.utf_buf[0]),
+			    UCH(me->U.utf_buf[1]),
+			    clong));
+		} else {
+		    CTRACE((tfp, "... second: [%02X%02X] %ld\n",
+			    UCH(me->U.utf_buf[0]),
+			    UCH(me->U.utf_buf[1]),
+			    clong));
+		}
+	    }
+	    me->U.utf_count = 0;
+	}
+	goto top1;
+    } else
+#endif /* EXP_CHINESEUTF8_SUPPORT */
+	if (me->T.trans_to_uni &&
+	/* S/390 -- gil -- 0744 */
+	    ((TOASCII(clong) >= LYlowest_eightbit[me->inUCLYhndl]) ||
+	     (clong < ' ' && clong != 0 &&
+	      me->T.trans_C0_to_uni))) {
+	/*
+	 * Convert the octet to Unicode.  - FM
+	 */
+	clong = UCTransToUni((char) c, me->inUCLYhndl);
+	if (clong > 0) {
+	    saved_char_in = c;
+	    if (clong < 256) {
+		c = FROMASCII(UCH(clong));
+	    }
+	}
+	goto top1;
+    } else if (clong < ' ' && clong != 0 &&	/* S/390 -- gil -- 0768 */
+	       me->T.trans_C0_to_uni) {
+	/*
+	 * This else if may be too ugly to keep.  - KW
+	 */
+	if (me->T.trans_from_uni &&
+	    (((clong = UCTransToUni((char) c, me->inUCLYhndl)) >= ' ') ||
+	     (me->T.transp &&
+	      (clong = UCTransToUni((char) c, me->inUCLYhndl)) > 0))) {
+	    saved_char_in = c;
+	    if (clong < 256) {
+		c = FROMASCII(UCH(clong));
+	    }
+	    goto top1;
+	} else {
+	    uck = -1;
+	    if (me->T.transp) {
+		uck = UCTransCharStr(replace_buf, 60, (char) c,
+				     me->inUCLYhndl,
+				     me->inUCLYhndl, NO);
+	    }
+	    if (!me->T.transp || uck < 0) {
+		uck = UCTransCharStr(replace_buf, 60, (char) c,
+				     me->inUCLYhndl,
+				     me->outUCLYhndl, YES);
+	    }
+	    if (uck == 0) {
+		return;
+	    } else if (uck < 0) {
+		goto top0a;
+	    }
+	    c = UCH(replace_buf[0]);
+	    if (c && replace_buf[1]) {
+		if (me->state == S_text) {
+		    PUTS(replace_buf);
+		    return;
+		}
+		StrAllocCat(me->recover, replace_buf + 1);
+	    }
+	    goto top0a;
+	}			/*  Next line end of ugly stuff for C0. - KW */
+    } else {			/* end of me->T.trans_to_uni  S/390 -- gil -- 0791 */
+	goto top0a;
+    }
+
+    /*
+     *  We jump up to here from below if we have
+     *  stuff in the recover, insert, or csi buffers
+     *  to process.      We zero saved_char_in, in effect
+     *  as a flag that the octet is not that of the
+     *  actual call to this function.  This may be OK
+     *  for now, for the stuff this function adds to
+     *  its recover buffer, but it might not be for
+     *  stuff other functions added to the insert or
+     *  csi buffer, so bear that in mind. - FM
+     *  Stuff from the recover buffer is now handled
+     *  as UTF-8 if we can expect that's what it is,
+     *  and in that case we don't come back up here. - kw
+     */
+  top:
+    saved_char_in = '\0';
+    /*
+     *  We jump to here from above when we don't have
+     *  UTF-8 input, haven't converted to Unicode, and
+     *  want clong set to the input octet (unsigned)
+     *  without zeroing its saved_char_in copy (which
+     *  is signed). - FM
+     */
+  top0a:
+    *(me->U.utf_buf) = '\0';
+    clong = UCH(c);
+    /*
+     *  We jump to here from above if we have converted
+     *  the input, or a multibyte sequence across calls,
+     *  to a Unicode value and loaded it into clong (to
+     *  which unsign_c has been defined), and from below
+     *  when we are recycling a character (e.g., because
+     *  it terminated an entity but is not the standard
+     *  semi-colon).  The character will already have
+     *  been put through the Unicode conversions. - FM
+     */
+  top1:
+    /*
+     * Ignore low ISO 646 7-bit control characters if HTCJK is not set.  - FM
+     */
+    /*
+     * Works for both ASCII and EBCDIC. -- gil
+     * S/390 -- gil -- 0811
+     */
+    if (TOASCII(clong) < 32 &&
+	c != '\t' && c != '\n' && c != '\r' &&
+	!IS_CJK_TTY &&
+	!(UTF8_TTY_ISO2022JP && (TOASCII(c) == '\033')))
+	goto after_switch;
+
+    /*
+     * Ignore 127 if we don't have HTPassHighCtrlRaw or HTCJK set.  - FM
+     */
+#define PASSHICTRL (me->T.transp || \
+		    clong >= LYlowest_eightbit[me->inUCLYhndl])
+    if (TOASCII(c) == 127 &&	/* S/390 -- gil -- 0830 */
+	!(PASSHICTRL || IS_CJK_TTY))
+	goto after_switch;
+
+    /*
+     * Ignore 8-bit control characters 128 - 159 if neither HTPassHighCtrlRaw
+     * nor HTCJK is set.  - FM
+     */
+    if (TOASCII(clong) > 127 && TOASCII(clong) < 160 &&		/* S/390 -- gil -- 0847 */
+	!(PASSHICTRL || IS_CJK_TTY)) {
+	/*
+	 * If we happen to be reading from an "ISO-8859-1" or "US-ASCII"
+	 * document, allow the cp-1252 codes, to accommodate the HTML5 draft
+	 * recommendation for replacement encoding:
+	 *
+	 * http://www.whatwg.org/specs/web-apps/current-work/multipage/infrastructure.html#character-encodings-0
+	 */
+	if (AssumeCP1252(me)) {
+	    clong = LYcp1252ToUnicode((UCode_t) c);
+	    goto top1;
+	}
+	goto after_switch;
+    }
+
+    /* Almost all CJK characters are double byte but only Japanese
+     * JIS X0201 Kana is single byte. To prevent to fail SGML parsing
+     * we have to take care of them here. -- TH
+     */
+    if ((HTCJK == JAPANESE) && (me->state == S_in_kanji) &&
+	!IS_JAPANESE_2BYTE(me->kanji_buf, UCH(c))
+#ifdef USE_JAPANESEUTF8_SUPPORT
+	&& !me->T.decode_utf8
+#endif
+	) {
+#ifdef CONV_JISX0201KANA_JISX0208KANA
+	if (IS_SJIS_X0201KANA(me->kanji_buf)) {
+	    unsigned char sjis_hi, sjis_lo;
+
+	    JISx0201TO0208_SJIS(me->kanji_buf, &sjis_hi, &sjis_lo);
+	    PUTC(sjis_hi);
+	    PUTC(sjis_lo);
+	} else
+#endif
+	    PUTC(me->kanji_buf);
+	me->state = S_text;
+    }
+
+    /*
+     * Handle character based on me->state.
+     */
+    CTRACE2(TRACE_SGML, (tfp, "SGML before %s|%.*s|%c|\n",
+			 state_name(me->state),
+			 string->size,
+			 NonNull(string->data),
+			 UCH(c)));
+    switch (me->state) {
+
+    case S_in_kanji:
+	/*
+	 * Note that if we don't have a CJK input, then this is not the second
+	 * byte of a CJK di-byte, and we're trashing the input.  That's why
+	 * 8-bit characters followed by, for example, '<' can cause the tag to
+	 * be treated as text, not markup.  We could try to deal with it by
+	 * holding each first byte and then checking byte pairs, but that
+	 * doesn't seem worth the overhead (see below).  - FM
+	 */
+	me->state = S_text;
+	PUTC(me->kanji_buf);
+	PUTC(c);
+	break;
+
+    case S_tagname_slash:
+	/*
+	 * We had something link "<name/" so far, set state to S_text but keep
+	 * me->slashedtag as a flag; except if we get '>' directly
+	 * after the "<name/", and really have a tag for that name in
+	 * me->slashedtag, in which case keep state as is and let code
+	 * below deal with it.  - kw
+	 */
+	if (!(c == '>' && me->slashedtag && TOASCII(clong) < 127)) {
+	    me->state = S_text;
+	}
+	/* FALLTHRU */
+    case S_text:
+#ifdef EXP_CHINESEUTF8_SUPPORT
+	if (IS_CJK_TTY &&
+	    (!strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "euc-cn") ||
+	     !strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "big5") ||
+	     !strcmp(LYCharSet_UC[me->inUCLYhndl].MIMEname, "euc-kr"))) {
+	    /*
+	     * Leave the case statement if we have not collected both of the
+	     * bytes for the EUC-CN character.  If we have, then continue on
+	     * to convert it to Unicode.
+	     */
+	    if (clong == ucCannotConvert) {
+		break;
+	    }
+	} else
+#endif
+	    if (IS_CJK_TTY && ((TOASCII(c) & 0200) != 0)
+#ifdef USE_JAPANESEUTF8_SUPPORT
+		&& !me->T.decode_utf8
+#endif
+	    ) {			/* S/390 -- gil -- 0864 */
+	    /*
+	     * Setting up for Kanji multibyte handling (based on Takuya ASADA's
+	     * (asada@three-a.co.jp) CJK Lynx).  Note that if the input is not
+	     * in fact CJK, the next byte also will be mishandled, as explained
+	     * above.  Toggle raw mode off in such cases, or select the "7 bit
+	     * approximations" display character set, which is largely
+	     * equivalent to having raw mode off with CJK.  - FM
+	     */
+	    me->state = S_in_kanji;
+	    me->kanji_buf = c;
+	    break;
+	} else if ((IS_CJK_TTY || UTF8_TTY_ISO2022JP) && TOASCII(c) == '\033') {
+	    /* S/390 -- gil -- 0881 */
+	    /*
+	     * Setting up for CJK escape sequence handling (based on Takuya
+	     * ASADA's (asada@three-a.co.jp) CJK Lynx).  - FM
+	     */
+	    me->state = S_esc;
+	    if (!UTF8_TTY_ISO2022JP)
+		PUTC(c);
+	    break;
+	}
+
+	if (c == '&' || c == '<') {
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {	/*there is nothing useful in the element_stack */
+		testtag = me->current_tag;
+	    } else
+#endif
+	    {
+		testtag = me->element_stack ?
+		    me->element_stack->tag : NULL;
+	    }
+	}
+
+	if (c == '&' && TOASCII(clong) < 127 &&		/* S/390 -- gil -- 0898 */
+	    (!testtag ||
+	     (testtag->contents == SGML_MIXED ||
+	      testtag->contents == SGML_ELEMENT ||
+	      testtag->contents == SGML_PCDATA ||
+#ifdef USE_PRETTYSRC
+	      testtag->contents == SGML_EMPTY ||
+#endif
+	      testtag->contents == SGML_RCDATA))) {
+	    /*
+	     * Setting up for possible entity, without the leading '&'.  - FM
+	     */
+	    string->size = 0;
+	    me->state = S_ero;
+	} else if (c == '<' && TOASCII(clong) < 127) {	/* S/390 -- gil -- 0915 */
+	    /*
+	     * Setting up for possible tag.  - FM
+	     */
+	    string->size = 0;
+	    if (testtag && testtag->contents == SGML_PCDATA) {
+		me->state = S_pcdata;
+	    } else if (testtag && (testtag->contents == SGML_LITTERAL
+				   || testtag->contents == SGML_CDATA)) {
+		me->state = S_litteral;
+	    } else if (testtag && (testtag->contents == SGML_SCRIPT)) {
+		me->state = S_script;
+	    } else {
+		me->state = S_tag;
+	    }
+	    me->slashedtag = NULL;
+	} else if (me->slashedtag &&
+		   me->slashedtag->name &&
+		   (c == '/' ||
+		    (c == '>' && me->state == S_tagname_slash)) &&
+		   TOASCII(clong) < 127) {
+	    /*
+	     * We got either the second slash of a pending "<NAME/blah blah/"
+	     * shortref construct, or the '>' of a mere "<NAME/>".  In both
+	     * cases generate a "</NAME>" end tag in the recover buffer for
+	     * reparsing unless NAME is really an empty element.  - kw
+	     */
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(abracket);
+		PUTC(c);
+		PSRCSTOP(abracket);
+	    } else
+#endif
+		if (me->slashedtag != me->unknown_tag &&
+		    !ReallyEmptyTag(me->slashedtag)) {
+		if (me->recover == NULL) {
+		    StrAllocCopy(me->recover, "</");
+		    me->recover_index = 0;
+		} else {
+		    StrAllocCat(me->recover, "</");
+		}
+		StrAllocCat(me->recover, me->slashedtag->name);
+		StrAllocCat(me->recover, ">");
+	    }
+	    me->slashedtag = NULL;
+
+	} else if (me->element_stack &&
+		   (me->element_stack->tag->flags & Tgf_frecyc)) {
+	    /*
+	     * The element stack says we are within the contents of an element
+	     * that the next stage (HTML.c) may want to feed us back again (via
+	     * the *include string).  So try to output text in UTF-8 if
+	     * possible, using the same logic as for attribute values (which
+	     * should be in line with what me->current_tag_charset
+	     * indicates).  - kw
+	     */
+	    if (me->T.decode_utf8 &&
+		*me->U.utf_buf) {
+		PUTS(me->U.utf_buf);
+		me->U.utf_buf_p = me->U.utf_buf;
+		*(me->U.utf_buf_p) = '\0';
+	    } else if (!IS_CJK_TTY &&
+		       (me->T.output_utf8 ||
+			me->T.trans_from_uni)) {
+		if (LYIsASCII(clong)) {
+		    PUTC(c);
+		} else if (clong == UCS_REPL && saved_char_in &&
+			   HTPassEightBitRaw &&
+			   saved_char_in >=
+			   LYlowest_eightbit[me->outUCLYhndl]) {
+		    PUTUTF8((UCode_t) (0xf000 | saved_char_in));
+		} else {
+		    PUTUTF8(clong);
+		}
+	    } else if (saved_char_in && me->T.use_raw_char_in) {
+		PUTC(saved_char_in);
+	    } else {
+		PUTC(c);
+	    }
+
+#define PASS8859SPECL me->T.pass_160_173_raw
+	    /*
+	     * Convert 160 (nbsp) to Lynx special character if neither
+	     * HTPassHighCtrlRaw nor HTCJK is set.  - FM
+	     */
+	} else if (clong == CH_NBSP &&	/* S/390 -- gil -- 0932 */
+		   !me->no_lynx_specialcodes &&
+		   !(PASS8859SPECL || IS_CJK_TTY)) {
+	    PUTC(HT_NON_BREAK_SPACE);
+	    /*
+	     * Convert 173 (shy) to Lynx special character if neither
+	     * HTPassHighCtrlRaw nor HTCJK is set.  - FM
+	     */
+	} else if (clong == CH_SHY &&	/* S/390 -- gil -- 0949 */
+		   !me->no_lynx_specialcodes &&
+		   !(PASS8859SPECL || IS_CJK_TTY)) {
+	    PUTC(LY_SOFT_HYPHEN);
+	    /*
+	     * Handle the case in which we think we have a character which
+	     * doesn't need further processing (e.g., a koi8-r input for a
+	     * koi8-r output).  - FM
+	     */
+	} else if (me->T.use_raw_char_in && saved_char_in) {
+	    /*
+	     * Only if the original character is still in saved_char_in,
+	     * otherwise we may be iterating from a goto top.  - KW
+	     */
+	    PUTC(saved_char_in);
+	} else if ((chk = (BOOL) (me->T.trans_from_uni &&
+				  TOASCII(clong) >= 160)) &&	/* S/390 -- gil -- 0968 */
+		   (uck = UCTransUniChar(clong,
+					 me->outUCLYhndl)) >= ' ' &&
+		   uck < 256) {
+	    CTRACE((tfp, "UCTransUniChar returned 0x%.2" PRI_UCode_t
+		    ":'%c'.\n",
+		    uck, FROMASCII((char)uck)));
+	    /*
+	     * We got one octet from the conversions, so use it.  - FM
+	     */
+	    PUTC(FROMASCII((char) uck));
+	} else if ((chk &&
+		    (uck == -4 ||
+		     (me->T.repl_translated_C0 &&
+		      uck > 0 && uck < 32))) &&
+	    /*
+	     * Not found; look for replacement string.  - KW
+	     */
+		   (uck = UCTransUniCharStr(replace_buf, 60, clong,
+					    me->outUCLYhndl,
+					    0) >= 0)) {
+	    /*
+	     * Got a replacement string.  No further tests for validity -
+	     * assume that whoever defined replacement strings knew what she
+	     * was doing.  - KW
+	     */
+	    PUTS(replace_buf);
+	    /*
+	     * If we're displaying UTF-8, try that now.  - FM
+	     */
+	} else if (me->T.output_utf8 && PUTUTF8(clong)) {
+	    ;			/* do nothing more */
+	    /*
+	     * If it's any other (> 160) 8-bit character, and we have not set
+	     * HTPassEightBitRaw nor HTCJK, nor have the "ISO Latin 1"
+	     * character set selected, back translate for our character set.  -
+	     * FM
+	     */
+#define IncludesLatin1Enc \
+		(me->outUCLYhndl == LATIN1 || \
+		 (me->outUCI && \
+		  (me->outUCI->enc & (UCT_CP_SUPERSETOF_LAT1))))
+
+#define PASSHI8BIT (HTPassEightBitRaw || \
+		    (me->T.do_8bitraw && !me->T.trans_from_uni))
+
+	} else if (clong > 160 && clong < 256 &&
+		   !(PASSHI8BIT || IS_CJK_TTY) &&
+		   !IncludesLatin1Enc) {
+#ifdef USE_PRETTYSRC
+	    int psrc_view_backup = 0;
+#endif
+
+	    string->size = 0;
+	    EntityName = HTMLGetEntityName((UCode_t) (clong - 160));
+	    HTChunkPuts(string, EntityName);
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    /* we need to disable it temporarily */
+	    if (psrc_view) {
+		psrc_view_backup = 1;
+		psrc_view = 0;
+	    }
+#endif
+	    handle_entity(me, '\0');
+#ifdef USE_PRETTYSRC
+	    /* we need to disable it temporarily */
+	    if (psrc_view_backup)
+		psrc_view = TRUE;
+#endif
+
+	    string->size = 0;
+	    if (!FoundEntity)
+		PUTC(';');
+	    /*
+	     * If we get to here and have an ASCII char, pass the character.  -
+	     * KW
+	     */
+	} else if (TOASCII(clong) < 127 && clong > 0) {		/* S/390 -- gil -- 0987 */
+	    PUTC(c);
+	    /*
+	     * If we get to here, and should have translated, translation has
+	     * failed so far.  - KW
+	     *
+	     * We should have sent UTF-8 output to the parser already, but what
+	     * the heck, try again.  - FM
+	     */
+	} else if (me->T.output_utf8 && *me->U.utf_buf) {
+	    PUTS(me->U.utf_buf);
+	    me->U.utf_buf_p = me->U.utf_buf;
+	    *(me->U.utf_buf_p) = '\0';
+	    /*
+	     * If we don't actually want the character, make it safe and output
+	     * that now.  - FM
+	     */
+	} else if (TOASCII(UCH(c)) <	/* S/390 -- gil -- 0997 */
+		   LYlowest_eightbit[me->outUCLYhndl] ||
+		   (me->T.trans_from_uni && !HTPassEightBitRaw)) {
+	    /*
+	     * If we get to here, pass the character.  - FM
+	     */
+	} else {
+	    PUTC(c);
+	}
+	break;
+
+	/*
+	 * Found '<' in SGML_PCDATA content; treat this mode nearly like
+	 * S_litteral, but recognize '<!' and '<?' to filter out comments and
+	 * processing instructions.  - kw
+	 */
+    case S_pcdata:
+	if (!string->size && TOASCII(clong) < 127) {	/* first after '<' */
+	    if (c == '!') {	/* <! */
+		/*
+		 * Terminate and set up for possible comment, identifier,
+		 * declaration, or marked section as under S_tag.  - kw
+		 */
+		me->state = S_exclamation;
+		me->lead_exclamation = TRUE;
+		me->doctype_bracket = FALSE;
+		me->first_bracket = FALSE;
+		HTChunkPutc(string, c);
+		break;
+	    } else if (c == '?') {	/* <? - ignore as a PI until '>' - kw */
+		CTRACE((tfp,
+			"SGML: Found PI in PCDATA, junking it until '>'\n"));
+#ifdef USE_PRETTYSRC
+		if (psrc_view) {
+		    PSRCSTART(abracket);
+		    PUTS("<?");
+		    PSRCSTOP(abracket);
+		}
+#endif
+		me->state = S_pi;
+		break;
+	    }
+	}
+	goto case_S_litteral;
+
+	/*
+	 * Found '<' in SGML_SCRIPT content; treat this mode nearly like
+	 * S_litteral, but recognize '<!' to allow the content to be treated as
+	 * a comment by lynx.
+	 */
+    case S_script:
+	if (!string->size && TOASCII(clong) < 127) {	/* first after '<' */
+	    if (c == '!') {	/* <! */
+		/*
+		 * Terminate and set up for possible comment, identifier,
+		 * declaration, or marked section as under S_tag.  - kw
+		 */
+		me->state = S_exclamation;
+		me->lead_exclamation = TRUE;
+		me->doctype_bracket = FALSE;
+		me->first_bracket = FALSE;
+		HTChunkPutc(string, c);
+		break;
+	    }
+	}
+	goto case_S_litteral;
+
+	/*
+	 * In literal mode, waits only for specific end tag (for compatibility
+	 * with old servers, and for Lynx).  - FM
+	 */
+      case_S_litteral:
+    case S_litteral:
+	/*PSRC:this case not understood completely by HV, not done */
+	HTChunkPutc(string, c);
+#ifdef USE_PRETTYSRC
+	if (psrc_view) {
+	    /* there is nothing useful in the element_stack */
+	    testtag = me->current_tag;
+	} else
+#endif
+	    testtag = (me->element_stack
+		       ? me->element_stack->tag
+		       : NULL);
+
+	if (testtag == NULL || testtag->name == NULL) {
+	    string->size--;
+	    me->state = S_text;
+	    goto top1;
+	}
+
+	/*
+	 * Normally when we get the closing ">",
+	 *      testtag contains something like "TITLE"
+	 *      string contains something like "/title>"
+	 * so we decrement by 2 to compare the final character of each.
+	 */
+	testlast = string->size - 2 - me->trailing_spaces - me->leading_spaces;
+
+#ifdef USE_COLOR_STYLE
+#define TagSize(p) ((p)->name_len)
+#else
+#define TagSize(p) (strlen((p)->name))
+#endif
+
+	if (TOUPPER(c) != ((testlast < 0)
+			   ? '/'
+			   : ((testlast < (int) TagSize(testtag))
+			      ? testtag->name[testlast]
+			      : 0))) {
+	    int i;
+
+	    /*
+	     * If complete match, end literal.
+	     */
+	    if ((c == '>') &&
+		testlast >= 0 && !testtag->name[testlast]) {
+#ifdef USE_PRETTYSRC
+		if (psrc_view) {
+		    char *trailing = NULL;
+
+		    if (me->trailing_spaces) {
+			StrAllocCopy(trailing,
+				     string->data
+				     + string->size
+				     - 1
+				     - me->trailing_spaces);
+			trailing[me->trailing_spaces] = '\0';
+		    }
+
+		    PSRCSTART(abracket);
+		    PUTS("</");
+		    PSRCSTOP(abracket);
+		    PSRCSTART(tag);
+
+		    strcpy(string->data, me->current_tag->name);
+		    transform_tag(me, string);
+		    PUTS(string->data);
+
+		    if (trailing) {
+			PUTS(trailing);
+			FREE(trailing);
+		    }
+
+		    PSRCSTOP(tag);
+		    PSRCSTART(abracket);
+		    PUTC('>');
+		    PSRCSTOP(abracket);
+
+		    me->current_tag = NULL;
+		} else
+#endif
+		    end_element(me, me->element_stack->tag);
+
+		string->size = 0;
+		me->current_attribute_number = INVALID;
+		me->state = S_text;
+		me->leading_spaces = 0;
+		me->trailing_spaces = 0;
+		break;
+	    }
+
+	    /*
+	     * Allow whitespace between the "<" or ">" and the keyword, for
+	     * error-recovery.
+	     */
+	    if (isspace(UCH(c))) {
+		if (testlast == -1) {
+		    me->leading_spaces += 1;
+		    CTRACE2(TRACE_SGML, (tfp, "leading spaces: %d\n", me->leading_spaces));
+		    break;
+		} else if (testlast > 0) {
+		    me->trailing_spaces += 1;
+		    CTRACE2(TRACE_SGML, (tfp, "trailing spaces: %d\n", me->trailing_spaces));
+		    break;
+		}
+	    }
+
+	    /*
+	     * Mismatch - recover.
+	     */
+	    me->leading_spaces = 0;
+	    me->trailing_spaces = 0;
+	    if (((testtag->contents != SGML_LITTERAL &&
+		  (testtag->flags & Tgf_strict)) ||
+		 (me->state == S_pcdata &&
+		  (testtag->flags & (Tgf_strict | Tgf_endO)))) &&
+		(testlast > -1 &&
+		 (c == '>' || testlast > 0 || IsNmStart(c)))) {
+		me->state = S_end;
+		string->size--;
+		for (i = 0; i < string->size; i++)	/* remove '/' */
+		    string->data[i] = string->data[i + 1];
+		if ((string->size == 1) ? IsNmStart(c) : IsNmChar(c))
+		    break;
+		string->size--;
+		goto top1;
+	    }
+	    if (me->state == S_pcdata &&
+		(testtag->flags & (Tgf_strict | Tgf_endO)) &&
+		(testlast < 0 && IsNmStart(c))) {
+		me->state = S_tag;
+		break;
+	    }
+	    /*
+	     * If Mismatch:  recover string literally.
+	     */
+	    PUTC('<');
+	    for (i = 0; i < string->size - 1; i++)	/* recover, except last c */
+		PUTC(string->data[i]);
+	    string->size = 0;
+	    me->state = S_text;
+	    goto top1;		/* to recover last c */
+	}
+	break;
+
+	/*
+	 * Character reference (numeric entity) or named entity.
+	 */
+    case S_ero:
+	if (c == '#') {
+	    /*
+	     * Setting up for possible numeric entity.
+	     */
+	    me->state = S_cro;	/* &# is Char Ref Open */
+	    break;
+	}
+	me->state = S_entity;	/* Fall through! */
+
+	/*
+	 * Handle possible named entity.
+	 */
+    case S_entity:
+	if (TOASCII(clong) < 127 && (string->size ?	/* S/390 -- gil -- 1029 */
+				     isalnum(UCH(c)) : isalpha(UCH(c)))) {
+	    /* Should probably use IsNmStart/IsNmChar above (is that right?),
+	       but the world is not ready for that - there's &nbsp: (note
+	       colon!) and stuff around. */
+	    /*
+	     * Accept valid ASCII character.  - FM
+	     */
+	    HTChunkPutc(string, c);
+	} else if (string->size == 0) {
+	    /*
+	     * It was an ampersand that's just text, so output the ampersand
+	     * and recycle this character.  - FM
+	     */
+#ifdef USE_PRETTYSRC
+	    if (psrc_view)
+		PSRCSTART(badseq);
+#endif
+	    PUTC('&');
+#ifdef USE_PRETTYSRC
+	    if (psrc_view)
+		PSRCSTOP(badseq);
+#endif
+	    me->state = S_text;
+	    goto top1;
+	} else {
+	    /*
+	     * Terminate entity name and try to handle it.  - FM
+	     */
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    entity_string = string->data;
+#endif
+	    if (!strcmp(string->data, "zwnj") &&
+		(!me->element_stack ||
+		 (me->element_stack->tag &&
+		  me->element_stack->tag->contents == SGML_MIXED))) {
+		/*
+		 * Handle zwnj (8204) as <WBR>.  - FM
+		 */
+		char temp[8];
+
+		CTRACE((tfp,
+			"SGML_character: Handling 'zwnj' entity as 'WBR' element.\n"));
+
+		if (c != ';') {
+		    sprintf(temp, "<WBR>%c", c);
+		} else {
+		    sprintf(temp, "<WBR>");
+		}
+		if (me->recover == NULL) {
+		    StrAllocCopy(me->recover, temp);
+		    me->recover_index = 0;
+		} else {
+		    StrAllocCat(me->recover, temp);
+		}
+		string->size = 0;
+		me->state = S_text;
+		break;
+	    } else {
+		handle_entity(me, '\0');
+	    }
+	    string->size = 0;
+	    me->state = S_text;
+	    /*
+	     * Don't eat the terminator if we didn't find the entity name and
+	     * therefore sent the raw string via handle_entity(), or if the
+	     * terminator is not the "standard" semi-colon for HTML.  - FM
+	     */
+#ifdef USE_PRETTYSRC
+	    if (psrc_view && FoundEntity && c == ';') {
+		PSRCSTART(entity);
+		PUTC(c);
+		PSRCSTOP(entity);
+	    }
+#endif
+	    if (!FoundEntity || c != ';')
+		goto top1;
+	}
+	break;
+
+	/*
+	 * Check for a numeric entity.
+	 */
+    case S_cro:
+	if (TOASCII(clong) < 127 && TOLOWER(UCH(c)) == 'x') {	/* S/390 -- gil -- 1060 */
+	    me->isHex = TRUE;
+	    me->state = S_incro;
+	} else if (TOASCII(clong) < 127 && isdigit(UCH(c))) {
+	    /*
+	     * Accept only valid ASCII digits.  - FM
+	     */
+	    HTChunkPutc(string, c);	/* accumulate a character NUMBER */
+	    me->isHex = FALSE;
+	    me->state = S_incro;
+	} else if (string->size == 0) {
+	    /*
+	     * No 'x' or digit following the "&#" so recover them and recycle
+	     * the character.  - FM
+	     */
+#ifdef USE_PRETTYSRC
+	    if (psrc_view)
+		PSRCSTART(badseq);
+#endif
+	    PUTC('&');
+	    PUTC('#');
+#ifdef USE_PRETTYSRC
+	    if (psrc_view)
+		PSRCSTOP(badseq);
+#endif
+	    me->state = S_text;
+	    goto top1;
+	}
+	break;
+
+	/*
+	 * Handle a numeric entity.
+	 */
+    case S_incro:
+	/* S/390 -- gil -- 1075 */
+	if ((TOASCII(clong) < 127) &&
+	    (me->isHex
+	     ? isxdigit(UCH(c))
+	     : isdigit(UCH(c)))) {
+	    /*
+	     * Accept only valid hex or ASCII digits.  - FM
+	     */
+	    HTChunkPutc(string, c);	/* accumulate a character NUMBER */
+	} else if (string->size == 0) {
+	    /*
+	     * No hex digit following the "&#x" so recover them and recycle the
+	     * character.  - FM
+	     */
+#ifdef USE_PRETTYSRC
+	    if (psrc_view)
+		PSRCSTART(badseq);
+#endif
+	    PUTS("&#x");
+#ifdef USE_PRETTYSRC
+	    if (psrc_view)
+		PSRCSTOP(badseq);
+#endif
+	    me->isHex = FALSE;
+	    me->state = S_text;
+	    goto top1;
+	} else {
+	    /*
+	     * Terminate the numeric entity and try to handle it.  - FM
+	     */
+	    UCode_t code;
+	    int i;
+
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    entity_string = string->data;
+#endif
+	    if (UCScanCode(&code, string->data, me->isHex)) {
+
+/* =============== work in ASCII below here ===============  S/390 -- gil -- 1092 */
+		if (AssumeCP1252(me)) {
+		    code = LYcp1252ToUnicode(code);
+		}
+		/*
+		 * Check for special values.  - FM
+		 */
+		if ((code == 8204) &&
+		    (!me->element_stack ||
+		     (me->element_stack->tag &&
+		      me->element_stack->tag->contents == SGML_MIXED))) {
+		    /*
+		     * Handle zwnj (8204) as <WBR>.  - FM
+		     */
+		    char temp[8];
+
+		    CTRACE((tfp,
+			    "SGML_character: Handling '8204' (zwnj) reference as 'WBR' element.\n"));
+
+		    /*
+		     * Include the terminator if it is not the standard
+		     * semi-colon.  - FM
+		     */
+		    if (c != ';') {
+			sprintf(temp, "<WBR>%c", c);
+		    } else {
+			sprintf(temp, "<WBR>");
+		    }
+		    /*
+		     * Add the replacement string to the recover buffer for
+		     * processing.  - FM
+		     */
+		    if (me->recover == NULL) {
+			StrAllocCopy(me->recover, temp);
+			me->recover_index = 0;
+		    } else {
+			StrAllocCat(me->recover, temp);
+		    }
+		    string->size = 0;
+		    me->isHex = FALSE;
+		    me->state = S_text;
+		    break;
+		} else if (put_special_unicodes(me, code)) {
+		    /*
+		     * We handled the value as a special character, so recycle
+		     * the terminator or break.  - FM
+		     */
+#ifdef USE_PRETTYSRC
+		    if (psrc_view) {
+			PSRCSTART(entity);
+			PUTS((me->isHex ? "&#x" : "&#"));
+			PUTS(entity_string);
+			if (c == ';')
+			    PUTC(';');
+			PSRCSTOP(entity);
+		    }
+#endif
+		    string->size = 0;
+		    me->isHex = FALSE;
+		    me->state = S_text;
+		    if (c != ';')
+			goto top1;
+		    break;
+		}
+		/*
+		 * Seek a translation from the chartrans tables.
+		 */
+		if ((uck = UCTransUniChar(code,
+					  me->outUCLYhndl)) >= 32 &&
+		    uck < 256 &&
+		    (uck < 127 ||
+		     uck >= LYlowest_eightbit[me->outUCLYhndl])) {
+#ifdef USE_PRETTYSRC
+		    if (!psrc_view) {
+#endif
+			PUTC(FROMASCII((char) uck));
+#ifdef USE_PRETTYSRC
+		    } else {
+			put_pretty_number(me);
+		    }
+#endif
+		} else if ((uck == -4 ||
+			    (me->T.repl_translated_C0 &&
+			     uck > 0 && uck < 32)) &&
+		    /*
+		     * Not found; look for replacement string.
+		     */
+			   (uck = UCTransUniCharStr(replace_buf, 60, code,
+						    me->outUCLYhndl,
+						    0) >= 0)) {
+#ifdef USE_PRETTYSRC
+		    if (psrc_view) {
+			put_pretty_number(me);
+		    } else
+#endif
+			PUTS(replace_buf);
+		    /*
+		     * If we're displaying UTF-8, try that now.  - FM
+		     */
+		} else if (me->T.output_utf8 && PUTUTF8(code)) {
+		    ;		/* do nothing more */
+		    /*
+		     * Ignore 8205 (zwj), 8206 (lrm), and 8207 (rln), if we get
+		     * to here.  - FM
+		     */
+		} else if (code == 8205 ||
+			   code == 8206 ||
+			   code == 8207) {
+		    if (TRACE) {
+			string->size--;
+			LYStrNCpy(replace_buf,
+				  string->data,
+				  (string->size < 64 ? string->size : 63));
+			fprintf(tfp,
+				"SGML_character: Ignoring '%s%s'.\n",
+				(me->isHex ? "&#x" : "&#"),
+				replace_buf);
+		    }
+#ifdef USE_PRETTYSRC
+		    if (psrc_view) {
+			PSRCSTART(badseq);
+			PUTS((me->isHex ? "&#x" : "&#"));
+			PUTS(entity_string);
+			if (c == ';')
+			    PUTC(';');
+			PSRCSTOP(badseq);
+		    }
+#endif
+		    string->size = 0;
+		    me->isHex = FALSE;
+		    me->state = S_text;
+		    if (c != ';')
+			goto top1;
+		    break;
+		    /*
+		     * Show the numeric entity if we get to here and the value:
+		     * (1) Is greater than 255 (but use ASCII characters for
+		     * spaces or dashes).
+		     * (2) Is less than 32, and not valid or we don't have
+		     * HTCJK set.
+		     * (3) Is 127 and we don't have HTPassHighCtrlRaw or HTCJK
+		     * set.
+		     * (4) Is 128 - 159 and we don't have HTPassHighCtrlNum
+		     * set.
+		     * - FM
+		     */
+		} else if ((code > 255) ||
+			   (code < ' ' &&	/* S/390 -- gil -- 1140 */
+			    code != '\t' && code != '\n' && code != '\r' &&
+			    !IS_CJK_TTY) ||
+			   (TOASCII(code) == 127 &&
+			    !(HTPassHighCtrlRaw || IS_CJK_TTY)) ||
+			   (TOASCII(code) > 127 && code < 160 &&
+			    !HTPassHighCtrlNum)) {
+		    /*
+		     * Unhandled or illegal value.  Recover the "&#" or "&#x"
+		     * and digit(s), and recycle the terminator.  - FM
+		     */
+#ifdef USE_PRETTYSRC
+		    if (psrc_view) {
+			PSRCSTART(badseq);
+		    }
+#endif
+		    if (me->isHex) {
+			PUTS("&#x");
+			me->isHex = FALSE;
+		    } else {
+			PUTS("&#");
+		    }
+		    string->size--;
+		    for (i = 0; i < string->size; i++)	/* recover */
+			PUTC(string->data[i]);
+#ifdef USE_PRETTYSRC
+		    if (psrc_view) {
+			PSRCSTOP(badseq);
+		    }
+#endif
+		    string->size = 0;
+		    me->isHex = FALSE;
+		    me->state = S_text;
+		    goto top1;
+		} else if (TOASCII(code) < 161 ||	/* S/390 -- gil -- 1162 */
+			   HTPassEightBitNum ||
+			   IncludesLatin1Enc) {
+		    /*
+		     * No conversion needed.  - FM
+		     */
+#ifdef USE_PRETTYSRC
+		    if (psrc_view) {
+			put_pretty_number(me);
+		    } else
+#endif
+			PUTC(FROMASCII((char) code));
+		} else {
+		    /*
+		     * Handle as named entity.  - FM
+		     */
+		    code -= 160;
+		    EntityName = HTMLGetEntityName(code);
+		    if (EntityName && EntityName[0] != '\0') {
+			string->size = 0;
+			HTChunkPuts(string, EntityName);
+			HTChunkTerminate(string);
+			handle_entity(me, '\0');
+			/*
+			 * Add a semi-colon if something went wrong and
+			 * handle_entity() sent the string.  - FM
+			 */
+			if (!FoundEntity) {
+			    PUTC(';');
+			}
+		    } else {
+			/*
+			 * Our conversion failed, so recover the "&#" and
+			 * digit(s), and recycle the terminator.  - FM
+			 */
+#ifdef USE_PRETTYSRC
+			if (psrc_view)
+			    PSRCSTART(badseq);
+#endif
+			if (me->isHex) {
+			    PUTS("&#x");
+			    me->isHex = FALSE;
+			} else {
+			    PUTS("&#");
+			}
+			string->size--;
+			for (i = 0; i < string->size; i++)	/* recover */
+			    PUTC(string->data[i]);
+#ifdef USE_PRETTYSRC
+			if (psrc_view)
+			    PSRCSTOP(badseq);
+#endif
+			string->size = 0;
+			me->isHex = FALSE;
+			me->state = S_text;
+			goto top1;
+		    }
+		}
+		/*
+		 * If we get to here, we succeeded.  Hoorah!!!  - FM
+		 */
+		string->size = 0;
+		me->isHex = FALSE;
+		me->state = S_text;
+		/*
+		 * Don't eat the terminator if it's not the "standard"
+		 * semi-colon for HTML.  - FM
+		 */
+		if (c != ';') {
+		    goto top1;
+		}
+	    } else {
+		/*
+		 * Not an entity, and don't know why not, so add the terminator
+		 * to the string, output the "&#" or "&#x", and process the
+		 * string via the recover element.  - FM
+		 */
+		string->size--;
+		HTChunkPutc(string, c);
+		HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+		if (psrc_view)
+		    PSRCSTART(badseq);
+#endif
+		if (me->isHex) {
+		    PUTS("&#x");
+		    me->isHex = FALSE;
+		} else {
+		    PUTS("&#");
+		}
+#ifdef USE_PRETTYSRC
+		if (psrc_view)
+		    PSRCSTOP(badseq);
+#endif
+		if (me->recover == NULL) {
+		    StrAllocCopy(me->recover, string->data);
+		    me->recover_index = 0;
+		} else {
+		    StrAllocCat(me->recover, string->data);
+		}
+		string->size = 0;
+		me->isHex = FALSE;
+		me->state = S_text;
+		break;
+	    }
+	}
+	break;
+
+	/*
+	 * Tag
+	 */
+    case S_tag:		/* new tag */
+	if (TOASCII(clong) < 127 && (string->size ?	/* S/390 -- gil -- 1179 */
+				     IsNmChar(c) : IsNmStart(c))) {
+	    /*
+	     * Add valid ASCII character.  - FM
+	     */
+	    HTChunkPutc(string, c);
+	} else if (c == '!' && !string->size) {		/* <! */
+	    /*
+	     * Terminate and set up for possible comment, identifier,
+	     * declaration, or marked section.  - FM
+	     */
+	    me->state = S_exclamation;
+	    me->lead_exclamation = TRUE;
+	    me->doctype_bracket = FALSE;
+	    me->first_bracket = FALSE;
+	    HTChunkPutc(string, c);
+	    break;
+	} else if (!string->size &&
+		   (TOASCII(clong) <= 160 &&	/* S/390 -- gil -- 1196 */
+		    (c != '/' && c != '?' && c != '_' && c != ':'))) {
+	    /*
+	     * '<' must be followed by an ASCII letter to be a valid start tag. 
+	     * Here it isn't, nor do we have a '/' for an end tag, nor one of
+	     * some other characters with a special meaning for SGML or which
+	     * are likely to be legal Name Start characters in XML or some
+	     * other extension.  So recover the '<' and following character as
+	     * data.  - FM & KW
+	     */
+	    me->state = S_text;
+#ifdef USE_PRETTYSRC
+	    if (psrc_view)
+		PSRCSTART(badseq);
+#endif
+	    PUTC('<');
+#ifdef USE_PRETTYSRC
+	    if (psrc_view)
+		PSRCSTOP(badseq);
+#endif
+	    goto top1;
+	} else {		/* End of tag name */
+	    /*
+	     * Try to handle tag.  - FM
+	     */
+	    HTTag *t;
+
+	    if (c == '/') {
+		if (string->size == 0) {
+		    me->state = S_end;
+		    break;
+		}
+		CTRACE((tfp, "SGML: `<%.*s/' found!\n", string->size, string->data));
+	    }
+	    HTChunkTerminate(string);
+
+	    t = SGMLFindTag(dtd, string->data);
+	    if (t == me->unknown_tag &&
+		((c == ':' &&
+		  string->size == 4 && 0 == strcasecomp(string->data, "URL")) ||
+		 (string->size > 4 && 0 == strncasecomp(string->data, "URL:", 4)))) {
+		/*
+		 * Treat <URL:  as text rather than a junk tag, so we display
+		 * it and the URL (Lynxism 8-).  - FM
+		 */
+#ifdef USE_PRETTYSRC
+		if (psrc_view)
+		    PSRCSTART(badseq);
+#endif
+		PUTC('<');
+		PUTS(string->data);	/* recover */
+		PUTC(c);
+#ifdef USE_PRETTYSRC
+		if (psrc_view)
+		    PSRCSTOP(badseq);
+#endif
+		CTRACE((tfp, "SGML: Treating <%s%c as text\n",
+			string->data, c));
+		string->size = 0;
+		me->state = S_text;
+		break;
+	    }
+	    if (c == '/' && t) {
+		/*
+		 * Element name was ended by '/'.  Remember the tag that ended
+		 * thusly, we'll interpret this as either an indication of an
+		 * empty element (if '>' follows directly) or do some
+		 * SGMLshortref-ish treatment.  - kw
+		 */
+		me->slashedtag = t;
+	    }
+	    if (!t) {
+		if (c == '?' && string->size <= 1) {
+		    CTRACE((tfp, "SGML: Found PI, looking for '>'\n"));
+#ifdef USE_PRETTYSRC
+		    if (psrc_view) {
+			PSRCSTART(abracket);
+			PUTS("<?");
+			PSRCSTOP(abracket);
+		    }
+#endif
+		    string->size = 0;
+		    me->state = S_pi;
+		    HTChunkPutc(string, c);
+		    break;
+		}
+		CTRACE((tfp, "SGML: *** Invalid element %s\n",
+			string->data));
+
+#ifdef USE_PRETTYSRC
+		if (psrc_view) {
+		    PSRCSTART(abracket);
+		    PUTC('<');
+		    PSRCSTOP(abracket);
+		    PSRCSTART(badtag);
+		    transform_tag(me, string);
+		    PUTS(string->data);
+		    if (c == '>') {
+			PSRCSTOP(badtag);
+			PSRCSTART(abracket);
+			PUTC('>');
+			PSRCSTOP(abracket);
+		    } else {
+			PUTC(c);
+		    }
+		}
+#endif
+		me->state = (c == '>') ? S_text : S_junk_tag;
+		break;
+	    } else if (t == me->unknown_tag) {
+		CTRACE((tfp, "SGML: *** Unknown element \"%s\"\n",
+			string->data));
+		/*
+		 * Fall through and treat like valid tag for attribute parsing. 
+		 * - KW
+		 */
+
+	    }
+	    me->current_tag = t;
+
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(abracket);
+		PUTC('<');
+		PSRCSTOP(abracket);
+		if (t != me->unknown_tag)
+		    PSRCSTART(tag);
+		else
+		    PSRCSTART(badtag);
+		transform_tag(me, string);
+		PUTS(string->data);
+		if (t != me->unknown_tag)
+		    PSRCSTOP(tag);
+		else
+		    PSRCSTOP(badtag);
+	    }
+	    if (!psrc_view)	/*don't waste time */
+#endif
+	    {
+		/*
+		 * Clear out attributes.
+		 */
+		memset((void *) me->present, 0, sizeof(BOOL) *
+		         (unsigned) (me->current_tag->number_of_attributes));
+	    }
+
+	    string->size = 0;
+	    me->current_attribute_number = INVALID;
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		if (c == '>' || c == '<' || (c == '/' && me->slashedtag)) {
+		    if (c != '<') {
+			PSRCSTART(abracket);
+			PUTC(c);
+			PSRCSTOP(abracket);
+			me->state = (c == '>') ? S_text : S_tagname_slash;
+		    } else {
+			me->state = S_tag;
+		    }
+		} else {
+		    if (!WHITE(c))
+			PUTC(c);
+		    me->state = S_tag_gap;
+		}
+	    } else
+#endif
+	    if (c == '>' || c == '<' || (c == '/' && me->slashedtag)) {
+		if (me->current_tag->name)
+		    start_element(me);
+		me->state = (c == '>') ? S_text :
+		    (c == '<') ? S_tag : S_tagname_slash;
+	    } else {
+		me->state = S_tag_gap;
+	    }
+	}
+	break;
+
+    case S_exclamation:
+	if (me->lead_exclamation && c == '-') {
+	    /*
+	     * Set up for possible comment.  - FM
+	     */
+	    me->lead_exclamation = FALSE;
+	    me->first_dash = TRUE;
+	    HTChunkPutc(string, c);
+	    break;
+	}
+	if (me->lead_exclamation && c == '[') {
+	    /*
+	     * Set up for possible marked section.  - FM
+	     */
+	    me->lead_exclamation = FALSE;
+	    me->first_bracket = TRUE;
+	    me->second_bracket = FALSE;
+	    HTChunkPutc(string, c);
+	    me->state = S_marked;
+	    break;
+	}
+	if (me->first_dash && c == '-') {
+	    /*
+	     * Set up to handle comment.  - FM
+	     */
+	    me->lead_exclamation = FALSE;
+	    me->first_dash = FALSE;
+	    me->end_comment = FALSE;
+	    HTChunkPutc(string, c);
+	    me->state = S_comment;
+	    break;
+	}
+	me->lead_exclamation = FALSE;
+	me->first_dash = FALSE;
+	if (c == '>') {
+	    /*
+	     * Try to handle identifier.  - FM
+	     */
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(sgmlspecial);
+		PUTC('<');
+		PUTS(string->data);
+		PUTC('>');
+		PSRCSTOP(sgmlspecial);
+	    } else
+#endif
+		handle_identifier(me);
+	    string->size = 0;
+	    me->state = S_text;
+	    break;
+	}
+	if (WHITE(c)) {
+	    if (string->size == 8 &&
+		!strncasecomp(string->data, "!DOCTYPE", 8)) {
+		/*
+		 * Set up for DOCTYPE declaration.  - FM
+		 */
+		HTChunkPutc(string, c);
+		me->doctype_bracket = FALSE;
+		me->state = S_doctype;
+		break;
+	    }
+	    if (string->size == 7 &&
+		!strncasecomp(string->data, "!ENTITY", 7)) {
+		/*
+		 * Set up for ENTITY declaration.  - FM
+		 */
+		HTChunkPutc(string, c);
+		me->first_dash = FALSE;
+		me->end_comment = TRUE;
+		me->state = S_sgmlent;
+		break;
+	    }
+	    if (string->size == 8 &&
+		!strncasecomp(string->data, "!ELEMENT", 8)) {
+		/*
+		 * Set up for ELEMENT declaration.  - FM
+		 */
+		HTChunkPutc(string, c);
+		me->first_dash = FALSE;
+		me->end_comment = TRUE;
+		me->state = S_sgmlele;
+		break;
+	    }
+	    if (string->size == 8 &&
+		!strncasecomp(string->data, "!ATTLIST", 8)) {
+		/*
+		 * Set up for ATTLIST declaration.  - FM
+		 */
+		HTChunkPutc(string, c);
+		me->first_dash = FALSE;
+		me->end_comment = TRUE;
+		me->state = S_sgmlatt;
+		break;
+	    }
+	}
+	HTChunkPutc(string, c);
+	break;
+
+    case S_comment:		/* Expecting comment. - FM */
+	if (historical_comments) {
+	    /*
+	     * Any '>' terminates.  - FM
+	     */
+	    if (c == '>') {
+		HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+		if (psrc_view) {
+		    PSRCSTART(comm);
+		    PUTC('<');
+		    PUTS_TR(string->data);
+		    PUTC('>');
+		    PSRCSTOP(comm);
+		} else
+#endif
+		    handle_comment(me);
+		string->size = 0;
+		me->end_comment = FALSE;
+		me->first_dash = FALSE;
+		me->state = S_text;
+		break;
+	    }
+	    goto S_comment_put_c;
+	}
+	if (!me->first_dash && c == '-') {
+	    HTChunkPutc(string, c);
+	    me->first_dash = TRUE;
+	    break;
+	}
+	if (me->first_dash && c == '-') {
+	    HTChunkPutc(string, c);
+	    me->first_dash = FALSE;
+	    if (!me->end_comment)
+		me->end_comment = TRUE;
+	    else if (!minimal_comments)
+		/*
+		 * Validly treat '--' pairs as successive comments (for
+		 * minimal, any "--WHITE>" terminates).  - FM
+		 */
+		me->end_comment = FALSE;
+	    break;
+	}
+	if (me->end_comment && c == '>') {
+	    /*
+	     * Terminate and handle the comment.  - FM
+	     */
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(comm);
+		PUTC('<');
+		PUTS_TR(string->data);
+		PUTC('>');
+		PSRCSTOP(comm);
+	    } else
+#endif
+		handle_comment(me);
+	    string->size = 0;
+	    me->end_comment = FALSE;
+	    me->first_dash = FALSE;
+	    me->state = S_text;
+	    break;
+	}
+	me->first_dash = FALSE;
+	if (me->end_comment && !isspace(UCH(c)))
+	    me->end_comment = FALSE;
+
+      S_comment_put_c:
+	if (me->T.decode_utf8 &&
+	    *me->U.utf_buf) {
+	    HTChunkPuts(string, me->U.utf_buf);
+	    me->U.utf_buf_p = me->U.utf_buf;
+	    *(me->U.utf_buf_p) = '\0';
+	} else if (!IS_CJK_TTY &&
+		   (me->T.output_utf8 ||
+		    me->T.trans_from_uni)) {
+	    if (clong == UCS_REPL && saved_char_in &&
+		HTPassEightBitRaw &&
+		saved_char_in >=
+		LYlowest_eightbit[me->outUCLYhndl]) {
+		(HTChunkPutUtf8Char) (string,
+				      (UCode_t) (0xf000 | saved_char_in));
+	    } else {
+		HTChunkPutUtf8Char(string, clong);
+	    }
+	} else if (saved_char_in && me->T.use_raw_char_in) {
+	    HTChunkPutc(string, saved_char_in);
+	} else {
+	    HTChunkPutc(string, c);
+	}
+	break;
+
+    case S_doctype:		/* Expecting DOCTYPE. - FM */
+	if (me->doctype_bracket) {
+	    HTChunkPutc(string, c);
+	    if (c == ']')
+		me->doctype_bracket = FALSE;
+	    break;
+	}
+	if (c == '[' && WHITE(string->data[string->size - 1])) {
+	    HTChunkPutc(string, c);
+	    me->doctype_bracket = TRUE;
+	    break;
+	}
+	if (c == '>') {
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(sgmlspecial);
+		PUTC('<');
+		PUTS(string->data);
+		PUTC('>');
+		PSRCSTOP(sgmlspecial);
+	    } else
+#endif
+		handle_doctype(me);
+	    string->size = 0;
+	    me->state = S_text;
+	    break;
+	}
+	HTChunkPutc(string, c);
+	break;
+
+    case S_marked:		/* Expecting marked section. - FM */
+	if (me->first_bracket && c == '[') {
+	    HTChunkPutc(string, c);
+	    me->first_bracket = FALSE;
+	    me->second_bracket = TRUE;
+	    break;
+	}
+	if (me->second_bracket && c == ']' &&
+	    string->data[string->size - 1] == ']') {
+	    HTChunkPutc(string, c);
+	    me->second_bracket = FALSE;
+	    break;
+	}
+	if (!me->second_bracket && c == '>') {
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(sgmlspecial);
+		PUTC('<');
+		PUTS(string->data);
+		PUTC('>');
+		PSRCSTOP(sgmlspecial);
+	    } else
+#endif
+		handle_marked(me);
+	    string->size = 0;
+	    me->state = S_text;
+	    break;
+	}
+	HTChunkPutc(string, c);
+	break;
+
+    case S_sgmlent:		/* Expecting ENTITY. - FM */
+	if (!me->first_dash && c == '-') {
+	    HTChunkPutc(string, c);
+	    me->first_dash = TRUE;
+	    break;
+	}
+	if (me->first_dash && c == '-') {
+	    HTChunkPutc(string, c);
+	    me->first_dash = FALSE;
+	    if (!me->end_comment)
+		me->end_comment = TRUE;
+	    else
+		me->end_comment = FALSE;
+	    break;
+	}
+	if (me->end_comment && c == '>') {
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(sgmlspecial);
+		PUTC('<');
+		PUTS(string->data);
+		PUTC('>');
+		PSRCSTOP(sgmlspecial);
+	    } else
+#endif
+		handle_sgmlent(me);
+	    string->size = 0;
+	    me->end_comment = FALSE;
+	    me->first_dash = FALSE;
+	    me->state = S_text;
+	    break;
+	}
+	me->first_dash = FALSE;
+	HTChunkPutc(string, c);
+	break;
+
+    case S_sgmlele:		/* Expecting ELEMENT. - FM */
+	if (!me->first_dash && c == '-') {
+	    HTChunkPutc(string, c);
+	    me->first_dash = TRUE;
+	    break;
+	}
+	if (me->first_dash && c == '-') {
+	    HTChunkPutc(string, c);
+	    me->first_dash = FALSE;
+	    if (!me->end_comment)
+		me->end_comment = TRUE;
+	    else
+		me->end_comment = FALSE;
+	    break;
+	}
+	if (me->end_comment && c == '>') {
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(sgmlspecial);
+		PUTC('<');
+		PUTS(string->data);
+		PUTC('>');
+		PSRCSTOP(sgmlspecial);
+	    } else
+#endif
+		handle_sgmlele(me);
+	    string->size = 0;
+	    me->end_comment = FALSE;
+	    me->first_dash = FALSE;
+	    me->state = S_text;
+	    break;
+	}
+	me->first_dash = FALSE;
+	HTChunkPutc(string, c);
+	break;
+
+    case S_sgmlatt:		/* Expecting ATTLIST. - FM */
+	if (!me->first_dash && c == '-') {
+	    HTChunkPutc(string, c);
+	    me->first_dash = TRUE;
+	    break;
+	}
+	if (me->first_dash && c == '-') {
+	    HTChunkPutc(string, c);
+	    me->first_dash = FALSE;
+	    if (!me->end_comment)
+		me->end_comment = TRUE;
+	    else
+		me->end_comment = FALSE;
+	    break;
+	}
+	if (me->end_comment && c == '>') {
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(sgmlspecial);
+		PUTC('<');
+		PUTS(string->data);
+		PUTC('>');
+		PSRCSTOP(sgmlspecial);
+	    } else
+#endif
+		handle_sgmlatt(me);
+	    string->size = 0;
+	    me->end_comment = FALSE;
+	    me->first_dash = FALSE;
+	    me->state = S_text;
+	    break;
+	}
+	me->first_dash = FALSE;
+	HTChunkPutc(string, c);
+	break;
+
+    case S_tag_gap:		/* Expecting attribute or '>' */
+	if (WHITE(c)) {
+	    /* PUTC(c); - no, done as special case */
+	    break;		/* Gap between attributes */
+	}
+	if (c == '>') {		/* End of tag */
+#ifdef USE_PRETTYSRC
+	    if (!psrc_view)
+#endif
+		if (me->current_tag->name)
+		    start_element(me);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(abracket);
+		PUTC('>');
+		PSRCSTOP(abracket);
+	    }
+#endif
+	    me->state = S_text;
+	    break;
+	}
+	HTChunkPutc(string, c);
+	me->state = S_attr;	/* Get attribute */
+	break;
+
+	/* accumulating value */
+    case S_attr:
+	if (WHITE(c) || (c == '>') || (c == '=')) {	/* End of word */
+	    if ((c == '>')
+		&& (string->size >= 1)
+		&& (string->data[string->size - 1] == '/')) {
+		if ((LYxhtml_parsing || me->extended_html)
+		    && ignore_when_empty(me->current_tag)) {
+		    discard_empty(me);
+		}
+	    } else {
+		HTChunkTerminate(string);
+		handle_attribute_name(me, string->data);
+	    }
+#ifdef USE_PRETTYSRC
+	    if (!psrc_view) {
+#endif
+		string->size = 0;
+		if (c == '>') {	/* End of tag */
+		    if (me->current_tag->name)
+			start_element(me);
+		    me->state = S_text;
+		    break;
+		}
+#ifdef USE_PRETTYSRC
+	    } else {
+		PUTC(' ');
+		if (me->current_attribute_number == INVALID)
+		    PSRCSTART(badattr);
+		else
+		    PSRCSTART(attrib);
+		if (attrname_transform != 1) {
+		    if (attrname_transform == 0)
+			LYLowerCase(string->data);
+		    else
+			LYUpperCase(string->data);
+		}
+		PUTS(string->data);
+		if (c == '=' || WHITE(c))
+		    PUTC(c);
+		if (c == '=' || c == '>') {
+		    if (me->current_attribute_number == INVALID) {
+			PSRCSTOP(badattr);
+		    } else {
+			PSRCSTOP(attrib);
+		    }
+		}
+		if (c == '>') {
+		    PSRCSTART(abracket);
+		    PUTC('>');
+		    PSRCSTOP(abracket);
+		    me->state = S_text;
+		    break;
+		}
+		string->size = 0;
+	    }
+#endif
+	    me->state = (c == '=' ? S_equals : S_attr_gap);
+	} else {
+	    HTChunkPutc(string, c);
+	}
+	break;
+
+    case S_attr_gap:		/* Expecting attribute or '=' or '>' */
+	if (WHITE(c)) {
+	    PRETTYSRC_PUTC(c);
+	    break;		/* Gap after attribute */
+	}
+	if (c == '>') {		/* End of tag */
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		if (me->current_attribute_number == INVALID) {
+		    PSRCSTOP(badattr);
+		} else {
+		    PSRCSTOP(attrib);
+		}
+		PSRCSTART(abracket);
+		PUTC('>');
+		PSRCSTOP(abracket);
+	    } else
+#endif
+	    if (me->current_tag->name)
+		start_element(me);
+	    me->state = S_text;
+	    break;
+	} else if (c == '=') {
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PUTC('=');
+		if (me->current_attribute_number == INVALID) {
+		    PSRCSTOP(badattr);
+		} else {
+		    PSRCSTOP(attrib);
+		}
+	    }
+#endif
+	    me->state = S_equals;
+	    break;
+	}
+	HTChunkPutc(string, c);
+	me->state = S_attr;	/* Get next attribute */
+	break;
+
+    case S_equals:		/* After attr = */
+	if (WHITE(c)) {
+	    PRETTYSRC_PUTC(c);
+	    break;		/* Before attribute value */
+	}
+	if (c == '>') {		/* End of tag */
+	    CTRACE((tfp, "SGML: found = but no value\n"));
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(abracket);
+		PUTC('>');
+		PSRCSTOP(abracket);
+	    } else
+#endif
+	    if (me->current_tag->name)
+		start_element(me);
+	    me->state = S_text;
+	    break;
+
+	} else if (c == '\'') {
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(attrval);
+		PUTC(c);
+	    }
+#endif
+	    me->state = S_squoted;
+	    break;
+
+	} else if (c == '"') {
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PSRCSTART(attrval);
+		PUTC(c);
+	    }
+#endif
+	    me->state = S_dquoted;
+	    break;
+	}
+#ifdef USE_PRETTYSRC
+	if (psrc_view)
+	    PSRCSTART(attrval);
+#endif
+	me->state = S_value;
+	/* FALLTHRU */
+
+    case S_value:
+	if (WHITE(c) || (c == '>')) {	/* End of word */
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (!end_if_prettysrc(me, string, 0))
+#endif
+	    {
+#ifdef CJK_EX			/* Quick hack. - JH7AYN */
+		if (IS_CJK_TTY) {
+		    if (string->data[0] == '$') {
+			if (string->data[1] == 'B' || string->data[1] == '@') {
+			    char *jis_buf = 0;
+
+			    HTSprintf0(&jis_buf, "\033%s", string->data);
+			    TO_EUC((const unsigned char *) jis_buf,
+				   (unsigned char *) string->data);
+			    FREE(jis_buf);
+			}
+		    }
+		}
+#endif
+		handle_attribute_value(me, string->data);
+	    }
+	    string->size = 0;
+	    if (c == '>') {	/* End of tag */
+#ifdef USE_PRETTYSRC
+		if (psrc_view) {
+		    PSRCSTART(abracket);
+		    PUTC('>');
+		    PSRCSTOP(abracket);
+		} else
+#endif
+		if (me->current_tag->name)
+		    start_element(me);
+		me->state = S_text;
+		break;
+	    } else
+		me->state = S_tag_gap;
+	} else if (me->T.decode_utf8 &&
+		   *me->U.utf_buf) {
+	    HTChunkPuts(string, me->U.utf_buf);
+	    me->U.utf_buf_p = me->U.utf_buf;
+	    *(me->U.utf_buf_p) = '\0';
+	} else if (!IS_CJK_TTY &&
+		   (me->T.output_utf8 ||
+		    me->T.trans_from_uni)) {
+	    if (clong == UCS_REPL && saved_char_in &&
+		HTPassEightBitRaw &&
+		saved_char_in >=
+		LYlowest_eightbit[me->outUCLYhndl]) {
+		(HTChunkPutUtf8Char) (string,
+				      (UCode_t) (0xf000 | saved_char_in));
+	    } else {
+		HTChunkPutUtf8Char(string, clong);
+	    }
+	} else if (saved_char_in && me->T.use_raw_char_in) {
+	    HTChunkPutc(string, saved_char_in);
+	} else {
+	    HTChunkPutc(string, c);
+	}
+	break;
+
+    case S_squoted:		/* Quoted attribute value */
+	if (c == '\'') {	/* End of attribute value */
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (!end_if_prettysrc(me, string, '\''))
+#endif
+		handle_attribute_value(me, string->data);
+	    string->size = 0;
+	    me->state = S_tag_gap;
+	} else if (TOASCII(c) == '\033') {	/* S/390 -- gil -- 1213 */
+	    /*
+	     * Setting up for possible single quotes in CJK escape sequences. 
+	     * - Takuya ASADA (asada@three-a.co.jp)
+	     */
+	    me->state = S_esc_sq;
+	    if (!UTF8_TTY_ISO2022JP)
+		HTChunkPutc(string, c);
+	} else if (me->T.decode_utf8 &&
+		   *me->U.utf_buf) {
+	    HTChunkPuts(string, me->U.utf_buf);
+	    me->U.utf_buf_p = me->U.utf_buf;
+	    *(me->U.utf_buf_p) = '\0';
+	} else if (!IS_CJK_TTY &&
+		   (me->T.output_utf8 ||
+		    me->T.trans_from_uni)) {
+	    if (clong == UCS_REPL && saved_char_in &&
+		HTPassEightBitRaw &&
+		saved_char_in >=
+		LYlowest_eightbit[me->outUCLYhndl]) {
+		(HTChunkPutUtf8Char) (string,
+				      (UCode_t) (0xf000 | saved_char_in));
+	    } else {
+		HTChunkPutUtf8Char(string, clong);
+	    }
+	} else if (saved_char_in && me->T.use_raw_char_in) {
+	    HTChunkPutc(string, saved_char_in);
+	} else {
+	    HTChunkPutc(string, c);
+	}
+	break;
+
+    case S_dquoted:		/* Quoted attribute value */
+	if (c == '"' ||		/* Valid end of attribute value */
+	    (soft_dquotes &&	/*  If emulating old Netscape bug, treat '>' */
+	     c == '>')) {	/*  as a co-terminator of dquoted and tag    */
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (!end_if_prettysrc(me, string, (char) c))
+#endif
+		handle_attribute_value(me, string->data);
+	    string->size = 0;
+	    me->state = S_tag_gap;
+	    if (c == '>')	/* We emulated the Netscape bug, so we go  */
+		goto top1;	/* back and treat it as the tag terminator */
+	} else if (TOASCII(c) == '\033') {	/* S/390 -- gil -- 1230 */
+	    /*
+	     * Setting up for possible double quotes in CJK escape sequences. 
+	     * - Takuya ASADA (asada@three-a.co.jp)
+	     */
+	    me->state = S_esc_dq;
+	    if (!UTF8_TTY_ISO2022JP)
+		HTChunkPutc(string, c);
+	} else if (me->T.decode_utf8 &&
+		   *me->U.utf_buf) {
+	    HTChunkPuts(string, me->U.utf_buf);
+	    me->U.utf_buf_p = me->U.utf_buf;
+	    *(me->U.utf_buf_p) = '\0';
+	} else if (!IS_CJK_TTY &&
+		   (me->T.output_utf8 ||
+		    me->T.trans_from_uni)) {
+	    if (clong == UCS_REPL && saved_char_in &&
+		HTPassEightBitRaw &&
+		saved_char_in >=
+		LYlowest_eightbit[me->outUCLYhndl]) {
+		(HTChunkPutUtf8Char) (string,
+				      (UCode_t) (0xf000 | saved_char_in));
+	    } else {
+		HTChunkPutUtf8Char(string, clong);
+	    }
+	} else if (saved_char_in && me->T.use_raw_char_in) {
+	    HTChunkPutc(string, saved_char_in);
+	} else {
+	    HTChunkPutc(string, c);
+	}
+	break;
+
+    case S_end:		/* </ */
+	if (TOASCII(clong) < 127 && (string->size ?	/* S/390 -- gil -- 1247 */
+				     IsNmChar(c) : IsNmStart(c))) {
+	    HTChunkPutc(string, c);
+	} else {		/* End of end tag name */
+	    HTTag *t = 0;
+
+#ifdef USE_PRETTYSRC
+	    BOOL psrc_tagname_processed = FALSE;
+#endif
+
+	    HTChunkTerminate(string);
+	    if (!*string->data) {	/* Empty end tag */
+		if (me->element_stack)
+		    t = me->element_stack->tag;
+	    } else {
+		t = SGMLFindTag(dtd, string->data);
+	    }
+	    if (!t || t == me->unknown_tag) {
+		CTRACE((tfp, "Unknown end tag </%s>\n", string->data));
+#ifdef USE_PRETTYSRC
+		if (psrc_view) {
+		    PSRCSTART(abracket);
+		    PUTS("</");
+		    PSRCSTOP(abracket);
+		    PSRCSTART(badtag);
+		    transform_tag(me, string);
+		    PUTS(string->data);
+		    if (c != '>') {
+			PUTC(c);
+		    } else {
+			PSRCSTOP(badtag);
+			PSRCSTART(abracket);
+			PUTC('>');
+			PSRCSTOP(abracket);
+		    }
+		    psrc_tagname_processed = TRUE;
+		}
+	    } else if (psrc_view) {
+#endif
+	    } else {
+		BOOL tag_OK = (BOOL) (c == '>' || WHITE(c));
+		HTMLElement e = TAGNUM_OF_TAGP(t);
+		int branch = 2;	/* it can be 0,1,2 */
+
+		me->current_tag = t;
+		if (HAS_ALT_TAGNUM(TAGNUM_OF_TAGP(t)) &&
+		    me->element_stack &&
+		    ALT_TAGP(t) == me->element_stack->tag)
+		    me->element_stack->tag = NORMAL_TAGP(me->element_stack->tag);
+
+		if (tag_OK && Old_DTD) {
+		    switch (e) {
+		    case HTML_DD:
+		    case HTML_DT:
+		    case HTML_LI:
+		    case HTML_LH:
+		    case HTML_TD:
+		    case HTML_TH:
+		    case HTML_TR:
+		    case HTML_THEAD:
+		    case HTML_TFOOT:
+		    case HTML_TBODY:
+		    case HTML_COLGROUP:
+			branch = 0;
+			break;
+
+		    case HTML_A:
+		    case HTML_B:
+		    case HTML_BLINK:
+		    case HTML_CITE:
+		    case HTML_EM:
+		    case HTML_FONT:
+		    case HTML_FORM:
+		    case HTML_I:
+		    case HTML_P:
+		    case HTML_STRONG:
+		    case HTML_TT:
+		    case HTML_U:
+			branch = 1;
+			break;
+		    default:
+			break;
+		    }
+		}
+
+		/*
+		 * Just handle ALL end tags normally :-) - kw
+		 */
+		if (!Old_DTD) {
+		    end_element(me, me->current_tag);
+		} else if (tag_OK && (branch == 0)) {
+		    /*
+		     * Don't treat these end tags as invalid, nor act on them. 
+		     * - FM
+		     */
+		    CTRACE((tfp, "SGML: `</%s%c' found!  Ignoring it.\n",
+			    string->data, c));
+		    string->size = 0;
+		    me->current_attribute_number = INVALID;
+		    if (c != '>') {
+			me->state = S_junk_tag;
+		    } else {
+			me->current_tag = NULL;
+			me->state = S_text;
+		    }
+		    break;
+		} else if (tag_OK && (branch == 1)) {
+		    /*
+		     * Handle end tags for container elements declared as
+		     * SGML_EMPTY to prevent "expected tag substitution" but
+		     * still processed via HTML_end_element() in HTML.c with
+		     * checks there to avoid throwing the HTML.c stack out of
+		     * whack (Ugh, what a hack!  8-).  - FM
+		     */
+		    if (me->inSELECT) {
+			/*
+			 * We are in a SELECT block.  - FM
+			 */
+			if (strcasecomp(string->data, "FORM")) {
+			    /*
+			     * It is not at FORM end tag, so ignore it.  - FM
+			     */
+			    CTRACE((tfp,
+				    "SGML: ***Ignoring end tag </%s> in SELECT block.\n",
+				    string->data));
+			} else {
+			    /*
+			     * End the SELECT block and then handle the FORM
+			     * end tag.  - FM
+			     */
+			    CTRACE((tfp,
+				    "SGML: ***Faking SELECT end tag before </%s> end tag.\n",
+				    string->data));
+			    end_element(me,
+					SGMLFindTag(me->dtd, "SELECT"));
+			    CTRACE((tfp, "SGML: End </%s>\n", string->data));
+
+#ifdef USE_PRETTYSRC
+			    if (!psrc_view)	/* Don't actually call if viewing psrc - kw */
+#endif
+				(*me->actions->end_element)
+				    (me->target,
+				     (int) TAGNUM_OF_TAGP(me->current_tag),
+				     &me->include);
+			}
+		    } else if (!strcasecomp(string->data, "P")) {
+			/*
+			 * Treat a P end tag like a P start tag (Ugh, what a
+			 * hack!  8-).  - FM
+			 */
+			CTRACE((tfp,
+				"SGML: `</%s%c' found!  Treating as '<%s%c'.\n",
+				string->data, c, string->data, c));
+			{
+			    int i;
+
+			    for (i = 0;
+				 i < me->current_tag->number_of_attributes;
+				 i++) {
+				me->present[i] = NO;
+			    }
+			}
+			if (me->current_tag->name)
+			    start_element(me);
+		    } else {
+			CTRACE((tfp, "SGML: End </%s>\n", string->data));
+
+#ifdef USE_PRETTYSRC
+			if (!psrc_view)		/* Don't actually call if viewing psrc - kw */
+#endif
+			    (*me->actions->end_element)
+				(me->target,
+				 (int) TAGNUM_OF_TAGP(me->current_tag),
+				 &me->include);
+		    }
+		    string->size = 0;
+		    me->current_attribute_number = INVALID;
+		    if (c != '>') {
+			me->state = S_junk_tag;
+		    } else {
+			me->current_tag = NULL;
+			me->state = S_text;
+		    }
+		    break;
+		} else {
+		    /*
+		     * Handle all other end tags normally.  - FM
+		     */
+		    end_element(me, me->current_tag);
+		}
+	    }
+
+#ifdef USE_PRETTYSRC
+	    if (psrc_view && !psrc_tagname_processed) {
+		PSRCSTART(abracket);
+		PUTS("</");
+		PSRCSTOP(abracket);
+		PSRCSTART(tag);
+		if (tagname_transform != 1) {
+		    if (tagname_transform == 0)
+			LYLowerCase(string->data);
+		    else
+			LYUpperCase(string->data);
+		}
+		PUTS(string->data);
+		PSRCSTOP(tag);
+		if (c != '>') {
+		    PSRCSTART(badtag);
+		    PUTC(c);
+		} else {
+		    PSRCSTART(abracket);
+		    PUTC('>');
+		    PSRCSTOP(abracket);
+		}
+	    }
+#endif
+
+	    string->size = 0;
+	    me->current_attribute_number = INVALID;
+	    if (c != '>') {
+		if (!WHITE(c))
+		    CTRACE((tfp, "SGML: `</%s%c' found!\n", string->data, c));
+		me->state = S_junk_tag;
+	    } else {
+		me->current_tag = NULL;
+		me->state = S_text;
+	    }
+	}
+	break;
+
+    case S_esc:		/* Expecting '$'or '(' following CJK ESC. */
+	if (c == '$') {
+	    me->state = S_dollar;
+	} else if (c == '(') {
+	    me->state = S_paren;
+	} else {
+	    me->state = S_text;
+	    if (UTF8_TTY_ISO2022JP)
+		goto top1;
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    PUTC(c);
+	break;
+
+    case S_dollar:		/* Expecting '@', 'B', 'A' or '(' after CJK "ESC$". */
+	if (c == '@' || c == 'B' || c == 'A') {
+	    me->state = S_nonascii_text;
+	} else if (c == '(') {
+	    me->state = S_dollar_paren;
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    PUTC(c);
+	break;
+
+    case S_dollar_paren:	/* Expecting 'C' after CJK "ESC$(". */
+	if (c == 'C') {
+	    me->state = S_nonascii_text;
+	} else {
+	    me->state = S_text;
+	    if (UTF8_TTY_ISO2022JP) {
+		PUTS("$(");
+		goto top1;
+	    }
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    PUTC(c);
+	break;
+
+    case S_paren:		/* Expecting 'B', 'J', 'T' or 'I' after CJK "ESC(". */
+	if (c == 'B' || c == 'J' || c == 'T') {
+	    me->state = S_text;
+	} else if (c == 'I') {
+	    me->state = S_nonascii_text;
+	    if (UTF8_TTY_ISO2022JP)
+		me->kanji_buf = '\t';	/* flag for single byte katakana */
+	} else {
+	    me->state = S_text;
+	    if (UTF8_TTY_ISO2022JP) {
+		PUTC('(');
+		goto top1;
+	    }
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    PUTC(c);
+	break;
+
+    case S_nonascii_text:	/* Expecting CJK ESC after non-ASCII text. */
+	if (TOASCII(c) == '\033') {	/* S/390 -- gil -- 1264 */
+	    me->state = S_esc;
+	} else if (c < 32) {
+	    me->state = S_text;
+	}
+	if (UTF8_TTY_ISO2022JP) {
+	    if (TOASCII(c) != '\033')
+		PUTUTF8(clong);
+	} else
+	    PUTC(c);
+	break;
+
+    case S_esc_sq:		/* Expecting '$'or '(' following CJK ESC. */
+	if (c == '$') {
+	    me->state = S_dollar_sq;
+	} else if (c == '(') {
+	    me->state = S_paren_sq;
+	} else {
+	    me->state = S_squoted;
+	    if (UTF8_TTY_ISO2022JP)
+		goto top1;
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_dollar_sq:		/* Expecting '@', 'B', 'A' or '(' after CJK "ESC$". */
+	if (c == '@' || c == 'B' || c == 'A') {
+	    me->state = S_nonascii_text_sq;
+	} else if (c == '(') {
+	    me->state = S_dollar_paren_sq;
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_dollar_paren_sq:	/* Expecting 'C' after CJK "ESC$(". */
+	if (c == 'C') {
+	    me->state = S_nonascii_text_sq;
+	} else {
+	    me->state = S_squoted;
+	    if (UTF8_TTY_ISO2022JP) {
+		HTChunkPuts(string, "$(");
+		goto top1;
+	    }
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_paren_sq:		/* Expecting 'B', 'J', 'T' or 'I' after CJK "ESC(". */
+	if (c == 'B' || c == 'J' || c == 'T') {
+	    me->state = S_squoted;
+	} else if (c == 'I') {
+	    me->state = S_nonascii_text_sq;
+	    if (UTF8_TTY_ISO2022JP)
+		me->kanji_buf = '\t';	/* flag for single byte katakana */
+	} else {
+	    me->state = S_squoted;
+	    if (UTF8_TTY_ISO2022JP) {
+		HTChunkPutc(string, '(');
+		goto top1;
+	    }
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_nonascii_text_sq:	/* Expecting CJK ESC after non-ASCII text. */
+	if (TOASCII(c) == '\033') {	/* S/390 -- gil -- 1281 */
+	    me->state = S_esc_sq;
+	}
+	if (UTF8_TTY_ISO2022JP) {
+	    if (TOASCII(c) != '\033')
+		HTChunkPutUtf8Char(string, clong);
+	} else
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_esc_dq:		/* Expecting '$'or '(' following CJK ESC. */
+	if (c == '$') {
+	    me->state = S_dollar_dq;
+	} else if (c == '(') {
+	    me->state = S_paren_dq;
+	} else {
+	    me->state = S_dquoted;
+	    if (UTF8_TTY_ISO2022JP)
+		goto top1;
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_dollar_dq:		/* Expecting '@', 'B', 'A' or '(' after CJK "ESC$". */
+	if (c == '@' || c == 'B' || c == 'A') {
+	    me->state = S_nonascii_text_dq;
+	} else if (c == '(') {
+	    me->state = S_dollar_paren_dq;
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_dollar_paren_dq:	/* Expecting 'C' after CJK "ESC$(". */
+	if (c == 'C') {
+	    me->state = S_nonascii_text_dq;
+	} else {
+	    me->state = S_dquoted;
+	    if (UTF8_TTY_ISO2022JP) {
+		HTChunkPuts(string, "$(");
+		goto top1;
+	    }
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_paren_dq:		/* Expecting 'B', 'J', 'T' or 'I' after CJK "ESC(". */
+	if (c == 'B' || c == 'J' || c == 'T') {
+	    me->state = S_dquoted;
+	} else if (c == 'I') {
+	    me->state = S_nonascii_text_dq;
+	    if (UTF8_TTY_ISO2022JP)
+		me->kanji_buf = '\t';	/* flag for single byte katakana */
+	} else {
+	    me->state = S_dquoted;
+	    if (UTF8_TTY_ISO2022JP) {
+		HTChunkPutc(string, '(');
+		goto top1;
+	    }
+	}
+	if (!UTF8_TTY_ISO2022JP)
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_nonascii_text_dq:	/* Expecting CJK ESC after non-ASCII text. */
+	if (TOASCII(c) == '\033') {	/* S/390 -- gil -- 1298 */
+	    me->state = S_esc_dq;
+	}
+	if (UTF8_TTY_ISO2022JP) {
+	    if (TOASCII(c) != '\033')
+		HTChunkPutUtf8Char(string, clong);
+	} else
+	    HTChunkPutc(string, c);
+	break;
+
+    case S_junk_tag:
+    case S_pi:
+	if (c == '>') {
+	    HTChunkTerminate(string);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		if (me->state == S_junk_tag) {
+		    PSRCSTOP(badtag);
+		}
+		PSRCSTART(abracket);
+		PUTC('>');
+		PSRCSTOP(abracket);
+	    }
+#endif
+	    if (me->state == S_pi)
+		handle_processing_instruction(me);
+	    string->size = 0;
+	    me->current_tag = NULL;
+	    me->state = S_text;
+	} else {
+	    HTChunkPutc(string, c);
+#ifdef USE_PRETTYSRC
+	    if (psrc_view) {
+		PUTC(c);
+	    }
+#endif
+	}
+
+    }				/* switch on me->state */
+    CTRACE2(TRACE_SGML, (tfp, "SGML after  %s|%.*s|%c|\n",
+			 state_name(me->state),
+			 string->size,
+			 NonNull(string->data),
+			 UCH(c)));
+
+  after_switch:
+    /*
+     * Check whether an external function has added anything to the include
+     * buffer.  If so, move the new stuff to the beginning of active_include. 
+     * - kw
+     */
+    if (me->include != NULL) {
+	if (me->include[0] == '\0') {
+	    FREE(me->include);
+	} else {
+	    if (me->active_include &&
+		me->active_include[me->include_index] != '\0')
+		StrAllocCat(me->include,
+			    me->active_include + me->include_index);
+	    FREE(me->active_include);
+	    me->active_include = me->include;
+	    me->include_index = 0;
+	    me->include = NULL;
+	}
+    }
+
+    /*
+     * Check whether we've added anything to the recover buffer.  - FM
+     */
+    if (me->recover != NULL) {
+	if (me->recover[me->recover_index] == '\0') {
+	    FREE(me->recover);
+	    me->recover_index = 0;
+	} else {
+	    c = UCH(me->recover[me->recover_index]);
+	    me->recover_index++;
+	    goto top;
+	}
+    }
+
+    /*
+     * Check whether an external function had added anything to the include
+     * buffer; it should now be in active_include.  - FM / kw
+     */
+    if (me->active_include != NULL) {
+	if (me->active_include[me->include_index] == '\0') {
+	    FREE(me->active_include);
+	    me->include_index = 0;
+	} else {
+	    if (me->current_tag_charset == UTF8_handle ||
+		me->T.trans_from_uni) {
+		/*
+		 * If it looks like we would have fed UTF-8 to the next
+		 * processing stage, assume that whatever we were fed back is
+		 * in UTF-8 form, too.  This won't be always true for all uses
+		 * of the include buffer, but it's a start.  - kw
+		 */
+		const char *puni = me->active_include + me->include_index;
+
+		c = UCH(*puni);
+		clong = UCGetUniFromUtf8String(&puni);
+		if (clong < 256 && clong >= 0) {
+		    c = UCH((clong & 0xff));
+		}
+		saved_char_in = '\0';
+		me->include_index = (int) (puni
+					   - me->active_include
+					   + 1);
+		goto top1;
+	    } else {
+		/*
+		 * Otherwise assume no UTF-8 - do charset-naive processing and
+		 * hope for the best.  - kw
+		 */
+		c = UCH(me->active_include[me->include_index]);
+		me->include_index++;
+		goto top;
+	    }
+	}
+    }
+
+    /*
+     * Check whether an external function has added anything to the csi buffer. 
+     * - FM
+     */
+    if (me->csi != NULL) {
+	if (me->csi[me->csi_index] == '\0') {
+	    FREE(me->csi);
+	    me->csi_index = 0;
+	} else {
+	    c = UCH(me->csi[me->csi_index]);
+	    me->csi_index++;
+	    goto top;
+	}
+    }
+}				/* SGML_character */
+
+static void InferUtfFromBom(HTStream *me, int chndl)
+{
+    HTAnchor_setUCInfoStage(me->node_anchor, chndl,
+			    UCT_STAGE_PARSER,
+			    UCT_SETBY_PARSER);
+    change_chartrans_handling(me);
+}
+
+/*
+ * Avoid rewrite of SGML_character() to handle hypothetical case of UTF-16
+ * webpages, by pretending that the data is UTF-8.
+ */
+static void SGML_widechar(HTStream *me, int ch)
+{
+    if (!UCPutUtf8_charstring(me, SGML_character, (UCode_t) ch)) {
+	SGML_character(me, ch);
+    }
+}
+
+static void SGML_write(HTStream *me, const char *str, int l)
+{
+    const char *p;
+    const char *e = str + l;
+
+    if (sgml_offset == 0) {
+	if (l > 3
+	    && !MemCmp(str, "\357\273\277", 3)) {
+	    CTRACE((tfp, "SGML_write found UTF-8 BOM\n"));
+	    InferUtfFromBom(me, UTF8_handle);
+	    str += 3;
+	} else if (l > 2) {
+	    if (!MemCmp(str, "\377\376", 2)) {
+		CTRACE((tfp, "SGML_write found UCS-2 LE BOM\n"));
+		InferUtfFromBom(me, UTF8_handle);
+		str += 2;
+		me->T.ucs_mode = -1;
+	    } else if (!MemCmp(str, "\376\377", 2)) {
+		CTRACE((tfp, "SGML_write found UCS-2 BE BOM\n"));
+		InferUtfFromBom(me, UTF8_handle);
+		str += 2;
+		me->T.ucs_mode = 1;
+	    }
+	}
+    }
+    switch (me->T.ucs_mode) {
+    case -1:
+	for (p = str; p < e; p += 2)
+	    SGML_widechar(me, (UCH(p[1]) << 8) | UCH(p[0]));
+	break;
+    case 1:
+	for (p = str; p < e; p += 2)
+	    SGML_widechar(me, (UCH(p[0]) << 8) | UCH(p[1]));
+	break;
+    default:
+	for (p = str; p < e; p++)
+	    SGML_character(me, *p);
+	break;
+    }
+}
+
+static void SGML_string(HTStream *me, const char *str)
+{
+    SGML_write(me, str, (int) strlen(str));
+}
+
+/*_______________________________________________________________________
+*/
+
+/*	Structured Object Class
+ *	-----------------------
+ */
+const HTStreamClass SGMLParser =
+{
+    "SGMLParser",
+    SGML_free,
+    SGML_abort,
+    SGML_character,
+    SGML_string,
+    SGML_write,
+};
+
+/*	Create SGML Engine
+ *	------------------
+ *
+ * On entry,
+ *	dtd		represents the DTD, along with
+ *	actions		is the sink for the data as a set of routines.
+ *
+ */
+
+HTStream *SGML_new(const SGML_dtd * dtd,
+		   HTParentAnchor *anchor,
+		   HTStructured * target,
+		   int extended_html)
+{
+    HTStream *me = typecalloc(struct _HTStream);
+
+    if (!me)
+	outofmem(__FILE__, "SGML_begin");
+
+    me->isa = &SGMLParser;
+    me->string = HTChunkCreate(128);	/* Grow by this much */
+    me->dtd = dtd;
+    me->target = target;
+    me->actions = (const HTStructuredClass *) (((HTStream *) target)->isa);
+    /* Ugh: no OO */
+    me->unknown_tag = &HTTag_unrecognized;
+    me->current_tag = me->slashedtag = NULL;
+    me->state = S_text;
+#ifdef CALLERDATA
+    me->callerData = (void *) callerData;
+#endif /* CALLERDATA */
+
+    me->node_anchor = anchor;	/* Could be NULL? */
+    me->U.utf_buf_p = me->U.utf_buf;
+    UCTransParams_clear(&me->T);
+    me->inUCLYhndl = HTAnchor_getUCLYhndl(anchor,
+					  UCT_STAGE_PARSER);
+    if (me->inUCLYhndl < 0) {
+	HTAnchor_copyUCInfoStage(anchor,
+				 UCT_STAGE_PARSER,
+				 UCT_STAGE_MIME,
+				 -1);
+	me->inUCLYhndl = HTAnchor_getUCLYhndl(anchor,
+					      UCT_STAGE_PARSER);
+    }
+#ifdef CAN_SWITCH_DISPLAY_CHARSET	/* Allow a switch to a more suitable display charset */
+    else if (anchor->UCStages
+	     && anchor->UCStages->s[UCT_STAGE_PARSER].LYhndl >= 0
+	     && anchor->UCStages->s[UCT_STAGE_PARSER].LYhndl != current_char_set) {
+	int o = anchor->UCStages->s[UCT_STAGE_PARSER].LYhndl;
+
+	anchor->UCStages->s[UCT_STAGE_PARSER].LYhndl = -1;	/* Force reset */
+	HTAnchor_resetUCInfoStage(anchor, o, UCT_STAGE_PARSER,
+	/* Preserve change this: */
+				  anchor->UCStages->s[UCT_STAGE_PARSER].lock);
+    }
+#endif
+
+    me->inUCI = HTAnchor_getUCInfoStage(anchor,
+					UCT_STAGE_PARSER);
+    set_chartrans_handling(me, anchor, -1);
+
+    me->recover = NULL;
+    me->recover_index = 0;
+    me->include = NULL;
+    me->active_include = NULL;
+    me->include_index = 0;
+    me->url = NULL;
+    me->csi = NULL;
+    me->csi_index = 0;
+
+#ifdef USE_PRETTYSRC
+    if (psrc_view) {
+	psrc_view = FALSE;
+	mark_htext_as_source = TRUE;
+	SGML_string(me,
+		    "<HTML><HEAD><TITLE>source</TITLE></HEAD><BODY><PRE>");
+	psrc_view = TRUE;
+	psrc_convert_string = FALSE;
+	sgml_in_psrc_was_initialized = TRUE;
+    }
+#endif
+    if (extended_html)
+    {
+        me->extended_html = TRUE;
+    }
+
+    sgml_offset = 0;
+    return me;
+}
+
+/*
+ * Return the offset within the document where we're parsing.  This is used
+ * to help identify anchors which shift around while reparsing.
+ */
+int SGML_offset(void)
+{
+    int result = sgml_offset;
+
+#ifdef USE_PRETTYSRC
+    result += psrc_view;
+#endif
+    return result;
+}
+
+/*		Asian character conversion functions
+ *		====================================
+ *
+ *	Added 24-Mar-96 by FM, based on:
+ *
+ ////////////////////////////////////////////////////////////////////////
+Copyright (c) 1993 Electrotechnical Laboratory (ETL)
+
+Permission to use, copy, modify, and distribute this material
+for any purpose and without fee is hereby granted, provided
+that the above copyright notice and this permission notice
+appear in all copies, and that the name of ETL not be
+used in advertising or publicity pertaining to this
+material without the specific, prior written permission
+of an authorized representative of ETL.
+ETL MAKES NO REPRESENTATIONS ABOUT THE ACCURACY OR SUITABILITY
+OF THIS MATERIAL FOR ANY PURPOSE.  IT IS PROVIDED "AS IS",
+WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.
+/////////////////////////////////////////////////////////////////////////
+Content-Type:	program/C; charset=US-ASCII
+Program:	SJIS.c
+Author:		Yutaka Sato <ysato@etl.go.jp>
+Description:
+History:
+	930923	extracted from codeconv.c of cosmos
+///////////////////////////////////////////////////////////////////////
+*/
+
+static int TREAT_SJIS = 1;
+
+void JISx0201TO0208_EUC(unsigned IHI,
+			unsigned ILO,
+			unsigned char *OHI,
+			unsigned char *OLO)
+{
+    static const char *table[] =
+    {
+	"\241\243",		/* A1,A3 */
+	"\241\326",		/* A1,D6 */
+	"\241\327",		/* A1,D7 */
+	"\241\242",		/* A1,A2 */
+	"\241\246",		/* A1,A6 */
+	"\245\362",		/* A5,F2 */
+	"\245\241",		/* A5,A1 */
+	"\245\243",		/* A5,A3 */
+	"\245\245",		/* A5,A5 */
+	"\245\247",		/* A5,A7 */
+	"\245\251",		/* A5,A9 */
+	"\245\343",		/* A5,E3 */
+	"\245\345",		/* A5,E5 */
+	"\245\347",		/* A5,E7 */
+	"\245\303",		/* A5,C3 */
+	"\241\274",		/* A1,BC */
+	"\245\242",		/* A5,A2 */
+	"\245\244",		/* A5,A4 */
+	"\245\246",		/* A5,A6 */
+	"\245\250",		/* A5,A8 */
+	"\245\252",		/* A5,AA */
+	"\245\253",		/* A5,AB */
+	"\245\255",		/* A5,AD */
+	"\245\257",		/* A5,AF */
+	"\245\261",		/* A5,B1 */
+	"\245\263",		/* A5,B3 */
+	"\245\265",		/* A5,B5 */
+	"\245\267",		/* A5,B7 */
+	"\245\271",		/* A5,B9 */
+	"\245\273",		/* A5,BB */
+	"\245\275",		/* A5,BD */
+	"\245\277",		/* A5,BF */
+	"\245\301",		/* A5,C1 */
+	"\245\304",		/* A5,C4 */
+	"\245\306",		/* A5,C6 */
+	"\245\310",		/* A5,C8 */
+	"\245\312",		/* A5,CA */
+	"\245\313",		/* A5,CB */
+	"\245\314",		/* A5,CC */
+	"\245\315",		/* A5,CD */
+	"\245\316",		/* A5,CE */
+	"\245\317",		/* A5,CF */
+	"\245\322",		/* A5,D2 */
+	"\245\325",		/* A5,D5 */
+	"\245\330",		/* A5,D8 */
+	"\245\333",		/* A5,DB */
+	"\245\336",		/* A5,DE */
+	"\245\337",		/* A5,DF */
+	"\245\340",		/* A5,E0 */
+	"\245\341",		/* A5,E1 */
+	"\245\342",		/* A5,E2 */
+	"\245\344",		/* A5,E4 */
+	"\245\346",		/* A5,E6 */
+	"\245\350",		/* A5,E8 */
+	"\245\351",		/* A5,E9 */
+	"\245\352",		/* A5,EA */
+	"\245\353",		/* A5,EB */
+	"\245\354",		/* A5,EC */
+	"\245\355",		/* A5,ED */
+	"\245\357",		/* A5,EF */
+	"\245\363",		/* A5,F3 */
+	"\241\253",		/* A1,AB */
+	"\241\254"		/* A1,AC */
+    };
+
+    if ((IHI == 0x8E) && (ILO >= 0xA1) && (ILO <= 0xDF)) {
+	*OHI = UCH(table[ILO - 0xA1][0]);
+	*OLO = UCH(table[ILO - 0xA1][1]);
+    } else {
+	*OHI = UCH(IHI);
+	*OLO = UCH(ILO);
+    }
+}
+
+static int IS_SJIS_STR(const unsigned char *str)
+{
+    const unsigned char *s;
+    unsigned char ch;
+    int is_sjis = 0;
+
+    s = str;
+    while ((ch = *s++) != '\0') {
+	if (ch & 0x80)
+	    if (IS_SJIS(ch, *s, is_sjis))
+		return 1;
+    }
+    return 0;
+}
+
+unsigned char *SJIS_TO_JIS1(unsigned HI,
+			    unsigned LO,
+			    unsigned char *JCODE)
+{
+    HI = UCH(HI - (unsigned) UCH((HI <= 0x9F) ? 0x71 : 0xB1));
+    HI = UCH((HI << 1) + 1);
+    if (0x7F < LO)
+	LO--;
+    if (0x9E <= LO) {
+	LO = UCH(LO - UCH(0x7D));
+	HI++;
+    } else {
+	LO = UCH(LO - UCH(0x1F));
+    }
+    JCODE[0] = UCH(HI);
+    JCODE[1] = UCH(LO);
+    return JCODE;
+}
+
+unsigned char *JIS_TO_SJIS1(unsigned HI,
+			    unsigned LO,
+			    unsigned char *SJCODE)
+{
+    if (HI & 1)
+	LO = UCH(LO + UCH(0x1F));
+    else
+	LO = UCH(LO + UCH(0x7D));
+    if (0x7F <= LO)
+	LO++;
+
+    HI = UCH(((HI - 0x21) >> 1) + 0x81);
+    if (0x9F < HI)
+	HI = UCH(HI + UCH(0x40));
+    SJCODE[0] = UCH(HI);
+    SJCODE[1] = UCH(LO);
+    return SJCODE;
+}
+
+unsigned char *EUC_TO_SJIS1(unsigned HI,
+			    unsigned LO,
+			    unsigned char *SJCODE)
+{
+    unsigned char HI_data[2];
+    unsigned char LO_data[2];
+
+    HI_data[0] = UCH(HI);
+    LO_data[0] = UCH(LO);
+    if (HI == 0x8E) {
+	JISx0201TO0208_EUC(HI, LO, HI_data, LO_data);
+    }
+    JIS_TO_SJIS1(UCH(HI_data[0] & 0x7F), UCH(LO_data[0] & 0x7F), SJCODE);
+    return SJCODE;
+}
+
+void JISx0201TO0208_SJIS(unsigned I,
+			 unsigned char *OHI,
+			 unsigned char *OLO)
+{
+    unsigned char SJCODE[2];
+
+    JISx0201TO0208_EUC(0x8E, I, OHI, OLO);
+    JIS_TO_SJIS1(UCH(*OHI & 0x7F), UCH(*OLO & 0x7F), SJCODE);
+    *OHI = SJCODE[0];
+    *OLO = SJCODE[1];
+}
+
+unsigned char *SJIS_TO_EUC1(unsigned HI,
+			    unsigned LO,
+			    unsigned char *data)
+{
+    SJIS_TO_JIS1(HI, LO, data);
+    data[0] |= 0x80;
+    data[1] |= 0x80;
+    return data;
+}
+
+unsigned char *SJIS_TO_EUC(unsigned char *src,
+			   unsigned char *dst)
+{
+    unsigned char hi, lo, *sp, *dp;
+    int in_sjis = 0;
+
+    in_sjis = IS_SJIS_STR(src);
+    for (sp = src, dp = dst; (hi = sp[0]) != '\0';) {
+	lo = sp[1];
+	if (TREAT_SJIS && IS_SJIS(hi, lo, in_sjis)) {
+	    SJIS_TO_JIS1(hi, lo, dp);
+	    dp[0] |= 0x80;
+	    dp[1] |= 0x80;
+	    dp += 2;
+	    sp += 2;
+	} else
+	    *dp++ = *sp++;
+    }
+    *dp = 0;
+    return dst;
+}
+
+unsigned char *EUC_TO_SJIS(unsigned char *src,
+			   unsigned char *dst)
+{
+    unsigned char *sp, *dp;
+
+    for (sp = src, dp = dst; *sp;) {
+	if (*sp & 0x80) {
+	    if (sp[1] && (sp[1] & 0x80)) {
+		JIS_TO_SJIS1(UCH(sp[0] & 0x7F), UCH(sp[1] & 0x7F), dp);
+		dp += 2;
+		sp += 2;
+	    } else {
+		sp++;
+	    }
+	} else {
+	    *dp++ = *sp++;
+	}
+    }
+    *dp = 0;
+    return dst;
+}
+
+#define Strcpy(a,b)	(strcpy((char*)a,(const char*)b),&a[strlen((const char*)a)])
+
+unsigned char *EUC_TO_JIS(unsigned char *src,
+			  unsigned char *dst,
+			  const char *toK,
+			  const char *toA)
+{
+    unsigned char kana_mode = 0;
+    unsigned char cch;
+    unsigned char *sp = src;
+    unsigned char *dp = dst;
+    int is_JIS = 0;
+
+    while ((cch = *sp++) != '\0') {
+	if (cch & 0x80) {
+	    if (!IS_EUC(cch, *sp)) {
+		if (cch == 0xA0 && is_JIS)	/* ignore NBSP */
+		    continue;
+		is_JIS++;
+		*dp++ = cch;
+		continue;
+	    }
+	    if (!kana_mode) {
+		kana_mode = UCH(~kana_mode);
+		dp = Strcpy(dp, toK);
+	    }
+	    if (*sp & 0x80) {
+		*dp++ = UCH(cch & ~0x80);
+		*dp++ = UCH(*sp++ & ~0x80);
+	    }
+	} else {
+	    if (kana_mode) {
+		kana_mode = UCH(~kana_mode);
+		dp = Strcpy(dp, toA);
+	    }
+	    *dp++ = cch;
+	}
+    }
+    if (kana_mode)
+	dp = Strcpy(dp, toA);
+
+    if (dp)
+	*dp = 0;
+    return dst;
+}
+
+#define	IS_JIS7(c1,c2)	(0x20<(c1)&&(c1)<0x7F && 0x20<(c2)&&(c2)<0x7F)
+#define SO		('N'-0x40)
+#define SI		('O'-0x40)
+
+static int repair_JIS = 0;
+
+static const unsigned char *repairJIStoEUC(const unsigned char *src,
+					   unsigned char **dstp)
+{
+    const unsigned char *s;
+    unsigned char *d, ch1, ch2;
+
+    d = *dstp;
+    s = src;
+    while ((ch1 = s[0]) && (ch2 = s[1])) {
+	s += 2;
+	if (ch1 == '(')
+	    if (ch2 == 'B' || ch2 == 'J') {
+		*dstp = d;
+		return s;
+	    }
+	if (!IS_JIS7(ch1, ch2))
+	    return 0;
+
+	*d++ = UCH(0x80 | ch1);
+	*d++ = UCH(0x80 | ch2);
+    }
+    return 0;
+}
+
+unsigned char *TO_EUC(const unsigned char *jis,
+		      unsigned char *euc)
+{
+    const unsigned char *s;
+    unsigned char c, jis_stat;
+    unsigned char *d;
+    int to1B, to2B;
+    int in_sjis = 0;
+    static int nje;
+    int n8bits;
+    int is_JIS;
+
+    nje++;
+    n8bits = 0;
+    s = jis;
+    d = euc;
+    jis_stat = 0;
+    to2B = TO_2BCODE;
+    to1B = TO_1BCODE;
+    in_sjis = IS_SJIS_STR(jis);
+    is_JIS = 0;
+
+    while ((c = *s++) != '\0') {
+	if (c == 0x80)
+	    continue;		/* ignore it */
+	if (c == 0xA0 && is_JIS)
+	    continue;		/* ignore Non-breaking space */
+
+	if (c == to2B && jis_stat == 0 && repair_JIS) {
+	    if (*s == 'B' || *s == '@') {
+		const unsigned char *ts;
+
+		if ((ts = repairJIStoEUC(s + 1, &d)) != NULL) {
+		    s = ts;
+		    continue;
+		}
+	    }
+	}
+	if (c == CH_ESC) {
+	    if (*s == to2B) {
+		if ((s[1] == 'B') || (s[1] == '@')) {
+		    jis_stat = 0x80;
+		    s += 2;
+		    is_JIS++;
+		    continue;
+		}
+		jis_stat = 0;
+	    } else if (*s == to1B) {
+		jis_stat = 0;
+		if ((s[1] == 'B') || (s[1] == 'J') || (s[1] == 'H')) {
+		    s += 2;
+		    continue;
+		}
+	    } else if (*s == ',') {	/* MULE */
+		jis_stat = 0;
+	    }
+	}
+	if (c & 0x80)
+	    n8bits++;
+
+	if (IS_SJIS(c, *s, in_sjis)) {
+	    SJIS_TO_EUC1(c, *s, d);
+	    d += 2;
+	    s++;
+	    is_JIS++;
+	} else if (jis_stat) {
+	    if (c <= 0x20 || 0x7F <= c) {
+		*d++ = c;
+		if (c == '\n')
+		    jis_stat = 0;
+	    } else {
+		if (IS_JIS7(c, *s)) {
+		    *d++ = jis_stat | c;
+		    *d++ = jis_stat | *s++;
+		} else
+		    *d++ = c;
+	    }
+	} else {
+	    if (n8bits == 0 && (c == SI || c == SO)) {
+	    } else {
+		*d++ = c;
+	    }
+	}
+    }
+    *d = 0;
+    return euc;
+}
+
+#define non94(ch) ((ch) <= 0x20 || (ch) == 0x7F)
+
+static int is_EUC_JP(unsigned char *euc)
+{
+    unsigned char *cp;
+    int ch1, ch2;
+
+    for (cp = euc; (ch1 = *cp) != '\0'; cp++) {
+	if (ch1 & 0x80) {
+	    ch2 = cp[1] & 0xFF;
+	    if ((ch2 & 0x80) == 0) {
+		/* sv1log("NOT_EUC1[%x][%x]\n",ch1,ch2); */
+		return 0;
+	    }
+	    if (non94(ch1 & 0x7F) || non94(ch2 & 0x7F)) {
+		/* sv1log("NOT_EUC2[%x][%x]\n",ch1,ch2); */
+		return 0;
+	    }
+	    cp++;
+	}
+    }
+    return 1;
+}
+
+void TO_SJIS(const unsigned char *arg,
+	     unsigned char *sjis)
+{
+    unsigned char *euc;
+
+    euc = typeMallocn(unsigned char, strlen((const char *) arg) + 1);
+
+#ifdef CJK_EX
+    if (!euc)
+	outofmem(__FILE__, "TO_SJIS");
+#endif
+    TO_EUC(arg, euc);
+    if (is_EUC_JP(euc))
+	EUC_TO_SJIS(euc, sjis);
+    else
+	strcpy((char *) sjis, (const char *) arg);
+    free(euc);
+}
+
+void TO_JIS(const unsigned char *arg,
+	    unsigned char *jis)
+{
+    unsigned char *euc;
+
+    if (arg[0] == 0) {
+	jis[0] = 0;
+	return;
+    }
+    euc = typeMallocn(unsigned char, strlen((const char *)arg) + 1);
+#ifdef CJK_EX
+    if (!euc)
+	outofmem(__FILE__, "TO_JIS");
+#endif
+    TO_EUC(arg, euc);
+    EUC_TO_JIS(euc, jis, TO_KANJI, TO_ASCII);
+
+    free(euc);
+}
diff --git a/WWW/Library/Implementation/SGML.h b/WWW/Library/Implementation/SGML.h
new file mode 100644
index 0000000..4525fda
--- /dev/null
+++ b/WWW/Library/Implementation/SGML.h
@@ -0,0 +1,287 @@
+/*
+ * $LynxId: SGML.h,v 1.50 2023/01/05 22:23:44 tom Exp $
+ *			       SGML parse and stream definition for libwww
+ *                             SGML AND STRUCTURED STREAMS
+ *
+ * The SGML parser is a state machine.	It is called for every character
+ * of the input stream.	 The DTD data structure contains pointers
+ * to functions which are called to implement the actual effect of the
+ * text read. When these functions are called, the attribute structures pointed to by the
+ * DTD are valid, and the function is passed a pointer to the current tag structure, and an
+ * "element stack" which represents the state of nesting within SGML elements.
+ *
+ * The following aspects are from Dan Connolly's suggestions:  Binary search,
+ * Structured object scheme basically, SGML content enum type.
+ *
+ * (c) Copyright CERN 1991 - See Copyright.html
+ *
+ */
+#ifndef SGML_H
+#define SGML_H
+
+#include <HTStream.h>
+#include <HTAnchor.h>
+#include <LYJustify.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ *
+ * SGML content types
+ *
+ */ typedef enum {
+	SGML_EMPTY,		/* No content. */
+	SGML_LITTERAL,		/* Literal character data.  Recognize exact close tag only.
+				   Old www server compatibility only!  Not SGML */
+	SGML_CDATA,		/* Character data.  Recognize </ only.
+				   (But we treat it just as SGML_LITTERAL.) */
+	SGML_SCRIPT,		/* Like CDATA, but allow it to be a comment */
+	SGML_RCDATA,		/* Replaceable character data. Should recognize </ and &ref;
+				   (but we treat it like SGML_MIXED for old times' sake). */
+	SGML_MIXED,		/* Elements and parsed character data.
+				   Recognize all markup. */
+	SGML_ELEMENT,		/* Any data found should be regarded as an error.
+				   (But we treat it just like SGML_MIXED.) */
+	SGML_PCDATA		/* Should contain no elements but &ref; is parsed.
+				   (We treat it like SGML_CDATA wrt. contained tags
+				   i.e. pass them on literally, i.e. like we should
+				   treat SGML_RCDATA) (added by KW). */
+    } SGMLContent;
+
+    typedef struct {
+	const char *name;	/* The name of the attribute */
+#ifdef USE_PRETTYSRC
+	char type;		/* code of the type of the attribute. Code
+				   values are in HTMLDTD.h */
+#endif
+    } attr;
+
+    typedef const attr *AttrList;
+
+    typedef struct {
+	const char *name;
+	AttrList list;
+    } AttrType;
+
+    typedef int TagClass;
+
+    /* textflow */
+#define Tgc_FONTlike	0x00001	/* S,STRIKE,I,B,TT,U,BIG,SMALL,STYLE,BLINK;BR,TAB */
+#define Tgc_EMlike	0x00002	/* EM,STRONG,DFN,CODE,SAMP,KBD,VAR,CITE,Q,INS,DEL,SPAN,.. */
+#define Tgc_MATHlike	0x00004	/* SUB,SUP,MATH,COMMENT */
+#define Tgc_Alike	0x00008	/* A */
+#define Tgc_formula	0x00010	/* not used until math is supported better... */
+    /* used for special structures: forms, tables,... */
+#define Tgc_TRlike	0x00020	/* TR and similar */
+#define Tgc_SELECTlike	0x00040	/* SELECT,INPUT,TEXTAREA(,...) */
+    /* structure */
+#define Tgc_FORMlike	0x00080	/* FORM itself */
+#define Tgc_Plike	0x00100	/* P,H1..H6,... structures containing text or
+				   insertion but not other structures */
+#define Tgc_DIVlike	0x00200	/* ADDRESS,FIG,BDO,NOTE,FN,DIV,CENTER;FIG
+				   structures which can contain other structures */
+#define Tgc_LIlike	0x00400	/* LH,LI,DT,DD;TH,TD structure-like, only valid
+				   within certain other structures */
+#define Tgc_ULlike	0x00800	/* UL,OL,DL,DIR,MENU;TABLE;XMP,LISTING
+				   special in some way, cannot contain (parsed)
+				   text directly */
+    /* insertions */
+#define Tgc_BRlike	0x01000	/* BR,IMG,TAB allowed in any text */
+#define Tgc_APPLETlike	0x02000	/* APPLET,OBJECT,EMBED,SCRIPT;BUTTON */
+#define Tgc_HRlike	0x04000	/* HR,MARQUEE can contain all kinds of things
+				   and/or are not allowed (?) in running text */
+#define Tgc_MAPlike	0x08000	/* MAP,AREA some specials that never contain
+				   (directly or indirectly) other things than
+				   special insertions */
+#define Tgc_outer	0x10000	/* HTML,FRAMESET,FRAME,PLAINTEXT; */
+#define Tgc_BODYlike	0x20000	/* BODY,BODYTEXT,NOFRAMES,TEXTFLOW; */
+#define Tgc_HEADstuff	0x40000	/* HEAD,BASE,STYLE,TITLE; */
+    /* special relations */
+#define Tgc_same	0x80000
+#define Tgc_DELlike	0x100000
+    /* DELlike is a class of aliases for inline DEL/INS */
+    typedef unsigned char TagAlias;
+
+/*
+ * Groups for contains-data.
+ */
+#define Tgc_INLINElike	(Tgc_Alike | Tgc_APPLETlike | Tgc_BRlike | Tgc_EMlike | Tgc_FONTlike | Tgc_SELECTlike)
+#define Tgc_LISTlike	(Tgc_LIlike | Tgc_ULlike)
+#define Tgc_BLOCKlike	(Tgc_DIVlike | Tgc_LISTlike)
+
+/* Some more properties of tags (or rather, elements) and rules how
+   to deal with them. - kw */
+    typedef int TagFlags;
+
+#define Tgf_endO	0x00001	/* end tag can be Omitted */
+#define Tgf_startO	0x00002	/* start tag can be Omitted */
+#define Tgf_mafse	0x00004	/* Make Attribute-Free Start-tag End instead
+				   (if found invalid) */
+#define Tgf_strict	0x00008	/* Ignore contained invalid elements,
+				   don't pass them on; or other variant
+				   handling for some content types */
+#define Tgf_nreie	0x00010	/* Not Really Empty If Empty,
+				   used by color style code */
+#define Tgf_frecyc	0x00020	/* Pass element content on in a form that
+				   allows recycling, i.e. don't translate to
+				   output (display) character set yet (treat
+				   content similar to attribute values) */
+#define Tgf_nolyspcl	0x00040	/* Don't generate lynx special characters
+				   for soft hyphen and various spaces (nbsp,
+				   ensp,..) */
+
+/*		A tag structure describes an SGML element.
+ *		-----------------------------------------
+ *
+ *
+ *	name		is the string which comes after the tag opener "<".
+ *
+ *	attributes	points to a zero-terminated array
+ *			of attribute names.
+ */
+    typedef struct _tag HTTag;
+    struct _tag {
+	const char *name;	/* The name of the tag */
+#ifdef USE_COLOR_STYLE
+	unsigned name_len;	/* The length of the name */
+#endif
+#ifdef USE_JUSTIFY_ELTS
+	BOOL can_justify;	/* justification allowed? */
+#endif
+	AttrList attributes;	/* The list of acceptable attributes */
+	int number_of_attributes;	/* Number of possible attributes */
+	const AttrType *attr_types;
+	SGMLContent contents;	/* End only on end tag @@ */
+	TagClass tagclass;
+	TagClass contains;	/* which classes of elements this one can contain directly */
+	TagClass icontains;	/* which classes of elements this one can contain indirectly */
+	TagClass contained;	/* in which classes can this tag be contained ? */
+	TagClass icontained;	/* in which classes can this tag be indirectly contained ? */
+	TagClass canclose;	/* which classes of elements can this one close
+				   if something looks wrong ? */
+	TagFlags flags;
+	TagAlias alias;		/* extra levels, e.g, DEL/INS */
+	TagAlias aliases;	/* number of extra levels, e.g, DEL/INS */
+    };
+
+/*		DTD Information
+ *		---------------
+ *
+ *  Not the whole DTD, but all this parser uses of it.
+ */
+    typedef struct {
+	HTTag *tags;		/* Must be in strcmp order by name */
+	int number_of_tags;
+	STRING2PTR entity_names;	/* Must be in strcmp order by name */
+	size_t number_of_entities;
+	/*  "entity_names" table probably unused,
+	 *  see comments in HTMLDTD.c near the top
+	 */
+    } SGML_dtd;
+
+/*	SGML context passed to parsers
+*/
+    typedef struct _HTSGMLContext *HTSGMLContext;	/* Hidden */
+
+/*__________________________________________________________________________
+*/
+
+/*
+
+Structured Object definition
+
+   A structured object is something which can reasonably be represented
+   in SGML.  I'll rephrase that.  A structured object is an ordered
+   tree-structured arrangement of data which is representable as text.
+   The SGML parser outputs to a Structured object.  A Structured object
+   can output its contents to another Structured Object.  It's a kind of
+   typed stream.  The architecture is largely Dan Conolly's.  Elements and
+   entities are passed to the sob by number, implying a knowledge of the
+   DTD.	 Knowledge of the SGML syntax is not here, though.
+
+   Superclass: HTStream
+
+   The creation methods will vary on the type of Structured Object.
+   Maybe the callerData is enough info to pass along.
+
+ */
+    typedef struct _HTStructured HTStructured;
+
+    typedef struct _HTStructuredClass {
+
+	const char *name;	/* Just for diagnostics */
+
+	void (*_free) (HTStructured * me);
+
+	void (*_abort) (HTStructured * me, HTError e);
+
+	void (*put_character) (HTStructured * me, int ch);
+
+	void (*put_string) (HTStructured * me, const char *str);
+
+	void (*put_block) (HTStructured * me, const char *str, int len);
+
+	/* HTStreamClass ends here */
+
+	int (*start_element) (HTStructured * me, int element_number,
+			      const BOOL *attribute_present,
+			      STRING2PTR attribute_value,
+			      int charset,
+			      char **include);
+
+	int (*end_element) (HTStructured * me, int element_number,
+			    char **include);
+
+	int (*put_entity) (HTStructured * me, int entity_number);
+
+    } HTStructuredClass;
+
+/*
+  Equivalents to the following functions possibly could be generalised
+  into additional HTStructuredClass members.  For now they don't do
+  anything target-specific. - kw
+  */
+    extern BOOLEAN LYCheckForCSI(HTParentAnchor *anchor, char **url);
+    extern void LYDoCSI(char *url, const char *comment, char **csi);
+    extern BOOLEAN LYCommentHacks(HTParentAnchor *anchor, const char *comment);
+
+/*
+
+Find a Tag by Name
+
+   Returns a pointer to the tag within the DTD.
+
+ */
+    extern HTTag *SGMLFindTag(const SGML_dtd * dtd,
+			      const char *string);
+
+/*
+ * Return the current offset within the file that SGML is parsing
+ */
+    extern int SGML_offset(void);
+
+/*
+
+Create an SGML parser
+
+ */
+/*
+ * On entry,
+ *	dtd		must point to a DTD structure as defined above
+ *	callbacks	must point to user routines.
+ *	callData	is returned in callbacks transparently.
+ * On exit,
+ *		The default tag starter has been processed.
+ */
+    extern HTStream *SGML_new(const SGML_dtd * dtd,
+			      HTParentAnchor *anchor,
+			      HTStructured * target,
+			      int extended_html);
+
+    extern const HTStreamClass SGMLParser;
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* SGML_H */
diff --git a/WWW/Library/Implementation/UCAux.h b/WWW/Library/Implementation/UCAux.h
new file mode 100644
index 0000000..3e574a1
--- /dev/null
+++ b/WWW/Library/Implementation/UCAux.h
@@ -0,0 +1,92 @@
+/*
+ * $LynxId: UCAux.h,v 1.22 2014/12/10 09:48:41 tom Exp $
+ */
+#ifndef UCAUX_H
+#define UCAUX_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifndef UCDEFS_H
+#include <UCDefs.h>
+#endif /* UCDEFS_H */
+
+#ifndef HTSTREAM_H
+#include <HTStream.h>
+#endif /* HTSTREAM_H */
+
+#ifndef UCMAP_H
+#include <UCMap.h>
+#endif /* UCMAP_H */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    extern BOOL UCCanUniTranslateFrom(int from);
+    extern BOOL UCCanTranslateUniTo(int to);
+    extern BOOL UCCanTranslateFromTo(int from, int to);
+    extern BOOL UCNeedNotTranslate(int from,
+				   int to);
+
+    struct _UCTransParams {
+	BOOL transp;
+	BOOL do_cjk;
+	BOOL decode_utf8;
+	BOOL output_utf8;
+	BOOL use_raw_char_in;
+	BOOL strip_raw_char_in;
+	BOOL pass_160_173_raw;
+	BOOL do_8bitraw;
+	BOOL trans_to_uni;
+	BOOL trans_C0_to_uni;
+	BOOL repl_translated_C0;
+	BOOL trans_from_uni;
+	int ucs_mode;
+    };
+    typedef struct _UCTransParams UCTransParams;
+
+    typedef struct {
+	char utf_count;
+	UCode_t utf_char;
+	char utf_buf[8];
+	char *utf_buf_p;
+    } UTFDecodeState;
+
+    typedef enum {
+	dUTF8_ok,
+	dUTF8_err,
+	dUTF8_more
+    } dUTF8;
+
+    extern dUTF8 HTDecodeUTF8(UTFDecodeState * me, int *c_in_out, UCode_t *result);
+
+    extern void UCSetTransParams(UCTransParams * pT, int cs_in,
+				 const LYUCcharset *p_in,
+				 int cs_out,
+				 const LYUCcharset *p_out);
+
+    extern void UCTransParams_clear(UCTransParams * pT);
+
+    extern void UCSetBoxChars(int cset,
+			      int *pvert_out,
+			      int *phori_out,
+			      int vert_in,
+			      int hori_in);
+
+    typedef void putc_func_t (HTStream *me,
+			      int ch);
+
+    extern BOOL UCPutUtf8_charstring(HTStream *target,
+				     putc_func_t *actions,
+				     UCode_t code);
+
+    extern BOOL UCConvertUniToUtf8(UCode_t code,
+				   char *buffer);
+
+    extern UCode_t UCGetUniFromUtf8String(const char **ppuni);
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* UCAUX_H */
diff --git a/WWW/Library/Implementation/UCDefs.h b/WWW/Library/Implementation/UCDefs.h
new file mode 100644
index 0000000..4eb7c56
--- /dev/null
+++ b/WWW/Library/Implementation/UCDefs.h
@@ -0,0 +1,106 @@
+/*
+ * $LynxId: UCDefs.h,v 1.18 2021/06/29 00:21:51 tom Exp $
+ *
+ * Definitions for Unicode character-translations
+ */
+
+#ifndef UCDEFS_H
+#define UCDEFS_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+typedef struct _LYUCcharset {
+    int UChndl;			/* -1 for "old" charsets, >= 0 for chartrans tables */
+
+    const char *MIMEname;
+    int enc;
+    int codepage;		/* if positive, an IBM OS/2 specific number;
+				   if negative, flag for no table translation */
+
+    /* parameters below are not used by chartrans mechanism, */
+    /* they describe some relationships against built-in Latin1 charset... */
+    int repertoire;		/* unused */
+    int codepoints;		/* subset/superset of Latin1 ? */
+    int cpranges;		/* unused, obsolete by LYlowest_eightbit;
+				   "which ranges have valid displayable chars
+				   (including nbsp and shy)" */
+    int like8859;		/* currently used for nbsp and shy only
+				   (but UCT_R_8859SPECL assumed for any UCT_R_8BIT...);
+				   "for which ranges is it like 8859-1" */
+} LYUCcharset;
+
+typedef enum {
+    UCT_ENC_7BIT,
+    UCT_ENC_8BIT,
+    UCT_ENC_8859,		/* no displayable chars in 0x80-0x9F */
+    UCT_ENC_8BIT_C0,		/* 8-bit + some chars in C0 control area */
+    UCT_ENC_MAYBE2022,
+    UCT_ENC_CJK,
+    UCT_ENC_16BIT,
+    UCT_ENC_UTF8
+} eUCT_ENC;
+
+#define UCT_REP_SUBSETOF_LAT1 0x01
+#define UCT_REP_SUPERSETOF_LAT1 0x02
+#define UCT_REP_IS_LAT1 UCT_REP_SUBSETOF_LAT1 | UCT_REP_SUPERSETOF_LAT1
+/*
+ *  Assume everything we deal with is included in the UCS2 repertoire,
+ *  so a flag for _REP_SUBSETOF_UCS2 would be redundant.
+ */
+
+/*
+ *  More general description how the code points relate to 8859-1 and UCS:
+ */
+#define UCT_CP_SUBSETOF_LAT1 0x01	/* implies UCT_CP_SUBSETOF_UCS2 */
+#define UCT_CP_SUPERSETOF_LAT1 0x02
+#define UCT_CP_SUBSETOF_UCS2 0x04
+
+#define UCT_CP_IS_LAT1 UCT_CP_SUBSETOF_LAT1 | UCT_CP_SUPERSETOF_LAT1
+
+/*
+ *  More specific bitflags for practically important code point ranges:
+ */
+#define UCT_R_LOWCTRL 0x08	/* 0x00-0x1F, for completeness */
+#define UCT_R_7BITINV 0x10	/* invariant???, displayable 7bit chars */
+#define UCT_R_7BITNAT 0x20	/* displayable 7bit, national??? */
+#define UCT_R_HIGHCTRL 0x40	/* chars in 0x80-0x9F range */
+#define UCT_R_8859SPECL 0x80	/* special chars in 8859-x sets: nbsp and shy */
+#define UCT_R_HIGH8BIT 0x100	/* rest of 0xA0-0xFF range */
+
+#define UCT_R_ASCII UCT_R_7BITINV | UCT_R_7BITNAT	/* displayable US-ASCII */
+#define UCT_R_LAT1  UCT_R_ASCII   | UCT_R_8859SPECL | UCT_R_HIGH8BIT
+#define UCT_R_8BIT  UCT_R_LAT1    | UCT_R_HIGHCTRL	/* full 8bit range */
+
+/*
+ *  For the following some comments are in HTAnchor.c.
+ */
+typedef enum {
+    UCT_STAGE_MIME,
+    UCT_STAGE_PARSER,		/* What the parser (SGML.c) gets to see */
+    UCT_STAGE_STRUCTURED,	/* What the structured stream (HTML) gets fed */
+    UCT_STAGE_HTEXT,		/* What gets fed to the HText_* functions */
+    UCT_STAGEMAX
+} eUCT_STAGE;
+
+typedef enum {
+    UCT_SETBY_NONE,
+    UCT_SETBY_DEFAULT,
+    UCT_SETBY_LINK,		/* set by A or LINK CHARSET= hint */
+    UCT_SETBY_STRUCTURED,	/* structured stream stage (HTML.c) */
+    UCT_SETBY_PARSER,		/* set by SGML parser or similar */
+    UCT_SETBY_MIME		/* set explicitly by MIME charset parameter */
+} eUCT_SETBY;
+
+typedef struct _UCStageInfo {
+    int lock;			/* by what it has been set */
+    int LYhndl;
+    LYUCcharset C;
+} UCStageInfo;
+
+typedef struct _UCAnchorInfo {
+    struct _UCStageInfo s[UCT_STAGEMAX];
+} UCAnchorInfo;
+
+#endif /* UCDEFS_H */
diff --git a/WWW/Library/Implementation/UCMap.h b/WWW/Library/Implementation/UCMap.h
new file mode 100644
index 0000000..0c88969
--- /dev/null
+++ b/WWW/Library/Implementation/UCMap.h
@@ -0,0 +1,114 @@
+/*
+ * $LynxId: UCMap.h,v 1.30 2023/01/05 09:17:15 tom Exp $
+ */
+#ifndef UCMAP_H
+#define UCMAP_H
+
+#ifndef HTUTILS_H
+#include <HTUtils.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define UCS_HIDE 0xffff
+#define UCS_REPL 0xfffd
+
+    typedef enum {
+	ucError = -1,
+	ucZeroWidth = -2,
+	ucInvalidHash = -3,
+	ucNotFound = -4,
+	ucNeedMore = -10,
+	ucCannotConvert = -11,
+	ucCannotOutput = -12,
+	ucBufferTooSmall = -13,
+	ucUnknown = -14
+    } UCStatus;
+
+    typedef long UCode_t;
+
+    extern BOOL UCScanCode(UCode_t *, const char *, BOOL);
+
+    extern int UCTransUniChar(UCode_t unicode,
+			      int charset_out);
+    extern int UCTransUniCharStr(char *outbuf,
+				 int buflen,
+				 UCode_t unicode,
+				 int charset_out,
+				 int chk_single_flag);
+    extern int UCTransChar(int ch_in,
+			   int charset_in,
+			   int charset_out);
+    extern int UCReverseTransChar(int ch_out,
+				  int charset_in,
+				  int charset_out);
+    extern int UCTransCharStr(char *outbuf,
+			      int buflen,
+			      int ch_in,
+			      int charset_in,
+			      int charset_out,
+			      int chk_single_flag);
+#ifdef EXP_CHINESEUTF8_SUPPORT
+    extern UCode_t UCTransJPToUni(char *inbuf,
+				  int buflen,
+				  int charset_in);
+#endif
+    extern UCode_t UCTransToUni(int ch_in,
+				int charset_in);
+    extern int UCGetRawUniMode_byLYhndl(int i);
+    extern int UCGetLYhndl_byMIME(const char *p);	/* returns -1 if name not recognized */
+    extern int safeUCGetLYhndl_byMIME(const char *p);	/* returns LATIN1 if name not recognized */
+
+#ifdef USE_LOCALE_CHARSET
+    extern void LYFindLocaleCharset(void);
+#endif
+
+    extern int UCLYhndl_for_unspec;
+    extern int UCLYhndl_for_unrec;
+    extern int UCLYhndl_HTFile_for_unspec;
+    extern int UCLYhndl_HTFile_for_unrec;
+
+/* easy to type: */
+    extern int LATIN1;		/* UCGetLYhndl_byMIME("iso-8859-1") */
+    extern int US_ASCII;	/* UCGetLYhndl_byMIME("us-ascii")   */
+    extern int UTF8_handle;	/* UCGetLYhndl_byMIME("utf-8")      */
+
+#undef TRANSPARENT		/* defined on Solaris in <sys/stream.h> */
+    extern int TRANSPARENT;	/* UCGetLYhndl_byMIME("x-transparent")  */
+
+/*
+In general, Lynx translates letters from document charset to display charset.
+If document charset is not specified or not recognized by Lynx, we fall back
+to different assumptions below, read also lynx.cfg for info.
+
+UCLYhndl_for_unspec -  assume this as charset for documents that don't
+                       specify a charset parameter in HTTP headers or via META
+                       this corresponds to "assume_charset"
+
+UCLYhndl_HTFile_for_unspec -  assume this as charset of local file
+                       this corresponds to "assume_local_charset"
+
+UCLYhndl_for_unrec  -  in case a charset parameter is not recognized;
+                       this corresponds to "assume_unrec_charset"
+
+UCLYhndl_HTFile_for_unrec  - the same but only for local files,
+                             currently not used.
+
+current_char_set  -	this corresponds to "display charset",
+			declared in LYCharSets.c and really important.
+
+All external charset information is available in so called MIME format.
+For internal needs Lynx uses charset handlers as integers
+from UCGetLYhndl_byMIME().  However, there is no way to recover
+from user's error in configuration file lynx.cfg or command line switches,
+those unrecognized MIME names are assumed as LATIN1 (via safeUCGetLYhndl...).
+*/
+
+#define UCTRANS_NOTFOUND (-4)
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* UCMAP_H */
diff --git a/WWW/Library/Implementation/Version.make b/WWW/Library/Implementation/Version.make
new file mode 100644
index 0000000..4b4b380
--- /dev/null
+++ b/WWW/Library/Implementation/Version.make
@@ -0,0 +1 @@
+VC = 2.14
diff --git a/WWW/Library/Implementation/dtd_util.c b/WWW/Library/Implementation/dtd_util.c
new file mode 100644
index 0000000..cf88998
--- /dev/null
+++ b/WWW/Library/Implementation/dtd_util.c
@@ -0,0 +1,1722 @@
+/*
+ * $LynxId: dtd_util.c,v 1.89 2022/09/29 23:51:16 tom Exp $
+ *
+ * Given a SGML_dtd structure, write a corresponding flat file, or "C" source.
+ * Given the flat-file, write the "C" source.
+ *
+ * TODO: use symbols for HTMLA_NORMAL, etc.
+ */
+
+#include <HTUtils.h>
+#include <HTMLDTD.h>
+#include <string.h>
+#include <stdarg.h>
+
+/*
+ * Tweaks to build standalone.
+ */
+#undef exit
+
+BOOLEAN WWW_TraceFlag = FALSE;
+FILE *TraceFP(void)
+{
+    return stderr;
+}
+
+/*
+ * Begin the actual utility.
+ */
+#define GETOPT "chl:o:tsx"
+
+#define NOTE(message) fprintf(output, message "\n");
+/* *INDENT-OFF* */
+#ifdef USE_PRETTYSRC
+# define N HTMLA_NORMAL
+# define i HTMLA_ANAME
+# define h HTMLA_HREF
+# define c HTMLA_CLASS
+# define x HTMLA_AUXCLASS
+# define T(t) , t
+#else
+# define T(t)			/*nothing */
+#endif
+
+#define ATTR_TYPE(name) { #name, name##_attr_list }
+
+#define MY_LIMIT		1024
+#define FMT_WS			"%[ \t\n]"
+#define FMT_NUM_ATTR_TYPES	"%d attr_types"
+#define FMT_NUM_ATTRS		"%d attributes:"
+#define FMT_ONE_ATTR		"%d:%d:%s"
+#define NUM_ONE_ATTR		4
+
+static const char alias_codes[] = "!@#$%^&*";
+
+#define DATA(name) { #name, Tgc_##name }
+static const struct {
+    const char *name;
+    TagClass tagclass;
+} class_list[] = {
+	DATA(APPLETlike),
+	DATA(Alike),
+	DATA(BODYlike),
+	DATA(BRlike),
+	DATA(DELlike),
+	DATA(DIVlike),
+	DATA(EMlike),
+	DATA(FONTlike),
+	DATA(FORMlike),
+	DATA(HEADstuff),
+	DATA(HRlike),
+	DATA(LIlike),
+	DATA(MAPlike),
+	DATA(MATHlike),
+	DATA(Plike),
+	DATA(SELECTlike),
+	DATA(TRlike),
+	DATA(ULlike),
+	DATA(formula),
+	DATA(outer),
+	DATA(same)
+};
+
+static const attr core_attr_list[] = {
+	{ "CLASS"         T(c) },
+	{ "ID"            T(i) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr i18n_attr_list[] = {
+	{ "DIR"           T(N) },
+	{ "LANG"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr events_attr_list[] = {
+	{ "ONCLICK"       T(N) },
+	{ "ONDBLCLICK"    T(N) },
+	{ "ONKEYDOWN"     T(N) },
+	{ "ONKEYPRESS"    T(N) },
+	{ "ONKEYUP"       T(N) },
+	{ "ONMOUSEDOWN"   T(N) },
+	{ "ONMOUSEMOVE"   T(N) },
+	{ "ONMOUSEOUT"    T(N) },
+	{ "ONMOUSEOVER"   T(N) },
+	{ "ONMOUSEUP"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr align_attr_list[] = {
+	{ "ALIGN"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr cellalign_attr_list[] = {
+	{ "ALIGN"         T(N) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "VALIGN"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr bgcolor_attr_list[] = {
+	{ "BGCOLOR"       T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+#undef T
+/* *INDENT-ON* */
+
+static const char *input_filename;
+static int input_lineno;
+
+static void failed(const char *s)
+{
+    if (input_lineno) {
+	int save = errno;
+
+	fprintf(stderr, "%s:%d ", input_filename, input_lineno);
+	errno = save;
+    }
+    perror(s);
+    exit(EXIT_FAILURE);
+}
+
+static void warning(const char *, ...) GCC_PRINTFLIKE(1, 2);
+
+static void warning(const char *fmt, ...)
+{
+    va_list ap;
+
+    va_start(ap, fmt);
+    fprintf(stderr, "%s:%d: ", input_filename, input_lineno);
+    vfprintf(stderr, fmt, ap);
+    fputc('\n', stderr);
+    va_end(ap);
+}
+
+static void usage(void)
+{
+    static const char *tbl[] =
+    {
+	"Usage: dtd_util [options]",
+	"",
+	"Options:",
+	"  -c           generate C-source"
+	"  -h           generate C-header"
+	"  -l           load",
+	"  -o filename  specify output (default: stdout)",
+	"  -s           strict (HTML DTD 0)",
+	"  -t           tagsoup (HTML DTD 1)",
+	"  -x           cross-check contains/contained data (repeat for more)"
+    };
+    unsigned n;
+
+    for (n = 0; n < TABLESIZE(tbl); ++n) {
+	fprintf(stderr, "%s\n", tbl[n]);
+    }
+    exit(EXIT_FAILURE);
+}
+
+static const char *SGMLContent2s(SGMLContent contents)
+{
+    char *value = "?";
+
+    switch (contents) {
+    case SGML_EMPTY:
+	value = "SGML_EMPTY";
+	break;
+    case SGML_LITTERAL:
+	value = "SGML_LITTERAL";
+	break;
+    case SGML_CDATA:
+	value = "SGML_CDATA";
+	break;
+    case SGML_SCRIPT:
+	value = "SGML_SCRIPT";
+	break;
+    case SGML_RCDATA:
+	value = "SGML_RCDATA";
+	break;
+    case SGML_MIXED:
+	value = "SGML_MIXED";
+	break;
+    case SGML_ELEMENT:
+	value = "SGML_ELEMENT";
+	break;
+    case SGML_PCDATA:
+	value = "SGML_PCDATA";
+	break;
+    }
+    return value;
+}
+
+static SGMLContent s2SGMLContent(const char *value)
+{
+    static SGMLContent table[] =
+    {
+	SGML_EMPTY,
+	SGML_LITTERAL,
+	SGML_CDATA,
+	SGML_SCRIPT,
+	SGML_RCDATA,
+	SGML_MIXED,
+	SGML_ELEMENT,
+	SGML_PCDATA
+    };
+    unsigned n;
+    SGMLContent result = SGML_EMPTY;
+
+    for (n = 0; n < TABLESIZE(table); ++n) {
+	if (!strcmp(SGMLContent2s(table[n]), value)) {
+	    result = table[n];
+	    break;
+	}
+    }
+    return result;
+}
+
+static void PrintF(FILE *, int, const char *, ...) GCC_PRINTFLIKE(3, 4);
+
+static void PrintF(FILE *output, int width, const char *fmt, ...)
+{
+    char buffer[BUFSIZ];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsprintf(buffer, fmt, ap);
+    va_end(ap);
+
+    fprintf(output, "%-*s", width, buffer);
+}
+
+static char *get_line(FILE *input)
+{
+    char temp[MY_LIMIT];
+    char *result = 0;
+
+    if (fgets(temp, (int) sizeof(temp), input) != 0) {
+	result = strdup(temp);
+	++input_lineno;
+    }
+    return result;
+}
+
+static int read_num_attr_types(FILE *input)
+{
+    char *next = get_line(input);
+    int count;
+    int code;
+    char trail[MY_LIMIT];
+
+    if (next == 0
+	|| (code = sscanf(next, FMT_NUM_ATTR_TYPES FMT_WS, &count, trail)) < 2
+	|| !count) {
+	warning("expected attr_types");
+    }
+    return count;
+}
+
+static int same_AttrList(AttrList a, AttrList b)
+{
+    int result = 1;
+
+    if (a && b) {
+	while (a->name && b->name) {
+	    if (strcmp(a->name, b->name)) {
+		result = 0;
+		break;
+	    }
+	    ++a, ++b;
+	}
+	if (a->name || b->name)
+	    result = 0;
+    } else {
+	result = 0;
+    }
+    return result;
+}
+
+static int first_attrs(const SGML_dtd * dtd, int which)
+{
+    int check;
+    int result = TRUE;
+
+    for (check = 0; check < which; ++check) {
+	if (dtd->tags[check].attributes == dtd->tags[which].attributes) {
+	    result = FALSE;
+	    break;
+	} else if (same_AttrList(dtd->tags[check].attributes,
+				 dtd->tags[which].attributes)) {
+	    result = FALSE;
+	    dtd->tags[which].attributes = dtd->tags[check].attributes;
+	    break;
+	}
+    }
+    return result;
+}
+
+static char *no_dashes(char *target, const char *source)
+{
+    int j;
+
+    for (j = 0; (target[j] = source[j]) != '\0'; ++j) {
+	if (!isalnum(target[j]))
+	    target[j] = '_';
+    }
+    return target;
+}
+
+/* the second "OBJECT" is treated specially */
+static int first_object(const SGML_dtd * dtd, int which)
+{
+    int check;
+
+    for (check = 0; check <= which; ++check) {
+	if (!strcmp(dtd->tags[check].name, "OBJECT"))
+	    break;
+    }
+    return (check == which);
+}
+
+static const char *NameOfAttrs(const SGML_dtd * dtd, int which)
+{
+    int check;
+    const char *result = dtd->tags[which].name;
+
+    for (check = 0; check < which; ++check) {
+	if (dtd->tags[check].attributes == dtd->tags[which].attributes) {
+	    result = dtd->tags[check].name;
+	    break;
+	}
+    }
+    /* special cases to match existing headers */
+    if (!strcmp(result, "ABBR"))
+	result = "GEN";
+    else if (!strcmp(result, "ARTICLE"))
+	result = "GEN5";
+    else if (!strcmp(result, "BLOCKQUOTE"))
+	result = "BQ";
+    else if (!strcmp(result, "BASEFONT"))
+	result = "FONT";
+    else if (!strcmp(result, "CENTER"))
+	result = "DIV";
+    else if (!strcmp(result, "DIR"))
+	result = "UL";
+    else if (!strcmp(result, "H1"))
+	result = "H";
+    else if (!strcmp(result, "TBODY"))
+	result = "TR";
+    return result;
+}
+
+static const char *DEF_name(const SGML_dtd * dtd, int which, unsigned alias)
+{
+    const char *result = dtd->tags[which].name;
+
+    if (!strcmp(result, "OBJECT") && !first_object(dtd, which)) {
+	result = "OBJECT_PCDATA";
+    } else if (alias) {
+	char buffer[MY_LIMIT];
+
+	sprintf(buffer, "%s_%d", result, alias + 1);
+	result = strdup(buffer);
+    }
+    return result;
+}
+
+static const char *EXT_name(HTTag * tag)
+{
+    const char *result = tag->name;
+
+    if (tag->alias) {
+	char buffer[MY_LIMIT];
+
+	sprintf(buffer, "%s%c", result, alias_codes[tag->alias - 1]);
+	result = strdup(buffer);
+    }
+    return result;
+}
+
+typedef struct {
+    const char *name;
+    const attr *attrs;
+    int count;
+    int which;
+} AttrInfo;
+
+static int compare_attr_types(const void *a, const void *b)
+{
+    const AttrType *p = (const AttrType *) a;
+    const AttrType *q = (const AttrType *) b;
+    int result = 0;
+
+    /* keep lowercase AttrType lists before uppercase, since latter are derived */
+    if (isupper(p->name[0]) ^ isupper(q->name[0])) {
+	if (isupper(p->name[0])) {
+	    result = 1;
+	} else {
+	    result = -1;
+	}
+    } else {
+	result = strcmp(p->name, q->name);
+    }
+    return result;
+}
+
+static int len_AttrTypes(const AttrType * data)
+{
+    int result = 0;
+
+    for (result = 0; data[result].name != 0; ++result) {
+	;
+    }
+    return result;
+}
+
+static AttrType *sorted_AttrTypes(const AttrType * source)
+{
+    AttrType *result = 0;
+    unsigned number = len_AttrTypes(source);
+
+    if (number != 0) {
+	result = typecallocn(AttrType, number + 1);
+	if (result != 0) {
+	    MemCpy(result, source, number * sizeof(*result));
+	    qsort(result, number, sizeof(*result), compare_attr_types);
+	}
+    }
+
+    return result;
+}
+
+static int compare_attr(const void *a, const void *b)
+{
+    const AttrInfo *p = (const AttrInfo *) a;
+    const AttrInfo *q = (const AttrInfo *) b;
+
+    return strcmp(p->name, q->name);
+}
+
+static int len_AttrList(AttrList data)
+{
+    int result = 0;
+
+    for (result = 0; data[result].name != 0; ++result) {
+	;
+    }
+    return result;
+}
+
+static void sort_uniq_AttrList(attr * data)
+{
+    unsigned have = len_AttrList(data);
+    unsigned j, k;
+
+    qsort(data, have, sizeof(*data), compare_attr);
+    /*
+     * Eliminate duplicates
+     */
+    for (j = 0; j < have; ++j) {
+	for (k = j; data[k].name; ++k) {
+	    if (data[k + 1].name == 0)
+		break;
+	    if (strcmp(data[j].name, data[k + 1].name)) {
+		break;
+	    }
+	}
+	data[j] = data[k];
+    }
+    memset(data + j, 0, sizeof(data[0]));
+}
+
+static attr *copy_AttrList(AttrList data)
+{
+    unsigned need = len_AttrList(data);
+    unsigned n;
+
+    attr *result = (attr *) calloc(need + 1, sizeof(attr));
+
+    for (n = 0; n < need; ++n)
+	result[n] = data[n];
+    sort_uniq_AttrList(result);
+    return result;
+}
+
+static attr *merge_AttrLists(const AttrType * data)
+{
+    const AttrType *at;
+    attr *result = 0;
+    unsigned need = 1;
+    unsigned have = 0;
+    unsigned j;
+
+    for (at = data; at->name; ++at) {
+	need += len_AttrList(at->list);
+    }
+    result = (attr *) calloc(need + 1, sizeof(attr));
+    for (at = data; at->name; ++at) {
+	if (!strcmp(at->name, "events")) {
+	    ;			/* lynx does not use events */
+	} else {
+	    for (j = 0; at->list[j].name; ++j) {
+		result[have++] = at->list[j];
+	    }
+	}
+    }
+    sort_uniq_AttrList(result);
+    return result;
+}
+
+static int clean_AttrList(attr * target, AttrList source)
+{
+    int result = 0;
+    int j, k;
+
+    for (j = 0; target[j].name != 0; ++j) {
+	for (k = 0; source[k].name != 0; ++k) {
+	    if (!strcmp(target[j].name, source[k].name)) {
+		k = j--;
+		for (;;) {
+		    target[k] = target[k + 1];
+		    if (target[k++].name == 0)
+			break;
+		}
+		++result;
+		break;
+	    }
+	}
+    }
+    return result;
+}
+
+/*
+ * Actually COUNT the number of attributes, to make it possible to edit a
+ * attribute-table in src0_HTMLDTD.h and have all of the files updated by
+ * just doing a "make sources".
+ */
+static int AttrCount(HTTag * tag)
+{
+    return len_AttrList(tag->attributes);
+}
+
+static AttrInfo *sorted_attrs(const SGML_dtd * dtd, unsigned *countp)
+{
+    int j;
+
+    AttrInfo *data = (AttrInfo *) calloc(dtd->number_of_tags, sizeof(AttrInfo));
+    unsigned count = 0;
+
+    /* get the attribute-data */
+    for (j = 0; j < dtd->number_of_tags; ++j) {
+	if (first_attrs(dtd, j)) {
+	    data[count].name = NameOfAttrs(dtd, j);
+	    data[count].attrs = dtd->tags[j].attributes;
+	    data[count].count = AttrCount(&(dtd->tags[j]));
+	    data[count].which = j;
+	    ++count;
+	}
+    }
+    /* sort the data by the name of their associated tag */
+    qsort(data, count, sizeof(*data), compare_attr);
+    *countp = count;
+    return data;
+}
+
+static void dump_src_HTTag_Defines(FILE *output, const SGML_dtd * dtd, int which)
+{
+    HTTag *tag = &(dtd->tags[which]);
+
+#define myFMT "0x%05X"
+    fprintf(output,
+	    "#define T_%-13s "
+	    myFMT "," myFMT "," myFMT "," myFMT "," myFMT "," myFMT
+	    "," myFMT "\n",
+	    DEF_name(dtd, which, tag->alias),
+	    tag->tagclass,
+	    tag->contains,
+	    tag->icontains,
+	    tag->contained,
+	    tag->icontained,
+	    tag->canclose,
+	    tag->flags);
+}
+
+static void dump_AttrItem(FILE *output, const attr * data)
+{
+    char buffer[BUFSIZ];
+    char pretty = 'N';
+
+    sprintf(buffer, "\"%s\"", data->name);
+#ifdef USE_PRETTYSRC
+    switch (data->type) {
+    case HTMLA_NORMAL:
+	pretty = 'N';
+	break;
+    case HTMLA_ANAME:
+	pretty = 'i';
+	break;
+    case HTMLA_HREF:
+	pretty = 'h';
+	break;
+    case HTMLA_CLASS:
+	pretty = 'c';
+	break;
+    case HTMLA_AUXCLASS:
+	pretty = 'x';
+	break;
+    }
+#endif
+    fprintf(output, "\t{ %-15s T(%c) },\n", buffer, pretty);
+}
+
+static void dump_AttrItem0(FILE *output)
+{
+    fprintf(output, "\t{ 0               T(N) }\t/* Terminate list */\n");
+}
+
+static void dump_src_AttrType(FILE *output, const char *name, AttrList data, const char **from)
+{
+    int n;
+
+    fprintf(output, "static const attr %s_attr_list[] = {\n", name);
+    if (data != 0) {
+	for (n = 0; data[n].name != 0; ++n) {
+	    dump_AttrItem(output, data + n);
+	}
+    }
+    fprintf(output, "\t{ 0               T(N) }	/* Terminate list */\n");
+    fprintf(output, "};\n");
+    NOTE("");
+    fprintf(output, "static const AttrType %s_attr_type[] = {\n", name);
+    if (from != 0) {
+	while (*from != 0) {
+	    fprintf(output, "\t{ ATTR_TYPE(%s) },\n", *from);
+	    ++from;
+	}
+    } else {
+	fprintf(output, "\t{ ATTR_TYPE(%s) },\n", name);
+    }
+    fprintf(output, "\t{ 0, 0 },\n");
+    fprintf(output, "};\n");
+    NOTE("");
+}
+
+static void dump_src_HTTag_Attrs(FILE *output, const SGML_dtd * dtd, int which)
+{
+    HTTag *tag = &(dtd->tags[which]);
+    attr *list = merge_AttrLists(tag->attr_types);
+    char buffer[BUFSIZ];
+    int n;
+    int limit = len_AttrList(list);
+
+    sprintf(buffer, "static const attr %s_attr[] = {", NameOfAttrs(dtd, which));
+    fprintf(output,
+	    "%-40s/* %s attributes */\n", buffer, tag->name);
+    for (n = 0; n < limit; ++n) {
+	dump_AttrItem(output, list + n);
+    }
+    dump_AttrItem0(output);
+    fprintf(output, "};\n");
+    NOTE("");
+    free(list);
+}
+
+static void dump_src_HTTag(FILE *output, const SGML_dtd * dtd, int which)
+{
+    HTTag *tag = &(dtd->tags[which]);
+    char *P_macro = "P";
+
+#ifdef USE_JUSTIFY_ELTS
+    if (!tag->can_justify)
+	P_macro = "P0";
+#endif
+    PrintF(output, 19, " { %s(%s),", P_macro, tag->name);
+    PrintF(output, 24, "ATTR_DATA(%s), ", NameOfAttrs(dtd, which));
+    PrintF(output, 14, "%s,", SGMLContent2s(tag->contents));
+    fprintf(output, "T_%s", DEF_name(dtd, which, tag->alias));
+    fprintf(output, ", %d", tag->alias);
+    fprintf(output, ", %d", tag->aliases);
+    fprintf(output, "},\n");
+}
+
+static void dump_source(FILE *output, const SGML_dtd * dtd, int dtd_version)
+{
+    static AttrType generic_types[] =
+    {
+	ATTR_TYPE(core),
+	ATTR_TYPE(i18n),
+	ATTR_TYPE(events),
+	ATTR_TYPE(align),
+	ATTR_TYPE(cellalign),
+	ATTR_TYPE(bgcolor),
+	{0, 0}
+    };
+    AttrType *gt;
+    TagAlias aliases;
+
+    const char *marker = "src_HTMLDTD_H";
+    int j;
+    int inalias;
+
+    unsigned count = 0;
+    AttrInfo *data = sorted_attrs(dtd, &count);
+
+    fprintf(output, "/* %cLynxId%c */\n", '$', '$');
+    fprintf(output, "#ifndef %s%d\n", marker, dtd_version);
+    fprintf(output, "#define %s%d 1\n\n", marker, dtd_version);
+
+    /*
+     * If we ifdef this for once, and make the table names distinct, we can
+     * #include the strict- and tagsoup-output directly in HTMLDTD.c
+     */
+    NOTE("#ifndef once_HTMLDTD");
+    NOTE("#define once_HTMLDTD 1");
+    NOTE("");
+
+    /* construct TagClass-define's */
+    for (j = 0; j <= dtd->number_of_tags; ++j) {
+	dump_src_HTTag_Defines(output, dtd, j);
+    }
+    NOTE("#define T__UNREC_	0x00000,0x00000,0x00000,0x00000,0x00000,0x00000,0x00000");
+
+    /* construct attribute-tables */
+    NOTE("#ifdef USE_PRETTYSRC");
+    NOTE("# define N HTMLA_NORMAL");
+    NOTE("# define i HTMLA_ANAME");
+    NOTE("# define h HTMLA_HREF");
+    NOTE("# define c HTMLA_CLASS");
+    NOTE("# define x HTMLA_AUXCLASS");
+    NOTE("# define T(t) , t");
+    NOTE("#else");
+    NOTE("# define T(t)			/*nothing */");
+    NOTE("#endif");
+    NOTE("/* *INDENT-OFF* */");
+    NOTE("");
+    NOTE("#define ATTR_TYPE(name) #name, name##_attr_list");
+    NOTE("");
+    NOTE("/* generic attributes, used in different tags */");
+    for (gt = generic_types; gt->name != 0; ++gt) {
+	dump_src_AttrType(output, gt->name, gt->list, 0);
+    }
+    NOTE("");
+    NOTE("/* tables defining attributes per-tag in terms of generic attributes (editable) */");
+    for (j = 0; j < (int) count; ++j) {
+	int which = data[j].which;
+
+	if (first_attrs(dtd, which)) {
+	    HTTag *tag = &(dtd->tags[which]);
+	    const AttrType *types = tag->attr_types;
+	    const char *name = NameOfAttrs(dtd, which);
+	    attr *list = 0;
+	    const char *from_attr[10];
+	    int from_size = 0;
+
+	    while (types->name != 0) {
+		from_attr[from_size++] = types->name;
+		if (!strcmp(types->name, name)) {
+		    list = copy_AttrList(types->list);
+		    for (gt = generic_types; gt->name != 0; ++gt) {
+			if (clean_AttrList(list, gt->list)) {
+			    int k;
+			    int found = 0;
+
+			    for (k = 0; k < from_size; ++k) {
+				if (!strcmp(from_attr[k], gt->name)) {
+				    found = 1;
+				    break;
+				}
+			    }
+			    if (!found)
+				from_attr[from_size++] = gt->name;
+			    break;
+			}
+		    }
+		}
+		++types;
+	    }
+	    from_attr[from_size] = 0;
+
+	    if (list != 0) {
+		/* FIXME check if each remaining attribute is defined in XXX */
+
+		dump_src_AttrType(output, name, list, from_attr);
+		free(list);
+	    }
+	}
+    }
+    NOTE("");
+    NOTE("/* attribute lists for the runtime (generated by dtd_util) */");
+    for (j = 0; j < (int) count; ++j) {
+	dump_src_HTTag_Attrs(output, dtd, data[j].which);
+    }
+    NOTE("/* *INDENT-ON* */");
+    NOTE("");
+    NOTE("/* justification-flags */");
+    NOTE("#undef N");
+    NOTE("#undef i");
+    NOTE("#undef h");
+    NOTE("#undef c");
+    NOTE("#undef x");
+    NOTE("");
+    NOTE("#undef T");
+    NOTE("");
+    NOTE("/* tag-names */");
+    /* these may be needed as parameters to macros */
+    for (j = 0; j <= dtd->number_of_tags; ++j) {
+	fprintf(output, "#undef %s\n", DEF_name(dtd, j, 0));
+    }
+    NOTE("");
+    NOTE("/* these definitions are used in the tags-tables */");
+    NOTE("#undef P");
+    NOTE("#undef P_");
+    NOTE("#ifdef USE_COLOR_STYLE");
+    NOTE("#define P_(x) #x, (sizeof #x) -1");
+    NOTE("#define NULL_HTTag_ NULL, 0");
+    NOTE("#else");
+    NOTE("#define P_(x) #x");
+    NOTE("#define NULL_HTTag_ NULL");
+    NOTE("#endif");
+    NOTE("");
+    NOTE("#ifdef USE_JUSTIFY_ELTS");
+    NOTE("#define P(x) P_(x), 1");
+    NOTE("#define P0(x) P_(x), 0");
+    NOTE("#define NULL_HTTag NULL_HTTag_,0");
+    NOTE("#else");
+    NOTE("#define P(x) P_(x)");
+    NOTE("#define P0(x) P_(x)");
+    NOTE("#define NULL_HTTag NULL_HTTag_");
+    NOTE("#endif");
+    NOTE("");
+    NOTE("#define ATTR_DATA(name) name##_attr, HTML_##name##_ATTRIBUTES, name##_attr_type");
+    NOTE("");
+    NOTE("#endif /* once_HTMLDTD */");
+    NOTE("/* *INDENT-OFF* */");
+
+    /* construct the tags table */
+    fprintf(output,
+	    "static const HTTag tags_table%d[HTML_ALL_ELEMENTS] = {\n",
+	    dtd_version);
+    aliases = 0;
+    inalias = -1;
+    for (j = dtd->number_of_tags - 1; j >= 0; --j) {
+	dtd->tags[j].aliases = aliases;
+	if (aliases != 0) {
+	    if ((inalias - aliases) >= j) {
+		aliases = 0;
+		inalias = -1;
+	    }
+	} else if ((aliases = dtd->tags[j].alias) != 0) {
+	    inalias = j;
+	    dtd->tags[j].aliases = aliases;
+	}
+    }
+    for (j = 0; j <= dtd->number_of_tags; ++j) {
+	if (j == dtd->number_of_tags) {
+	    NOTE("/* additional (alternative variants), not counted in HTML_ELEMENTS: */");
+	    NOTE("/* This one will be used as a temporary substitute within the parser when");
+	    NOTE("   it has been signalled to parse OBJECT content as MIXED. - kw */");
+	}
+	dump_src_HTTag(output, dtd, j);
+    }
+    fprintf(output, "};\n");
+
+    NOTE("/* *INDENT-ON* */");
+    NOTE("");
+    fprintf(output, "#endif /* %s%d */\n", marker, dtd_version);
+
+    free(data);
+}
+
+static void dump_hdr_attr(FILE *output, AttrInfo * data)
+{
+    int j;
+    char buffer[BUFSIZ];
+
+    for (j = 0; j < data->count; ++j) {
+	PrintF(output, 33, "#define HTML_%s_%s",
+	       data->name,
+	       no_dashes(buffer, data->attrs[j].name));
+	fprintf(output, "%2d\n", j);
+    }
+    PrintF(output, 33, "#define HTML_%s_ATTRIBUTES", data->name);
+    fprintf(output, "%2d\n", data->count);
+    fprintf(output, "\n");
+}
+
+static void dump_header(FILE *output, const SGML_dtd * dtd)
+{
+    const char *marker = "hdr_HTMLDTD_H";
+    int j;
+
+    unsigned count = 0;
+    AttrInfo *data = sorted_attrs(dtd, &count);
+
+    fprintf(output, "/* %cLynxId%c */\n", '$', '$');
+    fprintf(output, "#ifndef %s\n", marker);
+    fprintf(output, "#define %s 1\n\n", marker);
+
+    NOTE("#ifdef __cplusplus");
+    NOTE("extern \"C\" {");
+    NOTE("#endif");
+
+    NOTE("/*");
+    NOTE("");
+    NOTE("   Element Numbers");
+    NOTE("");
+    NOTE("   Must Match all tables by element!");
+    NOTE("   These include tables in HTMLDTD.c");
+    NOTE("   and code in HTML.c.");
+    NOTE("");
+    NOTE(" */");
+
+    fprintf(output, "    typedef enum {\n");
+    for (j = 0; j < dtd->number_of_tags; ++j) {
+	if (dtd->tags[j].alias) {
+	    fprintf(output, "\tHTML_%s_%d,\n", dtd->tags[j].name,
+		    dtd->tags[j].alias + 1);
+	} else {
+	    fprintf(output, "\tHTML_%s,\n", dtd->tags[j].name);
+	}
+    }
+    NOTE("\tHTML_ALT_OBJECT");
+    NOTE("    } HTMLElement;\n");
+    NOTE("/* Notes: HTML.c uses a different extension of the");
+    NOTE("          HTML_ELEMENTS space privately, see");
+    NOTE("          HTNestedList.h.");
+    NOTE("");
+    NOTE("   Do NOT replace HTML_ELEMENTS with");
+    NOTE("   TABLESIZE(mumble_dtd.tags).");
+    NOTE("");
+    NOTE("   Keep the following defines in synch with");
+    NOTE("   the above enum!");
+    NOTE(" */");
+    NOTE("");
+    NOTE("/* # of elements generally visible to Lynx code */");
+    fprintf(output, "#define HTML_ELEMENTS %d\n", dtd->number_of_tags);
+    NOTE("");
+    NOTE("/* # of elements visible to SGML parser */");
+    fprintf(output, "#define HTML_ALL_ELEMENTS %d\n", dtd->number_of_tags + 1);
+    NOTE("");
+    NOTE("/*");
+    NOTE("");
+    NOTE("   Attribute numbers");
+    NOTE("");
+    NOTE("   Identifier is HTML_<element>_<attribute>.");
+    NOTE("   These must match the tables in HTML.c!");
+    NOTE("");
+    NOTE(" */");
+
+    /* output the sorted list */
+    for (j = 0; j < (int) count; ++j) {
+	dump_hdr_attr(output, data + j);
+    }
+    free(data);
+
+    NOTE("#ifdef __cplusplus");
+    NOTE("}");
+    NOTE("#endif");
+
+    fprintf(output, "#endif\t\t\t\t/* %s */\n", marker);
+}
+
+static void dump_flat_attrs(FILE *output,
+			    const attr * attributes,
+			    int number_of_attributes)
+{
+    int n;
+
+    fprintf(output, "\t\t" FMT_NUM_ATTRS "\n", number_of_attributes);
+    for (n = 0; n < number_of_attributes; ++n) {
+	fprintf(output, "\t\t\t" FMT_ONE_ATTR "\n", n,
+#ifdef USE_PRETTYSRC
+		attributes[n].type,
+#else
+		0,		/* need placeholder for source-compat */
+#endif
+		attributes[n].name
+	    );
+    }
+}
+
+static void dump_flat_attr_types(FILE *output, const AttrType * attr_types)
+{
+    const AttrType *p = sorted_AttrTypes(attr_types);
+    int number = len_AttrTypes(attr_types);
+
+    fprintf(output, "\t\t" FMT_NUM_ATTR_TYPES "\n", number);
+
+    if (p != 0) {
+	while (p->name != 0) {
+	    fprintf(output, "\t\t\t%s\n", p->name);
+	    ++p;
+	}
+    }
+}
+
+static void dump_flat_SGMLContent(FILE *output, const char *name, SGMLContent contents)
+{
+    fprintf(output, "\t\t%s: %s\n", name, SGMLContent2s(contents));
+}
+
+#define DUMP(name) \
+	if (theClass & Tgc_##name) {\
+	    fprintf(output, " " #name); \
+	    theClass &= ~(Tgc_##name); \
+	}
+
+static void dump_flat_TagClass(FILE *output, const char *name, TagClass theClass)
+{
+    fprintf(output, "\t\t%s:", name);
+    DUMP(FONTlike);
+    DUMP(EMlike);
+    DUMP(MATHlike);
+    DUMP(Alike);
+    DUMP(formula);
+    DUMP(TRlike);
+    DUMP(SELECTlike);
+    DUMP(FORMlike);
+    DUMP(Plike);
+    DUMP(DIVlike);
+    DUMP(LIlike);
+    DUMP(ULlike);
+    DUMP(BRlike);
+    DUMP(APPLETlike);
+    DUMP(HRlike);
+    DUMP(MAPlike);
+    DUMP(outer);
+    DUMP(BODYlike);
+    DUMP(HEADstuff);
+    DUMP(same);
+    DUMP(DELlike);
+    if (theClass)
+	fprintf(output, " OOPS:%#x", theClass);
+    fprintf(output, "\n");
+}
+
+#undef DUMP
+
+#define DUMP(name) \
+	if (theFlags & Tgf_##name) {\
+	    fprintf(output, " " #name); \
+	    theFlags &= ~(Tgf_##name); \
+	}
+
+static void dump_flat_TagFlags(FILE *output, const char *name, TagFlags theFlags)
+{
+    fprintf(output, "\t\t%s:", name);
+    DUMP(endO);
+    DUMP(startO);
+    DUMP(mafse);
+    DUMP(strict);
+    DUMP(nreie);
+    DUMP(frecyc);
+    DUMP(nolyspcl);
+    if (theFlags)
+	fprintf(output, " OOPS:%#x", theFlags);
+    fprintf(output, "\n");
+}
+
+#undef DUMP
+
+static void dump_flat_HTTag(FILE *output, unsigned n, HTTag * tag)
+{
+    fprintf(output, "\t%u:%s\n", n, EXT_name(tag));
+#ifdef USE_JUSTIFY_ELTS
+    fprintf(output, "\t\t%s\n", tag->can_justify ? "justify" : "nojustify");
+#endif
+    dump_flat_attrs(output, tag->attributes, AttrCount(tag));
+    dump_flat_attr_types(output, tag->attr_types);
+    dump_flat_SGMLContent(output, "contents", tag->contents);
+    dump_flat_TagClass(output, "tagclass", tag->tagclass);
+    dump_flat_TagClass(output, "contains", tag->contains);
+    dump_flat_TagClass(output, "icontains", tag->icontains);
+    dump_flat_TagClass(output, "contained", tag->contained);
+    dump_flat_TagClass(output, "icontained", tag->icontained);
+    dump_flat_TagClass(output, "canclose", tag->canclose);
+    dump_flat_TagFlags(output, "flags", tag->flags);
+}
+
+static int count_attr_types(AttrType * attr_types, HTTag * tag)
+{
+    int count = 0;
+    const AttrType *p;
+    AttrType *q;
+
+    if ((p = tag->attr_types) != 0) {
+	while (p->name != 0) {
+	    if ((q = attr_types) != 0) {
+		while (q->name != 0) {
+		    if (!strcmp(q->name, p->name)) {
+			--count;
+			break;
+		    }
+		    ++q;
+		}
+		*q = *p;
+	    }
+	    ++count;
+	    ++p;
+	}
+    }
+    return count;
+}
+
+static void dump_flatfile(FILE *output, const SGML_dtd * dtd)
+{
+    AttrType *attr_types = 0;
+    int pass;
+    unsigned count = 0;
+    unsigned n;
+
+    /* merge all of the attr_types data */
+    for (pass = 0; pass < 2; ++pass) {
+	for (n = 0; (int) n < dtd->number_of_tags; ++n) {
+	    count += count_attr_types(attr_types, &(dtd->tags[n]));
+	}
+	if (pass == 0) {
+	    attr_types = typecallocn(AttrType, count + 1);
+	    count = 0;
+	} else {
+	    count = len_AttrTypes(attr_types);
+	    qsort(attr_types, count, sizeof(*attr_types), compare_attr_types);
+	    fprintf(output, FMT_NUM_ATTR_TYPES "\n", count);
+	    for (n = 0; n < count; ++n) {
+		fprintf(output, "\t%d:%s\n", n, attr_types[n].name);
+		dump_flat_attrs(output, attr_types[n].list,
+				len_AttrList(attr_types[n].list));
+	    }
+	}
+    }
+
+    fprintf(output, "%d tags\n", dtd->number_of_tags);
+    for (n = 0; (int) n < dtd->number_of_tags; ++n) {
+	dump_flat_HTTag(output, n, &(dtd->tags[n]));
+    }
+#if 0
+    fprintf(output, "%d entities\n", dtd->number_of_entities);
+    for (n = 0; n < dtd->number_of_entities; ++n) {
+    }
+#endif
+}
+
+#define LOAD(name) \
+	if (!strcmp(data, #name)) {\
+	    *theClass |= Tgc_##name; \
+	    continue; \
+	}
+
+static int load_flat_TagClass(FILE *input, const char *name, TagClass * theClass)
+{
+    char prefix[80];
+    char *next = get_line(input);
+    char *data;
+    int result = 0;
+
+    *theClass = 0;
+    if (next != 0) {
+	sprintf(prefix, "\t\t%s:", name);
+	data = strtok(next, "\n ");
+
+	if (data != 0 && !strcmp(data, prefix)) {
+	    result = 1;
+
+	    while ((data = strtok(NULL, "\n ")) != 0) {
+
+		LOAD(FONTlike);
+		LOAD(EMlike);
+		LOAD(MATHlike);
+		LOAD(Alike);
+		LOAD(formula);
+		LOAD(TRlike);
+		LOAD(SELECTlike);
+		LOAD(FORMlike);
+		LOAD(Plike);
+		LOAD(DIVlike);
+		LOAD(LIlike);
+		LOAD(ULlike);
+		LOAD(BRlike);
+		LOAD(APPLETlike);
+		LOAD(HRlike);
+		LOAD(MAPlike);
+		LOAD(outer);
+		LOAD(BODYlike);
+		LOAD(HEADstuff);
+		LOAD(same);
+		LOAD(DELlike);
+
+		warning("Unexpected TagClass '%s'", data);
+		result = 0;
+		break;
+	    }
+	} else if (data) {
+	    warning("load_flat_TagClass: '%s' vs '%s'", data, prefix);
+	}
+	free(next);
+    } else {
+	warning("Did not find contents");
+    }
+    return result;
+}
+
+#undef LOAD
+
+#define LOAD(name) \
+	if (!strcmp(data, #name)) {\
+	    *flags |= Tgf_##name; \
+	    continue; \
+	}
+
+static int load_flat_TagFlags(FILE *input, const char *name, TagFlags * flags)
+{
+    char prefix[80];
+    char *next = get_line(input);
+    char *data;
+    int result = 0;
+
+    *flags = 0;
+    if (next != 0) {
+	sprintf(prefix, "\t\t%s:", name);
+	data = strtok(next, "\n ");
+
+	if (data != 0 && !strcmp(data, prefix)) {
+	    result = 1;
+
+	    while ((data = strtok(NULL, "\n ")) != 0) {
+
+		LOAD(endO);
+		LOAD(startO);
+		LOAD(mafse);
+		LOAD(strict);
+		LOAD(nreie);
+		LOAD(frecyc);
+		LOAD(nolyspcl);
+
+		warning("Unexpected TagFlag '%s'", data);
+		result = 0;
+		break;
+	    }
+	} else if (data) {
+	    warning("load_flat_TagFlags: '%s' vs '%s'", data, prefix);
+	}
+	free(next);
+    }
+    return result;
+}
+
+#undef LOAD
+
+static int load_flat_AttrList(FILE *input, AttrList * attrs, int *length)
+{
+    attr *attributes;
+    int j, jcmp, code;
+    int result = 1;
+    char name[MY_LIMIT];
+    char *next;
+    char trail[MY_LIMIT];
+
+#ifdef USE_PRETTYSRC
+    int atype;
+#endif
+
+    next = get_line(input);
+    if (sscanf(next, FMT_NUM_ATTRS FMT_WS, length, trail) == 2
+	&& *length > 0
+	&& (attributes = typecallocn(attr, *length + 1)) != 0) {
+	*attrs = attributes;
+	for (j = 0; j < *length; ++j) {
+	    next = get_line(input);
+	    code = sscanf(next, FMT_ONE_ATTR FMT_WS, &jcmp, &atype, name, trail);
+	    if (code == NUM_ONE_ATTR) {
+		if (j != jcmp)
+		    warning("resequence %s from %d to %d", name, jcmp, j);
+		attributes[j].name = strdup(name);
+#ifdef USE_PRETTYSRC
+		attributes[j].type = atype;
+#endif
+	    } else {
+		warning("Did not find attributes");
+		result = 0;
+		break;
+	    }
+	}
+	if (*length > 1 && result)
+	    qsort(attributes, *length, sizeof(attributes[0]), compare_attr);
+    } else {
+	warning("expected attribute count:\n%s", next);
+    }
+    return result;
+}
+
+/* find the given attribute in the list of attr_types */
+static int find_attribute(const char *attribute, const AttrType * attr_types)
+{
+    int j, k;
+    int found = -1;
+
+    for (j = 0; attr_types[j].name; ++j) {
+	AttrList list = attr_types[j].list;
+
+	for (k = 0; list[k].name; ++k) {
+	    if (!strcmp(attribute, list[k].name)) {
+		if (found >= 0)
+		    warning("attribute %s is in attr_types %s and %s",
+			    attribute,
+			    attr_types[found].name,
+			    attr_types[j].name);
+		found = j;
+	    }
+	}
+    }
+    return (found >= 0);
+}
+
+static int load_flat_HTTag(FILE *input, HTTag * tag, AttrType * allTypes)
+{
+    int result = 0;
+    unsigned ncmp = 0;
+    char name[MY_LIMIT];
+    char trail[MY_LIMIT];
+    char *next;
+    int code;
+    int j;
+
+    next = get_line(input);
+    code = sscanf(next, "%d:%s" FMT_WS, &ncmp, name, trail);
+    if (code == 3) {
+	result = 1;
+	tag->alias = 0;
+	tag->aliases = 0;
+	for (j = 0; name[j] != '\0'; ++j) {
+	    int ch = UCH(name[j]);
+
+	    if (!isalnum(ch)) {
+		if (strchr(alias_codes, ch) != NULL) {
+		    tag->alias = (ch - '!') + 1;
+		    name[j] = '\0';
+		} else {
+		    result = 0;
+		}
+		break;
+	    }
+	}
+	tag->name = strdup(name);
+#ifdef USE_COLOR_STYLE
+	tag->name_len = strlen(tag->name);
+#endif
+#ifdef USE_JUSTIFY_ELTS
+	next = get_line(input);
+	if (sscanf(next, "%s" FMT_WS, name, trail) == 2) {
+	    tag->can_justify = !strcmp(name, "justify");
+	} else {
+	    warning("Did not find can_justify");
+	    result = 0;
+	}
+#endif
+	if (result) {
+	    result = load_flat_AttrList(input, &(tag->attributes), &(tag->number_of_attributes));
+	}
+	if (result) {
+	    AttrType *myTypes;
+	    int k, count;
+
+	    if ((count = read_num_attr_types(input)) > 0
+		&& (myTypes = typecallocn(AttrType, count + 1)) != 0) {
+		tag->attr_types = myTypes;
+		for (k = 0; k < count; ++k) {
+		    next = get_line(input);
+		    if (next != 0
+			&& sscanf(next, "%s" FMT_WS, name, trail)) {
+			int found = -1;
+
+			for (j = 0; allTypes[j].name != 0; ++j) {
+			    if (!strcmp(allTypes[j].name, name)) {
+				myTypes[k].name = strdup(name);
+				myTypes[k].list = allTypes[j].list;
+				found = k;
+				break;
+			    }
+			}
+			if (found < 0) {
+			    warning("not found in attr_types: %s", name);
+			    continue;
+			}
+		    } else {
+			result = 0;
+			break;
+		    }
+		}
+		if (result) {
+		    if (count > 1)
+			qsort(myTypes,
+			      count,
+			      sizeof(myTypes[0]),
+			      compare_attr_types);
+		    for (k = 0; k < tag->number_of_attributes; ++k) {
+			if (!find_attribute(tag->attributes[k].name, tag->attr_types)) {
+			    warning("%s attribute %s not found in attr_types",
+				    tag->name, tag->attributes[k].name);
+			}
+		    }
+		}
+	    }
+	}
+	if (result) {
+
+	    next = get_line(input);
+	    if (next != 0
+		&& sscanf(next, "\t\tcontents: %s" FMT_WS, name, trail)) {
+		tag->contents = s2SGMLContent(name);
+		free(next);
+	    } else {
+		warning("Did not find contents");
+		result = 0;
+	    }
+	}
+	if (result) {
+	    result = load_flat_TagClass(input, "tagclass", &(tag->tagclass));
+	}
+	if (result) {
+	    result = load_flat_TagClass(input, "contains", &(tag->contains));
+	}
+	if (result) {
+	    result = load_flat_TagClass(input, "icontains", &(tag->icontains));
+	}
+	if (result) {
+	    result = load_flat_TagClass(input, "contained", &(tag->contained));
+	}
+	if (result) {
+	    result = load_flat_TagClass(input, "icontained", &(tag->icontained));
+	}
+	if (result) {
+	    result = load_flat_TagClass(input, "canclose", &(tag->canclose));
+	}
+	if (result) {
+	    result = load_flat_TagFlags(input, "flags", &(tag->flags));
+	}
+    } else {
+	warning("load_flat_HTTag error");
+    }
+    return result;
+}
+
+static int load_flat_AttrType(FILE *input, AttrType * types, size_t ncmp)
+{
+    int result = 0;
+    int ntst;
+    char name[MY_LIMIT];
+    char trail[MY_LIMIT];
+    char *next;
+
+    next = get_line(input);
+    if (sscanf(next, "%d:%s" FMT_WS, &ntst, name, trail) == 3
+	&& (ntst == (int) ncmp)) {
+	result = 1;
+	types->name = strdup(name);
+	if (!load_flat_AttrList(input, &(types->list), &ntst))
+	    result = 0;
+    } else {
+	warning("expected a tag:\n%s", next);
+    }
+    return result;
+}
+
+static int compare_tags(const void *a, const void *b)
+{
+    const HTTag *p = (const HTTag *) a;
+    const HTTag *q = (const HTTag *) b;
+    int result = 0;
+
+    if ((result = strcmp(p->name, q->name)) == 0) {
+	result = p->alias - q->alias;
+    }
+    return result;
+}
+
+static SGML_dtd *load_flatfile(FILE *input)
+{
+    AttrType *attr_types = 0;
+    SGML_dtd *result = 0;
+    char *next;
+    size_t n;
+    int number_of_attrs = 0;
+    int number_of_tags = 0;
+    HTTag *tag;
+    int code;
+    char trail[MY_LIMIT];
+
+    if ((number_of_attrs = read_num_attr_types(input)) <= 0) {
+	;
+    } else if ((attr_types = typecallocn(AttrType, number_of_attrs + 1)) == 0) {
+	failed("calloc attr_types");
+    }
+
+    for (n = 0; n < (size_t) number_of_attrs; ++n) {
+	if (!load_flat_AttrType(input, attr_types + n, n)) {
+	    break;
+	}
+    }
+
+    next = get_line(input);
+    code = sscanf(next, "%d tags" FMT_WS, &number_of_tags, trail);
+    if (code == 2) {
+	if ((result = typecalloc(SGML_dtd)) != 0
+	    && (result->tags = typecallocn(HTTag, number_of_tags + 2)) != 0) {
+	    for (n = 0; n < (size_t) number_of_tags; ++n) {
+		if (load_flat_HTTag(input, &(result->tags[n]), attr_types)) {
+		    result->number_of_tags = (n + 1);
+		} else {
+		    break;
+		}
+	    }
+	    tag = 0;
+	    for (n = 0; n < (size_t) number_of_tags; ++n) {
+		if (result->tags[n].name != 0
+		    && !strcmp(result->tags[n].name, "OBJECT")) {
+		    tag = result->tags + number_of_tags;
+		    *tag = result->tags[n];
+		    tag->contents = SGML_MIXED;
+		    tag->flags = Tgf_strict;
+		    break;
+		}
+	    }
+	    if (tag == 0) {
+		warning("Did not find OBJECT tag");
+		result = 0;
+	    } else {
+		qsort(result->tags, number_of_tags, sizeof(HTTag), compare_tags);
+	    }
+	}
+    } else {
+	warning("expected tag count:\n%s", next);
+    }
+    return result;
+}
+
+static void cross_check(FILE *output, const SGML_dtd * the_dtd, int level)
+{
+    int ft;
+
+    fprintf(output, "Cross-check HTML DTD:\n");
+    fprintf(output, "\n");
+    /* make a sorted list of tags */
+    /* for each tag in the list, find the classes it might contain */
+    for (ft = 0; ft < the_dtd->number_of_tags; ++ft) {
+	int xc;
+	HTTag *ftag = &(the_dtd->tags[ft]);
+
+	/* for each contained-class, check if it says it can be contained */
+	fprintf(output, "tag %s\n", EXT_name(ftag));
+	for (xc = 0; class_list[xc].name != 0; ++xc) {
+	    int rt;
+	    int direct;
+	    int passes = 2;
+
+	    /* most of the tags are (should be) symmetric */
+	    if (level <= 1) {
+		BOOL same = TRUE;
+
+		if ((ftag->contains & class_list[xc].tagclass)
+		    != (ftag->icontains & class_list[xc].tagclass)) {
+		    same = FALSE;
+		} else if ((ftag->contains & class_list[xc].tagclass) == 0) {
+		    continue;
+		} else if (0) {
+		    HTTag *rtag;
+
+		    for (rt = 0; rt < the_dtd->number_of_tags; ++rt) {
+			rtag = &(the_dtd->tags[rt]);
+			if (ftag == rtag)
+			    continue;
+			if ((ftag->contains & rtag->tagclass) == 0)
+			    continue;
+			if ((rtag->contained & ftag->tagclass)
+			    != (rtag->icontained & ftag->tagclass)) {
+			    same = FALSE;
+			    break;
+			}
+		    }
+		}
+		if (same)
+		    passes = 1;
+	    }
+
+	    for (direct = 0; direct < passes; ++direct) {
+		TagClass check = (direct ? ftag->contains : ftag->icontains);
+		BOOL first = TRUE;
+
+		if ((check &= class_list[xc].tagclass) == 0)
+		    continue;
+
+		for (rt = 0; rt < the_dtd->number_of_tags; ++rt) {
+		    HTTag *rtag = &(the_dtd->tags[rt]);
+		    TagClass check2 = (direct ? rtag->contained : rtag->icontained);
+
+		    if (rt == ft)
+			continue;
+		    if ((check & rtag->tagclass) == 0)
+			continue;
+		    if ((check2 & ftag->tagclass) == 0)
+			continue;
+		    if (first) {
+			if (passes == 2) {
+			    fprintf(output, "\t%s (%s)\n",
+				    class_list[xc].name,
+				    direct ? "direct" : "indirect");
+			} else {
+			    fprintf(output, "\t%s\n",
+				    class_list[xc].name);
+			}
+		    }
+		    fprintf(output, "%s%s",
+			    first ? "\t\t" : " ",
+			    EXT_name(rtag));
+		    first = FALSE;
+		}
+		if (first) {
+		    if (level > 1) {
+			if (passes == 2) {
+			    fprintf(output, "\t%s (%s)\n",
+				    class_list[xc].name,
+				    direct ? "direct" : "indirect");
+			} else {
+			    fprintf(output, "\t%s\n",
+				    class_list[xc].name);
+			}
+			fprintf(output, "\t\t(missing)\n");
+		    }
+		} else {
+		    fprintf(output, "\n");
+		}
+	    }
+	}
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    const SGML_dtd *the_dtd = &HTML_dtd;
+    int ch;
+    int dtd_version = 0;
+    int c_option = FALSE;
+    int h_option = FALSE;
+    int l_option = FALSE;
+    int x_option = 0;
+    FILE *input = stdin;
+    FILE *output = stdout;
+
+    input_filename = "<builtin>";
+    input_lineno = 0;
+
+    while ((ch = getopt(argc, argv, GETOPT)) != -1) {
+	switch (ch) {
+	case 'c':
+	    c_option = TRUE;
+	    break;
+	case 'h':
+	    h_option = TRUE;
+	    break;
+	case 'l':
+	    l_option = TRUE;
+	    input = fopen((input_filename = optarg), "r");
+	    if (input == 0)
+		failed(optarg);
+	    break;
+	case 'o':
+	    output = fopen(optarg, "w");
+	    if (output == 0)
+		failed(optarg);
+	    break;
+	case 't':
+	    dtd_version = 1;
+	    break;
+	case 's':
+	    dtd_version = 0;
+	    break;
+	case 'x':
+	    ++x_option;
+	    break;
+	default:
+	    usage();
+	}
+    }
+
+    HTSwitchDTD(dtd_version);
+    if (l_option)
+	the_dtd = load_flatfile(input);
+
+    if (the_dtd != 0) {
+	if (c_option)
+	    dump_source(output, the_dtd, dtd_version);
+	if (h_option)
+	    dump_header(output, the_dtd);
+	if (x_option)
+	    cross_check(output, the_dtd, x_option);
+	if (!c_option && !h_option && !x_option)
+	    dump_flatfile(output, the_dtd);
+    }
+
+    return EXIT_SUCCESS;
+}
diff --git a/WWW/Library/Implementation/hdr_HTMLDTD.h b/WWW/Library/Implementation/hdr_HTMLDTD.h
new file mode 100644
index 0000000..21888d0
--- /dev/null
+++ b/WWW/Library/Implementation/hdr_HTMLDTD.h
@@ -0,0 +1,1000 @@
+/* $LynxId: hdr_HTMLDTD.h,v 1.25 2022/09/28 22:26:32 tom Exp $ */
+#ifndef hdr_HTMLDTD_H
+#define hdr_HTMLDTD_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+
+   Element Numbers
+
+   Must Match all tables by element!
+   These include tables in HTMLDTD.c
+   and code in HTML.c.
+
+ */
+    typedef enum {
+	HTML_A,
+	HTML_ABBR,
+	HTML_ACRONYM,
+	HTML_ADDRESS,
+	HTML_APPLET,
+	HTML_AREA,
+	HTML_ARTICLE,
+	HTML_ASIDE,
+	HTML_AU,
+	HTML_AUTHOR,
+	HTML_B,
+	HTML_BANNER,
+	HTML_BASE,
+	HTML_BASEFONT,
+	HTML_BDO,
+	HTML_BGSOUND,
+	HTML_BIG,
+	HTML_BLINK,
+	HTML_BLOCKQUOTE,
+	HTML_BODY,
+	HTML_BODYTEXT,
+	HTML_BQ,
+	HTML_BR,
+	HTML_BUTTON,
+	HTML_CAPTION,
+	HTML_CENTER,
+	HTML_CITE,
+	HTML_CODE,
+	HTML_COL,
+	HTML_COLGROUP,
+	HTML_COMMENT,
+	HTML_CREDIT,
+	HTML_DD,
+	HTML_DEL,
+	HTML_DEL_2,
+	HTML_DFN,
+	HTML_DIR,
+	HTML_DIV,
+	HTML_DL,
+	HTML_DLC,
+	HTML_DT,
+	HTML_EM,
+	HTML_EMBED,
+	HTML_FIELDSET,
+	HTML_FIG,
+	HTML_FIGURE,
+	HTML_FN,
+	HTML_FONT,
+	HTML_FOOTER,
+	HTML_FORM,
+	HTML_FRAME,
+	HTML_FRAMESET,
+	HTML_H1,
+	HTML_H2,
+	HTML_H3,
+	HTML_H4,
+	HTML_H5,
+	HTML_H6,
+	HTML_HEAD,
+	HTML_HEADER,
+	HTML_HR,
+	HTML_HTML,
+	HTML_HY,
+	HTML_I,
+	HTML_IFRAME,
+	HTML_IMG,
+	HTML_INPUT,
+	HTML_INS,
+	HTML_INS_2,
+	HTML_ISINDEX,
+	HTML_KBD,
+	HTML_KEYGEN,
+	HTML_LABEL,
+	HTML_LEGEND,
+	HTML_LH,
+	HTML_LI,
+	HTML_LINK,
+	HTML_LISTING,
+	HTML_MAIN,
+	HTML_MAP,
+	HTML_MARQUEE,
+	HTML_MATH,
+	HTML_MENU,
+	HTML_META,
+	HTML_NAV,
+	HTML_NEXTID,
+	HTML_NOFRAMES,
+	HTML_NOTE,
+	HTML_OBJECT,
+	HTML_OL,
+	HTML_OPTION,
+	HTML_OVERLAY,
+	HTML_P,
+	HTML_PARAM,
+	HTML_PLAINTEXT,
+	HTML_PRE,
+	HTML_Q,
+	HTML_S,
+	HTML_SAMP,
+	HTML_SCRIPT,
+	HTML_SECTION,
+	HTML_SELECT,
+	HTML_SHY,
+	HTML_SMALL,
+	HTML_SPAN,
+	HTML_SPOT,
+	HTML_STRIKE,
+	HTML_STRONG,
+	HTML_STYLE,
+	HTML_SUB,
+	HTML_SUP,
+	HTML_TAB,
+	HTML_TABLE,
+	HTML_TBODY,
+	HTML_TD,
+	HTML_TEXTAREA,
+	HTML_TEXTFLOW,
+	HTML_TFOOT,
+	HTML_TH,
+	HTML_THEAD,
+	HTML_TITLE,
+	HTML_TR,
+	HTML_TT,
+	HTML_U,
+	HTML_UL,
+	HTML_VAR,
+	HTML_WBR,
+	HTML_XMP,
+	HTML_ALT_OBJECT
+    } HTMLElement;
+
+/* Notes: HTML.c uses a different extension of the
+          HTML_ELEMENTS space privately, see
+          HTNestedList.h.
+
+   Do NOT replace HTML_ELEMENTS with
+   TABLESIZE(mumble_dtd.tags).
+
+   Keep the following defines in synch with
+   the above enum!
+ */
+
+/* # of elements generally visible to Lynx code */
+#define HTML_ELEMENTS 128
+
+/* # of elements visible to SGML parser */
+#define HTML_ALL_ELEMENTS 129
+
+/*
+
+   Attribute numbers
+
+   Identifier is HTML_<element>_<attribute>.
+   These must match the tables in HTML.c!
+
+ */
+#define HTML_A_ACCESSKEY          0
+#define HTML_A_CHARSET            1
+#define HTML_A_CLASS              2
+#define HTML_A_CLEAR              3
+#define HTML_A_COORDS             4
+#define HTML_A_DIR                5
+#define HTML_A_HREF               6
+#define HTML_A_HREFLANG           7
+#define HTML_A_ID                 8
+#define HTML_A_ISMAP              9
+#define HTML_A_LANG              10
+#define HTML_A_MD                11
+#define HTML_A_NAME              12
+#define HTML_A_NOTAB             13
+#define HTML_A_ONBLUR            14
+#define HTML_A_ONFOCUS           15
+#define HTML_A_REL               16
+#define HTML_A_REV               17
+#define HTML_A_SHAPE             18
+#define HTML_A_STYLE             19
+#define HTML_A_TABINDEX          20
+#define HTML_A_TARGET            21
+#define HTML_A_TITLE             22
+#define HTML_A_TYPE              23
+#define HTML_A_URN               24
+#define HTML_A_ATTRIBUTES        25
+
+#define HTML_ADDRESS_CLASS        0
+#define HTML_ADDRESS_CLEAR        1
+#define HTML_ADDRESS_DIR          2
+#define HTML_ADDRESS_ID           3
+#define HTML_ADDRESS_LANG         4
+#define HTML_ADDRESS_NOWRAP       5
+#define HTML_ADDRESS_STYLE        6
+#define HTML_ADDRESS_TITLE        7
+#define HTML_ADDRESS_ATTRIBUTES   8
+
+#define HTML_APPLET_ALIGN         0
+#define HTML_APPLET_ALT           1
+#define HTML_APPLET_CLASS         2
+#define HTML_APPLET_CLEAR         3
+#define HTML_APPLET_CODE          4
+#define HTML_APPLET_CODEBASE      5
+#define HTML_APPLET_DIR           6
+#define HTML_APPLET_DOWNLOAD      7
+#define HTML_APPLET_HEIGHT        8
+#define HTML_APPLET_HSPACE        9
+#define HTML_APPLET_ID           10
+#define HTML_APPLET_LANG         11
+#define HTML_APPLET_NAME         12
+#define HTML_APPLET_STYLE        13
+#define HTML_APPLET_TITLE        14
+#define HTML_APPLET_VSPACE       15
+#define HTML_APPLET_WIDTH        16
+#define HTML_APPLET_ATTRIBUTES   17
+
+#define HTML_AREA_ACCESSKEY       0
+#define HTML_AREA_ALT             1
+#define HTML_AREA_CLASS           2
+#define HTML_AREA_CLEAR           3
+#define HTML_AREA_COORDS          4
+#define HTML_AREA_DIR             5
+#define HTML_AREA_HREF            6
+#define HTML_AREA_ID              7
+#define HTML_AREA_LANG            8
+#define HTML_AREA_NOHREF          9
+#define HTML_AREA_NOTAB          10
+#define HTML_AREA_ONBLUR         11
+#define HTML_AREA_ONFOCUS        12
+#define HTML_AREA_SHAPE          13
+#define HTML_AREA_STYLE          14
+#define HTML_AREA_TABINDEX       15
+#define HTML_AREA_TARGET         16
+#define HTML_AREA_TITLE          17
+#define HTML_AREA_ATTRIBUTES     18
+
+#define HTML_BASE_CLASS           0
+#define HTML_BASE_HREF            1
+#define HTML_BASE_ID              2
+#define HTML_BASE_STYLE           3
+#define HTML_BASE_TARGET          4
+#define HTML_BASE_TITLE           5
+#define HTML_BASE_ATTRIBUTES      6
+
+#define HTML_BGSOUND_CLASS        0
+#define HTML_BGSOUND_CLEAR        1
+#define HTML_BGSOUND_DIR          2
+#define HTML_BGSOUND_ID           3
+#define HTML_BGSOUND_LANG         4
+#define HTML_BGSOUND_LOOP         5
+#define HTML_BGSOUND_SRC          6
+#define HTML_BGSOUND_STYLE        7
+#define HTML_BGSOUND_TITLE        8
+#define HTML_BGSOUND_ATTRIBUTES   9
+
+#define HTML_BODY_ALINK           0
+#define HTML_BODY_BACKGROUND      1
+#define HTML_BODY_BGCOLOR         2
+#define HTML_BODY_CLASS           3
+#define HTML_BODY_CLEAR           4
+#define HTML_BODY_DIR             5
+#define HTML_BODY_ID              6
+#define HTML_BODY_LANG            7
+#define HTML_BODY_LINK            8
+#define HTML_BODY_ONLOAD          9
+#define HTML_BODY_ONUNLOAD       10
+#define HTML_BODY_STYLE          11
+#define HTML_BODY_TEXT           12
+#define HTML_BODY_TITLE          13
+#define HTML_BODY_VLINK          14
+#define HTML_BODY_ATTRIBUTES     15
+
+#define HTML_BODYTEXT_CLASS       0
+#define HTML_BODYTEXT_CLEAR       1
+#define HTML_BODYTEXT_DATA        2
+#define HTML_BODYTEXT_DIR         3
+#define HTML_BODYTEXT_ID          4
+#define HTML_BODYTEXT_LANG        5
+#define HTML_BODYTEXT_NAME        6
+#define HTML_BODYTEXT_OBJECT      7
+#define HTML_BODYTEXT_REF         8
+#define HTML_BODYTEXT_STYLE       9
+#define HTML_BODYTEXT_TITLE      10
+#define HTML_BODYTEXT_TYPE       11
+#define HTML_BODYTEXT_VALUE      12
+#define HTML_BODYTEXT_VALUETYPE  13
+#define HTML_BODYTEXT_ATTRIBUTES 14
+
+#define HTML_BQ_CITE              0
+#define HTML_BQ_CLASS             1
+#define HTML_BQ_CLEAR             2
+#define HTML_BQ_DIR               3
+#define HTML_BQ_ID                4
+#define HTML_BQ_LANG              5
+#define HTML_BQ_NOWRAP            6
+#define HTML_BQ_STYLE             7
+#define HTML_BQ_TITLE             8
+#define HTML_BQ_ATTRIBUTES        9
+
+#define HTML_BUTTON_ACCESSKEY     0
+#define HTML_BUTTON_CLASS         1
+#define HTML_BUTTON_CLEAR         2
+#define HTML_BUTTON_DIR           3
+#define HTML_BUTTON_DISABLED      4
+#define HTML_BUTTON_FORMACTION    5
+#define HTML_BUTTON_ID            6
+#define HTML_BUTTON_LANG          7
+#define HTML_BUTTON_NAME          8
+#define HTML_BUTTON_ONBLUR        9
+#define HTML_BUTTON_ONFOCUS      10
+#define HTML_BUTTON_READONLY     11
+#define HTML_BUTTON_STYLE        12
+#define HTML_BUTTON_TABINDEX     13
+#define HTML_BUTTON_TITLE        14
+#define HTML_BUTTON_TYPE         15
+#define HTML_BUTTON_VALUE        16
+#define HTML_BUTTON_ATTRIBUTES   17
+
+#define HTML_CAPTION_ACCESSKEY    0
+#define HTML_CAPTION_ALIGN        1
+#define HTML_CAPTION_CLASS        2
+#define HTML_CAPTION_CLEAR        3
+#define HTML_CAPTION_DIR          4
+#define HTML_CAPTION_ID           5
+#define HTML_CAPTION_LANG         6
+#define HTML_CAPTION_STYLE        7
+#define HTML_CAPTION_TITLE        8
+#define HTML_CAPTION_ATTRIBUTES   9
+
+#define HTML_COL_ALIGN            0
+#define HTML_COL_CHAR             1
+#define HTML_COL_CHAROFF          2
+#define HTML_COL_CLASS            3
+#define HTML_COL_CLEAR            4
+#define HTML_COL_DIR              5
+#define HTML_COL_ID               6
+#define HTML_COL_LANG             7
+#define HTML_COL_SPAN             8
+#define HTML_COL_STYLE            9
+#define HTML_COL_TITLE           10
+#define HTML_COL_VALIGN          11
+#define HTML_COL_WIDTH           12
+#define HTML_COL_ATTRIBUTES      13
+
+#define HTML_DEL_CITE             0
+#define HTML_DEL_CLASS            1
+#define HTML_DEL_DATETIME         2
+#define HTML_DEL_DIR              3
+#define HTML_DEL_ID               4
+#define HTML_DEL_LANG             5
+#define HTML_DEL_STYLE            6
+#define HTML_DEL_TITLE            7
+#define HTML_DEL_ATTRIBUTES       8
+
+#define HTML_DIV_ALIGN            0
+#define HTML_DIV_CLASS            1
+#define HTML_DIV_CLEAR            2
+#define HTML_DIV_DIR              3
+#define HTML_DIV_ID               4
+#define HTML_DIV_LANG             5
+#define HTML_DIV_STYLE            6
+#define HTML_DIV_TITLE            7
+#define HTML_DIV_ATTRIBUTES       8
+
+#define HTML_DL_CLASS             0
+#define HTML_DL_CLEAR             1
+#define HTML_DL_COMPACT           2
+#define HTML_DL_DIR               3
+#define HTML_DL_ID                4
+#define HTML_DL_LANG              5
+#define HTML_DL_STYLE             6
+#define HTML_DL_TITLE             7
+#define HTML_DL_ATTRIBUTES        8
+
+#define HTML_EMBED_ALIGN          0
+#define HTML_EMBED_ALT            1
+#define HTML_EMBED_BORDER         2
+#define HTML_EMBED_CLASS          3
+#define HTML_EMBED_CLEAR          4
+#define HTML_EMBED_DIR            5
+#define HTML_EMBED_HEIGHT         6
+#define HTML_EMBED_ID             7
+#define HTML_EMBED_IMAGEMAP       8
+#define HTML_EMBED_ISMAP          9
+#define HTML_EMBED_LANG          10
+#define HTML_EMBED_MD            11
+#define HTML_EMBED_NAME          12
+#define HTML_EMBED_NOFLOW        13
+#define HTML_EMBED_PARAMS        14
+#define HTML_EMBED_SRC           15
+#define HTML_EMBED_STYLE         16
+#define HTML_EMBED_TITLE         17
+#define HTML_EMBED_UNITS         18
+#define HTML_EMBED_USEMAP        19
+#define HTML_EMBED_WIDTH         20
+#define HTML_EMBED_ATTRIBUTES    21
+
+#define HTML_FIG_ALIGN            0
+#define HTML_FIG_BORDER           1
+#define HTML_FIG_CLASS            2
+#define HTML_FIG_CLEAR            3
+#define HTML_FIG_DIR              4
+#define HTML_FIG_HEIGHT           5
+#define HTML_FIG_ID               6
+#define HTML_FIG_IMAGEMAP         7
+#define HTML_FIG_ISOBJECT         8
+#define HTML_FIG_LANG             9
+#define HTML_FIG_MD              10
+#define HTML_FIG_NOFLOW          11
+#define HTML_FIG_SRC             12
+#define HTML_FIG_STYLE           13
+#define HTML_FIG_TITLE           14
+#define HTML_FIG_UNITS           15
+#define HTML_FIG_WIDTH           16
+#define HTML_FIG_ATTRIBUTES      17
+
+#define HTML_FONT_CLASS           0
+#define HTML_FONT_CLEAR           1
+#define HTML_FONT_COLOR           2
+#define HTML_FONT_DIR             3
+#define HTML_FONT_END             4
+#define HTML_FONT_FACE            5
+#define HTML_FONT_ID              6
+#define HTML_FONT_LANG            7
+#define HTML_FONT_SIZE            8
+#define HTML_FONT_STYLE           9
+#define HTML_FONT_TITLE          10
+#define HTML_FONT_ATTRIBUTES     11
+
+#define HTML_FORM_ACCEPT          0
+#define HTML_FORM_ACCEPT_CHARSET  1
+#define HTML_FORM_ACTION          2
+#define HTML_FORM_CLASS           3
+#define HTML_FORM_CLEAR           4
+#define HTML_FORM_DIR             5
+#define HTML_FORM_ENCTYPE         6
+#define HTML_FORM_ID              7
+#define HTML_FORM_LANG            8
+#define HTML_FORM_METHOD          9
+#define HTML_FORM_ONRESET        10
+#define HTML_FORM_ONSUBMIT       11
+#define HTML_FORM_SCRIPT         12
+#define HTML_FORM_STYLE          13
+#define HTML_FORM_SUBJECT        14
+#define HTML_FORM_TARGET         15
+#define HTML_FORM_TITLE          16
+#define HTML_FORM_ATTRIBUTES     17
+
+#define HTML_FRAME_CLASS          0
+#define HTML_FRAME_FRAMEBORDER    1
+#define HTML_FRAME_ID             2
+#define HTML_FRAME_LONGDESC       3
+#define HTML_FRAME_MARGINHEIGHT   4
+#define HTML_FRAME_MARGINWIDTH    5
+#define HTML_FRAME_NAME           6
+#define HTML_FRAME_NORESIZE       7
+#define HTML_FRAME_SCROLLING      8
+#define HTML_FRAME_SRC            9
+#define HTML_FRAME_STYLE         10
+#define HTML_FRAME_TITLE         11
+#define HTML_FRAME_ATTRIBUTES    12
+
+#define HTML_FRAMESET_COLS        0
+#define HTML_FRAMESET_ONLOAD      1
+#define HTML_FRAMESET_ONUNLOAD    2
+#define HTML_FRAMESET_ROWS        3
+#define HTML_FRAMESET_ATTRIBUTES  4
+
+#define HTML_GEN_CLASS            0
+#define HTML_GEN_CLEAR            1
+#define HTML_GEN_DIR              2
+#define HTML_GEN_ID               3
+#define HTML_GEN_LANG             4
+#define HTML_GEN_STYLE            5
+#define HTML_GEN_TITLE            6
+#define HTML_GEN_ATTRIBUTES       7
+
+#define HTML_GEN5_CLASS           0
+#define HTML_GEN5_DIR             1
+#define HTML_GEN5_ID              2
+#define HTML_GEN5_LANG            3
+#define HTML_GEN5_ROLE            4
+#define HTML_GEN5_STYLE           5
+#define HTML_GEN5_TITLE           6
+#define HTML_GEN5_ATTRIBUTES      7
+
+#define HTML_H_ALIGN              0
+#define HTML_H_CLASS              1
+#define HTML_H_CLEAR              2
+#define HTML_H_DINGBAT            3
+#define HTML_H_DIR                4
+#define HTML_H_ID                 5
+#define HTML_H_LANG               6
+#define HTML_H_MD                 7
+#define HTML_H_NOWRAP             8
+#define HTML_H_SEQNUM             9
+#define HTML_H_SKIP              10
+#define HTML_H_SRC               11
+#define HTML_H_STYLE             12
+#define HTML_H_TITLE             13
+#define HTML_H_ATTRIBUTES        14
+
+#define HTML_HR_ALIGN             0
+#define HTML_HR_CLASS             1
+#define HTML_HR_CLEAR             2
+#define HTML_HR_DIR               3
+#define HTML_HR_ID                4
+#define HTML_HR_LANG              5
+#define HTML_HR_MD                6
+#define HTML_HR_NOSHADE           7
+#define HTML_HR_SIZE              8
+#define HTML_HR_SRC               9
+#define HTML_HR_STYLE            10
+#define HTML_HR_TITLE            11
+#define HTML_HR_WIDTH            12
+#define HTML_HR_ATTRIBUTES       13
+
+#define HTML_IFRAME_ALIGN         0
+#define HTML_IFRAME_CLASS         1
+#define HTML_IFRAME_FRAMEBORDER   2
+#define HTML_IFRAME_HEIGHT        3
+#define HTML_IFRAME_ID            4
+#define HTML_IFRAME_LONGDESC      5
+#define HTML_IFRAME_MARGINHEIGHT  6
+#define HTML_IFRAME_MARGINWIDTH   7
+#define HTML_IFRAME_NAME          8
+#define HTML_IFRAME_SCROLLING     9
+#define HTML_IFRAME_SRC          10
+#define HTML_IFRAME_STYLE        11
+#define HTML_IFRAME_TITLE        12
+#define HTML_IFRAME_WIDTH        13
+#define HTML_IFRAME_ATTRIBUTES   14
+
+#define HTML_IMG_ALIGN            0
+#define HTML_IMG_ALT              1
+#define HTML_IMG_BORDER           2
+#define HTML_IMG_CLASS            3
+#define HTML_IMG_CLEAR            4
+#define HTML_IMG_DIR              5
+#define HTML_IMG_HEIGHT           6
+#define HTML_IMG_HSPACE           7
+#define HTML_IMG_ID               8
+#define HTML_IMG_ISMAP            9
+#define HTML_IMG_ISOBJECT        10
+#define HTML_IMG_LANG            11
+#define HTML_IMG_LONGDESC        12
+#define HTML_IMG_MD              13
+#define HTML_IMG_NAME            14
+#define HTML_IMG_SRC             15
+#define HTML_IMG_STYLE           16
+#define HTML_IMG_TITLE           17
+#define HTML_IMG_UNITS           18
+#define HTML_IMG_USEMAP          19
+#define HTML_IMG_VSPACE          20
+#define HTML_IMG_WIDTH           21
+#define HTML_IMG_ATTRIBUTES      22
+
+#define HTML_INPUT_ACCEPT         0
+#define HTML_INPUT_ACCEPT_CHARSET 1
+#define HTML_INPUT_ACCESSKEY      2
+#define HTML_INPUT_ALIGN          3
+#define HTML_INPUT_ALT            4
+#define HTML_INPUT_CHECKED        5
+#define HTML_INPUT_CLASS          6
+#define HTML_INPUT_CLEAR          7
+#define HTML_INPUT_DIR            8
+#define HTML_INPUT_DISABLED       9
+#define HTML_INPUT_ERROR         10
+#define HTML_INPUT_HEIGHT        11
+#define HTML_INPUT_ID            12
+#define HTML_INPUT_ISMAP         13
+#define HTML_INPUT_LANG          14
+#define HTML_INPUT_MAX           15
+#define HTML_INPUT_MAXLENGTH     16
+#define HTML_INPUT_MD            17
+#define HTML_INPUT_MIN           18
+#define HTML_INPUT_NAME          19
+#define HTML_INPUT_NOTAB         20
+#define HTML_INPUT_ONBLUR        21
+#define HTML_INPUT_ONCHANGE      22
+#define HTML_INPUT_ONFOCUS       23
+#define HTML_INPUT_ONSELECT      24
+#define HTML_INPUT_READONLY      25
+#define HTML_INPUT_SIZE          26
+#define HTML_INPUT_SRC           27
+#define HTML_INPUT_STYLE         28
+#define HTML_INPUT_TABINDEX      29
+#define HTML_INPUT_TITLE         30
+#define HTML_INPUT_TYPE          31
+#define HTML_INPUT_USEMAP        32
+#define HTML_INPUT_VALUE         33
+#define HTML_INPUT_WIDTH         34
+#define HTML_INPUT_ATTRIBUTES    35
+
+#define HTML_ISINDEX_ACTION       0
+#define HTML_ISINDEX_CLASS        1
+#define HTML_ISINDEX_DIR          2
+#define HTML_ISINDEX_HREF         3
+#define HTML_ISINDEX_ID           4
+#define HTML_ISINDEX_LANG         5
+#define HTML_ISINDEX_PROMPT       6
+#define HTML_ISINDEX_STYLE        7
+#define HTML_ISINDEX_TITLE        8
+#define HTML_ISINDEX_ATTRIBUTES   9
+
+#define HTML_KEYGEN_CHALLENGE     0
+#define HTML_KEYGEN_CLASS         1
+#define HTML_KEYGEN_DIR           2
+#define HTML_KEYGEN_ID            3
+#define HTML_KEYGEN_LANG          4
+#define HTML_KEYGEN_NAME          5
+#define HTML_KEYGEN_STYLE         6
+#define HTML_KEYGEN_TITLE         7
+#define HTML_KEYGEN_ATTRIBUTES    8
+
+#define HTML_LABEL_ACCESSKEY      0
+#define HTML_LABEL_CLASS          1
+#define HTML_LABEL_CLEAR          2
+#define HTML_LABEL_DIR            3
+#define HTML_LABEL_FOR            4
+#define HTML_LABEL_ID             5
+#define HTML_LABEL_LANG           6
+#define HTML_LABEL_ONBLUR         7
+#define HTML_LABEL_ONFOCUS        8
+#define HTML_LABEL_STYLE          9
+#define HTML_LABEL_TITLE         10
+#define HTML_LABEL_ATTRIBUTES    11
+
+#define HTML_LI_CLASS             0
+#define HTML_LI_CLEAR             1
+#define HTML_LI_DINGBAT           2
+#define HTML_LI_DIR               3
+#define HTML_LI_ID                4
+#define HTML_LI_LANG              5
+#define HTML_LI_MD                6
+#define HTML_LI_SKIP              7
+#define HTML_LI_SRC               8
+#define HTML_LI_STYLE             9
+#define HTML_LI_TITLE            10
+#define HTML_LI_TYPE             11
+#define HTML_LI_VALUE            12
+#define HTML_LI_ATTRIBUTES       13
+
+#define HTML_LINK_CHARSET         0
+#define HTML_LINK_CLASS           1
+#define HTML_LINK_DIR             2
+#define HTML_LINK_HREF            3
+#define HTML_LINK_HREFLANG        4
+#define HTML_LINK_ID              5
+#define HTML_LINK_LANG            6
+#define HTML_LINK_MEDIA           7
+#define HTML_LINK_REL             8
+#define HTML_LINK_REV             9
+#define HTML_LINK_STYLE          10
+#define HTML_LINK_TARGET         11
+#define HTML_LINK_TITLE          12
+#define HTML_LINK_TYPE           13
+#define HTML_LINK_ATTRIBUTES     14
+
+#define HTML_MAP_CLASS            0
+#define HTML_MAP_CLEAR            1
+#define HTML_MAP_DIR              2
+#define HTML_MAP_ID               3
+#define HTML_MAP_LANG             4
+#define HTML_MAP_NAME             5
+#define HTML_MAP_STYLE            6
+#define HTML_MAP_TITLE            7
+#define HTML_MAP_ATTRIBUTES       8
+
+#define HTML_MATH_BOX             0
+#define HTML_MATH_CLASS           1
+#define HTML_MATH_CLEAR           2
+#define HTML_MATH_DIR             3
+#define HTML_MATH_ID              4
+#define HTML_MATH_LANG            5
+#define HTML_MATH_STYLE           6
+#define HTML_MATH_TITLE           7
+#define HTML_MATH_ATTRIBUTES      8
+
+#define HTML_META_CHARSET         0
+#define HTML_META_CONTENT         1
+#define HTML_META_HTTP_EQUIV      2
+#define HTML_META_NAME            3
+#define HTML_META_SCHEME          4
+#define HTML_META_ATTRIBUTES      5
+
+#define HTML_NEXTID_N             0
+#define HTML_NEXTID_ATTRIBUTES    1
+
+#define HTML_NOTE_CLASS           0
+#define HTML_NOTE_CLEAR           1
+#define HTML_NOTE_DIR             2
+#define HTML_NOTE_ID              3
+#define HTML_NOTE_LANG            4
+#define HTML_NOTE_MD              5
+#define HTML_NOTE_ROLE            6
+#define HTML_NOTE_SRC             7
+#define HTML_NOTE_STYLE           8
+#define HTML_NOTE_TITLE           9
+#define HTML_NOTE_ATTRIBUTES     10
+
+#define HTML_OBJECT_ALIGN         0
+#define HTML_OBJECT_ARCHIVE       1
+#define HTML_OBJECT_BORDER        2
+#define HTML_OBJECT_CLASS         3
+#define HTML_OBJECT_CLASSID       4
+#define HTML_OBJECT_CODEBASE      5
+#define HTML_OBJECT_CODETYPE      6
+#define HTML_OBJECT_DATA          7
+#define HTML_OBJECT_DECLARE       8
+#define HTML_OBJECT_DIR           9
+#define HTML_OBJECT_HEIGHT       10
+#define HTML_OBJECT_HSPACE       11
+#define HTML_OBJECT_ID           12
+#define HTML_OBJECT_ISMAP        13
+#define HTML_OBJECT_LANG         14
+#define HTML_OBJECT_NAME         15
+#define HTML_OBJECT_NOTAB        16
+#define HTML_OBJECT_SHAPES       17
+#define HTML_OBJECT_STANDBY      18
+#define HTML_OBJECT_STYLE        19
+#define HTML_OBJECT_TABINDEX     20
+#define HTML_OBJECT_TITLE        21
+#define HTML_OBJECT_TYPE         22
+#define HTML_OBJECT_USEMAP       23
+#define HTML_OBJECT_VSPACE       24
+#define HTML_OBJECT_WIDTH        25
+#define HTML_OBJECT_ATTRIBUTES   26
+
+#define HTML_OL_CLASS             0
+#define HTML_OL_CLEAR             1
+#define HTML_OL_COMPACT           2
+#define HTML_OL_CONTINUE          3
+#define HTML_OL_DIR               4
+#define HTML_OL_ID                5
+#define HTML_OL_LANG              6
+#define HTML_OL_SEQNUM            7
+#define HTML_OL_START             8
+#define HTML_OL_STYLE             9
+#define HTML_OL_TITLE            10
+#define HTML_OL_TYPE             11
+#define HTML_OL_ATTRIBUTES       12
+
+#define HTML_OPTION_CLASS         0
+#define HTML_OPTION_CLEAR         1
+#define HTML_OPTION_DIR           2
+#define HTML_OPTION_DISABLED      3
+#define HTML_OPTION_ERROR         4
+#define HTML_OPTION_ID            5
+#define HTML_OPTION_LABEL         6
+#define HTML_OPTION_LANG          7
+#define HTML_OPTION_SELECTED      8
+#define HTML_OPTION_SHAPE         9
+#define HTML_OPTION_STYLE        10
+#define HTML_OPTION_TITLE        11
+#define HTML_OPTION_VALUE        12
+#define HTML_OPTION_ATTRIBUTES   13
+
+#define HTML_OVERLAY_CLASS        0
+#define HTML_OVERLAY_HEIGHT       1
+#define HTML_OVERLAY_ID           2
+#define HTML_OVERLAY_IMAGEMAP     3
+#define HTML_OVERLAY_MD           4
+#define HTML_OVERLAY_SRC          5
+#define HTML_OVERLAY_STYLE        6
+#define HTML_OVERLAY_TITLE        7
+#define HTML_OVERLAY_UNITS        8
+#define HTML_OVERLAY_WIDTH        9
+#define HTML_OVERLAY_X           10
+#define HTML_OVERLAY_Y           11
+#define HTML_OVERLAY_ATTRIBUTES  12
+
+#define HTML_P_ALIGN              0
+#define HTML_P_CLASS              1
+#define HTML_P_CLEAR              2
+#define HTML_P_DIR                3
+#define HTML_P_ID                 4
+#define HTML_P_LANG               5
+#define HTML_P_NOWRAP             6
+#define HTML_P_STYLE              7
+#define HTML_P_TITLE              8
+#define HTML_P_ATTRIBUTES         9
+
+#define HTML_PARAM_ACCEPT         0
+#define HTML_PARAM_ACCEPT_CHARSET 1
+#define HTML_PARAM_ACCEPT_ENCODING 2
+#define HTML_PARAM_CLASS          3
+#define HTML_PARAM_CLEAR          4
+#define HTML_PARAM_DATA           5
+#define HTML_PARAM_DIR            6
+#define HTML_PARAM_ID             7
+#define HTML_PARAM_LANG           8
+#define HTML_PARAM_NAME           9
+#define HTML_PARAM_OBJECT        10
+#define HTML_PARAM_REF           11
+#define HTML_PARAM_STYLE         12
+#define HTML_PARAM_TITLE         13
+#define HTML_PARAM_TYPE          14
+#define HTML_PARAM_VALUE         15
+#define HTML_PARAM_VALUEREF      16
+#define HTML_PARAM_VALUETYPE     17
+#define HTML_PARAM_ATTRIBUTES    18
+
+#define HTML_Q_CITE               0
+#define HTML_Q_CLASS              1
+#define HTML_Q_CLEAR              2
+#define HTML_Q_DIR                3
+#define HTML_Q_ID                 4
+#define HTML_Q_LANG               5
+#define HTML_Q_STYLE              6
+#define HTML_Q_TITLE              7
+#define HTML_Q_ATTRIBUTES         8
+
+#define HTML_SCRIPT_CHARSET       0
+#define HTML_SCRIPT_CLASS         1
+#define HTML_SCRIPT_CLEAR         2
+#define HTML_SCRIPT_DEFER         3
+#define HTML_SCRIPT_DIR           4
+#define HTML_SCRIPT_EVENT         5
+#define HTML_SCRIPT_FOR           6
+#define HTML_SCRIPT_ID            7
+#define HTML_SCRIPT_LANG          8
+#define HTML_SCRIPT_LANGUAGE      9
+#define HTML_SCRIPT_NAME         10
+#define HTML_SCRIPT_SCRIPTENGINE 11
+#define HTML_SCRIPT_SRC          12
+#define HTML_SCRIPT_STYLE        13
+#define HTML_SCRIPT_TITLE        14
+#define HTML_SCRIPT_TYPE         15
+#define HTML_SCRIPT_ATTRIBUTES   16
+
+#define HTML_SELECT_ALIGN         0
+#define HTML_SELECT_CLASS         1
+#define HTML_SELECT_CLEAR         2
+#define HTML_SELECT_DIR           3
+#define HTML_SELECT_DISABLED      4
+#define HTML_SELECT_ERROR         5
+#define HTML_SELECT_HEIGHT        6
+#define HTML_SELECT_ID            7
+#define HTML_SELECT_LANG          8
+#define HTML_SELECT_MD            9
+#define HTML_SELECT_MULTIPLE     10
+#define HTML_SELECT_NAME         11
+#define HTML_SELECT_NOTAB        12
+#define HTML_SELECT_ONBLUR       13
+#define HTML_SELECT_ONCHANGE     14
+#define HTML_SELECT_ONFOCUS      15
+#define HTML_SELECT_SIZE         16
+#define HTML_SELECT_STYLE        17
+#define HTML_SELECT_TABINDEX     18
+#define HTML_SELECT_TITLE        19
+#define HTML_SELECT_UNITS        20
+#define HTML_SELECT_WIDTH        21
+#define HTML_SELECT_ATTRIBUTES   22
+
+#define HTML_STYLE_CLASS          0
+#define HTML_STYLE_DIR            1
+#define HTML_STYLE_ID             2
+#define HTML_STYLE_LANG           3
+#define HTML_STYLE_MEDIA          4
+#define HTML_STYLE_NOTATION       5
+#define HTML_STYLE_STYLE          6
+#define HTML_STYLE_TITLE          7
+#define HTML_STYLE_TYPE           8
+#define HTML_STYLE_ATTRIBUTES     9
+
+#define HTML_TAB_ALIGN            0
+#define HTML_TAB_CLASS            1
+#define HTML_TAB_CLEAR            2
+#define HTML_TAB_DIR              3
+#define HTML_TAB_DP               4
+#define HTML_TAB_ID               5
+#define HTML_TAB_INDENT           6
+#define HTML_TAB_LANG             7
+#define HTML_TAB_STYLE            8
+#define HTML_TAB_TITLE            9
+#define HTML_TAB_TO              10
+#define HTML_TAB_ATTRIBUTES      11
+
+#define HTML_TABLE_ALIGN          0
+#define HTML_TABLE_BACKGROUND     1
+#define HTML_TABLE_BORDER         2
+#define HTML_TABLE_CELLPADDING    3
+#define HTML_TABLE_CELLSPACING    4
+#define HTML_TABLE_CLASS          5
+#define HTML_TABLE_CLEAR          6
+#define HTML_TABLE_COLS           7
+#define HTML_TABLE_COLSPEC        8
+#define HTML_TABLE_DIR            9
+#define HTML_TABLE_DP            10
+#define HTML_TABLE_FRAME         11
+#define HTML_TABLE_ID            12
+#define HTML_TABLE_LANG          13
+#define HTML_TABLE_NOFLOW        14
+#define HTML_TABLE_NOWRAP        15
+#define HTML_TABLE_RULES         16
+#define HTML_TABLE_STYLE         17
+#define HTML_TABLE_SUMMARY       18
+#define HTML_TABLE_TITLE         19
+#define HTML_TABLE_UNITS         20
+#define HTML_TABLE_WIDTH         21
+#define HTML_TABLE_ATTRIBUTES    22
+
+#define HTML_TD_ABBR              0
+#define HTML_TD_ALIGN             1
+#define HTML_TD_AXES              2
+#define HTML_TD_AXIS              3
+#define HTML_TD_BACKGROUND        4
+#define HTML_TD_CHAR              5
+#define HTML_TD_CHAROFF           6
+#define HTML_TD_CLASS             7
+#define HTML_TD_CLEAR             8
+#define HTML_TD_COLSPAN           9
+#define HTML_TD_DIR              10
+#define HTML_TD_DP               11
+#define HTML_TD_HEADERS          12
+#define HTML_TD_HEIGHT           13
+#define HTML_TD_ID               14
+#define HTML_TD_LANG             15
+#define HTML_TD_NOWRAP           16
+#define HTML_TD_ROWSPAN          17
+#define HTML_TD_SCOPE            18
+#define HTML_TD_STYLE            19
+#define HTML_TD_TITLE            20
+#define HTML_TD_VALIGN           21
+#define HTML_TD_WIDTH            22
+#define HTML_TD_ATTRIBUTES       23
+
+#define HTML_TEXTAREA_ACCEPT_CHARSET 0
+#define HTML_TEXTAREA_ACCESSKEY   1
+#define HTML_TEXTAREA_ALIGN       2
+#define HTML_TEXTAREA_CLASS       3
+#define HTML_TEXTAREA_CLEAR       4
+#define HTML_TEXTAREA_COLS        5
+#define HTML_TEXTAREA_DIR         6
+#define HTML_TEXTAREA_DISABLED    7
+#define HTML_TEXTAREA_ERROR       8
+#define HTML_TEXTAREA_ID          9
+#define HTML_TEXTAREA_LANG       10
+#define HTML_TEXTAREA_NAME       11
+#define HTML_TEXTAREA_NOTAB      12
+#define HTML_TEXTAREA_ONBLUR     13
+#define HTML_TEXTAREA_ONCHANGE   14
+#define HTML_TEXTAREA_ONFOCUS    15
+#define HTML_TEXTAREA_ONSELECT   16
+#define HTML_TEXTAREA_READONLY   17
+#define HTML_TEXTAREA_ROWS       18
+#define HTML_TEXTAREA_STYLE      19
+#define HTML_TEXTAREA_TABINDEX   20
+#define HTML_TEXTAREA_TITLE      21
+#define HTML_TEXTAREA_ATTRIBUTES 22
+
+#define HTML_TR_ALIGN             0
+#define HTML_TR_CHAR              1
+#define HTML_TR_CHAROFF           2
+#define HTML_TR_CLASS             3
+#define HTML_TR_CLEAR             4
+#define HTML_TR_DIR               5
+#define HTML_TR_DP                6
+#define HTML_TR_ID                7
+#define HTML_TR_LANG              8
+#define HTML_TR_NOWRAP            9
+#define HTML_TR_STYLE            10
+#define HTML_TR_TITLE            11
+#define HTML_TR_VALIGN           12
+#define HTML_TR_ATTRIBUTES       13
+
+#define HTML_UL_CLASS             0
+#define HTML_UL_CLEAR             1
+#define HTML_UL_COMPACT           2
+#define HTML_UL_DINGBAT           3
+#define HTML_UL_DIR               4
+#define HTML_UL_ID                5
+#define HTML_UL_LANG              6
+#define HTML_UL_MD                7
+#define HTML_UL_PLAIN             8
+#define HTML_UL_SRC               9
+#define HTML_UL_STYLE            10
+#define HTML_UL_TITLE            11
+#define HTML_UL_TYPE             12
+#define HTML_UL_WRAP             13
+#define HTML_UL_ATTRIBUTES       14
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* hdr_HTMLDTD_H */
diff --git a/WWW/Library/Implementation/makefile.in b/WWW/Library/Implementation/makefile.in
new file mode 100644
index 0000000..0b467d7
--- /dev/null
+++ b/WWW/Library/Implementation/makefile.in
@@ -0,0 +1,384 @@
+# $LynxId: makefile.in,v 1.35 2021/07/16 20:01:00 tom Exp $
+# Make WWW under unix for a.n.other unix system (bsd)
+# Use this as a template
+
+# For W3 distribution, machine type for subdirectories
+WWW_MACH	= Implementation
+WWWINC		= $(top_srcdir)/WWW/Library/Implementation
+
+ECHO =		@DONT_ECHO_CC@
+LFLAGS =
+
+prefix		= @prefix@
+exec_prefix	= @exec_prefix@
+datarootdir	= @datarootdir@
+top_srcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= $(srcdir)
+
+LYFLAGS		= # FIXME: set in parent makefile
+
+CC		= @CC@
+DEFS		= @DEFS@
+EXTRA_CPPFLAGS	= @EXTRA_CPPFLAGS@
+CPPFLAGS	= @CPPFLAGS@
+
+AR		= @AR@
+ARFLAGS		= @ARFLAGS@
+
+RANLIB		= @RANLIB@
+
+o		= .@OBJEXT@
+x		= @EXEEXT@
+
+INTLDIR_CPPFLAGS= @INTLDIR_CPPFLAGS@ -I$(top_srcdir)/intl
+
+CPP		= @CPP@
+CPPOPTS		= $(DEFS) $(LYFLAGS) \
+		-I../../.. \
+		-I../../../src \
+		-I$(top_srcdir) \
+		-I$(top_srcdir)/src \
+		$(INTLDIR_CPPFLAGS) -I$(WWWINC) $(EXTRA_CPPFLAGS) $(CPPFLAGS)
+
+LY_CFLAGS	= @CFLAGS@ @EXTRA_CFLAGS@
+CFLAGS		= $(CPPOPTS) $(LY_CFLAGS)
+
+LINT		= @LINT@
+LINTOPTS	=
+
+CTAGS		= @CTAGS@
+
+# Directory for installed binary:
+BINDIR		= @bindir@
+
+# Where is the W3 object library to be installed (not normally done)?
+#_________________ OK if normal W3 distribution
+# Where is the WWW source root?
+WWW = $(top_srcdir)/WWW
+
+#  Where should temporary (object) files go?
+WTMP = ../..
+
+# (Version.make)
+VC = 2.14
+#______________________________________________________________________
+# (originally CommonMakefile)
+
+#  If this env var is set to something else Some makes will use that instead
+SHELL = @CONFIG_SHELL@
+
+#	.h files are distributed but originally are made from the
+#	self-documenting hypertext files.
+
+.SUFFIXES: .h .html
+.html.h:
+#	- chmod +w $*.h
+	www -w90 -na -to text/x-c $*.html > $*.h
+#	chmod -w $*.h
+
+# If this is actually run in a subdirectory,
+#
+# WWW = ../../..
+# WWW = ../..	For [cernlib] build in this directory
+
+CMN = $(WWW)/Library/Implementation/
+
+# Where shall we put the objects and built library?
+
+LOB = .
+
+# Only needed if HTWAIS.c is to be compiled. Put into your Makefile.include
+#  uncomment these and fill in WAISINC for adding direct wais access
+#  to Lynx.
+@MAKE_WAIS@HTWAIS_c = $(CMN)/HTWAIS.c
+@MAKE_WAIS@HTWAIS_o = $(LOB)/HTWAIS$o
+@MAKE_WAIS@WAIS = YES
+#WAISINC = -I../../../../freeWAIS-0.202/ir
+@MAKE_WAIS@WAISCFLAGS = -DDIRECT_WAIS
+#
+
+# add -DNEW_GATEWAY here for the new gateway config stuff
+CFLAGS2 = $(CFLAGS) $(LYFLAGS) $(WAISCFLAGS) -I$(CMN) -DACCESS_AUTH
+
+COMPILE	= $(ECHO) $(CC) $(CFLAGS2) -c
+
+COMMON = $(LOB)/HTParse$o $(LOB)/HTAccess$o $(LOB)/HTTP$o \
+	$(LOB)/HTFile$o	$(LOB)/HTBTree$o $(LOB)/HTFTP$o $(LOB)/HTTCP$o \
+	$(LOB)/SGML$o $(LOB)/HTMLDTD$o $(LOB)/HTChunk$o \
+	$(LOB)/HTPlain$o \
+	$(LOB)/HTMLGen$o \
+	$(LOB)/HTAtom$o $(LOB)/HTAnchor$o $(LOB)/HTStyle$o \
+	$(LOB)/HTList$o $(LOB)/HTString$o \
+	$(LOB)/HTRules$o $(LOB)/HTFormat$o  $(LOB)/HTMIME$o \
+	$(LOB)/HTNews$o  $(LOB)/HTGopher$o \
+	$(LOB)/HTTelnet$o $(LOB)/HTFinger$o $(LOB)/HTWSRC$o $(HTWAIS_o) \
+	$(LOB)/HTAAUtil$o $(LOB)/HTAABrow$o \
+	$(LOB)/HTGroup$o \
+	$(LOB)/HTAAProt$o \
+	$(LOB)/HTAssoc$o  $(LOB)/HTLex$o    $(LOB)/HTUU$o \
+	$(LOB)/HTDOS$o
+
+CFILES = $(CMN)HTParse.c $(CMN)HTAccess.c $(CMN)HTTP.c $(CMN)HTFile.c \
+	$(CMN)HTBTree.c \
+	$(CMN)HTFTP.c	$(CMN)HTTCP.c	  $(CMN)SGML.c \
+	$(CMN)HTMLDTD.c \
+	$(CMN)HTPlain.c	\
+	$(CMN)HTMLGen.c \
+	$(CMN)HTChunk.c $(CMN)HTAtom.c    $(CMN)HTAnchor.c $(CMN)HTStyle.c \
+	$(CMN)HTList.c  $(CMN)HTString.c  $(CMN)HTRules.c \
+	$(CMN)HTFormat.c $(CMN)HTMIME.c \
+	$(CMN)HTNews.c  $(CMN)HTGopher.c  $(CMN)HTTelnet.c \
+	$(CMN)HTFinger.c $(HTWAIS_c)	  $(CMN)HTWSRC.c \
+	$(CMN)HTAABrow.c \
+	$(CMN)HTGroup.c  \
+	$(CMN)HTAAProt.c \
+	$(CMN)HTAssoc.c  $(CMN)HTLex.c    $(CMN)HTUU.c
+
+HFILES = $(CMN)HTParse.h $(CMN)HTAccess.h $(CMN)HTTP.h $(CMN)HTFile.h \
+	$(CMN)HTBTree.h $(CMN)HTFTP.h $(CMN)HTTCP.h \
+	$(CMN)SGML.h $(CMN)HTML.h $(CMN)HTMLDTD.h $(CMN)HTChunk.h \
+	$(CMN)HTPlain.h	\
+	$(CMN)HTFWriter.h	$(CMN)HTMLGen.h \
+	$(CMN)HTStream.h \
+	$(CMN)HTAtom.h $(CMN)HTAnchor.h $(CMN)HTStyle.h \
+	$(CMN)HTList.h \
+	$(CMN)HTString.h $(CMN)HTRules.h \
+	$(CMN)HTFormat.h $(CMN)HTInit.h \
+	$(CMN)HTMIME.h $(CMN)HTNews.h \
+	$(CMN)HTGopher.h \
+	$(CMN)HTUtils.h $(CMN)www_tcp.h $(CMN)HText.h \
+	$(CMN)HTTelnet.h $(CMN)HTFinger.h \
+	$(CMN)HTWAIS.h  $(CMN)HTWSRC.h \
+	$(CMN)HTAABrow.h \
+	$(CMN)HTGroup.h  \
+	$(CMN)HTAAProt.h \
+	$(CMN)HTAssoc.h  $(CMN)HTLex.h    $(CMN)HTUU.h
+
+C_SRC		= $(COMMON:$o=.c)
+
+all : $(LOB)/libwww.a
+
+lint:
+	$(LINT) $(LINTOPTS) $(CPPOPTS) $(C_SRC) 2>&1 |tee ../../../lint.libwww
+
+.SUFFIXES: $o .i .h .html
+
+.c$o:
+	@RULE_CC@
+	@ECHO_CC@$(CC) $(CPPOPTS) $(CFLAGS) -c $(srcdir)/$*.c
+
+.c.i:
+	@RULE_CC@
+	@ECHO_CC@$(CPP) $(CPPOPTS) $(srcdir)/$*.c >$@
+
+depend :
+	makedepend -fmakefile -- $(CFLAGS) -- $(CFILES)
+
+#	Library
+#
+#  On SGI, ranlib is unnecessary and does not exist so we ignore errors
+# for that step
+$(LOB)/libwww.a : $(COMMON)
+	$(AR) $(ARFLAGS) $(LOB)/libwww.a $(COMMON)
+	-$(RANLIB) $(LOB)/libwww.a
+
+#	Clean up everything generatable except final products
+clean :
+	rm -f core *.core *.leaks *.[oi] *.bak tags TAGS
+	rm -f dtd_util$x
+	rm -f $(LOB)/*$o
+
+distclean : clean
+	@echo made $@
+
+tags:
+	$(CTAGS) *.[ch]
+
+#			Common code
+#			-----------
+
+$(LOB)/HTList$o : $(CMN)HTList.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(COMPILE) $(CMN)HTList.c
+
+$(LOB)/HTAnchor$o : $(CMN)HTAnchor.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(COMPILE) $(CMN)HTAnchor.c
+
+$(LOB)/HTFormat$o : $(CMN)HTFormat.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(COMPILE) $(CMN)HTFormat.c
+
+$(LOB)/HTMIME$o : $(CMN)HTMIME.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(COMPILE) $(CMN)HTMIME.c
+
+$(LOB)/HTNews$o : $(CMN)HTNews.c $(CMN)HTUtils.h $(CMN)HTList.h\
+	 $(CMN)HTMLDTD.h
+	$(COMPILE) $(CMN)HTNews.c
+
+$(LOB)/HTGopher$o : $(CMN)HTGopher.c $(CMN)HTUtils.h $(CMN)HTList.h \
+	 $(CMN)HTMLDTD.h
+	$(COMPILE) $(CMN)HTGopher.c
+
+$(LOB)/HTTelnet$o : $(CMN)HTTelnet.c $(CMN)HTUtils.h $(CMN)HTTelnet.h $(CMN)../../../userdefs.h
+	$(COMPILE) $(CMN)HTTelnet.c
+
+$(LOB)/HTFinger$o : $(CMN)HTFinger.c $(CMN)HTUtils.h $(CMN)HTList.h \
+	$(CMN)HTMLDTD.h
+	$(COMPILE) $(CMN)HTFinger.c
+
+$(LOB)/HTStyle$o : $(CMN)HTStyle.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTStyle.c
+
+$(LOB)/HTAtom$o : $(CMN)HTAtom.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(COMPILE) $(CMN)HTAtom.c
+
+$(LOB)/HTChunk$o : $(CMN)HTChunk.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTChunk.c
+
+$(LOB)/HTString$o : $(CMN)HTString.c $(CMN)HTUtils.h $(CMN)Version.make
+	$(COMPILE) -DVC=\"$(VC)\" $(CMN)HTString.c
+
+$(LOB)/HTRules$o : $(CMN)HTRules.c $(CMN)HTUtils.h $(CMN)Version.make \
+	 $(CMN)HTAAProt.h
+	$(COMPILE) -DVC=\"$(VC)\" $(CMN)HTRules.c
+
+$(LOB)/SGML$o : $(CMN)SGML.c $(CMN)HTUtils.h $(CMN)UCAux.h
+	$(COMPILE) $(CMN)SGML.c
+
+$(LOB)/HTMLGen$o : $(CMN)HTMLGen.c $(CMN)HTUtils.h $(CMN)HTMLDTD.h
+	$(COMPILE) $(CMN)HTMLGen.c
+
+$(LOB)/HTMLDTD$o : $(CMN)HTMLDTD.c $(CMN)SGML.h
+	$(COMPILE) $(CMN)HTMLDTD.c
+
+$(LOB)/HTPlain$o : $(CMN)HTPlain.c $(CMN)HTPlain.h $(CMN)HTStream.h \
+	 $(CMN)UCAux.h
+	$(COMPILE) $(CMN)HTPlain.c
+
+$(LOB)/HTWAIS$o : $(CMN)HTWAIS.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(COMPILE) $(WAISINC) $(CMN)HTWAIS.c
+
+$(LOB)/HTWSRC$o : $(CMN)HTWSRC.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(COMPILE) $(CMN)HTWSRC.c
+
+#	Access Authorization
+
+$(LOB)/HTAAUtil$o : $(CMN)HTAAUtil.c $(CMN)HTAAUtil.h \
+	 $(CMN)HTUtils.h $(CMN)HTString.h
+	$(COMPILE) $(CMN)HTAAUtil.c
+
+$(LOB)/HTGroup$o : $(CMN)HTGroup.c $(CMN)HTGroup.h \
+	 $(CMN)HTAAUtil.h \
+	 $(CMN)HTAssoc.h $(CMN)HTLex.h
+	$(COMPILE) $(CMN)HTGroup.c
+
+$(LOB)/HTAABrow$o : $(CMN)HTAABrow.c $(CMN)HTAABrow.h \
+	 $(CMN)HTAAUtil.h $(CMN)HTUU.h \
+	 $(CMN)HTUtils.h $(CMN)HTString.h \
+	 $(CMN)HTParse.h $(CMN)HTList.h \
+	 $(CMN)HTAssoc.h
+	$(COMPILE) $(CMN)HTAABrow.c
+
+$(LOB)/HTAAProt$o : $(CMN)HTAAProt.c $(CMN)HTAAProt.h \
+	 $(CMN)HTUtils.h $(CMN)HTAAUtil.h \
+	 $(CMN)HTAssoc.h $(CMN)HTLex.h
+	$(COMPILE) $(CMN)HTAAProt.c
+
+$(LOB)/HTAssoc$o : $(CMN)HTAssoc.c $(CMN)HTAssoc.h \
+	$(CMN)HTUtils.h $(CMN)HTString.h $(CMN)HTList.h
+	$(COMPILE) $(CMN)HTAssoc.c
+
+$(LOB)/HTLex$o : $(CMN)HTLex.c $(CMN)HTLex.h $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTLex.c
+
+$(LOB)/HTUU$o : $(CMN)HTUU.c $(CMN)HTUU.h $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTUU.c
+
+
+#	Communications & Files
+
+$(LOB)/HTTP$o : $(CMN)HTTP.c $(CMN)HTUtils.h $(CMN)HTAABrow.h
+	$(COMPILE) $(CMN)HTTP.c
+
+$(LOB)/HTTCP$o : $(CMN)HTTCP.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTTCP.c
+
+$(LOB)/HTFile$o : $(CMN)HTFile.c $(CMN)HTUtils.h \
+	 $(CMN)HTMLDTD.h
+	$(COMPILE) $(CMN)HTFile.c
+
+$(LOB)/HTBTree$o : $(CMN)HTBTree.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTBTree.c
+
+$(LOB)/HTFTP$o : $(CMN)HTFTP.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTFTP.c
+
+$(LOB)/HTAccess$o : $(CMN)HTAccess.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTAccess.c
+
+$(LOB)/HTParse$o : $(CMN)HTParse.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTParse.c
+
+$(LOB)/HTVMS_WaisUI$o : $(CMN)HTVMS_WaisUI.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTVMS_WaisUI.c
+
+$(LOB)/HTDOS$o : $(CMN)HTDOS.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)HTDOS.c
+
+# Utilities
+$(LOB)/dtd_util$o : $(CMN)dtd_util.c $(CMN)HTUtils.h
+	$(COMPILE) $(CMN)dtd_util.c
+
+DTD_UTIL = $(LOB)/dtd_util$o $(LOB)/HTMLDTD$o
+
+sources: dtd_util$x src0_HTMLDTD.txt src1_HTMLDTD.txt
+	-rm -f *_HTMLDTD.h
+	./dtd_util$x -l src0_HTMLDTD.txt -s -c -o src0_HTMLDTD.h
+	./dtd_util$x -l src1_HTMLDTD.txt -t -c -o src1_HTMLDTD.h
+	./dtd_util$x -l src0_HTMLDTD.txt -s -h -o hdr_HTMLDTD.h
+
+dtd_util$x: $(DTD_UTIL)
+	$(CC) $(CC_OPTS) $(LDFLAGS) -o $@  $(DTD_UTIL) $(LIBS)
+
+DIFFC	= diff -u -I LynxId
+check: dtd_util$x
+	@echo "** comparing builtin src0_HTMLDTD.txt"
+	./dtd_util$x >HTMLDTD.log
+	-$(DIFFC) src0_HTMLDTD.txt HTMLDTD.log
+
+	@echo "** comparing reloaded src0_HTMLDTD.txt"
+	./dtd_util$x -l src0_HTMLDTD.txt >HTMLDTD.log
+	-$(DIFFC) src0_HTMLDTD.txt HTMLDTD.log
+
+	@echo "** comparing reloaded src1_HTMLDTD.txt"
+	./dtd_util$x -t -l src1_HTMLDTD.txt >HTMLDTD.log
+	-$(DIFFC) src1_HTMLDTD.txt HTMLDTD.log
+
+	@echo "** comparing header generated from builtin"
+	./dtd_util$x -s -h -o HTMLDTD.log
+	-$(DIFFC) hdr_HTMLDTD.h HTMLDTD.log
+	./dtd_util$x -t -h -o HTMLDTD.log
+	-$(DIFFC) hdr_HTMLDTD.h HTMLDTD.log
+
+	@echo "** comparing header generated by load"
+	./dtd_util$x -s -h -o HTMLDTD.log -l src0_HTMLDTD.txt
+	-$(DIFFC) hdr_HTMLDTD.h HTMLDTD.log
+	./dtd_util$x -t -h -o HTMLDTD.log -l src1_HTMLDTD.txt
+	-$(DIFFC) hdr_HTMLDTD.h HTMLDTD.log
+
+	@echo "** comparing strict source generated from builtin"
+	./dtd_util$x -s -c -o HTMLDTD.log
+	-$(DIFFC) src0_HTMLDTD.h HTMLDTD.log
+
+	@echo "** comparing strict source generated by load"
+	./dtd_util$x -s -c -o HTMLDTD.log -l src0_HTMLDTD.txt
+	-$(DIFFC) src0_HTMLDTD.h HTMLDTD.log
+
+	@echo "** comparing tagsoup source generated from builtin"
+	./dtd_util$x -t -c -o HTMLDTD.log
+	-$(DIFFC) src1_HTMLDTD.h HTMLDTD.log
+
+	@echo "** comparing tagsoup source generated by load"
+	./dtd_util$x -t -c -o HTMLDTD.log -l src1_HTMLDTD.txt
+	-$(DIFFC) src1_HTMLDTD.h HTMLDTD.log
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
diff --git a/WWW/Library/Implementation/src0_HTMLDTD.h b/WWW/Library/Implementation/src0_HTMLDTD.h
new file mode 100644
index 0000000..a2daa4f
--- /dev/null
+++ b/WWW/Library/Implementation/src0_HTMLDTD.h
@@ -0,0 +1,2478 @@
+/* $LynxId: src0_HTMLDTD.h,v 1.49 2022/09/30 00:04:06 tom Exp $ */
+#ifndef src_HTMLDTD_H0
+#define src_HTMLDTD_H0 1
+
+#ifndef once_HTMLDTD
+#define once_HTMLDTD 1
+
+#define T_A             0x00008,0x0B007,0x0FF17,0x37787,0x77BA7,0x8604F,0x00014
+#define T_ABBR          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00003,0x00000
+#define T_ACRONYM       0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00003,0x00000
+#define T_ADDRESS       0x00200,0x0F14F,0x8FFFF,0x136680,0x1B6FAF,0x80317,0x00000
+#define T_APPLET        0x02000,0x0B0CF,0x8FFFF,0x37F9F,0xB7FBF,0x8300F,0x00000
+#define T_AREA          0x08000,0x00000,0x00000,0x08000,0x3FFFF,0x00F1F,0x00001
+#define T_ARTICLE       0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_ASIDE         0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_AU            0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00003,0x00000
+#define T_AUTHOR        0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00003,0x00000
+#define T_B             0x00001,0x8B04F,0xAFFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_BANNER        0x00200,0x0FB8F,0x0FFFF,0x130000,0x130000,0x8031F,0x00000
+#define T_BASE          0x40000,0x00000,0x00000,0x50000,0x50000,0x8000F,0x00001
+#define T_BASEFONT      0x01000,0x00000,0x00000,0x377AF,0x37FAF,0x8F000,0x00001
+#define T_BDO           0x00100,0x0B04F,0x8FFFF,0x136680,0x1B6FAF,0x0033F,0x00000
+#define T_BGSOUND       0x01000,0x00000,0x00000,0x777AF,0x77FAF,0x8730F,0x00001
+#define T_BIG           0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_BLINK         0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FAF,0x00001,0x00014
+#define T_BLOCKQUOTE    0x00200,0xAFBCF,0xAFFFF,0x1B6680,0x1B6FAF,0x8031F,0x00000
+#define T_BODY          0x20000,0x12FB8F,0x12FFFF,0x30000,0x30000,0xDFF7F,0x00003
+#define T_BODYTEXT      0x20000,0x10FB8F,0x1AFFFF,0x30200,0xB7FAF,0x8F17F,0x00003
+#define T_BQ            0x00200,0xAFBCF,0xAFFFF,0x1B6680,0x1B6FAF,0x8031F,0x00000
+#define T_BR            0x01000,0x00000,0x00000,0x377BF,0x77FBF,0x8101F,0x00001
+#define T_BUTTON        0x02000,0x0BB07,0x0FF37,0x0378F,0x37FBF,0x8115F,0x00000
+#define T_CAPTION       0x00100,0x0B04F,0x8FFFF,0x106A00,0x1B6FA7,0x8035F,0x00000
+#define T_CENTER        0x00200,0x8FBCF,0x8FFFF,0x1B6680,0x1B6FA7,0x8071F,0x00000
+#define T_CITE          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00002,0x00010
+#define T_CODE          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00002,0x00000
+#define T_COL           0x04000,0x00000,0x00000,0x00820,0x36FA7,0x88F5F,0x00001
+#define T_COLGROUP      0x00020,0x04000,0x04000,0x00800,0x36FA7,0x8875F,0x00001
+#define T_COMMENT       0x00004,0x00000,0x00000,0xA77AF,0x7FFFF,0x00003,0x00000
+#define T_CREDIT        0x00100,0x0B04F,0x8FFFF,0x106A00,0x1B7FBF,0x8030F,0x00000
+#define T_DD            0x00400,0x0FBCF,0x8FFFF,0x00800,0xB6FFF,0x8071F,0x00001
+#define T_DEL           0x00002,0x8B04F,0x8FEFF,0x87F8F,0xF7FBF,0x100003,0x00000
+#define T_DEL_2         0x100000,0x8BBCF,0x8FFFF,0xA7F8F,0xF7FBF,0x100003,0x00000
+#define T_DFN           0x00002,0x8B0CF,0x8FFFF,0x8778F,0xF7FBF,0x00003,0x00000
+#define T_DIR           0x00800,0x0B400,0x0F75F,0x137680,0x136FB7,0x84F7F,0x00000
+#define T_DIV           0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x80317,0x00004
+#define T_DL            0x00800,0x0C480,0x8FFFF,0x136680,0x1B7FB7,0x00757,0x00000
+#define T_DLC           0x00800,0x0C480,0x8FFFF,0x136680,0x1B7FB7,0x0075F,0x00000
+#define T_DT            0x00400,0x0B04F,0x0B1FF,0x00800,0x17FFF,0x8071F,0x00001
+#define T_EM            0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FAF,0x00003,0x00010
+#define T_EMBED         0x02000,0x8F107,0x8FFF7,0xB6FBF,0xB7FBF,0x1FF7F,0x00001
+#define T_FIELDSET      0x00200,0x8FB4F,0x8FF7F,0x186787,0x1B7FF7,0x8805F,0x00000
+#define T_FIG           0x00200,0x0FB00,0x8FFFF,0x136680,0x1B6FBF,0x8834F,0x00000
+#define T_FIGURE        0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_FN            0x00200,0x8FBCF,0x8FFFF,0x1B6680,0x1B7EBF,0x8114F,0x00000
+#define T_FONT          0x00001,0x8B04F,0x8FFFF,0xB778F,0xF7FBF,0x00001,0x00014
+#define T_FOOTER        0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_FORM          0x00080,0x0FF6F,0x0FF7F,0x136E07,0x132F07,0x88DFF,0x00000
+#define T_FRAME         0x10000,0x00000,0x00000,0x10000,0x10000,0x9FFFF,0x00001
+#define T_FRAMESET      0x10000,0x90000,0x90000,0x90000,0x93000,0x9FFFF,0x00000
+#define T_H1            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H2            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H3            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H4            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H5            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H6            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_HEAD          0x40000,0x4F000,0x47000,0x10000,0x10000,0x9FF7F,0x00007
+#define T_HEADER        0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_HR            0x04000,0x00000,0x00000,0x3FE80,0x3FFBF,0x87F37,0x00001
+#define T_HTML          0x10000,0x7FB8F,0x7FFFF,0x00000,0x00000,0x1FFFF,0x00003
+#define T_HY            0x01000,0x00000,0x00000,0x3779F,0x77FBF,0x8101F,0x00001
+#define T_I             0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_IFRAME        0x02000,0x8FBCF,0x8FFFF,0xB679F,0xB6FBF,0xD315F,0x00000
+#define T_IMG           0x01000,0x00000,0x00000,0x3779F,0x37FBF,0x80000,0x00001
+#define T_INPUT         0x00040,0x00000,0x00000,0x03F87,0x37F87,0x8904F,0x00001
+#define T_INS           0x00002,0x8B04F,0x8FEFF,0x87F8F,0xF7FBF,0x100003,0x00000
+#define T_INS_2         0x100000,0x8BBCF,0x8FFFF,0xA7F8F,0xF7FBF,0x100003,0x00000
+#define T_ISINDEX       0x08000,0x00000,0x00000,0x7778F,0x7FFAF,0x80007,0x00001
+#define T_KBD           0x00002,0x00000,0x00000,0x2778F,0x77FBF,0x00003,0x00000
+#define T_KEYGEN        0x00040,0x00000,0x00000,0x07FB7,0x37FB7,0x80070,0x00001
+#define T_LABEL         0x00002,0x0304F,0x0FFFF,0x0679F,0x36FBF,0x00007,0x00000
+#define T_LEGEND        0x00002,0x0B04F,0x8FF7F,0x00200,0xB7FA7,0x00003,0x00000
+#define T_LH            0x00400,0x0BB7F,0x8FFFF,0x00800,0x97FFF,0x8071F,0x00001
+#define T_LI            0x00400,0x0BBFF,0x8FFFF,0x00800,0x97FFF,0x8071F,0x00001
+#define T_LINK          0x08000,0x00000,0x00000,0x50000,0x50000,0x0FF7F,0x00001
+#define T_LISTING       0x00800,0x00000,0x00000,0x136600,0x136F00,0x80F1F,0x00000
+#define T_MAIN          0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_MAP           0x08000,0x08000,0x08000,0x37FCF,0x37FBF,0x0051F,0x00000
+#define T_MARQUEE       0x04000,0x0000F,0x8F01F,0x37787,0xB7FA7,0x8301C,0x00000
+#define T_MATH          0x00004,0x0B05F,0x8FFFF,0x2778F,0xF7FBF,0x0001F,0x00000
+#define T_MENU          0x00800,0x0B400,0x0F75F,0x117680,0x136FB7,0x88F7F,0x00000
+#define T_META          0x08000,0x00000,0x00000,0x50000,0x50000,0x0FF7F,0x00001
+#define T_NAV           0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_NEXTID        0x01000,0x00000,0x00000,0x50000,0x1FFF7,0x00001,0x00001
+#define T_NOFRAMES      0x20000,0x12FB8F,0x10FFFF,0x17000,0x17000,0x0CF5F,0x00000
+#define T_NOTE          0x00200,0x0BBAF,0x8FFFF,0x1376B0,0x1B7FFF,0x8031F,0x00000
+#define T_OBJECT        0x02000,0x8FBCF,0x8FFFF,0xB679F,0xB6FBF,0x83D5F,0x00020
+#define T_OL            0x00800,0x0C400,0x8FFFF,0x137680,0x1B7FB7,0x88F7F,0x00000
+#define T_OPTION        0x08000,0x00000,0x00000,0x00040,0x37FFF,0x8031F,0x00001
+#define T_OVERLAY       0x04000,0x00000,0x00000,0x00200,0x37FBF,0x83F7F,0x00001
+#define T_P             0x00100,0x0B04F,0x8FFFF,0x136680,0x1B6FA7,0x80117,0x00001
+#define T_PARAM         0x01000,0x00000,0x00000,0x33500,0x37FFF,0x81560,0x00001
+#define T_PLAINTEXT     0x10000,0xFFFFF,0xFFFFF,0x90000,0x90000,0x3FFFF,0x00001
+#define T_PRE           0x00200,0x0F04F,0x0F05E,0x136680,0x136FF0,0x8071E,0x00000
+#define T_Q             0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FAF,0x00003,0x00000
+#define T_S             0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00000
+#define T_SAMP          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00002,0x00010
+#define T_SCRIPT        0x02000,0x00000,0x00000,0x77F9F,0x77FFF,0x87D5F,0x00000
+#define T_SECTION       0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_SELECT        0x00040,0x08000,0x08000,0x03FAF,0x33FBF,0x80D5F,0x00008
+#define T_SHY           0x01000,0x00000,0x00000,0x3779F,0x77FBF,0x8101F,0x00001
+#define T_SMALL         0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_SPAN          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x80003,0x00000
+#define T_SPOT          0x00008,0x00000,0x00000,0x3FFF7,0x3FFF7,0x00008,0x00001
+#define T_STRIKE        0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00000
+#define T_STRONG        0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FAF,0x00003,0x00010
+#define T_STYLE         0x40000,0x00000,0x00000,0x7638F,0x76FAF,0x8001F,0x00000
+#define T_SUB           0x00004,0x8B05F,0x8FFFF,0x8779F,0xF7FBF,0x00007,0x00000
+#define T_SUP           0x00004,0x8B05F,0x8FFFF,0x8779F,0xF7FBF,0x00007,0x00000
+#define T_TAB           0x01000,0x00000,0x00000,0x3778F,0x57FAF,0x00001,0x00001
+#define T_TABLE         0x00800,0x0F1E0,0x8FFFF,0x136680,0x1B6FA7,0x8C57F,0x00000
+#define T_TBODY         0x00020,0x00020,0x8FFFF,0x00880,0xB7FB7,0x8C75F,0x00003
+#define T_TD            0x00400,0x0FBCF,0x8FFFF,0x00020,0xB7FB7,0x8C75F,0x00001
+#define T_TEXTAREA      0x00040,0x00000,0x00000,0x07F8F,0x33FBF,0x80D5F,0x00040
+#define T_TEXTFLOW      0x20000,0x18FBFF,0x19FFFF,0x977B0,0xB7FB7,0x9B00F,0x00003
+#define T_TFOOT         0x00020,0x00020,0x8FFFF,0x00800,0xB7FB7,0x8CF5F,0x00001
+#define T_TH            0x00400,0x0FBCF,0x0FFFF,0x00020,0xB7FB7,0x8CF5F,0x00001
+#define T_THEAD         0x00020,0x00020,0x8FFFF,0x00800,0xB7FB7,0x8CF5F,0x00001
+#define T_TITLE         0x40000,0x00000,0x00000,0x50000,0x50000,0x0031F,0x0000C
+#define T_TR            0x00020,0x00400,0x8FFFF,0x00820,0xB7FB7,0x8C75F,0x00001
+#define T_TT            0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00010
+#define T_U             0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_UL            0x00800,0x0C480,0x8FFFF,0x136680,0x1B7FFF,0x8075F,0x00000
+#define T_VAR           0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00000
+#define T_WBR           0x00001,0x00000,0x00000,0x3778F,0x77FBF,0x8101F,0x00001
+#define T_XMP           0x00800,0x00000,0x00000,0x1367E0,0x136FFF,0x0875F,0x00001
+#define T_OBJECT_PCDATA 0x02000,0x8FBCF,0x8FFFF,0xB679F,0xB6FBF,0x83D5F,0x00008
+#define T__UNREC_	0x00000,0x00000,0x00000,0x00000,0x00000,0x00000,0x00000
+#ifdef USE_PRETTYSRC
+# define N HTMLA_NORMAL
+# define i HTMLA_ANAME
+# define h HTMLA_HREF
+# define c HTMLA_CLASS
+# define x HTMLA_AUXCLASS
+# define T(t) , t
+#else
+# define T(t)			/*nothing */
+#endif
+/* *INDENT-OFF* */
+
+#define ATTR_TYPE(name) #name, name##_attr_list
+
+/* generic attributes, used in different tags */
+static const attr core_attr_list[] = {
+	{ "CLASS"         T(c) },
+	{ "ID"            T(i) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType core_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ 0, 0 },
+};
+
+static const attr i18n_attr_list[] = {
+	{ "DIR"           T(N) },
+	{ "LANG"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType i18n_attr_type[] = {
+	{ ATTR_TYPE(i18n) },
+	{ 0, 0 },
+};
+
+static const attr events_attr_list[] = {
+	{ "ONCLICK"       T(N) },
+	{ "ONDBLCLICK"    T(N) },
+	{ "ONKEYDOWN"     T(N) },
+	{ "ONKEYPRESS"    T(N) },
+	{ "ONKEYUP"       T(N) },
+	{ "ONMOUSEDOWN"   T(N) },
+	{ "ONMOUSEMOVE"   T(N) },
+	{ "ONMOUSEOUT"    T(N) },
+	{ "ONMOUSEOVER"   T(N) },
+	{ "ONMOUSEUP"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType events_attr_type[] = {
+	{ ATTR_TYPE(events) },
+	{ 0, 0 },
+};
+
+static const attr align_attr_list[] = {
+	{ "ALIGN"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType align_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ 0, 0 },
+};
+
+static const attr cellalign_attr_list[] = {
+	{ "ALIGN"         T(N) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "VALIGN"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType cellalign_attr_type[] = {
+	{ ATTR_TYPE(cellalign) },
+	{ 0, 0 },
+};
+
+static const attr bgcolor_attr_list[] = {
+	{ "BGCOLOR"       T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType bgcolor_attr_type[] = {
+	{ ATTR_TYPE(bgcolor) },
+	{ 0, 0 },
+};
+
+
+/* tables defining attributes per-tag in terms of generic attributes (editable) */
+static const attr A_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "CHARSET"       T(N) },
+	{ "CLEAR"         T(N) },
+	{ "COORDS"        T(N) },
+	{ "HREF"          T(h) },
+	{ "HREFLANG"      T(N) },
+	{ "ISMAP"         T(N) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(i) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "REL"           T(N) },
+	{ "REV"           T(N) },
+	{ "SHAPE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TARGET"        T(N) },
+	{ "TYPE"          T(N) },
+	{ "URN"           T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType A_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(A) },
+	{ 0, 0 },
+};
+
+static const attr ADDRESS_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "NOWRAP"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType ADDRESS_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(ADDRESS) },
+	{ 0, 0 },
+};
+
+static const attr APPLET_attr_list[] = {
+	{ "ALT"           T(N) },
+	{ "CLEAR"         T(N) },
+	{ "CODE"          T(N) },
+	{ "CODEBASE"      T(h) },
+	{ "DOWNLOAD"      T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "NAME"          T(i) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType APPLET_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(APPLET) },
+	{ 0, 0 },
+};
+
+static const attr AREA_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "ALT"           T(N) },
+	{ "CLEAR"         T(N) },
+	{ "COORDS"        T(N) },
+	{ "HREF"          T(h) },
+	{ "NOHREF"        T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "SHAPE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TARGET"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType AREA_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(AREA) },
+	{ 0, 0 },
+};
+
+static const attr BASE_attr_list[] = {
+	{ "HREF"          T(h) },
+	{ "TARGET"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BASE_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(BASE) },
+	{ 0, 0 },
+};
+
+static const attr BGSOUND_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "LOOP"          T(N) },
+	{ "SRC"           T(h) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BGSOUND_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BGSOUND) },
+	{ 0, 0 },
+};
+
+static const attr BODY_attr_list[] = {
+	{ "ALINK"         T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "CLEAR"         T(N) },
+	{ "LINK"          T(N) },
+	{ "ONLOAD"        T(N) },
+	{ "ONUNLOAD"      T(N) },
+	{ "TEXT"          T(N) },
+	{ "VLINK"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BODY_attr_type[] = {
+	{ ATTR_TYPE(bgcolor) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BODY) },
+	{ 0, 0 },
+};
+
+static const attr BODYTEXT_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DATA"          T(N) },
+	{ "NAME"          T(N) },
+	{ "OBJECT"        T(N) },
+	{ "REF"           T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ "VALUETYPE"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BODYTEXT_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BODYTEXT) },
+	{ 0, 0 },
+};
+
+static const attr BQ_attr_list[] = {
+	{ "CITE"          T(h) },
+	{ "CLEAR"         T(N) },
+	{ "NOWRAP"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BQ_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BQ) },
+	{ 0, 0 },
+};
+
+static const attr BUTTON_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "CLEAR"         T(N) },
+	{ "DISABLED"      T(N) },
+	{ "FORMACTION"    T(N) },
+	{ "NAME"          T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "READONLY"      T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BUTTON_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BUTTON) },
+	{ 0, 0 },
+};
+
+static const attr CAPTION_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType CAPTION_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(CAPTION) },
+	{ 0, 0 },
+};
+
+static const attr COL_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "SPAN"          T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType COL_attr_type[] = {
+	{ ATTR_TYPE(cellalign) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(COL) },
+	{ 0, 0 },
+};
+
+static const attr DEL_attr_list[] = {
+	{ "CITE"          T(N) },
+	{ "DATETIME"      T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType DEL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(DEL) },
+	{ 0, 0 },
+};
+
+static const attr DIV_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType DIV_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(DIV) },
+	{ 0, 0 },
+};
+
+static const attr DL_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType DL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(DL) },
+	{ 0, 0 },
+};
+
+static const attr EMBED_attr_list[] = {
+	{ "ALT"           T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLEAR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "IMAGEMAP"      T(N) },
+	{ "ISMAP"         T(N) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(i) },
+	{ "NOFLOW"        T(N) },
+	{ "PARAMS"        T(N) },
+	{ "SRC"           T(h) },
+	{ "UNITS"         T(N) },
+	{ "USEMAP"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType EMBED_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(EMBED) },
+	{ 0, 0 },
+};
+
+static const attr FIG_attr_list[] = {
+	{ "BORDER"        T(N) },
+	{ "CLEAR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "IMAGEMAP"      T(N) },
+	{ "ISOBJECT"      T(N) },
+	{ "MD"            T(N) },
+	{ "NOFLOW"        T(N) },
+	{ "SRC"           T(h) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FIG_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(FIG) },
+	{ 0, 0 },
+};
+
+static const attr FONT_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "COLOR"         T(N) },
+	{ "END"           T(N) },
+	{ "FACE"          T(N) },
+	{ "SIZE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FONT_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(FONT) },
+	{ 0, 0 },
+};
+
+static const attr FORM_attr_list[] = {
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACTION"        T(h) },
+	{ "CLEAR"         T(N) },
+	{ "ENCTYPE"       T(N) },
+	{ "METHOD"        T(N) },
+	{ "ONRESET"       T(N) },
+	{ "ONSUBMIT"      T(N) },
+	{ "SCRIPT"        T(N) },
+	{ "SUBJECT"       T(N) },
+	{ "TARGET"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FORM_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(FORM) },
+	{ 0, 0 },
+};
+
+static const attr FRAME_attr_list[] = {
+	{ "FRAMEBORDER"   T(N) },
+	{ "LONGDESC"      T(h) },
+	{ "MARGINHEIGHT"  T(N) },
+	{ "MARGINWIDTH"   T(N) },
+	{ "NAME"          T(N) },
+	{ "NORESIZE"      T(N) },
+	{ "SCROLLING"     T(N) },
+	{ "SRC"           T(h) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FRAME_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(FRAME) },
+	{ 0, 0 },
+};
+
+static const attr FRAMESET_attr_list[] = {
+	{ "COLS"          T(N) },
+	{ "ONLOAD"        T(N) },
+	{ "ONUNLOAD"      T(N) },
+	{ "ROWS"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FRAMESET_attr_type[] = {
+	{ ATTR_TYPE(FRAMESET) },
+	{ 0, 0 },
+};
+
+static const attr GEN_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType GEN_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(GEN) },
+	{ 0, 0 },
+};
+
+static const attr GEN5_attr_list[] = {
+	{ "ROLE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType GEN5_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(GEN5) },
+	{ 0, 0 },
+};
+
+static const attr H_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "MD"            T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "SEQNUM"        T(N) },
+	{ "SKIP"          T(N) },
+	{ "SRC"           T(h) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType H_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(H) },
+	{ 0, 0 },
+};
+
+static const attr HR_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "MD"            T(N) },
+	{ "NOSHADE"       T(N) },
+	{ "SIZE"          T(N) },
+	{ "SRC"           T(h) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType HR_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(HR) },
+	{ 0, 0 },
+};
+
+static const attr IFRAME_attr_list[] = {
+	{ "FRAMEBORDER"   T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "LONGDESC"      T(h) },
+	{ "MARGINHEIGHT"  T(N) },
+	{ "MARGINWIDTH"   T(N) },
+	{ "NAME"          T(N) },
+	{ "SCROLLING"     T(N) },
+	{ "SRC"           T(h) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType IFRAME_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(IFRAME) },
+	{ 0, 0 },
+};
+
+static const attr IMG_attr_list[] = {
+	{ "ALT"           T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLEAR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ISMAP"         T(N) },
+	{ "ISOBJECT"      T(N) },
+	{ "LONGDESC"      T(h) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(N) },
+	{ "SRC"           T(h) },
+	{ "UNITS"         T(N) },
+	{ "USEMAP"        T(h) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType IMG_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(IMG) },
+	{ 0, 0 },
+};
+
+static const attr INPUT_attr_list[] = {
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCESSKEY"     T(N) },
+	{ "ALT"           T(N) },
+	{ "CHECKED"       T(N) },
+	{ "CLEAR"         T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ISMAP"         T(N) },
+	{ "MAX"           T(N) },
+	{ "MAXLENGTH"     T(N) },
+	{ "MD"            T(N) },
+	{ "MIN"           T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "ONSELECT"      T(N) },
+	{ "READONLY"      T(N) },
+	{ "SIZE"          T(N) },
+	{ "SRC"           T(h) },
+	{ "TABINDEX"      T(N) },
+	{ "TYPE"          T(N) },
+	{ "USEMAP"        T(N) },
+	{ "VALUE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType INPUT_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(INPUT) },
+	{ 0, 0 },
+};
+
+static const attr ISINDEX_attr_list[] = {
+	{ "ACTION"        T(h) },
+	{ "HREF"          T(h) },
+	{ "PROMPT"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType ISINDEX_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(ISINDEX) },
+	{ 0, 0 },
+};
+
+static const attr KEYGEN_attr_list[] = {
+	{ "CHALLENGE"     T(N) },
+	{ "NAME"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType KEYGEN_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(KEYGEN) },
+	{ 0, 0 },
+};
+
+static const attr LABEL_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "CLEAR"         T(N) },
+	{ "FOR"           T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType LABEL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(LABEL) },
+	{ 0, 0 },
+};
+
+static const attr LI_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "MD"            T(N) },
+	{ "SKIP"          T(N) },
+	{ "SRC"           T(h) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType LI_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(LI) },
+	{ 0, 0 },
+};
+
+static const attr LINK_attr_list[] = {
+	{ "CHARSET"       T(N) },
+	{ "HREF"          T(h) },
+	{ "HREFLANG"      T(N) },
+	{ "MEDIA"         T(N) },
+	{ "REL"           T(N) },
+	{ "REV"           T(N) },
+	{ "TARGET"        T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType LINK_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(LINK) },
+	{ 0, 0 },
+};
+
+static const attr MAP_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "NAME"          T(i) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType MAP_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(MAP) },
+	{ 0, 0 },
+};
+
+static const attr MATH_attr_list[] = {
+	{ "BOX"           T(N) },
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType MATH_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(MATH) },
+	{ 0, 0 },
+};
+
+static const attr META_attr_list[] = {
+	{ "CHARSET"       T(N) },
+	{ "CONTENT"       T(N) },
+	{ "HTTP-EQUIV"    T(N) },
+	{ "NAME"          T(N) },
+	{ "SCHEME"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType META_attr_type[] = {
+	{ ATTR_TYPE(META) },
+	{ 0, 0 },
+};
+
+static const attr NEXTID_attr_list[] = {
+	{ "N"             T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType NEXTID_attr_type[] = {
+	{ ATTR_TYPE(NEXTID) },
+	{ 0, 0 },
+};
+
+static const attr NOTE_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "MD"            T(N) },
+	{ "ROLE"          T(x) },
+	{ "SRC"           T(h) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType NOTE_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(NOTE) },
+	{ 0, 0 },
+};
+
+static const attr OBJECT_attr_list[] = {
+	{ "ARCHIVE"       T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASSID"       T(h) },
+	{ "CODEBASE"      T(h) },
+	{ "CODETYPE"      T(N) },
+	{ "DATA"          T(h) },
+	{ "DECLARE"       T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ISMAP"         T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "SHAPES"        T(N) },
+	{ "STANDBY"       T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TYPE"          T(N) },
+	{ "USEMAP"        T(h) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType OBJECT_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(OBJECT) },
+	{ 0, 0 },
+};
+
+static const attr OL_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "CONTINUE"      T(N) },
+	{ "SEQNUM"        T(N) },
+	{ "START"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType OL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(OL) },
+	{ 0, 0 },
+};
+
+static const attr OPTION_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "LABEL"         T(N) },
+	{ "SELECTED"      T(N) },
+	{ "SHAPE"         T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType OPTION_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(OPTION) },
+	{ 0, 0 },
+};
+
+static const attr OVERLAY_attr_list[] = {
+	{ "HEIGHT"        T(N) },
+	{ "IMAGEMAP"      T(N) },
+	{ "MD"            T(N) },
+	{ "SRC"           T(h) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ "X"             T(N) },
+	{ "Y"             T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType OVERLAY_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(OVERLAY) },
+	{ 0, 0 },
+};
+
+static const attr P_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "NOWRAP"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType P_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(P) },
+	{ 0, 0 },
+};
+
+static const attr PARAM_attr_list[] = {
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCEPT-ENCODING" T(N) },
+	{ "CLEAR"         T(N) },
+	{ "DATA"          T(N) },
+	{ "NAME"          T(N) },
+	{ "OBJECT"        T(N) },
+	{ "REF"           T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ "VALUEREF"      T(N) },
+	{ "VALUETYPE"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType PARAM_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(PARAM) },
+	{ 0, 0 },
+};
+
+static const attr Q_attr_list[] = {
+	{ "CITE"          T(h) },
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType Q_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(Q) },
+	{ 0, 0 },
+};
+
+static const attr SCRIPT_attr_list[] = {
+	{ "CHARSET"       T(N) },
+	{ "CLEAR"         T(N) },
+	{ "DEFER"         T(N) },
+	{ "EVENT"         T(N) },
+	{ "FOR"           T(N) },
+	{ "LANGUAGE"      T(N) },
+	{ "NAME"          T(N) },
+	{ "SCRIPTENGINE"  T(N) },
+	{ "SRC"           T(h) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType SCRIPT_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(SCRIPT) },
+	{ 0, 0 },
+};
+
+static const attr SELECT_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "MD"            T(N) },
+	{ "MULTIPLE"      T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "SIZE"          T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType SELECT_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(SELECT) },
+	{ 0, 0 },
+};
+
+static const attr STYLE_attr_list[] = {
+	{ "MEDIA"         T(N) },
+	{ "NOTATION"      T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType STYLE_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(STYLE) },
+	{ 0, 0 },
+};
+
+static const attr TAB_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DP"            T(N) },
+	{ "INDENT"        T(N) },
+	{ "TO"            T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TAB_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TAB) },
+	{ 0, 0 },
+};
+
+static const attr TABLE_attr_list[] = {
+	{ "BACKGROUND"    T(h) },
+	{ "BORDER"        T(N) },
+	{ "CELLPADDING"   T(N) },
+	{ "CELLSPACING"   T(N) },
+	{ "CLEAR"         T(N) },
+	{ "COLS"          T(N) },
+	{ "COLSPEC"       T(N) },
+	{ "DP"            T(N) },
+	{ "FRAME"         T(N) },
+	{ "NOFLOW"        T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "RULES"         T(N) },
+	{ "SUMMARY"       T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TABLE_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TABLE) },
+	{ 0, 0 },
+};
+
+static const attr TD_attr_list[] = {
+	{ "ABBR"          T(N) },
+	{ "AXES"          T(N) },
+	{ "AXIS"          T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "CLEAR"         T(N) },
+	{ "COLSPAN"       T(N) },
+	{ "DP"            T(N) },
+	{ "HEADERS"       T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "ROWSPAN"       T(N) },
+	{ "SCOPE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TD_attr_type[] = {
+	{ ATTR_TYPE(cellalign) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TD) },
+	{ 0, 0 },
+};
+
+static const attr TEXTAREA_attr_list[] = {
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCESSKEY"     T(N) },
+	{ "CLEAR"         T(N) },
+	{ "COLS"          T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "ONSELECT"      T(N) },
+	{ "READONLY"      T(N) },
+	{ "ROWS"          T(N) },
+	{ "TABINDEX"      T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TEXTAREA_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TEXTAREA) },
+	{ 0, 0 },
+};
+
+static const attr TR_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DP"            T(N) },
+	{ "NOWRAP"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TR_attr_type[] = {
+	{ ATTR_TYPE(cellalign) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TR) },
+	{ 0, 0 },
+};
+
+static const attr UL_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "MD"            T(N) },
+	{ "PLAIN"         T(N) },
+	{ "SRC"           T(h) },
+	{ "TYPE"          T(N) },
+	{ "WRAP"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType UL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(UL) },
+	{ 0, 0 },
+};
+
+
+/* attribute lists for the runtime (generated by dtd_util) */
+static const attr A_attr[] = {          /* A attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "CHARSET"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COORDS"        T(N) },
+	{ "DIR"           T(N) },
+	{ "HREF"          T(h) },
+	{ "HREFLANG"      T(N) },
+	{ "ID"            T(i) },
+	{ "ISMAP"         T(N) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(i) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "REL"           T(N) },
+	{ "REV"           T(N) },
+	{ "SHAPE"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "URN"           T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr ADDRESS_attr[] = {    /* ADDRESS attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr APPLET_attr[] = {     /* APPLET attributes */
+	{ "ALIGN"         T(N) },
+	{ "ALT"           T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "CODE"          T(N) },
+	{ "CODEBASE"      T(h) },
+	{ "DIR"           T(N) },
+	{ "DOWNLOAD"      T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(i) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr AREA_attr[] = {       /* AREA attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "ALT"           T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COORDS"        T(N) },
+	{ "DIR"           T(N) },
+	{ "HREF"          T(h) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOHREF"        T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "SHAPE"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BASE_attr[] = {       /* BASE attributes */
+	{ "CLASS"         T(c) },
+	{ "HREF"          T(h) },
+	{ "ID"            T(i) },
+	{ "STYLE"         T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BGSOUND_attr[] = {    /* BGSOUND attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "LOOP"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BODY_attr[] = {       /* BODY attributes */
+	{ "ALINK"         T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "BGCOLOR"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "LINK"          T(N) },
+	{ "ONLOAD"        T(N) },
+	{ "ONUNLOAD"      T(N) },
+	{ "STYLE"         T(N) },
+	{ "TEXT"          T(N) },
+	{ "TITLE"         T(N) },
+	{ "VLINK"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BODYTEXT_attr[] = {   /* BODYTEXT attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DATA"          T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "OBJECT"        T(N) },
+	{ "REF"           T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ "VALUETYPE"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BQ_attr[] = {         /* BLOCKQUOTE attributes */
+	{ "CITE"          T(h) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BUTTON_attr[] = {     /* BUTTON attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "FORMACTION"    T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "READONLY"      T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr CAPTION_attr[] = {    /* CAPTION attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr COL_attr[] = {        /* COL attributes */
+	{ "ALIGN"         T(N) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "SPAN"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VALIGN"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr DEL_attr[] = {        /* DEL attributes */
+	{ "CITE"          T(N) },
+	{ "CLASS"         T(c) },
+	{ "DATETIME"      T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr DIV_attr[] = {        /* CENTER attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr DL_attr[] = {         /* DL attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr EMBED_attr[] = {      /* EMBED attributes */
+	{ "ALIGN"         T(N) },
+	{ "ALT"           T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "IMAGEMAP"      T(N) },
+	{ "ISMAP"         T(N) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(i) },
+	{ "NOFLOW"        T(N) },
+	{ "PARAMS"        T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "USEMAP"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FIG_attr[] = {        /* FIG attributes */
+	{ "ALIGN"         T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "IMAGEMAP"      T(N) },
+	{ "ISOBJECT"      T(N) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NOFLOW"        T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FONT_attr[] = {       /* BASEFONT attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COLOR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "END"           T(N) },
+	{ "FACE"          T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "SIZE"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FORM_attr[] = {       /* FORM attributes */
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACTION"        T(h) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ENCTYPE"       T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "METHOD"        T(N) },
+	{ "ONRESET"       T(N) },
+	{ "ONSUBMIT"      T(N) },
+	{ "SCRIPT"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "SUBJECT"       T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FRAME_attr[] = {      /* FRAME attributes */
+	{ "CLASS"         T(c) },
+	{ "FRAMEBORDER"   T(N) },
+	{ "ID"            T(i) },
+	{ "LONGDESC"      T(h) },
+	{ "MARGINHEIGHT"  T(N) },
+	{ "MARGINWIDTH"   T(N) },
+	{ "NAME"          T(N) },
+	{ "NORESIZE"      T(N) },
+	{ "SCROLLING"     T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FRAMESET_attr[] = {   /* FRAMESET attributes */
+	{ "COLS"          T(N) },
+	{ "ONLOAD"        T(N) },
+	{ "ONUNLOAD"      T(N) },
+	{ "ROWS"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr GEN_attr[] = {        /* ABBR attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr GEN5_attr[] = {       /* ARTICLE attributes */
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "ROLE"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr H_attr[] = {          /* H1 attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "SEQNUM"        T(N) },
+	{ "SKIP"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr HR_attr[] = {         /* HR attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NOSHADE"       T(N) },
+	{ "SIZE"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr IFRAME_attr[] = {     /* IFRAME attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "FRAMEBORDER"   T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "LONGDESC"      T(h) },
+	{ "MARGINHEIGHT"  T(N) },
+	{ "MARGINWIDTH"   T(N) },
+	{ "NAME"          T(N) },
+	{ "SCROLLING"     T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr IMG_attr[] = {        /* IMG attributes */
+	{ "ALIGN"         T(N) },
+	{ "ALT"           T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ID"            T(i) },
+	{ "ISMAP"         T(N) },
+	{ "ISOBJECT"      T(N) },
+	{ "LANG"          T(N) },
+	{ "LONGDESC"      T(h) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "USEMAP"        T(h) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr INPUT_attr[] = {      /* INPUT attributes */
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCESSKEY"     T(N) },
+	{ "ALIGN"         T(N) },
+	{ "ALT"           T(N) },
+	{ "CHECKED"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "ISMAP"         T(N) },
+	{ "LANG"          T(N) },
+	{ "MAX"           T(N) },
+	{ "MAXLENGTH"     T(N) },
+	{ "MD"            T(N) },
+	{ "MIN"           T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "ONSELECT"      T(N) },
+	{ "READONLY"      T(N) },
+	{ "SIZE"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "USEMAP"        T(N) },
+	{ "VALUE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr ISINDEX_attr[] = {    /* ISINDEX attributes */
+	{ "ACTION"        T(h) },
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "HREF"          T(h) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "PROMPT"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr KEYGEN_attr[] = {     /* KEYGEN attributes */
+	{ "CHALLENGE"     T(N) },
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr LABEL_attr[] = {      /* LABEL attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "FOR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr LI_attr[] = {         /* LI attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "SKIP"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr LINK_attr[] = {       /* LINK attributes */
+	{ "CHARSET"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "HREF"          T(h) },
+	{ "HREFLANG"      T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MEDIA"         T(N) },
+	{ "REL"           T(N) },
+	{ "REV"           T(N) },
+	{ "STYLE"         T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr MAP_attr[] = {        /* MAP attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(i) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr MATH_attr[] = {       /* MATH attributes */
+	{ "BOX"           T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr META_attr[] = {       /* META attributes */
+	{ "CHARSET"       T(N) },
+	{ "CONTENT"       T(N) },
+	{ "HTTP-EQUIV"    T(N) },
+	{ "NAME"          T(N) },
+	{ "SCHEME"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr NEXTID_attr[] = {     /* NEXTID attributes */
+	{ "N"             T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr NOTE_attr[] = {       /* NOTE attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "ROLE"          T(x) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr OBJECT_attr[] = {     /* OBJECT attributes */
+	{ "ALIGN"         T(N) },
+	{ "ARCHIVE"       T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLASSID"       T(h) },
+	{ "CODEBASE"      T(h) },
+	{ "CODETYPE"      T(N) },
+	{ "DATA"          T(h) },
+	{ "DECLARE"       T(N) },
+	{ "DIR"           T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ID"            T(i) },
+	{ "ISMAP"         T(N) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "SHAPES"        T(N) },
+	{ "STANDBY"       T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "USEMAP"        T(h) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr OL_attr[] = {         /* OL attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "CONTINUE"      T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "SEQNUM"        T(N) },
+	{ "START"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr OPTION_attr[] = {     /* OPTION attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "ID"            T(i) },
+	{ "LABEL"         T(N) },
+	{ "LANG"          T(N) },
+	{ "SELECTED"      T(N) },
+	{ "SHAPE"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr OVERLAY_attr[] = {    /* OVERLAY attributes */
+	{ "CLASS"         T(c) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "IMAGEMAP"      T(N) },
+	{ "MD"            T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ "X"             T(N) },
+	{ "Y"             T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr P_attr[] = {          /* P attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr PARAM_attr[] = {      /* PARAM attributes */
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCEPT-ENCODING" T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DATA"          T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "OBJECT"        T(N) },
+	{ "REF"           T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ "VALUEREF"      T(N) },
+	{ "VALUETYPE"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr Q_attr[] = {          /* Q attributes */
+	{ "CITE"          T(h) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr SCRIPT_attr[] = {     /* SCRIPT attributes */
+	{ "CHARSET"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DEFER"         T(N) },
+	{ "DIR"           T(N) },
+	{ "EVENT"         T(N) },
+	{ "FOR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "LANGUAGE"      T(N) },
+	{ "NAME"          T(N) },
+	{ "SCRIPTENGINE"  T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr SELECT_attr[] = {     /* SELECT attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "MULTIPLE"      T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "SIZE"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr STYLE_attr[] = {      /* STYLE attributes */
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MEDIA"         T(N) },
+	{ "NOTATION"      T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TAB_attr[] = {        /* TAB attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DP"            T(N) },
+	{ "ID"            T(i) },
+	{ "INDENT"        T(N) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TO"            T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TABLE_attr[] = {      /* TABLE attributes */
+	{ "ALIGN"         T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "BORDER"        T(N) },
+	{ "CELLPADDING"   T(N) },
+	{ "CELLSPACING"   T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COLS"          T(N) },
+	{ "COLSPEC"       T(N) },
+	{ "DIR"           T(N) },
+	{ "DP"            T(N) },
+	{ "FRAME"         T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOFLOW"        T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "RULES"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "SUMMARY"       T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TD_attr[] = {         /* TD attributes */
+	{ "ABBR"          T(N) },
+	{ "ALIGN"         T(N) },
+	{ "AXES"          T(N) },
+	{ "AXIS"          T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COLSPAN"       T(N) },
+	{ "DIR"           T(N) },
+	{ "DP"            T(N) },
+	{ "HEADERS"       T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "ROWSPAN"       T(N) },
+	{ "SCOPE"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VALIGN"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TEXTAREA_attr[] = {   /* TEXTAREA attributes */
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCESSKEY"     T(N) },
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COLS"          T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "ONSELECT"      T(N) },
+	{ "READONLY"      T(N) },
+	{ "ROWS"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TR_attr[] = {         /* TBODY attributes */
+	{ "ALIGN"         T(N) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DP"            T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VALIGN"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr UL_attr[] = {         /* DIR attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "PLAIN"         T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "WRAP"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+/* *INDENT-ON* */
+
+/* justification-flags */
+#undef N
+#undef i
+#undef h
+#undef c
+#undef x
+
+#undef T
+
+/* tag-names */
+#undef A
+#undef ABBR
+#undef ACRONYM
+#undef ADDRESS
+#undef APPLET
+#undef AREA
+#undef ARTICLE
+#undef ASIDE
+#undef AU
+#undef AUTHOR
+#undef B
+#undef BANNER
+#undef BASE
+#undef BASEFONT
+#undef BDO
+#undef BGSOUND
+#undef BIG
+#undef BLINK
+#undef BLOCKQUOTE
+#undef BODY
+#undef BODYTEXT
+#undef BQ
+#undef BR
+#undef BUTTON
+#undef CAPTION
+#undef CENTER
+#undef CITE
+#undef CODE
+#undef COL
+#undef COLGROUP
+#undef COMMENT
+#undef CREDIT
+#undef DD
+#undef DEL
+#undef DEL
+#undef DFN
+#undef DIR
+#undef DIV
+#undef DL
+#undef DLC
+#undef DT
+#undef EM
+#undef EMBED
+#undef FIELDSET
+#undef FIG
+#undef FIGURE
+#undef FN
+#undef FONT
+#undef FOOTER
+#undef FORM
+#undef FRAME
+#undef FRAMESET
+#undef H1
+#undef H2
+#undef H3
+#undef H4
+#undef H5
+#undef H6
+#undef HEAD
+#undef HEADER
+#undef HR
+#undef HTML
+#undef HY
+#undef I
+#undef IFRAME
+#undef IMG
+#undef INPUT
+#undef INS
+#undef INS
+#undef ISINDEX
+#undef KBD
+#undef KEYGEN
+#undef LABEL
+#undef LEGEND
+#undef LH
+#undef LI
+#undef LINK
+#undef LISTING
+#undef MAIN
+#undef MAP
+#undef MARQUEE
+#undef MATH
+#undef MENU
+#undef META
+#undef NAV
+#undef NEXTID
+#undef NOFRAMES
+#undef NOTE
+#undef OBJECT
+#undef OL
+#undef OPTION
+#undef OVERLAY
+#undef P
+#undef PARAM
+#undef PLAINTEXT
+#undef PRE
+#undef Q
+#undef S
+#undef SAMP
+#undef SCRIPT
+#undef SECTION
+#undef SELECT
+#undef SHY
+#undef SMALL
+#undef SPAN
+#undef SPOT
+#undef STRIKE
+#undef STRONG
+#undef STYLE
+#undef SUB
+#undef SUP
+#undef TAB
+#undef TABLE
+#undef TBODY
+#undef TD
+#undef TEXTAREA
+#undef TEXTFLOW
+#undef TFOOT
+#undef TH
+#undef THEAD
+#undef TITLE
+#undef TR
+#undef TT
+#undef U
+#undef UL
+#undef VAR
+#undef WBR
+#undef XMP
+#undef OBJECT_PCDATA
+
+/* these definitions are used in the tags-tables */
+#undef P
+#undef P_
+#ifdef USE_COLOR_STYLE
+#define P_(x) #x, (sizeof #x) -1
+#define NULL_HTTag_ NULL, 0
+#else
+#define P_(x) #x
+#define NULL_HTTag_ NULL
+#endif
+
+#ifdef USE_JUSTIFY_ELTS
+#define P(x) P_(x), 1
+#define P0(x) P_(x), 0
+#define NULL_HTTag NULL_HTTag_,0
+#else
+#define P(x) P_(x)
+#define P0(x) P_(x)
+#define NULL_HTTag NULL_HTTag_
+#endif
+
+#define ATTR_DATA(name) name##_attr, HTML_##name##_ATTRIBUTES, name##_attr_type
+
+#endif /* once_HTMLDTD */
+/* *INDENT-OFF* */
+static const HTTag tags_table0[HTML_ALL_ELEMENTS] = {
+ { P(A),           ATTR_DATA(A),           SGML_EMPTY,   T_A, 0, 0},
+ { P(ABBR),        ATTR_DATA(GEN),         SGML_MIXED,   T_ABBR, 0, 0},
+ { P(ACRONYM),     ATTR_DATA(GEN),         SGML_MIXED,   T_ACRONYM, 0, 0},
+ { P(ADDRESS),     ATTR_DATA(ADDRESS),     SGML_MIXED,   T_ADDRESS, 0, 0},
+ { P(APPLET),      ATTR_DATA(APPLET),      SGML_MIXED,   T_APPLET, 0, 0},
+ { P(AREA),        ATTR_DATA(AREA),        SGML_EMPTY,   T_AREA, 0, 0},
+ { P(ARTICLE),     ATTR_DATA(GEN5),        SGML_MIXED,   T_ARTICLE, 0, 0},
+ { P(ASIDE),       ATTR_DATA(GEN5),        SGML_MIXED,   T_ASIDE, 0, 0},
+ { P(AU),          ATTR_DATA(GEN),         SGML_MIXED,   T_AU, 0, 0},
+ { P(AUTHOR),      ATTR_DATA(GEN),         SGML_MIXED,   T_AUTHOR, 0, 0},
+ { P(B),           ATTR_DATA(GEN),         SGML_EMPTY,   T_B, 0, 0},
+ { P0(BANNER),     ATTR_DATA(GEN),         SGML_MIXED,   T_BANNER, 0, 0},
+ { P(BASE),        ATTR_DATA(BASE),        SGML_EMPTY,   T_BASE, 0, 0},
+ { P(BASEFONT),    ATTR_DATA(FONT),        SGML_EMPTY,   T_BASEFONT, 0, 0},
+ { P(BDO),         ATTR_DATA(GEN),         SGML_MIXED,   T_BDO, 0, 0},
+ { P(BGSOUND),     ATTR_DATA(BGSOUND),     SGML_EMPTY,   T_BGSOUND, 0, 0},
+ { P(BIG),         ATTR_DATA(GEN),         SGML_MIXED,   T_BIG, 0, 0},
+ { P(BLINK),       ATTR_DATA(GEN),         SGML_EMPTY,   T_BLINK, 0, 0},
+ { P(BLOCKQUOTE),  ATTR_DATA(BQ),          SGML_MIXED,   T_BLOCKQUOTE, 0, 0},
+ { P(BODY),        ATTR_DATA(BODY),        SGML_MIXED,   T_BODY, 0, 0},
+ { P(BODYTEXT),    ATTR_DATA(BODYTEXT),    SGML_MIXED,   T_BODYTEXT, 0, 0},
+ { P(BQ),          ATTR_DATA(BQ),          SGML_MIXED,   T_BQ, 0, 0},
+ { P(BR),          ATTR_DATA(GEN),         SGML_EMPTY,   T_BR, 0, 0},
+ { P(BUTTON),      ATTR_DATA(BUTTON),      SGML_MIXED,   T_BUTTON, 0, 0},
+ { P(CAPTION),     ATTR_DATA(CAPTION),     SGML_MIXED,   T_CAPTION, 0, 0},
+ { P(CENTER),      ATTR_DATA(DIV),         SGML_MIXED,   T_CENTER, 0, 0},
+ { P(CITE),        ATTR_DATA(GEN),         SGML_EMPTY,   T_CITE, 0, 0},
+ { P(CODE),        ATTR_DATA(GEN),         SGML_MIXED,   T_CODE, 0, 0},
+ { P(COL),         ATTR_DATA(COL),         SGML_EMPTY,   T_COL, 0, 0},
+ { P(COLGROUP),    ATTR_DATA(COL),         SGML_EMPTY,   T_COLGROUP, 0, 0},
+ { P(COMMENT),     ATTR_DATA(GEN),         SGML_MIXED,   T_COMMENT, 0, 0},
+ { P(CREDIT),      ATTR_DATA(GEN),         SGML_MIXED,   T_CREDIT, 0, 0},
+ { P(DD),          ATTR_DATA(GEN),         SGML_EMPTY,   T_DD, 0, 0},
+ { P(DEL),         ATTR_DATA(DEL),         SGML_MIXED,   T_DEL, 0, 1},
+ { P(DEL),         ATTR_DATA(DEL),         SGML_MIXED,   T_DEL_2, 1, 1},
+ { P(DFN),         ATTR_DATA(GEN),         SGML_MIXED,   T_DFN, 0, 0},
+ { P(DIR),         ATTR_DATA(UL),          SGML_MIXED,   T_DIR, 0, 0},
+ { P(DIV),         ATTR_DATA(DIV),         SGML_MIXED,   T_DIV, 0, 0},
+ { P(DL),          ATTR_DATA(DL),          SGML_MIXED,   T_DL, 0, 0},
+ { P(DLC),         ATTR_DATA(DL),          SGML_MIXED,   T_DLC, 0, 0},
+ { P(DT),          ATTR_DATA(GEN),         SGML_EMPTY,   T_DT, 0, 0},
+ { P(EM),          ATTR_DATA(GEN),         SGML_EMPTY,   T_EM, 0, 0},
+ { P(EMBED),       ATTR_DATA(EMBED),       SGML_EMPTY,   T_EMBED, 0, 0},
+ { P(FIELDSET),    ATTR_DATA(GEN),         SGML_MIXED,   T_FIELDSET, 0, 0},
+ { P(FIG),         ATTR_DATA(FIG),         SGML_MIXED,   T_FIG, 0, 0},
+ { P(FIGURE),      ATTR_DATA(GEN5),        SGML_MIXED,   T_FIGURE, 0, 0},
+ { P(FN),          ATTR_DATA(GEN),         SGML_MIXED,   T_FN, 0, 0},
+ { P(FONT),        ATTR_DATA(FONT),        SGML_EMPTY,   T_FONT, 0, 0},
+ { P(FOOTER),      ATTR_DATA(GEN5),        SGML_MIXED,   T_FOOTER, 0, 0},
+ { P(FORM),        ATTR_DATA(FORM),        SGML_EMPTY,   T_FORM, 0, 0},
+ { P(FRAME),       ATTR_DATA(FRAME),       SGML_EMPTY,   T_FRAME, 0, 0},
+ { P(FRAMESET),    ATTR_DATA(FRAMESET),    SGML_MIXED,   T_FRAMESET, 0, 0},
+ { P0(H1),         ATTR_DATA(H),           SGML_MIXED,   T_H1, 0, 0},
+ { P0(H2),         ATTR_DATA(H),           SGML_MIXED,   T_H2, 0, 0},
+ { P0(H3),         ATTR_DATA(H),           SGML_MIXED,   T_H3, 0, 0},
+ { P0(H4),         ATTR_DATA(H),           SGML_MIXED,   T_H4, 0, 0},
+ { P0(H5),         ATTR_DATA(H),           SGML_MIXED,   T_H5, 0, 0},
+ { P0(H6),         ATTR_DATA(H),           SGML_MIXED,   T_H6, 0, 0},
+ { P(HEAD),        ATTR_DATA(GEN),         SGML_MIXED,   T_HEAD, 0, 0},
+ { P(HEADER),      ATTR_DATA(GEN5),        SGML_MIXED,   T_HEADER, 0, 0},
+ { P(HR),          ATTR_DATA(HR),          SGML_EMPTY,   T_HR, 0, 0},
+ { P(HTML),        ATTR_DATA(GEN),         SGML_MIXED,   T_HTML, 0, 0},
+ { P(HY),          ATTR_DATA(GEN),         SGML_EMPTY,   T_HY, 0, 0},
+ { P(I),           ATTR_DATA(GEN),         SGML_EMPTY,   T_I, 0, 0},
+ { P(IFRAME),      ATTR_DATA(IFRAME),      SGML_MIXED,   T_IFRAME, 0, 0},
+ { P(IMG),         ATTR_DATA(IMG),         SGML_EMPTY,   T_IMG, 0, 0},
+ { P(INPUT),       ATTR_DATA(INPUT),       SGML_EMPTY,   T_INPUT, 0, 0},
+ { P(INS),         ATTR_DATA(DEL),         SGML_MIXED,   T_INS, 0, 1},
+ { P(INS),         ATTR_DATA(DEL),         SGML_MIXED,   T_INS_2, 1, 1},
+ { P(ISINDEX),     ATTR_DATA(ISINDEX),     SGML_EMPTY,   T_ISINDEX, 0, 0},
+ { P(KBD),         ATTR_DATA(GEN),         SGML_MIXED,   T_KBD, 0, 0},
+ { P(KEYGEN),      ATTR_DATA(KEYGEN),      SGML_EMPTY,   T_KEYGEN, 0, 0},
+ { P(LABEL),       ATTR_DATA(LABEL),       SGML_MIXED,   T_LABEL, 0, 0},
+ { P(LEGEND),      ATTR_DATA(CAPTION),     SGML_MIXED,   T_LEGEND, 0, 0},
+ { P(LH),          ATTR_DATA(GEN),         SGML_EMPTY,   T_LH, 0, 0},
+ { P(LI),          ATTR_DATA(LI),          SGML_EMPTY,   T_LI, 0, 0},
+ { P(LINK),        ATTR_DATA(LINK),        SGML_EMPTY,   T_LINK, 0, 0},
+ { P(LISTING),     ATTR_DATA(GEN),         SGML_LITTERAL,T_LISTING, 0, 0},
+ { P(MAIN),        ATTR_DATA(GEN5),        SGML_MIXED,   T_MAIN, 0, 0},
+ { P(MAP),         ATTR_DATA(MAP),         SGML_MIXED,   T_MAP, 0, 0},
+ { P(MARQUEE),     ATTR_DATA(GEN),         SGML_MIXED,   T_MARQUEE, 0, 0},
+ { P(MATH),        ATTR_DATA(MATH),        SGML_LITTERAL,T_MATH, 0, 0},
+ { P(MENU),        ATTR_DATA(UL),          SGML_MIXED,   T_MENU, 0, 0},
+ { P(META),        ATTR_DATA(META),        SGML_EMPTY,   T_META, 0, 0},
+ { P(NAV),         ATTR_DATA(GEN5),        SGML_MIXED,   T_NAV, 0, 0},
+ { P(NEXTID),      ATTR_DATA(NEXTID),      SGML_EMPTY,   T_NEXTID, 0, 0},
+ { P(NOFRAMES),    ATTR_DATA(GEN),         SGML_MIXED,   T_NOFRAMES, 0, 0},
+ { P(NOTE),        ATTR_DATA(NOTE),        SGML_MIXED,   T_NOTE, 0, 0},
+ { P(OBJECT),      ATTR_DATA(OBJECT),      SGML_LITTERAL,T_OBJECT, 0, 0},
+ { P(OL),          ATTR_DATA(OL),          SGML_MIXED,   T_OL, 0, 0},
+ { P(OPTION),      ATTR_DATA(OPTION),      SGML_EMPTY,   T_OPTION, 0, 0},
+ { P(OVERLAY),     ATTR_DATA(OVERLAY),     SGML_EMPTY,   T_OVERLAY, 0, 0},
+ { P(P),           ATTR_DATA(P),           SGML_EMPTY,   T_P, 0, 0},
+ { P(PARAM),       ATTR_DATA(PARAM),       SGML_EMPTY,   T_PARAM, 0, 0},
+ { P(PLAINTEXT),   ATTR_DATA(GEN),         SGML_LITTERAL,T_PLAINTEXT, 0, 0},
+ { P0(PRE),        ATTR_DATA(GEN),         SGML_MIXED,   T_PRE, 0, 0},
+ { P(Q),           ATTR_DATA(Q),           SGML_MIXED,   T_Q, 0, 0},
+ { P(S),           ATTR_DATA(GEN),         SGML_MIXED,   T_S, 0, 0},
+ { P(SAMP),        ATTR_DATA(GEN),         SGML_MIXED,   T_SAMP, 0, 0},
+ { P(SCRIPT),      ATTR_DATA(SCRIPT),      SGML_LITTERAL,T_SCRIPT, 0, 0},
+ { P(SECTION),     ATTR_DATA(GEN5),        SGML_MIXED,   T_SECTION, 0, 0},
+ { P(SELECT),      ATTR_DATA(SELECT),      SGML_MIXED,   T_SELECT, 0, 0},
+ { P(SHY),         ATTR_DATA(GEN),         SGML_EMPTY,   T_SHY, 0, 0},
+ { P(SMALL),       ATTR_DATA(GEN),         SGML_MIXED,   T_SMALL, 0, 0},
+ { P(SPAN),        ATTR_DATA(GEN),         SGML_MIXED,   T_SPAN, 0, 0},
+ { P(SPOT),        ATTR_DATA(GEN),         SGML_EMPTY,   T_SPOT, 0, 0},
+ { P(STRIKE),      ATTR_DATA(GEN),         SGML_MIXED,   T_STRIKE, 0, 0},
+ { P(STRONG),      ATTR_DATA(GEN),         SGML_EMPTY,   T_STRONG, 0, 0},
+ { P(STYLE),       ATTR_DATA(STYLE),       SGML_LITTERAL,T_STYLE, 0, 0},
+ { P(SUB),         ATTR_DATA(GEN),         SGML_MIXED,   T_SUB, 0, 0},
+ { P(SUP),         ATTR_DATA(GEN),         SGML_MIXED,   T_SUP, 0, 0},
+ { P(TAB),         ATTR_DATA(TAB),         SGML_EMPTY,   T_TAB, 0, 0},
+ { P(TABLE),       ATTR_DATA(TABLE),       SGML_MIXED,   T_TABLE, 0, 0},
+ { P(TBODY),       ATTR_DATA(TR),          SGML_EMPTY,   T_TBODY, 0, 0},
+ { P(TD),          ATTR_DATA(TD),          SGML_EMPTY,   T_TD, 0, 0},
+ { P(TEXTAREA),    ATTR_DATA(TEXTAREA),    SGML_LITTERAL,T_TEXTAREA, 0, 0},
+ { P(TEXTFLOW),    ATTR_DATA(BODYTEXT),    SGML_MIXED,   T_TEXTFLOW, 0, 0},
+ { P(TFOOT),       ATTR_DATA(TR),          SGML_EMPTY,   T_TFOOT, 0, 0},
+ { P(TH),          ATTR_DATA(TD),          SGML_EMPTY,   T_TH, 0, 0},
+ { P(THEAD),       ATTR_DATA(TR),          SGML_EMPTY,   T_THEAD, 0, 0},
+ { P(TITLE),       ATTR_DATA(GEN),         SGML_RCDATA,  T_TITLE, 0, 0},
+ { P(TR),          ATTR_DATA(TR),          SGML_EMPTY,   T_TR, 0, 0},
+ { P(TT),          ATTR_DATA(GEN),         SGML_EMPTY,   T_TT, 0, 0},
+ { P(U),           ATTR_DATA(GEN),         SGML_EMPTY,   T_U, 0, 0},
+ { P(UL),          ATTR_DATA(UL),          SGML_MIXED,   T_UL, 0, 0},
+ { P(VAR),         ATTR_DATA(GEN),         SGML_MIXED,   T_VAR, 0, 0},
+ { P(WBR),         ATTR_DATA(GEN),         SGML_EMPTY,   T_WBR, 0, 0},
+ { P0(XMP),        ATTR_DATA(GEN),         SGML_LITTERAL,T_XMP, 0, 0},
+/* additional (alternative variants), not counted in HTML_ELEMENTS: */
+/* This one will be used as a temporary substitute within the parser when
+   it has been signalled to parse OBJECT content as MIXED. - kw */
+ { P(OBJECT),      ATTR_DATA(OBJECT),      SGML_MIXED,   T_OBJECT_PCDATA, 0, 0},
+};
+/* *INDENT-ON* */
+
+#endif /* src_HTMLDTD_H0 */
diff --git a/WWW/Library/Implementation/src0_HTMLDTD.txt b/WWW/Library/Implementation/src0_HTMLDTD.txt
new file mode 100644
index 0000000..a3c51d9
--- /dev/null
+++ b/WWW/Library/Implementation/src0_HTMLDTD.txt
@@ -0,0 +1,3901 @@
+60 attr_types
+	0:align
+		1 attributes:
+			0:0:ALIGN
+	1:bgcolor
+		1 attributes:
+			0:0:BGCOLOR
+	2:cellalign
+		4 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:0:VALIGN
+	3:core
+		4 attributes:
+			0:4:CLASS
+			1:1:ID
+			2:0:STYLE
+			3:0:TITLE
+	4:events
+		10 attributes:
+			0:0:ONCLICK
+			1:0:ONDBLCLICK
+			2:0:ONKEYDOWN
+			3:0:ONKEYPRESS
+			4:0:ONKEYUP
+			5:0:ONMOUSEDOWN
+			6:0:ONMOUSEMOVE
+			7:0:ONMOUSEOUT
+			8:0:ONMOUSEOVER
+			9:0:ONMOUSEUP
+	5:i18n
+		2 attributes:
+			0:0:DIR
+			1:0:LANG
+	6:A
+		19 attributes:
+			0:0:ACCESSKEY
+			1:0:CHARSET
+			2:0:CLEAR
+			3:0:COORDS
+			4:2:HREF
+			5:0:HREFLANG
+			6:0:ISMAP
+			7:0:MD
+			8:1:NAME
+			9:0:NOTAB
+			10:0:ONBLUR
+			11:0:ONFOCUS
+			12:0:REL
+			13:0:REV
+			14:0:SHAPE
+			15:0:TABINDEX
+			16:0:TARGET
+			17:0:TYPE
+			18:0:URN
+	7:ADDRESS
+		2 attributes:
+			0:0:CLEAR
+			1:0:NOWRAP
+	8:APPLET
+		10 attributes:
+			0:0:ALT
+			1:0:CLEAR
+			2:0:CODE
+			3:2:CODEBASE
+			4:0:DOWNLOAD
+			5:0:HEIGHT
+			6:0:HSPACE
+			7:1:NAME
+			8:0:VSPACE
+			9:0:WIDTH
+	9:AREA
+		12 attributes:
+			0:0:ACCESSKEY
+			1:0:ALT
+			2:0:CLEAR
+			3:0:COORDS
+			4:2:HREF
+			5:0:NOHREF
+			6:0:NOTAB
+			7:0:ONBLUR
+			8:0:ONFOCUS
+			9:0:SHAPE
+			10:0:TABINDEX
+			11:0:TARGET
+	10:BASE
+		2 attributes:
+			0:2:HREF
+			1:0:TARGET
+	11:BGSOUND
+		3 attributes:
+			0:0:CLEAR
+			1:0:LOOP
+			2:2:SRC
+	12:BODY
+		8 attributes:
+			0:0:ALINK
+			1:2:BACKGROUND
+			2:0:CLEAR
+			3:0:LINK
+			4:0:ONLOAD
+			5:0:ONUNLOAD
+			6:0:TEXT
+			7:0:VLINK
+	13:BODYTEXT
+		8 attributes:
+			0:0:CLEAR
+			1:0:DATA
+			2:0:NAME
+			3:0:OBJECT
+			4:0:REF
+			5:0:TYPE
+			6:0:VALUE
+			7:0:VALUETYPE
+	14:BQ
+		3 attributes:
+			0:2:CITE
+			1:0:CLEAR
+			2:0:NOWRAP
+	15:BUTTON
+		11 attributes:
+			0:0:ACCESSKEY
+			1:0:CLEAR
+			2:0:DISABLED
+			3:0:FORMACTION
+			4:0:NAME
+			5:0:ONBLUR
+			6:0:ONFOCUS
+			7:0:READONLY
+			8:0:TABINDEX
+			9:0:TYPE
+			10:0:VALUE
+	16:CAPTION
+		2 attributes:
+			0:0:ACCESSKEY
+			1:0:CLEAR
+	17:COL
+		3 attributes:
+			0:0:CLEAR
+			1:0:SPAN
+			2:0:WIDTH
+	18:DEL
+		2 attributes:
+			0:0:CITE
+			1:0:DATETIME
+	19:DIV
+		1 attributes:
+			0:0:CLEAR
+	20:DL
+		2 attributes:
+			0:0:CLEAR
+			1:0:COMPACT
+	21:EMBED
+		14 attributes:
+			0:0:ALT
+			1:0:BORDER
+			2:0:CLEAR
+			3:0:HEIGHT
+			4:0:IMAGEMAP
+			5:0:ISMAP
+			6:0:MD
+			7:1:NAME
+			8:0:NOFLOW
+			9:0:PARAMS
+			10:2:SRC
+			11:0:UNITS
+			12:0:USEMAP
+			13:0:WIDTH
+	22:FIG
+		10 attributes:
+			0:0:BORDER
+			1:0:CLEAR
+			2:0:HEIGHT
+			3:0:IMAGEMAP
+			4:0:ISOBJECT
+			5:0:MD
+			6:0:NOFLOW
+			7:2:SRC
+			8:0:UNITS
+			9:0:WIDTH
+	23:FONT
+		5 attributes:
+			0:0:CLEAR
+			1:0:COLOR
+			2:0:END
+			3:0:FACE
+			4:0:SIZE
+	24:FORM
+		11 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:2:ACTION
+			3:0:CLEAR
+			4:0:ENCTYPE
+			5:0:METHOD
+			6:0:ONRESET
+			7:0:ONSUBMIT
+			8:0:SCRIPT
+			9:0:SUBJECT
+			10:0:TARGET
+	25:FRAME
+		8 attributes:
+			0:0:FRAMEBORDER
+			1:2:LONGDESC
+			2:0:MARGINHEIGHT
+			3:0:MARGINWIDTH
+			4:0:NAME
+			5:0:NORESIZE
+			6:0:SCROLLING
+			7:2:SRC
+	26:FRAMESET
+		4 attributes:
+			0:0:COLS
+			1:0:ONLOAD
+			2:0:ONUNLOAD
+			3:0:ROWS
+	27:GEN
+		1 attributes:
+			0:0:CLEAR
+	28:GEN5
+		1 attributes:
+			0:0:ROLE
+	29:H
+		7 attributes:
+			0:0:CLEAR
+			1:0:DINGBAT
+			2:0:MD
+			3:0:NOWRAP
+			4:0:SEQNUM
+			5:0:SKIP
+			6:2:SRC
+	30:HR
+		6 attributes:
+			0:0:CLEAR
+			1:0:MD
+			2:0:NOSHADE
+			3:0:SIZE
+			4:2:SRC
+			5:0:WIDTH
+	31:IFRAME
+		9 attributes:
+			0:0:FRAMEBORDER
+			1:0:HEIGHT
+			2:2:LONGDESC
+			3:0:MARGINHEIGHT
+			4:0:MARGINWIDTH
+			5:0:NAME
+			6:0:SCROLLING
+			7:2:SRC
+			8:0:WIDTH
+	32:IMG
+		15 attributes:
+			0:0:ALT
+			1:0:BORDER
+			2:0:CLEAR
+			3:0:HEIGHT
+			4:0:HSPACE
+			5:0:ISMAP
+			6:0:ISOBJECT
+			7:2:LONGDESC
+			8:0:MD
+			9:0:NAME
+			10:2:SRC
+			11:0:UNITS
+			12:2:USEMAP
+			13:0:VSPACE
+			14:0:WIDTH
+	33:INPUT
+		28 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:0:ACCESSKEY
+			3:0:ALT
+			4:0:CHECKED
+			5:0:CLEAR
+			6:0:DISABLED
+			7:0:ERROR
+			8:0:HEIGHT
+			9:0:ISMAP
+			10:0:MAX
+			11:0:MAXLENGTH
+			12:0:MD
+			13:0:MIN
+			14:0:NAME
+			15:0:NOTAB
+			16:0:ONBLUR
+			17:0:ONCHANGE
+			18:0:ONFOCUS
+			19:0:ONSELECT
+			20:0:READONLY
+			21:0:SIZE
+			22:2:SRC
+			23:0:TABINDEX
+			24:0:TYPE
+			25:0:USEMAP
+			26:0:VALUE
+			27:0:WIDTH
+	34:ISINDEX
+		3 attributes:
+			0:2:ACTION
+			1:2:HREF
+			2:0:PROMPT
+	35:KEYGEN
+		2 attributes:
+			0:0:CHALLENGE
+			1:0:NAME
+	36:LABEL
+		5 attributes:
+			0:0:ACCESSKEY
+			1:0:CLEAR
+			2:0:FOR
+			3:0:ONBLUR
+			4:0:ONFOCUS
+	37:LI
+		7 attributes:
+			0:0:CLEAR
+			1:0:DINGBAT
+			2:0:MD
+			3:0:SKIP
+			4:2:SRC
+			5:0:TYPE
+			6:0:VALUE
+	38:LINK
+		8 attributes:
+			0:0:CHARSET
+			1:2:HREF
+			2:0:HREFLANG
+			3:0:MEDIA
+			4:0:REL
+			5:0:REV
+			6:0:TARGET
+			7:0:TYPE
+	39:MAP
+		2 attributes:
+			0:0:CLEAR
+			1:1:NAME
+	40:MATH
+		2 attributes:
+			0:0:BOX
+			1:0:CLEAR
+	41:META
+		5 attributes:
+			0:0:CHARSET
+			1:0:CONTENT
+			2:0:HTTP-EQUIV
+			3:0:NAME
+			4:0:SCHEME
+	42:NEXTID
+		1 attributes:
+			0:0:N
+	43:NOTE
+		4 attributes:
+			0:0:CLEAR
+			1:0:MD
+			2:8:ROLE
+			3:2:SRC
+	44:OBJECT
+		19 attributes:
+			0:0:ARCHIVE
+			1:0:BORDER
+			2:2:CLASSID
+			3:2:CODEBASE
+			4:0:CODETYPE
+			5:2:DATA
+			6:0:DECLARE
+			7:0:HEIGHT
+			8:0:HSPACE
+			9:0:ISMAP
+			10:0:NAME
+			11:0:NOTAB
+			12:0:SHAPES
+			13:0:STANDBY
+			14:0:TABINDEX
+			15:0:TYPE
+			16:2:USEMAP
+			17:0:VSPACE
+			18:0:WIDTH
+	45:OL
+		6 attributes:
+			0:0:CLEAR
+			1:0:COMPACT
+			2:0:CONTINUE
+			3:0:SEQNUM
+			4:0:START
+			5:0:TYPE
+	46:OPTION
+		7 attributes:
+			0:0:CLEAR
+			1:0:DISABLED
+			2:0:ERROR
+			3:0:LABEL
+			4:0:SELECTED
+			5:0:SHAPE
+			6:0:VALUE
+	47:OVERLAY
+		8 attributes:
+			0:0:HEIGHT
+			1:0:IMAGEMAP
+			2:0:MD
+			3:2:SRC
+			4:0:UNITS
+			5:0:WIDTH
+			6:0:X
+			7:0:Y
+	48:P
+		2 attributes:
+			0:0:CLEAR
+			1:0:NOWRAP
+	49:PARAM
+		12 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:0:ACCEPT-ENCODING
+			3:0:CLEAR
+			4:0:DATA
+			5:0:NAME
+			6:0:OBJECT
+			7:0:REF
+			8:0:TYPE
+			9:0:VALUE
+			10:0:VALUEREF
+			11:0:VALUETYPE
+	50:Q
+		2 attributes:
+			0:2:CITE
+			1:0:CLEAR
+	51:SCRIPT
+		10 attributes:
+			0:0:CHARSET
+			1:0:CLEAR
+			2:0:DEFER
+			3:0:EVENT
+			4:0:FOR
+			5:0:LANGUAGE
+			6:0:NAME
+			7:0:SCRIPTENGINE
+			8:2:SRC
+			9:0:TYPE
+	52:SELECT
+		15 attributes:
+			0:0:CLEAR
+			1:0:DISABLED
+			2:0:ERROR
+			3:0:HEIGHT
+			4:0:MD
+			5:0:MULTIPLE
+			6:0:NAME
+			7:0:NOTAB
+			8:0:ONBLUR
+			9:0:ONCHANGE
+			10:0:ONFOCUS
+			11:0:SIZE
+			12:0:TABINDEX
+			13:0:UNITS
+			14:0:WIDTH
+	53:STYLE
+		3 attributes:
+			0:0:MEDIA
+			1:0:NOTATION
+			2:0:TYPE
+	54:TAB
+		4 attributes:
+			0:0:CLEAR
+			1:0:DP
+			2:0:INDENT
+			3:0:TO
+	55:TABLE
+		15 attributes:
+			0:2:BACKGROUND
+			1:0:BORDER
+			2:0:CELLPADDING
+			3:0:CELLSPACING
+			4:0:CLEAR
+			5:0:COLS
+			6:0:COLSPEC
+			7:0:DP
+			8:0:FRAME
+			9:0:NOFLOW
+			10:0:NOWRAP
+			11:0:RULES
+			12:0:SUMMARY
+			13:0:UNITS
+			14:0:WIDTH
+	56:TD
+		13 attributes:
+			0:0:ABBR
+			1:0:AXES
+			2:0:AXIS
+			3:2:BACKGROUND
+			4:0:CLEAR
+			5:0:COLSPAN
+			6:0:DP
+			7:0:HEADERS
+			8:0:HEIGHT
+			9:0:NOWRAP
+			10:0:ROWSPAN
+			11:0:SCOPE
+			12:0:WIDTH
+	57:TEXTAREA
+		15 attributes:
+			0:0:ACCEPT-CHARSET
+			1:0:ACCESSKEY
+			2:0:CLEAR
+			3:0:COLS
+			4:0:DISABLED
+			5:0:ERROR
+			6:0:NAME
+			7:0:NOTAB
+			8:0:ONBLUR
+			9:0:ONCHANGE
+			10:0:ONFOCUS
+			11:0:ONSELECT
+			12:0:READONLY
+			13:0:ROWS
+			14:0:TABINDEX
+	58:TR
+		3 attributes:
+			0:0:CLEAR
+			1:0:DP
+			2:0:NOWRAP
+	59:UL
+		8 attributes:
+			0:0:CLEAR
+			1:0:COMPACT
+			2:0:DINGBAT
+			3:0:MD
+			4:0:PLAIN
+			5:2:SRC
+			6:0:TYPE
+			7:0:WRAP
+128 tags
+	0:A
+		justify
+		25 attributes:
+			0:0:ACCESSKEY
+			1:0:CHARSET
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:COORDS
+			5:0:DIR
+			6:2:HREF
+			7:0:HREFLANG
+			8:1:ID
+			9:0:ISMAP
+			10:0:LANG
+			11:0:MD
+			12:1:NAME
+			13:0:NOTAB
+			14:0:ONBLUR
+			15:0:ONFOCUS
+			16:0:REL
+			17:0:REV
+			18:0:SHAPE
+			19:0:STYLE
+			20:0:TABINDEX
+			21:0:TARGET
+			22:0:TITLE
+			23:0:TYPE
+			24:0:URN
+		4 attr_types
+			core
+			events
+			i18n
+			A
+		contents: SGML_EMPTY
+		tagclass: Alike
+		contains: FONTlike EMlike MATHlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike formula Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike SELECTlike APPLETlike HRlike same
+		flags: mafse nreie
+	1:ABBR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	2:ACRONYM
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	3:ADDRESS
+		justify
+		8 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:NOWRAP
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			ADDRESS
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike Plike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike DIVlike same
+		flags:
+	4:APPLET
+		justify
+		17 attributes:
+			0:0:ALIGN
+			1:0:ALT
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:CODE
+			5:2:CODEBASE
+			6:0:DIR
+			7:0:DOWNLOAD
+			8:0:HEIGHT
+			9:0:HSPACE
+			10:1:ID
+			11:0:LANG
+			12:1:NAME
+			13:0:STYLE
+			14:0:TITLE
+			15:0:VSPACE
+			16:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			APPLET
+		contents: SGML_MIXED
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike BRlike APPLETlike same
+		flags:
+	5:AREA
+		justify
+		18 attributes:
+			0:0:ACCESSKEY
+			1:0:ALT
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:COORDS
+			5:0:DIR
+			6:2:HREF
+			7:1:ID
+			8:0:LANG
+			9:0:NOHREF
+			10:0:NOTAB
+			11:0:ONBLUR
+			12:0:ONFOCUS
+			13:0:SHAPE
+			14:0:STYLE
+			15:0:TABINDEX
+			16:0:TARGET
+			17:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			AREA
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: MAPlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike ULlike
+		flags: endO
+	6:ARTICLE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	7:ASIDE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	8:AU
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	9:AUTHOR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	10:B
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	11:BANNER
+		nojustify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: outer BODYlike DELlike
+		icontained: outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags:
+	12:BASE
+		justify
+		6 attributes:
+			0:4:CLASS
+			1:2:HREF
+			2:1:ID
+			3:0:STYLE
+			4:0:TARGET
+			5:0:TITLE
+		2 attr_types
+			core
+			BASE
+		contents: SGML_EMPTY
+		tagclass: HEADstuff
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: outer HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike same
+		flags: endO
+	13:BASEFONT
+		justify
+		11 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COLOR
+			3:0:DIR
+			4:0:END
+			5:0:FACE
+			6:1:ID
+			7:0:LANG
+			8:0:SIZE
+			9:0:STYLE
+			10:0:TITLE
+		3 attr_types
+			core
+			i18n
+			FONT
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: BRlike APPLETlike HRlike MAPlike same
+		flags: endO
+	14:BDO
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike Plike DIVlike
+		flags:
+	15:BGSOUND
+		justify
+		9 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:LOOP
+			6:2:SRC
+			7:0:STYLE
+			8:0:TITLE
+		3 attr_types
+			core
+			i18n
+			BGSOUND
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike Plike DIVlike BRlike APPLETlike HRlike same
+		flags: endO
+	16:BIG
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	17:BLINK
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	18:BLOCKQUOTE
+		justify
+		9 attributes:
+			0:2:CITE
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NOWRAP
+			7:0:STYLE
+			8:0:TITLE
+		3 attr_types
+			core
+			i18n
+			BQ
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags:
+	19:BODY
+		justify
+		15 attributes:
+			0:0:ALINK
+			1:2:BACKGROUND
+			2:0:BGCOLOR
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:1:ID
+			7:0:LANG
+			8:0:LINK
+			9:0:ONLOAD
+			10:0:ONUNLOAD
+			11:0:STYLE
+			12:0:TEXT
+			13:0:TITLE
+			14:0:VLINK
+		4 attr_types
+			bgcolor
+			core
+			i18n
+			BODY
+		contents: SGML_MIXED
+		tagclass: BODYlike
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike DELlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike DELlike
+		contained: outer BODYlike
+		icontained: outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer HEADstuff same
+		flags: endO startO
+	20:BODYTEXT
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DATA
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NAME
+			7:0:OBJECT
+			8:0:REF
+			9:0:STYLE
+			10:0:TITLE
+			11:0:TYPE
+			12:0:VALUE
+			13:0:VALUETYPE
+		3 attr_types
+			core
+			i18n
+			BODYTEXT
+		contents: SGML_MIXED
+		tagclass: BODYlike
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike DELlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same DELlike
+		contained: DIVlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike BRlike APPLETlike HRlike MAPlike same
+		flags: endO startO
+	21:BQ
+		justify
+		9 attributes:
+			0:2:CITE
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NOWRAP
+			7:0:STYLE
+			8:0:TITLE
+		3 attr_types
+			core
+			i18n
+			BQ
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags:
+	22:BR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula BRlike same
+		flags: endO
+	23:BUTTON
+		justify
+		17 attributes:
+			0:0:ACCESSKEY
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:0:DISABLED
+			5:0:FORMACTION
+			6:1:ID
+			7:0:LANG
+			8:0:NAME
+			9:0:ONBLUR
+			10:0:ONFOCUS
+			11:0:READONLY
+			12:0:STYLE
+			13:0:TABINDEX
+			14:0:TITLE
+			15:0:TYPE
+			16:0:VALUE
+		4 attr_types
+			core
+			events
+			i18n
+			BUTTON
+		contents: SGML_MIXED
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Plike DIVlike ULlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike formula TRlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike BRlike same
+		flags:
+	24:CAPTION
+		justify
+		9 attributes:
+			0:0:ACCESSKEY
+			1:0:ALIGN
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:STYLE
+			8:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			CAPTION
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: DIVlike ULlike APPLETlike HRlike DELlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike same
+		flags:
+	25:CENTER
+		justify
+		8 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			align
+			core
+			i18n
+			DIV
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags:
+	26:CITE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: EMlike
+		flags: nreie
+	27:CODE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: EMlike
+		flags:
+	28:COL
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:1:ID
+			7:0:LANG
+			8:0:SPAN
+			9:0:STYLE
+			10:0:TITLE
+			11:0:VALIGN
+			12:0:WIDTH
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			COL
+		contents: SGML_EMPTY
+		tagclass: HRlike
+		contains:
+		icontains:
+		contained: TRlike ULlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike MAPlike same
+		flags: endO
+	29:COLGROUP
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:1:ID
+			7:0:LANG
+			8:0:SPAN
+			9:0:STYLE
+			10:0:TITLE
+			11:0:VALIGN
+			12:0:WIDTH
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			COL
+		contents: SGML_EMPTY
+		tagclass: TRlike
+		contains: HRlike
+		icontains: HRlike
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike MAPlike same
+		flags: endO
+	30:COMMENT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: MATHlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike
+		flags:
+	31:CREDIT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: DIVlike ULlike APPLETlike HRlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike Plike DIVlike same
+		flags:
+	32:DD
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags: endO
+	33:DEL
+		justify
+		8 attributes:
+			0:0:CITE
+			1:4:CLASS
+			2:0:DATETIME
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			DEL
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike DELlike
+		flags:
+	34:DEL!
+		justify
+		8 attributes:
+			0:0:CITE
+			1:4:CLASS
+			2:0:DATETIME
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			DEL
+		contents: SGML_MIXED
+		tagclass: DELlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike DELlike
+		flags:
+	35:DFN
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	36:DIR
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:PLAIN
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+			12:0:TYPE
+			13:0:WRAP
+		3 attr_types
+			core
+			i18n
+			UL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: LIlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike BRlike APPLETlike HRlike MAPlike
+		contained: FORMlike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike HRlike same
+		flags:
+	37:DIV
+		justify
+		8 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			align
+			core
+			i18n
+			DIV
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike DIVlike same
+		flags: mafse
+	38:DL
+		justify
+		8 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			DL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: FORMlike LIlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike formula SELECTlike Plike DIVlike LIlike
+		flags:
+	39:DLC
+		justify
+		8 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			DL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: FORMlike LIlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike
+		flags:
+	40:DT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike BRlike APPLETlike MAPlike
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags: endO
+	41:EM
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags: nreie
+	42:EMBED
+		justify
+		21 attributes:
+			0:0:ALIGN
+			1:0:ALT
+			2:0:BORDER
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:HEIGHT
+			7:1:ID
+			8:0:IMAGEMAP
+			9:0:ISMAP
+			10:0:LANG
+			11:0:MD
+			12:1:NAME
+			13:0:NOFLOW
+			14:0:PARAMS
+			15:2:SRC
+			16:0:STYLE
+			17:0:TITLE
+			18:0:UNITS
+			19:0:USEMAP
+			20:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			EMBED
+		contents: SGML_EMPTY
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Plike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer
+		flags: endO
+	43:FIELDSET
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike APPLETlike HRlike same DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike MAPlike same
+		flags:
+	44:FIG
+		justify
+		17 attributes:
+			0:0:ALIGN
+			1:0:BORDER
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:DIR
+			5:0:HEIGHT
+			6:1:ID
+			7:0:IMAGEMAP
+			8:0:ISOBJECT
+			9:0:LANG
+			10:0:MD
+			11:0:NOFLOW
+			12:2:SRC
+			13:0:STYLE
+			14:0:TITLE
+			15:0:UNITS
+			16:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			FIG
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike SELECTlike Plike DIVlike MAPlike same
+		flags:
+	45:FIGURE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	46:FN
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike SELECTlike Plike BRlike same
+		flags:
+	47:FONT
+		justify
+		11 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COLOR
+			3:0:DIR
+			4:0:END
+			5:0:FACE
+			6:1:ID
+			7:0:LANG
+			8:0:SIZE
+			9:0:STYLE
+			10:0:TITLE
+		3 attr_types
+			core
+			i18n
+			FONT
+		contents: SGML_EMPTY
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	48:FOOTER
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	49:FORM
+		justify
+		17 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:2:ACTION
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:ENCTYPE
+			7:1:ID
+			8:0:LANG
+			9:0:METHOD
+			10:0:ONRESET
+			11:0:ONSUBMIT
+			12:0:SCRIPT
+			13:0:STYLE
+			14:0:SUBJECT
+			15:0:TARGET
+			16:0:TITLE
+		3 attr_types
+			core
+			i18n
+			FORM
+		contents: SGML_EMPTY
+		tagclass: FORMlike
+		contains: FONTlike EMlike MATHlike Alike TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: FONTlike EMlike MATHlike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Plike DIVlike LIlike ULlike APPLETlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike LIlike ULlike MAPlike same
+		flags:
+	50:FRAME
+		justify
+		12 attributes:
+			0:4:CLASS
+			1:0:FRAMEBORDER
+			2:1:ID
+			3:2:LONGDESC
+			4:0:MARGINHEIGHT
+			5:0:MARGINWIDTH
+			6:0:NAME
+			7:0:NORESIZE
+			8:0:SCROLLING
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+		2 attr_types
+			core
+			FRAME
+		contents: SGML_EMPTY
+		tagclass: outer
+		contains:
+		icontains:
+		contained: outer
+		icontained: outer
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer same
+		flags: endO
+	51:FRAMESET
+		justify
+		4 attributes:
+			0:0:COLS
+			1:0:ONLOAD
+			2:0:ONUNLOAD
+			3:0:ROWS
+		1 attr_types
+			FRAMESET
+		contents: SGML_MIXED
+		tagclass: outer
+		contains: outer same
+		icontains: outer same
+		contained: outer same
+		icontained: BRlike APPLETlike outer same
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer same
+		flags:
+	52:H1
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	53:H2
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	54:H3
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	55:H4
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	56:H5
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	57:H6
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	58:HEAD
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: HEADstuff
+		contains: BRlike APPLETlike HRlike MAPlike HEADstuff
+		icontains: BRlike APPLETlike HRlike HEADstuff
+		contained: outer
+		icontained: outer
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer same
+		flags: endO startO mafse
+	59:HEADER
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	60:HR
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:MD
+			7:0:NOSHADE
+			8:0:SIZE
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+			12:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			HR
+		contents: SGML_EMPTY
+		tagclass: HRlike
+		contains:
+		icontains:
+		contained: FORMlike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike formula TRlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike same
+		flags: endO
+	61:HTML
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: outer
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff
+		contained:
+		icontained:
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer
+		flags: endO startO
+	62:HY
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula BRlike same
+		flags: endO
+	63:I
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	64:IFRAME
+		justify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:FRAMEBORDER
+			3:0:HEIGHT
+			4:1:ID
+			5:2:LONGDESC
+			6:0:MARGINHEIGHT
+			7:0:MARGINWIDTH
+			8:0:NAME
+			9:0:SCROLLING
+			10:2:SRC
+			11:0:STYLE
+			12:0:TITLE
+			13:0:WIDTH
+		3 attr_types
+			align
+			core
+			IFRAME
+		contents: SGML_MIXED
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike APPLETlike HRlike outer BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike BRlike APPLETlike outer HEADstuff same
+		flags:
+	65:IMG
+		justify
+		22 attributes:
+			0:0:ALIGN
+			1:0:ALT
+			2:0:BORDER
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:HEIGHT
+			7:0:HSPACE
+			8:1:ID
+			9:0:ISMAP
+			10:0:ISOBJECT
+			11:0:LANG
+			12:2:LONGDESC
+			13:0:MD
+			14:0:NAME
+			15:2:SRC
+			16:0:STYLE
+			17:0:TITLE
+			18:0:UNITS
+			19:2:USEMAP
+			20:0:VSPACE
+			21:0:WIDTH
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			IMG
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: same
+		flags: endO
+	66:INPUT
+		justify
+		35 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:0:ACCESSKEY
+			3:0:ALIGN
+			4:0:ALT
+			5:0:CHECKED
+			6:4:CLASS
+			7:0:CLEAR
+			8:0:DIR
+			9:0:DISABLED
+			10:0:ERROR
+			11:0:HEIGHT
+			12:1:ID
+			13:0:ISMAP
+			14:0:LANG
+			15:0:MAX
+			16:0:MAXLENGTH
+			17:0:MD
+			18:0:MIN
+			19:0:NAME
+			20:0:NOTAB
+			21:0:ONBLUR
+			22:0:ONCHANGE
+			23:0:ONFOCUS
+			24:0:ONSELECT
+			25:0:READONLY
+			26:0:SIZE
+			27:2:SRC
+			28:0:STYLE
+			29:0:TABINDEX
+			30:0:TITLE
+			31:0:TYPE
+			32:0:USEMAP
+			33:0:VALUE
+			34:0:WIDTH
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			INPUT
+		contents: SGML_EMPTY
+		tagclass: SELECTlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike
+		icontained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike SELECTlike BRlike MAPlike same
+		flags: endO
+	67:INS
+		justify
+		8 attributes:
+			0:0:CITE
+			1:4:CLASS
+			2:0:DATETIME
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			DEL
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike DELlike
+		flags:
+	68:INS!
+		justify
+		8 attributes:
+			0:0:CITE
+			1:4:CLASS
+			2:0:DATETIME
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			DEL
+		contents: SGML_MIXED
+		tagclass: DELlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike DELlike
+		flags:
+	69:ISINDEX
+		justify
+		9 attributes:
+			0:2:ACTION
+			1:4:CLASS
+			2:0:DIR
+			3:2:HREF
+			4:1:ID
+			5:0:LANG
+			6:0:PROMPT
+			7:0:STYLE
+			8:0:TITLE
+		3 attr_types
+			core
+			i18n
+			ISINDEX
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike same
+		flags: endO
+	70:KBD
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike
+		flags:
+	71:KEYGEN
+		justify
+		8 attributes:
+			0:0:CHALLENGE
+			1:4:CLASS
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:NAME
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			KEYGEN
+		contents: SGML_EMPTY
+		tagclass: SELECTlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: formula TRlike SELECTlike same
+		flags: endO
+	72:LABEL
+		justify
+		11 attributes:
+			0:0:ACCESSKEY
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:0:FOR
+			5:1:ID
+			6:0:LANG
+			7:0:ONBLUR
+			8:0:ONFOCUS
+			9:0:STYLE
+			10:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			LABEL
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike APPLETlike HRlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike
+		flags:
+	73:LEGEND
+		justify
+		9 attributes:
+			0:0:ACCESSKEY
+			1:0:ALIGN
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:STYLE
+			8:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			CAPTION
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: DIVlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike
+		flags:
+	74:LH
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike ULlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer same
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags: endO
+	75:LI
+		justify
+		13 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DINGBAT
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:MD
+			7:0:SKIP
+			8:2:SRC
+			9:0:STYLE
+			10:0:TITLE
+			11:0:TYPE
+			12:0:VALUE
+		4 attr_types
+			core
+			events
+			i18n
+			LI
+		contents: SGML_EMPTY
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer same
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags: endO
+	76:LINK
+		justify
+		14 attributes:
+			0:0:CHARSET
+			1:4:CLASS
+			2:0:DIR
+			3:2:HREF
+			4:0:HREFLANG
+			5:1:ID
+			6:0:LANG
+			7:0:MEDIA
+			8:0:REL
+			9:0:REV
+			10:0:STYLE
+			11:0:TARGET
+			12:0:TITLE
+			13:0:TYPE
+		4 attr_types
+			core
+			events
+			i18n
+			LINK
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: outer HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		flags: endO
+	77:LISTING
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_LITTERAL
+		tagclass: ULlike
+		contains:
+		icontains:
+		contained: DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike ULlike same
+		flags:
+	78:MAIN
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	79:MAP
+		justify
+		8 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:1:NAME
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			MAP
+		contents: SGML_MIXED
+		tagclass: MAPlike
+		contains: MAPlike
+		icontains: MAPlike
+		contained: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike LIlike
+		flags:
+	80:MARQUEE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: HRlike
+		contains: FONTlike EMlike MATHlike Alike
+		icontains: FONTlike EMlike MATHlike Alike formula BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: MATHlike Alike formula BRlike APPLETlike same
+		flags:
+	81:MATH
+		justify
+		8 attributes:
+			0:0:BOX
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			MATH
+		contents: SGML_LITTERAL
+		tagclass: MATHlike
+		contains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike MATHlike Alike formula
+		flags:
+	82:MENU
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:PLAIN
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+			12:0:TYPE
+			13:0:WRAP
+		3 attr_types
+			core
+			i18n
+			UL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: LIlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike BRlike APPLETlike HRlike MAPlike
+		contained: FORMlike DIVlike LIlike BRlike APPLETlike HRlike outer DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike MAPlike same
+		flags:
+	83:META
+		justify
+		5 attributes:
+			0:0:CHARSET
+			1:0:CONTENT
+			2:0:HTTP-EQUIV
+			3:0:NAME
+			4:0:SCHEME
+		1 attr_types
+			META
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: outer HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		flags: endO
+	84:NAV
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	85:NEXTID
+		justify
+		1 attributes:
+			0:0:N
+		1 attr_types
+			NEXTID
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer
+		canclose: FONTlike
+		flags: endO
+	86:NOFRAMES
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: BODYlike
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike DELlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike DELlike
+		contained: BRlike APPLETlike HRlike outer
+		icontained: BRlike APPLETlike HRlike outer
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike HRlike MAPlike
+		flags:
+	87:NOTE
+		justify
+		10 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:MD
+			6:8:ROLE
+			7:2:SRC
+			8:0:STYLE
+			9:0:TITLE
+		3 attr_types
+			core
+			i18n
+			NOTE
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike ULlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: formula TRlike FORMlike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags:
+	88:OBJECT
+		justify
+		26 attributes:
+			0:0:ALIGN
+			1:0:ARCHIVE
+			2:0:BORDER
+			3:4:CLASS
+			4:2:CLASSID
+			5:2:CODEBASE
+			6:0:CODETYPE
+			7:2:DATA
+			8:0:DECLARE
+			9:0:DIR
+			10:0:HEIGHT
+			11:0:HSPACE
+			12:1:ID
+			13:0:ISMAP
+			14:0:LANG
+			15:0:NAME
+			16:0:NOTAB
+			17:0:SHAPES
+			18:0:STANDBY
+			19:0:STYLE
+			20:0:TABINDEX
+			21:0:TITLE
+			22:0:TYPE
+			23:2:USEMAP
+			24:0:VSPACE
+			25:0:WIDTH
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			OBJECT
+		contents: SGML_LITTERAL
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike APPLETlike HRlike outer BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike LIlike ULlike BRlike APPLETlike same
+		flags: frecyc
+	89:OL
+		justify
+		12 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:CONTINUE
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:SEQNUM
+			8:0:START
+			9:0:STYLE
+			10:0:TITLE
+			11:0:TYPE
+		3 attr_types
+			core
+			i18n
+			OL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: LIlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike MAPlike same
+		flags:
+	90:OPTION
+		justify
+		13 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:0:DISABLED
+			4:0:ERROR
+			5:1:ID
+			6:0:LABEL
+			7:0:LANG
+			8:0:SELECTED
+			9:0:SHAPE
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALUE
+		4 attr_types
+			core
+			events
+			i18n
+			OPTION
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: SELECTlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: endO
+	91:OVERLAY
+		justify
+		12 attributes:
+			0:4:CLASS
+			1:0:HEIGHT
+			2:1:ID
+			3:0:IMAGEMAP
+			4:0:MD
+			5:2:SRC
+			6:0:STYLE
+			7:0:TITLE
+			8:0:UNITS
+			9:0:WIDTH
+			10:0:X
+			11:0:Y
+		2 attr_types
+			core
+			OVERLAY
+		contents: SGML_EMPTY
+		tagclass: HRlike
+		contains:
+		icontains:
+		contained: DIVlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike same
+		flags: endO
+	92:P
+		justify
+		9 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NOWRAP
+			7:0:STYLE
+			8:0:TITLE
+		4 attr_types
+			align
+			core
+			i18n
+			P
+		contents: SGML_EMPTY
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags: endO
+	93:PARAM
+		justify
+		18 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:0:ACCEPT-ENCODING
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DATA
+			6:0:DIR
+			7:1:ID
+			8:0:LANG
+			9:0:NAME
+			10:0:OBJECT
+			11:0:REF
+			12:0:STYLE
+			13:0:TITLE
+			14:0:TYPE
+			15:0:VALUE
+			16:0:VALUEREF
+			17:0:VALUETYPE
+		3 attr_types
+			core
+			i18n
+			PARAM
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: Plike LIlike BRlike APPLETlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: TRlike SELECTlike Plike LIlike BRlike same
+		flags: endO
+	94:PLAINTEXT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_LITTERAL
+		tagclass: outer
+		contains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff same
+		contained: outer same
+		icontained: outer same
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		flags: endO
+	95:PRE
+		nojustify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike HRlike MAPlike
+		icontains: EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike HRlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags:
+	96:Q
+		justify
+		8 attributes:
+			0:2:CITE
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			Q
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	97:S
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags:
+	98:SAMP
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: EMlike
+		flags: nreie
+	99:SCRIPT
+		justify
+		16 attributes:
+			0:0:CHARSET
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DEFER
+			4:0:DIR
+			5:0:EVENT
+			6:0:FOR
+			7:1:ID
+			8:0:LANG
+			9:0:LANGUAGE
+			10:0:NAME
+			11:0:SCRIPTENGINE
+			12:2:SRC
+			13:0:STYLE
+			14:0:TITLE
+			15:0:TYPE
+		3 attr_types
+			core
+			i18n
+			SCRIPT
+		contents: SGML_LITTERAL
+		tagclass: APPLETlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike LIlike ULlike BRlike APPLETlike HRlike same
+		flags:
+	100:SECTION
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	101:SELECT
+		justify
+		22 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:0:DISABLED
+			5:0:ERROR
+			6:0:HEIGHT
+			7:1:ID
+			8:0:LANG
+			9:0:MD
+			10:0:MULTIPLE
+			11:0:NAME
+			12:0:NOTAB
+			13:0:ONBLUR
+			14:0:ONCHANGE
+			15:0:ONFOCUS
+			16:0:SIZE
+			17:0:STYLE
+			18:0:TABINDEX
+			19:0:TITLE
+			20:0:UNITS
+			21:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			SELECT
+		contents: SGML_MIXED
+		tagclass: SELECTlike
+		contains: MAPlike
+		icontains: MAPlike
+		contained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike LIlike ULlike same
+		flags: strict
+	102:SHY
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula BRlike same
+		flags: endO
+	103:SMALL
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	104:SPAN
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike same
+		flags:
+	105:SPOT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: Alike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		canclose: Alike
+		flags: endO
+	106:STRIKE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags:
+	107:STRONG
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags: nreie
+	108:STYLE
+		justify
+		9 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:MEDIA
+			5:0:NOTATION
+			6:0:STYLE
+			7:0:TITLE
+			8:0:TYPE
+		3 attr_types
+			core
+			i18n
+			STYLE
+		contents: SGML_LITTERAL
+		tagclass: HEADstuff
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike APPLETlike HRlike outer BODYlike HEADstuff
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula same
+		flags:
+	109:SUB
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: MATHlike
+		contains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike MATHlike
+		flags:
+	110:SUP
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: MATHlike
+		contains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike MATHlike
+		flags:
+	111:TAB
+		justify
+		11 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:0:DP
+			5:1:ID
+			6:0:INDENT
+			7:0:LANG
+			8:0:STYLE
+			9:0:TITLE
+			10:0:TO
+		4 attr_types
+			align
+			core
+			i18n
+			TAB
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer HEADstuff
+		canclose: FONTlike
+		flags: endO
+	112:TABLE
+		justify
+		22 attributes:
+			0:0:ALIGN
+			1:2:BACKGROUND
+			2:0:BORDER
+			3:0:CELLPADDING
+			4:0:CELLSPACING
+			5:4:CLASS
+			6:0:CLEAR
+			7:0:COLS
+			8:0:COLSPEC
+			9:0:DIR
+			10:0:DP
+			11:0:FRAME
+			12:1:ID
+			13:0:LANG
+			14:0:NOFLOW
+			15:0:NOWRAP
+			16:0:RULES
+			17:0:STYLE
+			18:0:SUMMARY
+			19:0:TITLE
+			20:0:UNITS
+			21:0:WIDTH
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			TABLE
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: TRlike SELECTlike FORMlike Plike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike LIlike HRlike MAPlike same
+		flags:
+	113:TBODY
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:DP
+			7:1:ID
+			8:0:LANG
+			9:0:NOWRAP
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALIGN
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			TR
+		contents: SGML_EMPTY
+		tagclass: TRlike
+		contains: TRlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike ULlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike HRlike MAPlike same
+		flags: endO startO
+	114:TD
+		justify
+		23 attributes:
+			0:0:ABBR
+			1:0:ALIGN
+			2:0:AXES
+			3:0:AXIS
+			4:2:BACKGROUND
+			5:0:CHAR
+			6:0:CHAROFF
+			7:4:CLASS
+			8:0:CLEAR
+			9:0:COLSPAN
+			10:0:DIR
+			11:0:DP
+			12:0:HEADERS
+			13:0:HEIGHT
+			14:1:ID
+			15:0:LANG
+			16:0:NOWRAP
+			17:0:ROWSPAN
+			18:0:SCOPE
+			19:0:STYLE
+			20:0:TITLE
+			21:0:VALIGN
+			22:0:WIDTH
+		4 attr_types
+			cellalign
+			core
+			i18n
+			TD
+		contents: SGML_EMPTY
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike HRlike MAPlike same
+		flags: endO
+	115:TEXTAREA
+		justify
+		22 attributes:
+			0:0:ACCEPT-CHARSET
+			1:0:ACCESSKEY
+			2:0:ALIGN
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:COLS
+			6:0:DIR
+			7:0:DISABLED
+			8:0:ERROR
+			9:1:ID
+			10:0:LANG
+			11:0:NAME
+			12:0:NOTAB
+			13:0:ONBLUR
+			14:0:ONCHANGE
+			15:0:ONFOCUS
+			16:0:ONSELECT
+			17:0:READONLY
+			18:0:ROWS
+			19:0:STYLE
+			20:0:TABINDEX
+			21:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			TEXTAREA
+		contents: SGML_LITTERAL
+		tagclass: SELECTlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike LIlike ULlike same
+		flags: nolyspcl
+	116:TEXTFLOW
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DATA
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NAME
+			7:0:OBJECT
+			8:0:REF
+			9:0:STYLE
+			10:0:TITLE
+			11:0:TYPE
+			12:0:VALUE
+			13:0:VALUETYPE
+		3 attr_types
+			core
+			i18n
+			BODYTEXT
+		contents: SGML_MIXED
+		tagclass: BODYlike
+		contains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same DELlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer same DELlike
+		contained: formula TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer same
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike BRlike APPLETlike MAPlike outer same
+		flags: endO startO
+	117:TFOOT
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:DP
+			7:1:ID
+			8:0:LANG
+			9:0:NOWRAP
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALIGN
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			TR
+		contents: SGML_EMPTY
+		tagclass: TRlike
+		contains: TRlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike HRlike MAPlike same
+		flags: endO
+	118:TH
+		justify
+		23 attributes:
+			0:0:ABBR
+			1:0:ALIGN
+			2:0:AXES
+			3:0:AXIS
+			4:2:BACKGROUND
+			5:0:CHAR
+			6:0:CHAROFF
+			7:4:CLASS
+			8:0:CLEAR
+			9:0:COLSPAN
+			10:0:DIR
+			11:0:DP
+			12:0:HEADERS
+			13:0:HEIGHT
+			14:1:ID
+			15:0:LANG
+			16:0:NOWRAP
+			17:0:ROWSPAN
+			18:0:SCOPE
+			19:0:STYLE
+			20:0:TITLE
+			21:0:VALIGN
+			22:0:WIDTH
+		4 attr_types
+			cellalign
+			core
+			i18n
+			TD
+		contents: SGML_EMPTY
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: TRlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike HRlike MAPlike same
+		flags: endO
+	119:THEAD
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:DP
+			7:1:ID
+			8:0:LANG
+			9:0:NOWRAP
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALIGN
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			TR
+		contents: SGML_EMPTY
+		tagclass: TRlike
+		contains: TRlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike HRlike MAPlike same
+		flags: endO
+	120:TITLE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_RCDATA
+		tagclass: HEADstuff
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: outer HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike
+		flags: mafse strict
+	121:TR
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:DP
+			7:1:ID
+			8:0:LANG
+			9:0:NOWRAP
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALIGN
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			TR
+		contents: SGML_EMPTY
+		tagclass: TRlike
+		contains: LIlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike ULlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike HRlike MAPlike same
+		flags: endO
+	122:TT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: nreie
+	123:U
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	124:UL
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:PLAIN
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+			12:0:TYPE
+			13:0:WRAP
+		3 attr_types
+			core
+			i18n
+			UL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: FORMlike LIlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike same
+		flags:
+	125:VAR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags:
+	126:WBR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: FONTlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula BRlike same
+		flags: endO
+	127:XMP
+		nojustify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_LITTERAL
+		tagclass: ULlike
+		contains:
+		icontains:
+		contained: TRlike SELECTlike FORMlike Plike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike MAPlike
+		flags: endO
diff --git a/WWW/Library/Implementation/src1_HTMLDTD.h b/WWW/Library/Implementation/src1_HTMLDTD.h
new file mode 100644
index 0000000..39c9594
--- /dev/null
+++ b/WWW/Library/Implementation/src1_HTMLDTD.h
@@ -0,0 +1,2478 @@
+/* $LynxId: src1_HTMLDTD.h,v 1.49 2022/09/30 00:03:49 tom Exp $ */
+#ifndef src_HTMLDTD_H1
+#define src_HTMLDTD_H1 1
+
+#ifndef once_HTMLDTD
+#define once_HTMLDTD 1
+
+#define T_A             0x00008,0x0B007,0x0FF17,0x37787,0x77BA7,0x8604F,0x00014
+#define T_ABBR          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00003,0x00000
+#define T_ACRONYM       0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00003,0x00000
+#define T_ADDRESS       0x00200,0x0F14F,0x8FFFF,0x136680,0x1B6FAF,0x80317,0x00000
+#define T_APPLET        0x02000,0x0B0CF,0x8FFFF,0x37F9F,0xB7FBF,0x8300F,0x00000
+#define T_AREA          0x08000,0x00000,0x00000,0x08000,0x3FFFF,0x00F1F,0x00001
+#define T_ARTICLE       0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_ASIDE         0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_AU            0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00003,0x00000
+#define T_AUTHOR        0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00003,0x00000
+#define T_B             0x00001,0x8B04F,0xAFFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_BANNER        0x00200,0x0FB8F,0x0FFFF,0x130000,0x130000,0x8031F,0x00000
+#define T_BASE          0x40000,0x00000,0x00000,0x50000,0x50000,0x8000F,0x00001
+#define T_BASEFONT      0x01000,0x00000,0x00000,0x377AF,0x37FAF,0x8F000,0x00001
+#define T_BDO           0x00100,0x0B04F,0x8FFFF,0x136680,0x1B6FAF,0x0033F,0x00000
+#define T_BGSOUND       0x01000,0x00000,0x00000,0x777AF,0x77FAF,0x8730F,0x00001
+#define T_BIG           0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_BLINK         0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FAF,0x00001,0x00014
+#define T_BLOCKQUOTE    0x00200,0xAFBCF,0xAFFFF,0x1B6680,0x1B6FAF,0x8031F,0x00000
+#define T_BODY          0x20000,0x12FB8F,0x12FFFF,0x30000,0x30000,0xDFF7F,0x00003
+#define T_BODYTEXT      0x20000,0x10FB8F,0x1AFFFF,0x30200,0xB7FAF,0x8F17F,0x00003
+#define T_BQ            0x00200,0xAFBCF,0xAFFFF,0x1B6680,0x1B6FAF,0x8031F,0x00000
+#define T_BR            0x01000,0x00000,0x00000,0x377BF,0x77FBF,0x8101F,0x00001
+#define T_BUTTON        0x02000,0x0BB07,0x0FF37,0x0378F,0x37FBF,0x8115F,0x00000
+#define T_CAPTION       0x00100,0x0B04F,0x8FFFF,0x106A00,0x1B6FA7,0x8035F,0x00000
+#define T_CENTER        0x00200,0x8FBCF,0x8FFFF,0x1B6680,0x1B6FA7,0x8071F,0x00000
+#define T_CITE          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00002,0x00010
+#define T_CODE          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00002,0x00000
+#define T_COL           0x04000,0x00000,0x00000,0x00820,0x36FA7,0x88F5F,0x00001
+#define T_COLGROUP      0x00020,0x04000,0x04000,0x00800,0x36FA7,0x8875F,0x00001
+#define T_COMMENT       0x00004,0x00000,0x00000,0xA77AF,0x7FFFF,0x00003,0x00000
+#define T_CREDIT        0x00100,0x0B04F,0x8FFFF,0x106A00,0x1B7FBF,0x8030F,0x00000
+#define T_DD            0x00400,0x0FBCF,0x8FFFF,0x00800,0xB6FFF,0x8071F,0x00001
+#define T_DEL           0x00002,0x8B04F,0x8FEFF,0x87F8F,0xF7FBF,0x100003,0x00000
+#define T_DEL_2         0x100000,0x8BBCF,0x8FFFF,0xA7F8F,0xF7FBF,0x100003,0x00000
+#define T_DFN           0x00002,0x8B0CF,0x8FFFF,0x8778F,0xF7FBF,0x00003,0x00000
+#define T_DIR           0x00800,0x0B400,0x0F75F,0x137680,0x136FB7,0x84F7F,0x00000
+#define T_DIV           0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x80317,0x00004
+#define T_DL            0x00800,0x0C480,0x8FFFF,0x136680,0x1B7FB7,0x00757,0x00000
+#define T_DLC           0x00800,0x0C480,0x8FFFF,0x136680,0x1B7FB7,0x0075F,0x00000
+#define T_DT            0x00400,0x0B04F,0x0B1FF,0x00800,0x17FFF,0x8071F,0x00001
+#define T_EM            0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FAF,0x00003,0x00010
+#define T_EMBED         0x02000,0x8F107,0x8FFF7,0xB6FBF,0xB7FBF,0x1FF7F,0x00001
+#define T_FIELDSET      0x00200,0x8FB4F,0x8FF7F,0x186787,0x1B7FF7,0x8805F,0x00000
+#define T_FIG           0x00200,0x0FB00,0x8FFFF,0x136680,0x1B6FBF,0x8834F,0x00000
+#define T_FIGURE        0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_FN            0x00200,0x8FBCF,0x8FFFF,0x1B6680,0x1B7EBF,0x8114F,0x00000
+#define T_FONT          0x00001,0x8B04F,0x8FFFF,0xB778F,0xF7FBF,0x00001,0x00014
+#define T_FOOTER        0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_FORM          0x00080,0x0FF6F,0x0FF7F,0x136E07,0x132F07,0x88DFF,0x00000
+#define T_FRAME         0x10000,0x00000,0x00000,0x10000,0x10000,0x9FFFF,0x00001
+#define T_FRAMESET      0x10000,0x90000,0x90000,0x90000,0x93000,0x9FFFF,0x00000
+#define T_H1            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H2            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H3            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H4            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H5            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_H6            0x00100,0x0B04F,0x0B05F,0x136680,0x137FAF,0x80117,0x00000
+#define T_HEAD          0x40000,0x4F000,0x47000,0x10000,0x10000,0x9FF7F,0x00007
+#define T_HEADER        0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_HR            0x04000,0x00000,0x00000,0x3FE80,0x3FFBF,0x87F37,0x00001
+#define T_HTML          0x10000,0x7FB8F,0x7FFFF,0x00000,0x00000,0x1FFFF,0x00003
+#define T_HY            0x01000,0x00000,0x00000,0x3779F,0x77FBF,0x8101F,0x00001
+#define T_I             0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_IFRAME        0x02000,0x8FBCF,0x8FFFF,0xB679F,0xB6FBF,0xD315F,0x00000
+#define T_IMG           0x01000,0x00000,0x00000,0x3779F,0x37FBF,0x80000,0x00001
+#define T_INPUT         0x00040,0x00000,0x00000,0x03F87,0x37F87,0x8904F,0x00001
+#define T_INS           0x00002,0x8B04F,0x8FEFF,0x87F8F,0xF7FBF,0x100003,0x00000
+#define T_INS_2         0x100000,0x8BBCF,0x8FFFF,0xA7F8F,0xF7FBF,0x100003,0x00000
+#define T_ISINDEX       0x08000,0x00000,0x00000,0x7778F,0x7FFAF,0x80007,0x00001
+#define T_KBD           0x00002,0x00000,0x00000,0x2778F,0x77FBF,0x00003,0x00000
+#define T_KEYGEN        0x00040,0x00000,0x00000,0x07FB7,0x37FB7,0x80070,0x00001
+#define T_LABEL         0x00002,0x0304F,0x0FFFF,0x0679F,0x36FBF,0x00007,0x00000
+#define T_LEGEND        0x00002,0x0B04F,0x8FF7F,0x00200,0xB7FA7,0x00003,0x00000
+#define T_LH            0x00400,0x0BB7F,0x8FFFF,0x00800,0x97FFF,0x8071F,0x00001
+#define T_LI            0x00400,0x0BBFF,0x8FFFF,0x00800,0x97FFF,0x8071F,0x00001
+#define T_LINK          0x08000,0x00000,0x00000,0x50000,0x50000,0x0FF7F,0x00001
+#define T_LISTING       0x00800,0x00000,0x00000,0x136600,0x136F00,0x80F1F,0x00000
+#define T_MAIN          0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_MAP           0x08000,0x08000,0x08000,0x37FCF,0x37FBF,0x0051F,0x00000
+#define T_MARQUEE       0x04000,0x0000F,0x8F01F,0x37787,0xB7FA7,0x8301C,0x00000
+#define T_MATH          0x00004,0x0B05F,0x8FFFF,0x2778F,0xF7FBF,0x0001F,0x00000
+#define T_MENU          0x00800,0x0B400,0x0F75F,0x117680,0x136FB7,0x88F7F,0x00000
+#define T_META          0x08000,0x00000,0x00000,0x50000,0x50000,0x0FF7F,0x00001
+#define T_NAV           0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_NEXTID        0x01000,0x00000,0x00000,0x50000,0x1FFF7,0x00001,0x00001
+#define T_NOFRAMES      0x20000,0x12FB8F,0x10FFFF,0x17000,0x17000,0x0CF5F,0x00000
+#define T_NOTE          0x00200,0x0BBAF,0x8FFFF,0x1376B0,0x1B7FFF,0x8031F,0x00000
+#define T_OBJECT        0x02000,0x8FBCF,0x8FFFF,0xB679F,0xB6FBF,0x83D5F,0x00020
+#define T_OL            0x00800,0x0C400,0x8FFFF,0x137680,0x1B7FB7,0x88F7F,0x00000
+#define T_OPTION        0x08000,0x00000,0x00000,0x00040,0x37FFF,0x8031F,0x00001
+#define T_OVERLAY       0x04000,0x00000,0x00000,0x00200,0x37FBF,0x83F7F,0x00001
+#define T_P             0x00100,0x0B04F,0x8FFFF,0x136680,0x1B6FA7,0x80117,0x00001
+#define T_PARAM         0x01000,0x00000,0x00000,0x33500,0x37FFF,0x81560,0x00001
+#define T_PLAINTEXT     0x10000,0xFFFFF,0xFFFFF,0x90000,0x90000,0x3FFFF,0x00001
+#define T_PRE           0x00200,0x0F04F,0x0F05E,0x136680,0x136FF0,0x8071E,0x00000
+#define T_Q             0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FAF,0x00003,0x00000
+#define T_S             0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00000
+#define T_SAMP          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00002,0x00010
+#define T_SCRIPT        0x02000,0x00000,0x00000,0x77F9F,0x77FFF,0x87D5F,0x00000
+#define T_SECTION       0x00200,0x8FBCF,0x8FFFF,0x1B66A0,0x1B7FFF,0x8031F,0x00004
+#define T_SELECT        0x00040,0x08000,0x08000,0x03FAF,0x33FBF,0x80D5F,0x00008
+#define T_SHY           0x01000,0x00000,0x00000,0x3779F,0x77FBF,0x8101F,0x00001
+#define T_SMALL         0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_SPAN          0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x80003,0x00000
+#define T_SPOT          0x00008,0x00000,0x00000,0x3FFF7,0x3FFF7,0x00008,0x00001
+#define T_STRIKE        0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00000
+#define T_STRONG        0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FAF,0x00003,0x00010
+#define T_STYLE         0x40000,0x00000,0x00000,0x7638F,0x76FAF,0x8001F,0x00000
+#define T_SUB           0x00004,0x8B05F,0x8FFFF,0x8779F,0xF7FBF,0x00007,0x00000
+#define T_SUP           0x00004,0x8B05F,0x8FFFF,0x8779F,0xF7FBF,0x00007,0x00000
+#define T_TAB           0x01000,0x00000,0x00000,0x3778F,0x57FAF,0x00001,0x00001
+#define T_TABLE         0x00800,0x0F1E0,0x8FFFF,0x136680,0x1B6FA7,0x8C57F,0x00000
+#define T_TBODY         0x00020,0x00020,0x8FFFF,0x00880,0xB7FB7,0x8C75F,0x00003
+#define T_TD            0x00400,0x0FBCF,0x8FFFF,0x00020,0xB7FB7,0x8C75F,0x00001
+#define T_TEXTAREA      0x00040,0x00000,0x00000,0x07F8F,0x33FBF,0x80D5F,0x00040
+#define T_TEXTFLOW      0x20000,0x18FBFF,0x19FFFF,0x977B0,0xB7FB7,0x9B00F,0x00003
+#define T_TFOOT         0x00020,0x00020,0x8FFFF,0x00800,0xB7FB7,0x8CF5F,0x00001
+#define T_TH            0x00400,0x0FBCF,0x0FFFF,0x00020,0xB7FB7,0x8CF5F,0x00001
+#define T_THEAD         0x00020,0x00020,0x8FFFF,0x00800,0xB7FB7,0x8CF5F,0x00001
+#define T_TITLE         0x40000,0x00000,0x00000,0x50000,0x50000,0x0031F,0x0000C
+#define T_TR            0x00020,0x00400,0x8FFFF,0x00820,0xB7FB7,0x8C75F,0x00001
+#define T_TT            0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00010
+#define T_U             0x00001,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00014
+#define T_UL            0x00800,0x0C480,0x8FFFF,0x136680,0x1B7FFF,0x8075F,0x00000
+#define T_VAR           0x00002,0x8B04F,0x8FFFF,0xA778F,0xF7FBF,0x00001,0x00000
+#define T_WBR           0x00001,0x00000,0x00000,0x3778F,0x77FBF,0x8101F,0x00001
+#define T_XMP           0x00800,0x00000,0x00000,0x1367E0,0x136FFF,0x0875F,0x00001
+#define T_OBJECT_PCDATA 0x02000,0x8FBCF,0x8FFFF,0xB679F,0xB6FBF,0x83D5F,0x00008
+#define T__UNREC_	0x00000,0x00000,0x00000,0x00000,0x00000,0x00000,0x00000
+#ifdef USE_PRETTYSRC
+# define N HTMLA_NORMAL
+# define i HTMLA_ANAME
+# define h HTMLA_HREF
+# define c HTMLA_CLASS
+# define x HTMLA_AUXCLASS
+# define T(t) , t
+#else
+# define T(t)			/*nothing */
+#endif
+/* *INDENT-OFF* */
+
+#define ATTR_TYPE(name) #name, name##_attr_list
+
+/* generic attributes, used in different tags */
+static const attr core_attr_list[] = {
+	{ "CLASS"         T(c) },
+	{ "ID"            T(i) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType core_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ 0, 0 },
+};
+
+static const attr i18n_attr_list[] = {
+	{ "DIR"           T(N) },
+	{ "LANG"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType i18n_attr_type[] = {
+	{ ATTR_TYPE(i18n) },
+	{ 0, 0 },
+};
+
+static const attr events_attr_list[] = {
+	{ "ONCLICK"       T(N) },
+	{ "ONDBLCLICK"    T(N) },
+	{ "ONKEYDOWN"     T(N) },
+	{ "ONKEYPRESS"    T(N) },
+	{ "ONKEYUP"       T(N) },
+	{ "ONMOUSEDOWN"   T(N) },
+	{ "ONMOUSEMOVE"   T(N) },
+	{ "ONMOUSEOUT"    T(N) },
+	{ "ONMOUSEOVER"   T(N) },
+	{ "ONMOUSEUP"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType events_attr_type[] = {
+	{ ATTR_TYPE(events) },
+	{ 0, 0 },
+};
+
+static const attr align_attr_list[] = {
+	{ "ALIGN"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType align_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ 0, 0 },
+};
+
+static const attr cellalign_attr_list[] = {
+	{ "ALIGN"         T(N) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "VALIGN"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType cellalign_attr_type[] = {
+	{ ATTR_TYPE(cellalign) },
+	{ 0, 0 },
+};
+
+static const attr bgcolor_attr_list[] = {
+	{ "BGCOLOR"       T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType bgcolor_attr_type[] = {
+	{ ATTR_TYPE(bgcolor) },
+	{ 0, 0 },
+};
+
+
+/* tables defining attributes per-tag in terms of generic attributes (editable) */
+static const attr A_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "CHARSET"       T(N) },
+	{ "CLEAR"         T(N) },
+	{ "COORDS"        T(N) },
+	{ "HREF"          T(h) },
+	{ "HREFLANG"      T(N) },
+	{ "ISMAP"         T(N) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(i) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "REL"           T(N) },
+	{ "REV"           T(N) },
+	{ "SHAPE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TARGET"        T(N) },
+	{ "TYPE"          T(N) },
+	{ "URN"           T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType A_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(A) },
+	{ 0, 0 },
+};
+
+static const attr ADDRESS_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "NOWRAP"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType ADDRESS_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(ADDRESS) },
+	{ 0, 0 },
+};
+
+static const attr APPLET_attr_list[] = {
+	{ "ALT"           T(N) },
+	{ "CLEAR"         T(N) },
+	{ "CODE"          T(N) },
+	{ "CODEBASE"      T(h) },
+	{ "DOWNLOAD"      T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "NAME"          T(i) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType APPLET_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(APPLET) },
+	{ 0, 0 },
+};
+
+static const attr AREA_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "ALT"           T(N) },
+	{ "CLEAR"         T(N) },
+	{ "COORDS"        T(N) },
+	{ "HREF"          T(h) },
+	{ "NOHREF"        T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "SHAPE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TARGET"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType AREA_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(AREA) },
+	{ 0, 0 },
+};
+
+static const attr BASE_attr_list[] = {
+	{ "HREF"          T(h) },
+	{ "TARGET"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BASE_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(BASE) },
+	{ 0, 0 },
+};
+
+static const attr BGSOUND_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "LOOP"          T(N) },
+	{ "SRC"           T(h) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BGSOUND_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BGSOUND) },
+	{ 0, 0 },
+};
+
+static const attr BODY_attr_list[] = {
+	{ "ALINK"         T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "CLEAR"         T(N) },
+	{ "LINK"          T(N) },
+	{ "ONLOAD"        T(N) },
+	{ "ONUNLOAD"      T(N) },
+	{ "TEXT"          T(N) },
+	{ "VLINK"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BODY_attr_type[] = {
+	{ ATTR_TYPE(bgcolor) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BODY) },
+	{ 0, 0 },
+};
+
+static const attr BODYTEXT_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DATA"          T(N) },
+	{ "NAME"          T(N) },
+	{ "OBJECT"        T(N) },
+	{ "REF"           T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ "VALUETYPE"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BODYTEXT_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BODYTEXT) },
+	{ 0, 0 },
+};
+
+static const attr BQ_attr_list[] = {
+	{ "CITE"          T(h) },
+	{ "CLEAR"         T(N) },
+	{ "NOWRAP"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BQ_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BQ) },
+	{ 0, 0 },
+};
+
+static const attr BUTTON_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "CLEAR"         T(N) },
+	{ "DISABLED"      T(N) },
+	{ "FORMACTION"    T(N) },
+	{ "NAME"          T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "READONLY"      T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType BUTTON_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(BUTTON) },
+	{ 0, 0 },
+};
+
+static const attr CAPTION_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType CAPTION_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(CAPTION) },
+	{ 0, 0 },
+};
+
+static const attr COL_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "SPAN"          T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType COL_attr_type[] = {
+	{ ATTR_TYPE(cellalign) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(COL) },
+	{ 0, 0 },
+};
+
+static const attr DEL_attr_list[] = {
+	{ "CITE"          T(N) },
+	{ "DATETIME"      T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType DEL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(DEL) },
+	{ 0, 0 },
+};
+
+static const attr DIV_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType DIV_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(DIV) },
+	{ 0, 0 },
+};
+
+static const attr DL_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType DL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(DL) },
+	{ 0, 0 },
+};
+
+static const attr EMBED_attr_list[] = {
+	{ "ALT"           T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLEAR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "IMAGEMAP"      T(N) },
+	{ "ISMAP"         T(N) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(i) },
+	{ "NOFLOW"        T(N) },
+	{ "PARAMS"        T(N) },
+	{ "SRC"           T(h) },
+	{ "UNITS"         T(N) },
+	{ "USEMAP"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType EMBED_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(EMBED) },
+	{ 0, 0 },
+};
+
+static const attr FIG_attr_list[] = {
+	{ "BORDER"        T(N) },
+	{ "CLEAR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "IMAGEMAP"      T(N) },
+	{ "ISOBJECT"      T(N) },
+	{ "MD"            T(N) },
+	{ "NOFLOW"        T(N) },
+	{ "SRC"           T(h) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FIG_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(FIG) },
+	{ 0, 0 },
+};
+
+static const attr FONT_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "COLOR"         T(N) },
+	{ "END"           T(N) },
+	{ "FACE"          T(N) },
+	{ "SIZE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FONT_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(FONT) },
+	{ 0, 0 },
+};
+
+static const attr FORM_attr_list[] = {
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACTION"        T(h) },
+	{ "CLEAR"         T(N) },
+	{ "ENCTYPE"       T(N) },
+	{ "METHOD"        T(N) },
+	{ "ONRESET"       T(N) },
+	{ "ONSUBMIT"      T(N) },
+	{ "SCRIPT"        T(N) },
+	{ "SUBJECT"       T(N) },
+	{ "TARGET"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FORM_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(FORM) },
+	{ 0, 0 },
+};
+
+static const attr FRAME_attr_list[] = {
+	{ "FRAMEBORDER"   T(N) },
+	{ "LONGDESC"      T(h) },
+	{ "MARGINHEIGHT"  T(N) },
+	{ "MARGINWIDTH"   T(N) },
+	{ "NAME"          T(N) },
+	{ "NORESIZE"      T(N) },
+	{ "SCROLLING"     T(N) },
+	{ "SRC"           T(h) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FRAME_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(FRAME) },
+	{ 0, 0 },
+};
+
+static const attr FRAMESET_attr_list[] = {
+	{ "COLS"          T(N) },
+	{ "ONLOAD"        T(N) },
+	{ "ONUNLOAD"      T(N) },
+	{ "ROWS"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType FRAMESET_attr_type[] = {
+	{ ATTR_TYPE(FRAMESET) },
+	{ 0, 0 },
+};
+
+static const attr GEN_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType GEN_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(GEN) },
+	{ 0, 0 },
+};
+
+static const attr GEN5_attr_list[] = {
+	{ "ROLE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType GEN5_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(GEN5) },
+	{ 0, 0 },
+};
+
+static const attr H_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "MD"            T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "SEQNUM"        T(N) },
+	{ "SKIP"          T(N) },
+	{ "SRC"           T(h) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType H_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(H) },
+	{ 0, 0 },
+};
+
+static const attr HR_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "MD"            T(N) },
+	{ "NOSHADE"       T(N) },
+	{ "SIZE"          T(N) },
+	{ "SRC"           T(h) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType HR_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(HR) },
+	{ 0, 0 },
+};
+
+static const attr IFRAME_attr_list[] = {
+	{ "FRAMEBORDER"   T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "LONGDESC"      T(h) },
+	{ "MARGINHEIGHT"  T(N) },
+	{ "MARGINWIDTH"   T(N) },
+	{ "NAME"          T(N) },
+	{ "SCROLLING"     T(N) },
+	{ "SRC"           T(h) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType IFRAME_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(IFRAME) },
+	{ 0, 0 },
+};
+
+static const attr IMG_attr_list[] = {
+	{ "ALT"           T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLEAR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ISMAP"         T(N) },
+	{ "ISOBJECT"      T(N) },
+	{ "LONGDESC"      T(h) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(N) },
+	{ "SRC"           T(h) },
+	{ "UNITS"         T(N) },
+	{ "USEMAP"        T(h) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType IMG_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(IMG) },
+	{ 0, 0 },
+};
+
+static const attr INPUT_attr_list[] = {
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCESSKEY"     T(N) },
+	{ "ALT"           T(N) },
+	{ "CHECKED"       T(N) },
+	{ "CLEAR"         T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ISMAP"         T(N) },
+	{ "MAX"           T(N) },
+	{ "MAXLENGTH"     T(N) },
+	{ "MD"            T(N) },
+	{ "MIN"           T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "ONSELECT"      T(N) },
+	{ "READONLY"      T(N) },
+	{ "SIZE"          T(N) },
+	{ "SRC"           T(h) },
+	{ "TABINDEX"      T(N) },
+	{ "TYPE"          T(N) },
+	{ "USEMAP"        T(N) },
+	{ "VALUE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType INPUT_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(INPUT) },
+	{ 0, 0 },
+};
+
+static const attr ISINDEX_attr_list[] = {
+	{ "ACTION"        T(h) },
+	{ "HREF"          T(h) },
+	{ "PROMPT"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType ISINDEX_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(ISINDEX) },
+	{ 0, 0 },
+};
+
+static const attr KEYGEN_attr_list[] = {
+	{ "CHALLENGE"     T(N) },
+	{ "NAME"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType KEYGEN_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(KEYGEN) },
+	{ 0, 0 },
+};
+
+static const attr LABEL_attr_list[] = {
+	{ "ACCESSKEY"     T(N) },
+	{ "CLEAR"         T(N) },
+	{ "FOR"           T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType LABEL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(LABEL) },
+	{ 0, 0 },
+};
+
+static const attr LI_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "MD"            T(N) },
+	{ "SKIP"          T(N) },
+	{ "SRC"           T(h) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType LI_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(LI) },
+	{ 0, 0 },
+};
+
+static const attr LINK_attr_list[] = {
+	{ "CHARSET"       T(N) },
+	{ "HREF"          T(h) },
+	{ "HREFLANG"      T(N) },
+	{ "MEDIA"         T(N) },
+	{ "REL"           T(N) },
+	{ "REV"           T(N) },
+	{ "TARGET"        T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType LINK_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(LINK) },
+	{ 0, 0 },
+};
+
+static const attr MAP_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "NAME"          T(i) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType MAP_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(MAP) },
+	{ 0, 0 },
+};
+
+static const attr MATH_attr_list[] = {
+	{ "BOX"           T(N) },
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType MATH_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(MATH) },
+	{ 0, 0 },
+};
+
+static const attr META_attr_list[] = {
+	{ "CHARSET"       T(N) },
+	{ "CONTENT"       T(N) },
+	{ "HTTP-EQUIV"    T(N) },
+	{ "NAME"          T(N) },
+	{ "SCHEME"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType META_attr_type[] = {
+	{ ATTR_TYPE(META) },
+	{ 0, 0 },
+};
+
+static const attr NEXTID_attr_list[] = {
+	{ "N"             T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType NEXTID_attr_type[] = {
+	{ ATTR_TYPE(NEXTID) },
+	{ 0, 0 },
+};
+
+static const attr NOTE_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "MD"            T(N) },
+	{ "ROLE"          T(x) },
+	{ "SRC"           T(h) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType NOTE_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(NOTE) },
+	{ 0, 0 },
+};
+
+static const attr OBJECT_attr_list[] = {
+	{ "ARCHIVE"       T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASSID"       T(h) },
+	{ "CODEBASE"      T(h) },
+	{ "CODETYPE"      T(N) },
+	{ "DATA"          T(h) },
+	{ "DECLARE"       T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ISMAP"         T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "SHAPES"        T(N) },
+	{ "STANDBY"       T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TYPE"          T(N) },
+	{ "USEMAP"        T(h) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType OBJECT_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(OBJECT) },
+	{ 0, 0 },
+};
+
+static const attr OL_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "CONTINUE"      T(N) },
+	{ "SEQNUM"        T(N) },
+	{ "START"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType OL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(OL) },
+	{ 0, 0 },
+};
+
+static const attr OPTION_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "LABEL"         T(N) },
+	{ "SELECTED"      T(N) },
+	{ "SHAPE"         T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType OPTION_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(OPTION) },
+	{ 0, 0 },
+};
+
+static const attr OVERLAY_attr_list[] = {
+	{ "HEIGHT"        T(N) },
+	{ "IMAGEMAP"      T(N) },
+	{ "MD"            T(N) },
+	{ "SRC"           T(h) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ "X"             T(N) },
+	{ "Y"             T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType OVERLAY_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(OVERLAY) },
+	{ 0, 0 },
+};
+
+static const attr P_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "NOWRAP"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType P_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(P) },
+	{ 0, 0 },
+};
+
+static const attr PARAM_attr_list[] = {
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCEPT-ENCODING" T(N) },
+	{ "CLEAR"         T(N) },
+	{ "DATA"          T(N) },
+	{ "NAME"          T(N) },
+	{ "OBJECT"        T(N) },
+	{ "REF"           T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ "VALUEREF"      T(N) },
+	{ "VALUETYPE"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType PARAM_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(PARAM) },
+	{ 0, 0 },
+};
+
+static const attr Q_attr_list[] = {
+	{ "CITE"          T(h) },
+	{ "CLEAR"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType Q_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(Q) },
+	{ 0, 0 },
+};
+
+static const attr SCRIPT_attr_list[] = {
+	{ "CHARSET"       T(N) },
+	{ "CLEAR"         T(N) },
+	{ "DEFER"         T(N) },
+	{ "EVENT"         T(N) },
+	{ "FOR"           T(N) },
+	{ "LANGUAGE"      T(N) },
+	{ "NAME"          T(N) },
+	{ "SCRIPTENGINE"  T(N) },
+	{ "SRC"           T(h) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType SCRIPT_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(SCRIPT) },
+	{ 0, 0 },
+};
+
+static const attr SELECT_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "MD"            T(N) },
+	{ "MULTIPLE"      T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "SIZE"          T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType SELECT_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(SELECT) },
+	{ 0, 0 },
+};
+
+static const attr STYLE_attr_list[] = {
+	{ "MEDIA"         T(N) },
+	{ "NOTATION"      T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType STYLE_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(STYLE) },
+	{ 0, 0 },
+};
+
+static const attr TAB_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DP"            T(N) },
+	{ "INDENT"        T(N) },
+	{ "TO"            T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TAB_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TAB) },
+	{ 0, 0 },
+};
+
+static const attr TABLE_attr_list[] = {
+	{ "BACKGROUND"    T(h) },
+	{ "BORDER"        T(N) },
+	{ "CELLPADDING"   T(N) },
+	{ "CELLSPACING"   T(N) },
+	{ "CLEAR"         T(N) },
+	{ "COLS"          T(N) },
+	{ "COLSPEC"       T(N) },
+	{ "DP"            T(N) },
+	{ "FRAME"         T(N) },
+	{ "NOFLOW"        T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "RULES"         T(N) },
+	{ "SUMMARY"       T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TABLE_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TABLE) },
+	{ 0, 0 },
+};
+
+static const attr TD_attr_list[] = {
+	{ "ABBR"          T(N) },
+	{ "AXES"          T(N) },
+	{ "AXIS"          T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "CLEAR"         T(N) },
+	{ "COLSPAN"       T(N) },
+	{ "DP"            T(N) },
+	{ "HEADERS"       T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "ROWSPAN"       T(N) },
+	{ "SCOPE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TD_attr_type[] = {
+	{ ATTR_TYPE(cellalign) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TD) },
+	{ 0, 0 },
+};
+
+static const attr TEXTAREA_attr_list[] = {
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCESSKEY"     T(N) },
+	{ "CLEAR"         T(N) },
+	{ "COLS"          T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "ONSELECT"      T(N) },
+	{ "READONLY"      T(N) },
+	{ "ROWS"          T(N) },
+	{ "TABINDEX"      T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TEXTAREA_attr_type[] = {
+	{ ATTR_TYPE(align) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TEXTAREA) },
+	{ 0, 0 },
+};
+
+static const attr TR_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "DP"            T(N) },
+	{ "NOWRAP"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType TR_attr_type[] = {
+	{ ATTR_TYPE(cellalign) },
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(events) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(TR) },
+	{ 0, 0 },
+};
+
+static const attr UL_attr_list[] = {
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "MD"            T(N) },
+	{ "PLAIN"         T(N) },
+	{ "SRC"           T(h) },
+	{ "TYPE"          T(N) },
+	{ "WRAP"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const AttrType UL_attr_type[] = {
+	{ ATTR_TYPE(core) },
+	{ ATTR_TYPE(i18n) },
+	{ ATTR_TYPE(UL) },
+	{ 0, 0 },
+};
+
+
+/* attribute lists for the runtime (generated by dtd_util) */
+static const attr A_attr[] = {          /* A attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "CHARSET"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COORDS"        T(N) },
+	{ "DIR"           T(N) },
+	{ "HREF"          T(h) },
+	{ "HREFLANG"      T(N) },
+	{ "ID"            T(i) },
+	{ "ISMAP"         T(N) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(i) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "REL"           T(N) },
+	{ "REV"           T(N) },
+	{ "SHAPE"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "URN"           T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr ADDRESS_attr[] = {    /* ADDRESS attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr APPLET_attr[] = {     /* APPLET attributes */
+	{ "ALIGN"         T(N) },
+	{ "ALT"           T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "CODE"          T(N) },
+	{ "CODEBASE"      T(h) },
+	{ "DIR"           T(N) },
+	{ "DOWNLOAD"      T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(i) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr AREA_attr[] = {       /* AREA attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "ALT"           T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COORDS"        T(N) },
+	{ "DIR"           T(N) },
+	{ "HREF"          T(h) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOHREF"        T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "SHAPE"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BASE_attr[] = {       /* BASE attributes */
+	{ "CLASS"         T(c) },
+	{ "HREF"          T(h) },
+	{ "ID"            T(i) },
+	{ "STYLE"         T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BGSOUND_attr[] = {    /* BGSOUND attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "LOOP"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BODY_attr[] = {       /* BODY attributes */
+	{ "ALINK"         T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "BGCOLOR"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "LINK"          T(N) },
+	{ "ONLOAD"        T(N) },
+	{ "ONUNLOAD"      T(N) },
+	{ "STYLE"         T(N) },
+	{ "TEXT"          T(N) },
+	{ "TITLE"         T(N) },
+	{ "VLINK"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BODYTEXT_attr[] = {   /* BODYTEXT attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DATA"          T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "OBJECT"        T(N) },
+	{ "REF"           T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ "VALUETYPE"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BQ_attr[] = {         /* BLOCKQUOTE attributes */
+	{ "CITE"          T(h) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr BUTTON_attr[] = {     /* BUTTON attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "FORMACTION"    T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "READONLY"      T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr CAPTION_attr[] = {    /* CAPTION attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr COL_attr[] = {        /* COL attributes */
+	{ "ALIGN"         T(N) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "SPAN"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VALIGN"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr DEL_attr[] = {        /* DEL attributes */
+	{ "CITE"          T(N) },
+	{ "CLASS"         T(c) },
+	{ "DATETIME"      T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr DIV_attr[] = {        /* CENTER attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr DL_attr[] = {         /* DL attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr EMBED_attr[] = {      /* EMBED attributes */
+	{ "ALIGN"         T(N) },
+	{ "ALT"           T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "IMAGEMAP"      T(N) },
+	{ "ISMAP"         T(N) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(i) },
+	{ "NOFLOW"        T(N) },
+	{ "PARAMS"        T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "USEMAP"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FIG_attr[] = {        /* FIG attributes */
+	{ "ALIGN"         T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "IMAGEMAP"      T(N) },
+	{ "ISOBJECT"      T(N) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NOFLOW"        T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FONT_attr[] = {       /* BASEFONT attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COLOR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "END"           T(N) },
+	{ "FACE"          T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "SIZE"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FORM_attr[] = {       /* FORM attributes */
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACTION"        T(h) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ENCTYPE"       T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "METHOD"        T(N) },
+	{ "ONRESET"       T(N) },
+	{ "ONSUBMIT"      T(N) },
+	{ "SCRIPT"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "SUBJECT"       T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FRAME_attr[] = {      /* FRAME attributes */
+	{ "CLASS"         T(c) },
+	{ "FRAMEBORDER"   T(N) },
+	{ "ID"            T(i) },
+	{ "LONGDESC"      T(h) },
+	{ "MARGINHEIGHT"  T(N) },
+	{ "MARGINWIDTH"   T(N) },
+	{ "NAME"          T(N) },
+	{ "NORESIZE"      T(N) },
+	{ "SCROLLING"     T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr FRAMESET_attr[] = {   /* FRAMESET attributes */
+	{ "COLS"          T(N) },
+	{ "ONLOAD"        T(N) },
+	{ "ONUNLOAD"      T(N) },
+	{ "ROWS"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr GEN_attr[] = {        /* ABBR attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr GEN5_attr[] = {       /* ARTICLE attributes */
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "ROLE"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr H_attr[] = {          /* H1 attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "SEQNUM"        T(N) },
+	{ "SKIP"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr HR_attr[] = {         /* HR attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "NOSHADE"       T(N) },
+	{ "SIZE"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr IFRAME_attr[] = {     /* IFRAME attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "FRAMEBORDER"   T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "LONGDESC"      T(h) },
+	{ "MARGINHEIGHT"  T(N) },
+	{ "MARGINWIDTH"   T(N) },
+	{ "NAME"          T(N) },
+	{ "SCROLLING"     T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr IMG_attr[] = {        /* IMG attributes */
+	{ "ALIGN"         T(N) },
+	{ "ALT"           T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ID"            T(i) },
+	{ "ISMAP"         T(N) },
+	{ "ISOBJECT"      T(N) },
+	{ "LANG"          T(N) },
+	{ "LONGDESC"      T(h) },
+	{ "MD"            T(N) },
+	{ "NAME"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "USEMAP"        T(h) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr INPUT_attr[] = {      /* INPUT attributes */
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCESSKEY"     T(N) },
+	{ "ALIGN"         T(N) },
+	{ "ALT"           T(N) },
+	{ "CHECKED"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "ISMAP"         T(N) },
+	{ "LANG"          T(N) },
+	{ "MAX"           T(N) },
+	{ "MAXLENGTH"     T(N) },
+	{ "MD"            T(N) },
+	{ "MIN"           T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "ONSELECT"      T(N) },
+	{ "READONLY"      T(N) },
+	{ "SIZE"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "USEMAP"        T(N) },
+	{ "VALUE"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr ISINDEX_attr[] = {    /* ISINDEX attributes */
+	{ "ACTION"        T(h) },
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "HREF"          T(h) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "PROMPT"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr KEYGEN_attr[] = {     /* KEYGEN attributes */
+	{ "CHALLENGE"     T(N) },
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr LABEL_attr[] = {      /* LABEL attributes */
+	{ "ACCESSKEY"     T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "FOR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr LI_attr[] = {         /* LI attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "SKIP"          T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr LINK_attr[] = {       /* LINK attributes */
+	{ "CHARSET"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "HREF"          T(h) },
+	{ "HREFLANG"      T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MEDIA"         T(N) },
+	{ "REL"           T(N) },
+	{ "REV"           T(N) },
+	{ "STYLE"         T(N) },
+	{ "TARGET"        T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr MAP_attr[] = {        /* MAP attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(i) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr MATH_attr[] = {       /* MATH attributes */
+	{ "BOX"           T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr META_attr[] = {       /* META attributes */
+	{ "CHARSET"       T(N) },
+	{ "CONTENT"       T(N) },
+	{ "HTTP-EQUIV"    T(N) },
+	{ "NAME"          T(N) },
+	{ "SCHEME"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr NEXTID_attr[] = {     /* NEXTID attributes */
+	{ "N"             T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr NOTE_attr[] = {       /* NOTE attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "ROLE"          T(x) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr OBJECT_attr[] = {     /* OBJECT attributes */
+	{ "ALIGN"         T(N) },
+	{ "ARCHIVE"       T(N) },
+	{ "BORDER"        T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLASSID"       T(h) },
+	{ "CODEBASE"      T(h) },
+	{ "CODETYPE"      T(N) },
+	{ "DATA"          T(h) },
+	{ "DECLARE"       T(N) },
+	{ "DIR"           T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "HSPACE"        T(N) },
+	{ "ID"            T(i) },
+	{ "ISMAP"         T(N) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "SHAPES"        T(N) },
+	{ "STANDBY"       T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "USEMAP"        T(h) },
+	{ "VSPACE"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr OL_attr[] = {         /* OL attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "CONTINUE"      T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "SEQNUM"        T(N) },
+	{ "START"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr OPTION_attr[] = {     /* OPTION attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "ID"            T(i) },
+	{ "LABEL"         T(N) },
+	{ "LANG"          T(N) },
+	{ "SELECTED"      T(N) },
+	{ "SHAPE"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VALUE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr OVERLAY_attr[] = {    /* OVERLAY attributes */
+	{ "CLASS"         T(c) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "IMAGEMAP"      T(N) },
+	{ "MD"            T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ "X"             T(N) },
+	{ "Y"             T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr P_attr[] = {          /* P attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr PARAM_attr[] = {      /* PARAM attributes */
+	{ "ACCEPT"        T(N) },
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCEPT-ENCODING" T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DATA"          T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "OBJECT"        T(N) },
+	{ "REF"           T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "VALUE"         T(N) },
+	{ "VALUEREF"      T(N) },
+	{ "VALUETYPE"     T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr Q_attr[] = {          /* Q attributes */
+	{ "CITE"          T(h) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr SCRIPT_attr[] = {     /* SCRIPT attributes */
+	{ "CHARSET"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DEFER"         T(N) },
+	{ "DIR"           T(N) },
+	{ "EVENT"         T(N) },
+	{ "FOR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "LANGUAGE"      T(N) },
+	{ "NAME"          T(N) },
+	{ "SCRIPTENGINE"  T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr SELECT_attr[] = {     /* SELECT attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "MULTIPLE"      T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "SIZE"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr STYLE_attr[] = {      /* STYLE attributes */
+	{ "CLASS"         T(c) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MEDIA"         T(N) },
+	{ "NOTATION"      T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TAB_attr[] = {        /* TAB attributes */
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DP"            T(N) },
+	{ "ID"            T(i) },
+	{ "INDENT"        T(N) },
+	{ "LANG"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TO"            T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TABLE_attr[] = {      /* TABLE attributes */
+	{ "ALIGN"         T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "BORDER"        T(N) },
+	{ "CELLPADDING"   T(N) },
+	{ "CELLSPACING"   T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COLS"          T(N) },
+	{ "COLSPEC"       T(N) },
+	{ "DIR"           T(N) },
+	{ "DP"            T(N) },
+	{ "FRAME"         T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOFLOW"        T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "RULES"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "SUMMARY"       T(N) },
+	{ "TITLE"         T(N) },
+	{ "UNITS"         T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TD_attr[] = {         /* TD attributes */
+	{ "ABBR"          T(N) },
+	{ "ALIGN"         T(N) },
+	{ "AXES"          T(N) },
+	{ "AXIS"          T(N) },
+	{ "BACKGROUND"    T(h) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COLSPAN"       T(N) },
+	{ "DIR"           T(N) },
+	{ "DP"            T(N) },
+	{ "HEADERS"       T(N) },
+	{ "HEIGHT"        T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "ROWSPAN"       T(N) },
+	{ "SCOPE"         T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VALIGN"        T(N) },
+	{ "WIDTH"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TEXTAREA_attr[] = {   /* TEXTAREA attributes */
+	{ "ACCEPT-CHARSET" T(N) },
+	{ "ACCESSKEY"     T(N) },
+	{ "ALIGN"         T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COLS"          T(N) },
+	{ "DIR"           T(N) },
+	{ "DISABLED"      T(N) },
+	{ "ERROR"         T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NAME"          T(N) },
+	{ "NOTAB"         T(N) },
+	{ "ONBLUR"        T(N) },
+	{ "ONCHANGE"      T(N) },
+	{ "ONFOCUS"       T(N) },
+	{ "ONSELECT"      T(N) },
+	{ "READONLY"      T(N) },
+	{ "ROWS"          T(N) },
+	{ "STYLE"         T(N) },
+	{ "TABINDEX"      T(N) },
+	{ "TITLE"         T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr TR_attr[] = {         /* TBODY attributes */
+	{ "ALIGN"         T(N) },
+	{ "CHAR"          T(N) },
+	{ "CHAROFF"       T(N) },
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "DIR"           T(N) },
+	{ "DP"            T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "NOWRAP"        T(N) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "VALIGN"        T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+static const attr UL_attr[] = {         /* DIR attributes */
+	{ "CLASS"         T(c) },
+	{ "CLEAR"         T(N) },
+	{ "COMPACT"       T(N) },
+	{ "DINGBAT"       T(N) },
+	{ "DIR"           T(N) },
+	{ "ID"            T(i) },
+	{ "LANG"          T(N) },
+	{ "MD"            T(N) },
+	{ "PLAIN"         T(N) },
+	{ "SRC"           T(h) },
+	{ "STYLE"         T(N) },
+	{ "TITLE"         T(N) },
+	{ "TYPE"          T(N) },
+	{ "WRAP"          T(N) },
+	{ 0               T(N) }	/* Terminate list */
+};
+
+/* *INDENT-ON* */
+
+/* justification-flags */
+#undef N
+#undef i
+#undef h
+#undef c
+#undef x
+
+#undef T
+
+/* tag-names */
+#undef A
+#undef ABBR
+#undef ACRONYM
+#undef ADDRESS
+#undef APPLET
+#undef AREA
+#undef ARTICLE
+#undef ASIDE
+#undef AU
+#undef AUTHOR
+#undef B
+#undef BANNER
+#undef BASE
+#undef BASEFONT
+#undef BDO
+#undef BGSOUND
+#undef BIG
+#undef BLINK
+#undef BLOCKQUOTE
+#undef BODY
+#undef BODYTEXT
+#undef BQ
+#undef BR
+#undef BUTTON
+#undef CAPTION
+#undef CENTER
+#undef CITE
+#undef CODE
+#undef COL
+#undef COLGROUP
+#undef COMMENT
+#undef CREDIT
+#undef DD
+#undef DEL
+#undef DEL
+#undef DFN
+#undef DIR
+#undef DIV
+#undef DL
+#undef DLC
+#undef DT
+#undef EM
+#undef EMBED
+#undef FIELDSET
+#undef FIG
+#undef FIGURE
+#undef FN
+#undef FONT
+#undef FOOTER
+#undef FORM
+#undef FRAME
+#undef FRAMESET
+#undef H1
+#undef H2
+#undef H3
+#undef H4
+#undef H5
+#undef H6
+#undef HEAD
+#undef HEADER
+#undef HR
+#undef HTML
+#undef HY
+#undef I
+#undef IFRAME
+#undef IMG
+#undef INPUT
+#undef INS
+#undef INS
+#undef ISINDEX
+#undef KBD
+#undef KEYGEN
+#undef LABEL
+#undef LEGEND
+#undef LH
+#undef LI
+#undef LINK
+#undef LISTING
+#undef MAIN
+#undef MAP
+#undef MARQUEE
+#undef MATH
+#undef MENU
+#undef META
+#undef NAV
+#undef NEXTID
+#undef NOFRAMES
+#undef NOTE
+#undef OBJECT
+#undef OL
+#undef OPTION
+#undef OVERLAY
+#undef P
+#undef PARAM
+#undef PLAINTEXT
+#undef PRE
+#undef Q
+#undef S
+#undef SAMP
+#undef SCRIPT
+#undef SECTION
+#undef SELECT
+#undef SHY
+#undef SMALL
+#undef SPAN
+#undef SPOT
+#undef STRIKE
+#undef STRONG
+#undef STYLE
+#undef SUB
+#undef SUP
+#undef TAB
+#undef TABLE
+#undef TBODY
+#undef TD
+#undef TEXTAREA
+#undef TEXTFLOW
+#undef TFOOT
+#undef TH
+#undef THEAD
+#undef TITLE
+#undef TR
+#undef TT
+#undef U
+#undef UL
+#undef VAR
+#undef WBR
+#undef XMP
+#undef OBJECT_PCDATA
+
+/* these definitions are used in the tags-tables */
+#undef P
+#undef P_
+#ifdef USE_COLOR_STYLE
+#define P_(x) #x, (sizeof #x) -1
+#define NULL_HTTag_ NULL, 0
+#else
+#define P_(x) #x
+#define NULL_HTTag_ NULL
+#endif
+
+#ifdef USE_JUSTIFY_ELTS
+#define P(x) P_(x), 1
+#define P0(x) P_(x), 0
+#define NULL_HTTag NULL_HTTag_,0
+#else
+#define P(x) P_(x)
+#define P0(x) P_(x)
+#define NULL_HTTag NULL_HTTag_
+#endif
+
+#define ATTR_DATA(name) name##_attr, HTML_##name##_ATTRIBUTES, name##_attr_type
+
+#endif /* once_HTMLDTD */
+/* *INDENT-OFF* */
+static const HTTag tags_table1[HTML_ALL_ELEMENTS] = {
+ { P(A),           ATTR_DATA(A),           SGML_MIXED,   T_A, 0, 0},
+ { P(ABBR),        ATTR_DATA(GEN),         SGML_MIXED,   T_ABBR, 0, 0},
+ { P(ACRONYM),     ATTR_DATA(GEN),         SGML_MIXED,   T_ACRONYM, 0, 0},
+ { P(ADDRESS),     ATTR_DATA(ADDRESS),     SGML_MIXED,   T_ADDRESS, 0, 0},
+ { P(APPLET),      ATTR_DATA(APPLET),      SGML_MIXED,   T_APPLET, 0, 0},
+ { P(AREA),        ATTR_DATA(AREA),        SGML_EMPTY,   T_AREA, 0, 0},
+ { P(ARTICLE),     ATTR_DATA(GEN5),        SGML_MIXED,   T_ARTICLE, 0, 0},
+ { P(ASIDE),       ATTR_DATA(GEN5),        SGML_MIXED,   T_ASIDE, 0, 0},
+ { P(AU),          ATTR_DATA(GEN),         SGML_MIXED,   T_AU, 0, 0},
+ { P(AUTHOR),      ATTR_DATA(GEN),         SGML_MIXED,   T_AUTHOR, 0, 0},
+ { P(B),           ATTR_DATA(GEN),         SGML_MIXED,   T_B, 0, 0},
+ { P0(BANNER),     ATTR_DATA(GEN),         SGML_MIXED,   T_BANNER, 0, 0},
+ { P(BASE),        ATTR_DATA(BASE),        SGML_EMPTY,   T_BASE, 0, 0},
+ { P(BASEFONT),    ATTR_DATA(FONT),        SGML_EMPTY,   T_BASEFONT, 0, 0},
+ { P(BDO),         ATTR_DATA(GEN),         SGML_MIXED,   T_BDO, 0, 0},
+ { P(BGSOUND),     ATTR_DATA(BGSOUND),     SGML_EMPTY,   T_BGSOUND, 0, 0},
+ { P(BIG),         ATTR_DATA(GEN),         SGML_MIXED,   T_BIG, 0, 0},
+ { P(BLINK),       ATTR_DATA(GEN),         SGML_MIXED,   T_BLINK, 0, 0},
+ { P(BLOCKQUOTE),  ATTR_DATA(BQ),          SGML_MIXED,   T_BLOCKQUOTE, 0, 0},
+ { P(BODY),        ATTR_DATA(BODY),        SGML_MIXED,   T_BODY, 0, 0},
+ { P(BODYTEXT),    ATTR_DATA(BODYTEXT),    SGML_MIXED,   T_BODYTEXT, 0, 0},
+ { P(BQ),          ATTR_DATA(BQ),          SGML_MIXED,   T_BQ, 0, 0},
+ { P(BR),          ATTR_DATA(GEN),         SGML_EMPTY,   T_BR, 0, 0},
+ { P(BUTTON),      ATTR_DATA(BUTTON),      SGML_MIXED,   T_BUTTON, 0, 0},
+ { P(CAPTION),     ATTR_DATA(CAPTION),     SGML_MIXED,   T_CAPTION, 0, 0},
+ { P(CENTER),      ATTR_DATA(DIV),         SGML_MIXED,   T_CENTER, 0, 0},
+ { P(CITE),        ATTR_DATA(GEN),         SGML_MIXED,   T_CITE, 0, 0},
+ { P(CODE),        ATTR_DATA(GEN),         SGML_MIXED,   T_CODE, 0, 0},
+ { P(COL),         ATTR_DATA(COL),         SGML_EMPTY,   T_COL, 0, 0},
+ { P(COLGROUP),    ATTR_DATA(COL),         SGML_ELEMENT, T_COLGROUP, 0, 0},
+ { P(COMMENT),     ATTR_DATA(GEN),         SGML_PCDATA,  T_COMMENT, 0, 0},
+ { P(CREDIT),      ATTR_DATA(GEN),         SGML_MIXED,   T_CREDIT, 0, 0},
+ { P(DD),          ATTR_DATA(GEN),         SGML_MIXED,   T_DD, 0, 0},
+ { P(DEL),         ATTR_DATA(DEL),         SGML_MIXED,   T_DEL, 0, 1},
+ { P(DEL),         ATTR_DATA(DEL),         SGML_MIXED,   T_DEL_2, 1, 1},
+ { P(DFN),         ATTR_DATA(GEN),         SGML_MIXED,   T_DFN, 0, 0},
+ { P(DIR),         ATTR_DATA(UL),          SGML_MIXED,   T_DIR, 0, 0},
+ { P(DIV),         ATTR_DATA(DIV),         SGML_MIXED,   T_DIV, 0, 0},
+ { P(DL),          ATTR_DATA(DL),          SGML_MIXED,   T_DL, 0, 0},
+ { P(DLC),         ATTR_DATA(DL),          SGML_MIXED,   T_DLC, 0, 0},
+ { P(DT),          ATTR_DATA(GEN),         SGML_MIXED,   T_DT, 0, 0},
+ { P(EM),          ATTR_DATA(GEN),         SGML_MIXED,   T_EM, 0, 0},
+ { P(EMBED),       ATTR_DATA(EMBED),       SGML_EMPTY,   T_EMBED, 0, 0},
+ { P(FIELDSET),    ATTR_DATA(GEN),         SGML_MIXED,   T_FIELDSET, 0, 0},
+ { P(FIG),         ATTR_DATA(FIG),         SGML_MIXED,   T_FIG, 0, 0},
+ { P(FIGURE),      ATTR_DATA(GEN5),        SGML_MIXED,   T_FIGURE, 0, 0},
+ { P(FN),          ATTR_DATA(GEN),         SGML_MIXED,   T_FN, 0, 0},
+ { P(FONT),        ATTR_DATA(FONT),        SGML_MIXED,   T_FONT, 0, 0},
+ { P(FOOTER),      ATTR_DATA(GEN5),        SGML_MIXED,   T_FOOTER, 0, 0},
+ { P(FORM),        ATTR_DATA(FORM),        SGML_MIXED,   T_FORM, 0, 0},
+ { P(FRAME),       ATTR_DATA(FRAME),       SGML_EMPTY,   T_FRAME, 0, 0},
+ { P(FRAMESET),    ATTR_DATA(FRAMESET),    SGML_ELEMENT, T_FRAMESET, 0, 0},
+ { P0(H1),         ATTR_DATA(H),           SGML_MIXED,   T_H1, 0, 0},
+ { P0(H2),         ATTR_DATA(H),           SGML_MIXED,   T_H2, 0, 0},
+ { P0(H3),         ATTR_DATA(H),           SGML_MIXED,   T_H3, 0, 0},
+ { P0(H4),         ATTR_DATA(H),           SGML_MIXED,   T_H4, 0, 0},
+ { P0(H5),         ATTR_DATA(H),           SGML_MIXED,   T_H5, 0, 0},
+ { P0(H6),         ATTR_DATA(H),           SGML_MIXED,   T_H6, 0, 0},
+ { P(HEAD),        ATTR_DATA(GEN),         SGML_ELEMENT, T_HEAD, 0, 0},
+ { P(HEADER),      ATTR_DATA(GEN5),        SGML_MIXED,   T_HEADER, 0, 0},
+ { P(HR),          ATTR_DATA(HR),          SGML_EMPTY,   T_HR, 0, 0},
+ { P(HTML),        ATTR_DATA(GEN),         SGML_MIXED,   T_HTML, 0, 0},
+ { P(HY),          ATTR_DATA(GEN),         SGML_EMPTY,   T_HY, 0, 0},
+ { P(I),           ATTR_DATA(GEN),         SGML_MIXED,   T_I, 0, 0},
+ { P(IFRAME),      ATTR_DATA(IFRAME),      SGML_MIXED,   T_IFRAME, 0, 0},
+ { P(IMG),         ATTR_DATA(IMG),         SGML_EMPTY,   T_IMG, 0, 0},
+ { P(INPUT),       ATTR_DATA(INPUT),       SGML_EMPTY,   T_INPUT, 0, 0},
+ { P(INS),         ATTR_DATA(DEL),         SGML_MIXED,   T_INS, 0, 1},
+ { P(INS),         ATTR_DATA(DEL),         SGML_MIXED,   T_INS_2, 1, 1},
+ { P(ISINDEX),     ATTR_DATA(ISINDEX),     SGML_EMPTY,   T_ISINDEX, 0, 0},
+ { P(KBD),         ATTR_DATA(GEN),         SGML_MIXED,   T_KBD, 0, 0},
+ { P(KEYGEN),      ATTR_DATA(KEYGEN),      SGML_EMPTY,   T_KEYGEN, 0, 0},
+ { P(LABEL),       ATTR_DATA(LABEL),       SGML_MIXED,   T_LABEL, 0, 0},
+ { P(LEGEND),      ATTR_DATA(CAPTION),     SGML_MIXED,   T_LEGEND, 0, 0},
+ { P(LH),          ATTR_DATA(GEN),         SGML_MIXED,   T_LH, 0, 0},
+ { P(LI),          ATTR_DATA(LI),          SGML_MIXED,   T_LI, 0, 0},
+ { P(LINK),        ATTR_DATA(LINK),        SGML_EMPTY,   T_LINK, 0, 0},
+ { P(LISTING),     ATTR_DATA(GEN),         SGML_LITTERAL,T_LISTING, 0, 0},
+ { P(MAIN),        ATTR_DATA(GEN5),        SGML_MIXED,   T_MAIN, 0, 0},
+ { P(MAP),         ATTR_DATA(MAP),         SGML_ELEMENT, T_MAP, 0, 0},
+ { P(MARQUEE),     ATTR_DATA(GEN),         SGML_MIXED,   T_MARQUEE, 0, 0},
+ { P(MATH),        ATTR_DATA(MATH),        SGML_PCDATA,  T_MATH, 0, 0},
+ { P(MENU),        ATTR_DATA(UL),          SGML_MIXED,   T_MENU, 0, 0},
+ { P(META),        ATTR_DATA(META),        SGML_EMPTY,   T_META, 0, 0},
+ { P(NAV),         ATTR_DATA(GEN5),        SGML_MIXED,   T_NAV, 0, 0},
+ { P(NEXTID),      ATTR_DATA(NEXTID),      SGML_EMPTY,   T_NEXTID, 0, 0},
+ { P(NOFRAMES),    ATTR_DATA(GEN),         SGML_MIXED,   T_NOFRAMES, 0, 0},
+ { P(NOTE),        ATTR_DATA(NOTE),        SGML_MIXED,   T_NOTE, 0, 0},
+ { P(OBJECT),      ATTR_DATA(OBJECT),      SGML_LITTERAL,T_OBJECT, 0, 0},
+ { P(OL),          ATTR_DATA(OL),          SGML_MIXED,   T_OL, 0, 0},
+ { P(OPTION),      ATTR_DATA(OPTION),      SGML_PCDATA,  T_OPTION, 0, 0},
+ { P(OVERLAY),     ATTR_DATA(OVERLAY),     SGML_PCDATA,  T_OVERLAY, 0, 0},
+ { P(P),           ATTR_DATA(P),           SGML_MIXED,   T_P, 0, 0},
+ { P(PARAM),       ATTR_DATA(PARAM),       SGML_EMPTY,   T_PARAM, 0, 0},
+ { P(PLAINTEXT),   ATTR_DATA(GEN),         SGML_LITTERAL,T_PLAINTEXT, 0, 0},
+ { P0(PRE),        ATTR_DATA(GEN),         SGML_MIXED,   T_PRE, 0, 0},
+ { P(Q),           ATTR_DATA(Q),           SGML_MIXED,   T_Q, 0, 0},
+ { P(S),           ATTR_DATA(GEN),         SGML_MIXED,   T_S, 0, 0},
+ { P(SAMP),        ATTR_DATA(GEN),         SGML_MIXED,   T_SAMP, 0, 0},
+ { P(SCRIPT),      ATTR_DATA(SCRIPT),      SGML_SCRIPT,  T_SCRIPT, 0, 0},
+ { P(SECTION),     ATTR_DATA(GEN5),        SGML_MIXED,   T_SECTION, 0, 0},
+ { P(SELECT),      ATTR_DATA(SELECT),      SGML_ELEMENT, T_SELECT, 0, 0},
+ { P(SHY),         ATTR_DATA(GEN),         SGML_EMPTY,   T_SHY, 0, 0},
+ { P(SMALL),       ATTR_DATA(GEN),         SGML_MIXED,   T_SMALL, 0, 0},
+ { P(SPAN),        ATTR_DATA(GEN),         SGML_MIXED,   T_SPAN, 0, 0},
+ { P(SPOT),        ATTR_DATA(GEN),         SGML_EMPTY,   T_SPOT, 0, 0},
+ { P(STRIKE),      ATTR_DATA(GEN),         SGML_MIXED,   T_STRIKE, 0, 0},
+ { P(STRONG),      ATTR_DATA(GEN),         SGML_MIXED,   T_STRONG, 0, 0},
+ { P(STYLE),       ATTR_DATA(STYLE),       SGML_CDATA,   T_STYLE, 0, 0},
+ { P(SUB),         ATTR_DATA(GEN),         SGML_MIXED,   T_SUB, 0, 0},
+ { P(SUP),         ATTR_DATA(GEN),         SGML_MIXED,   T_SUP, 0, 0},
+ { P(TAB),         ATTR_DATA(TAB),         SGML_EMPTY,   T_TAB, 0, 0},
+ { P(TABLE),       ATTR_DATA(TABLE),       SGML_ELEMENT, T_TABLE, 0, 0},
+ { P(TBODY),       ATTR_DATA(TR),          SGML_ELEMENT, T_TBODY, 0, 0},
+ { P(TD),          ATTR_DATA(TD),          SGML_MIXED,   T_TD, 0, 0},
+ { P(TEXTAREA),    ATTR_DATA(TEXTAREA),    SGML_PCDATA,  T_TEXTAREA, 0, 0},
+ { P(TEXTFLOW),    ATTR_DATA(BODYTEXT),    SGML_MIXED,   T_TEXTFLOW, 0, 0},
+ { P(TFOOT),       ATTR_DATA(TR),          SGML_ELEMENT, T_TFOOT, 0, 0},
+ { P(TH),          ATTR_DATA(TD),          SGML_MIXED,   T_TH, 0, 0},
+ { P(THEAD),       ATTR_DATA(TR),          SGML_ELEMENT, T_THEAD, 0, 0},
+ { P(TITLE),       ATTR_DATA(GEN),         SGML_PCDATA,  T_TITLE, 0, 0},
+ { P(TR),          ATTR_DATA(TR),          SGML_MIXED,   T_TR, 0, 0},
+ { P(TT),          ATTR_DATA(GEN),         SGML_MIXED,   T_TT, 0, 0},
+ { P(U),           ATTR_DATA(GEN),         SGML_MIXED,   T_U, 0, 0},
+ { P(UL),          ATTR_DATA(UL),          SGML_MIXED,   T_UL, 0, 0},
+ { P(VAR),         ATTR_DATA(GEN),         SGML_MIXED,   T_VAR, 0, 0},
+ { P(WBR),         ATTR_DATA(GEN),         SGML_EMPTY,   T_WBR, 0, 0},
+ { P0(XMP),        ATTR_DATA(GEN),         SGML_LITTERAL,T_XMP, 0, 0},
+/* additional (alternative variants), not counted in HTML_ELEMENTS: */
+/* This one will be used as a temporary substitute within the parser when
+   it has been signalled to parse OBJECT content as MIXED. - kw */
+ { P(OBJECT),      ATTR_DATA(OBJECT),      SGML_MIXED,   T_OBJECT_PCDATA, 0, 0},
+};
+/* *INDENT-ON* */
+
+#endif /* src_HTMLDTD_H1 */
diff --git a/WWW/Library/Implementation/src1_HTMLDTD.txt b/WWW/Library/Implementation/src1_HTMLDTD.txt
new file mode 100644
index 0000000..df1521b
--- /dev/null
+++ b/WWW/Library/Implementation/src1_HTMLDTD.txt
@@ -0,0 +1,3901 @@
+60 attr_types
+	0:align
+		1 attributes:
+			0:0:ALIGN
+	1:bgcolor
+		1 attributes:
+			0:0:BGCOLOR
+	2:cellalign
+		4 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:0:VALIGN
+	3:core
+		4 attributes:
+			0:4:CLASS
+			1:1:ID
+			2:0:STYLE
+			3:0:TITLE
+	4:events
+		10 attributes:
+			0:0:ONCLICK
+			1:0:ONDBLCLICK
+			2:0:ONKEYDOWN
+			3:0:ONKEYPRESS
+			4:0:ONKEYUP
+			5:0:ONMOUSEDOWN
+			6:0:ONMOUSEMOVE
+			7:0:ONMOUSEOUT
+			8:0:ONMOUSEOVER
+			9:0:ONMOUSEUP
+	5:i18n
+		2 attributes:
+			0:0:DIR
+			1:0:LANG
+	6:A
+		19 attributes:
+			0:0:ACCESSKEY
+			1:0:CHARSET
+			2:0:CLEAR
+			3:0:COORDS
+			4:2:HREF
+			5:0:HREFLANG
+			6:0:ISMAP
+			7:0:MD
+			8:1:NAME
+			9:0:NOTAB
+			10:0:ONBLUR
+			11:0:ONFOCUS
+			12:0:REL
+			13:0:REV
+			14:0:SHAPE
+			15:0:TABINDEX
+			16:0:TARGET
+			17:0:TYPE
+			18:0:URN
+	7:ADDRESS
+		2 attributes:
+			0:0:CLEAR
+			1:0:NOWRAP
+	8:APPLET
+		10 attributes:
+			0:0:ALT
+			1:0:CLEAR
+			2:0:CODE
+			3:2:CODEBASE
+			4:0:DOWNLOAD
+			5:0:HEIGHT
+			6:0:HSPACE
+			7:1:NAME
+			8:0:VSPACE
+			9:0:WIDTH
+	9:AREA
+		12 attributes:
+			0:0:ACCESSKEY
+			1:0:ALT
+			2:0:CLEAR
+			3:0:COORDS
+			4:2:HREF
+			5:0:NOHREF
+			6:0:NOTAB
+			7:0:ONBLUR
+			8:0:ONFOCUS
+			9:0:SHAPE
+			10:0:TABINDEX
+			11:0:TARGET
+	10:BASE
+		2 attributes:
+			0:2:HREF
+			1:0:TARGET
+	11:BGSOUND
+		3 attributes:
+			0:0:CLEAR
+			1:0:LOOP
+			2:2:SRC
+	12:BODY
+		8 attributes:
+			0:0:ALINK
+			1:2:BACKGROUND
+			2:0:CLEAR
+			3:0:LINK
+			4:0:ONLOAD
+			5:0:ONUNLOAD
+			6:0:TEXT
+			7:0:VLINK
+	13:BODYTEXT
+		8 attributes:
+			0:0:CLEAR
+			1:0:DATA
+			2:0:NAME
+			3:0:OBJECT
+			4:0:REF
+			5:0:TYPE
+			6:0:VALUE
+			7:0:VALUETYPE
+	14:BQ
+		3 attributes:
+			0:2:CITE
+			1:0:CLEAR
+			2:0:NOWRAP
+	15:BUTTON
+		11 attributes:
+			0:0:ACCESSKEY
+			1:0:CLEAR
+			2:0:DISABLED
+			3:0:FORMACTION
+			4:0:NAME
+			5:0:ONBLUR
+			6:0:ONFOCUS
+			7:0:READONLY
+			8:0:TABINDEX
+			9:0:TYPE
+			10:0:VALUE
+	16:CAPTION
+		2 attributes:
+			0:0:ACCESSKEY
+			1:0:CLEAR
+	17:COL
+		3 attributes:
+			0:0:CLEAR
+			1:0:SPAN
+			2:0:WIDTH
+	18:DEL
+		2 attributes:
+			0:0:CITE
+			1:0:DATETIME
+	19:DIV
+		1 attributes:
+			0:0:CLEAR
+	20:DL
+		2 attributes:
+			0:0:CLEAR
+			1:0:COMPACT
+	21:EMBED
+		14 attributes:
+			0:0:ALT
+			1:0:BORDER
+			2:0:CLEAR
+			3:0:HEIGHT
+			4:0:IMAGEMAP
+			5:0:ISMAP
+			6:0:MD
+			7:1:NAME
+			8:0:NOFLOW
+			9:0:PARAMS
+			10:2:SRC
+			11:0:UNITS
+			12:0:USEMAP
+			13:0:WIDTH
+	22:FIG
+		10 attributes:
+			0:0:BORDER
+			1:0:CLEAR
+			2:0:HEIGHT
+			3:0:IMAGEMAP
+			4:0:ISOBJECT
+			5:0:MD
+			6:0:NOFLOW
+			7:2:SRC
+			8:0:UNITS
+			9:0:WIDTH
+	23:FONT
+		5 attributes:
+			0:0:CLEAR
+			1:0:COLOR
+			2:0:END
+			3:0:FACE
+			4:0:SIZE
+	24:FORM
+		11 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:2:ACTION
+			3:0:CLEAR
+			4:0:ENCTYPE
+			5:0:METHOD
+			6:0:ONRESET
+			7:0:ONSUBMIT
+			8:0:SCRIPT
+			9:0:SUBJECT
+			10:0:TARGET
+	25:FRAME
+		8 attributes:
+			0:0:FRAMEBORDER
+			1:2:LONGDESC
+			2:0:MARGINHEIGHT
+			3:0:MARGINWIDTH
+			4:0:NAME
+			5:0:NORESIZE
+			6:0:SCROLLING
+			7:2:SRC
+	26:FRAMESET
+		4 attributes:
+			0:0:COLS
+			1:0:ONLOAD
+			2:0:ONUNLOAD
+			3:0:ROWS
+	27:GEN
+		1 attributes:
+			0:0:CLEAR
+	28:GEN5
+		1 attributes:
+			0:0:ROLE
+	29:H
+		7 attributes:
+			0:0:CLEAR
+			1:0:DINGBAT
+			2:0:MD
+			3:0:NOWRAP
+			4:0:SEQNUM
+			5:0:SKIP
+			6:2:SRC
+	30:HR
+		6 attributes:
+			0:0:CLEAR
+			1:0:MD
+			2:0:NOSHADE
+			3:0:SIZE
+			4:2:SRC
+			5:0:WIDTH
+	31:IFRAME
+		9 attributes:
+			0:0:FRAMEBORDER
+			1:0:HEIGHT
+			2:2:LONGDESC
+			3:0:MARGINHEIGHT
+			4:0:MARGINWIDTH
+			5:0:NAME
+			6:0:SCROLLING
+			7:2:SRC
+			8:0:WIDTH
+	32:IMG
+		15 attributes:
+			0:0:ALT
+			1:0:BORDER
+			2:0:CLEAR
+			3:0:HEIGHT
+			4:0:HSPACE
+			5:0:ISMAP
+			6:0:ISOBJECT
+			7:2:LONGDESC
+			8:0:MD
+			9:0:NAME
+			10:2:SRC
+			11:0:UNITS
+			12:2:USEMAP
+			13:0:VSPACE
+			14:0:WIDTH
+	33:INPUT
+		28 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:0:ACCESSKEY
+			3:0:ALT
+			4:0:CHECKED
+			5:0:CLEAR
+			6:0:DISABLED
+			7:0:ERROR
+			8:0:HEIGHT
+			9:0:ISMAP
+			10:0:MAX
+			11:0:MAXLENGTH
+			12:0:MD
+			13:0:MIN
+			14:0:NAME
+			15:0:NOTAB
+			16:0:ONBLUR
+			17:0:ONCHANGE
+			18:0:ONFOCUS
+			19:0:ONSELECT
+			20:0:READONLY
+			21:0:SIZE
+			22:2:SRC
+			23:0:TABINDEX
+			24:0:TYPE
+			25:0:USEMAP
+			26:0:VALUE
+			27:0:WIDTH
+	34:ISINDEX
+		3 attributes:
+			0:2:ACTION
+			1:2:HREF
+			2:0:PROMPT
+	35:KEYGEN
+		2 attributes:
+			0:0:CHALLENGE
+			1:0:NAME
+	36:LABEL
+		5 attributes:
+			0:0:ACCESSKEY
+			1:0:CLEAR
+			2:0:FOR
+			3:0:ONBLUR
+			4:0:ONFOCUS
+	37:LI
+		7 attributes:
+			0:0:CLEAR
+			1:0:DINGBAT
+			2:0:MD
+			3:0:SKIP
+			4:2:SRC
+			5:0:TYPE
+			6:0:VALUE
+	38:LINK
+		8 attributes:
+			0:0:CHARSET
+			1:2:HREF
+			2:0:HREFLANG
+			3:0:MEDIA
+			4:0:REL
+			5:0:REV
+			6:0:TARGET
+			7:0:TYPE
+	39:MAP
+		2 attributes:
+			0:0:CLEAR
+			1:1:NAME
+	40:MATH
+		2 attributes:
+			0:0:BOX
+			1:0:CLEAR
+	41:META
+		5 attributes:
+			0:0:CHARSET
+			1:0:CONTENT
+			2:0:HTTP-EQUIV
+			3:0:NAME
+			4:0:SCHEME
+	42:NEXTID
+		1 attributes:
+			0:0:N
+	43:NOTE
+		4 attributes:
+			0:0:CLEAR
+			1:0:MD
+			2:8:ROLE
+			3:2:SRC
+	44:OBJECT
+		19 attributes:
+			0:0:ARCHIVE
+			1:0:BORDER
+			2:2:CLASSID
+			3:2:CODEBASE
+			4:0:CODETYPE
+			5:2:DATA
+			6:0:DECLARE
+			7:0:HEIGHT
+			8:0:HSPACE
+			9:0:ISMAP
+			10:0:NAME
+			11:0:NOTAB
+			12:0:SHAPES
+			13:0:STANDBY
+			14:0:TABINDEX
+			15:0:TYPE
+			16:2:USEMAP
+			17:0:VSPACE
+			18:0:WIDTH
+	45:OL
+		6 attributes:
+			0:0:CLEAR
+			1:0:COMPACT
+			2:0:CONTINUE
+			3:0:SEQNUM
+			4:0:START
+			5:0:TYPE
+	46:OPTION
+		7 attributes:
+			0:0:CLEAR
+			1:0:DISABLED
+			2:0:ERROR
+			3:0:LABEL
+			4:0:SELECTED
+			5:0:SHAPE
+			6:0:VALUE
+	47:OVERLAY
+		8 attributes:
+			0:0:HEIGHT
+			1:0:IMAGEMAP
+			2:0:MD
+			3:2:SRC
+			4:0:UNITS
+			5:0:WIDTH
+			6:0:X
+			7:0:Y
+	48:P
+		2 attributes:
+			0:0:CLEAR
+			1:0:NOWRAP
+	49:PARAM
+		12 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:0:ACCEPT-ENCODING
+			3:0:CLEAR
+			4:0:DATA
+			5:0:NAME
+			6:0:OBJECT
+			7:0:REF
+			8:0:TYPE
+			9:0:VALUE
+			10:0:VALUEREF
+			11:0:VALUETYPE
+	50:Q
+		2 attributes:
+			0:2:CITE
+			1:0:CLEAR
+	51:SCRIPT
+		10 attributes:
+			0:0:CHARSET
+			1:0:CLEAR
+			2:0:DEFER
+			3:0:EVENT
+			4:0:FOR
+			5:0:LANGUAGE
+			6:0:NAME
+			7:0:SCRIPTENGINE
+			8:2:SRC
+			9:0:TYPE
+	52:SELECT
+		15 attributes:
+			0:0:CLEAR
+			1:0:DISABLED
+			2:0:ERROR
+			3:0:HEIGHT
+			4:0:MD
+			5:0:MULTIPLE
+			6:0:NAME
+			7:0:NOTAB
+			8:0:ONBLUR
+			9:0:ONCHANGE
+			10:0:ONFOCUS
+			11:0:SIZE
+			12:0:TABINDEX
+			13:0:UNITS
+			14:0:WIDTH
+	53:STYLE
+		3 attributes:
+			0:0:MEDIA
+			1:0:NOTATION
+			2:0:TYPE
+	54:TAB
+		4 attributes:
+			0:0:CLEAR
+			1:0:DP
+			2:0:INDENT
+			3:0:TO
+	55:TABLE
+		15 attributes:
+			0:2:BACKGROUND
+			1:0:BORDER
+			2:0:CELLPADDING
+			3:0:CELLSPACING
+			4:0:CLEAR
+			5:0:COLS
+			6:0:COLSPEC
+			7:0:DP
+			8:0:FRAME
+			9:0:NOFLOW
+			10:0:NOWRAP
+			11:0:RULES
+			12:0:SUMMARY
+			13:0:UNITS
+			14:0:WIDTH
+	56:TD
+		13 attributes:
+			0:0:ABBR
+			1:0:AXES
+			2:0:AXIS
+			3:2:BACKGROUND
+			4:0:CLEAR
+			5:0:COLSPAN
+			6:0:DP
+			7:0:HEADERS
+			8:0:HEIGHT
+			9:0:NOWRAP
+			10:0:ROWSPAN
+			11:0:SCOPE
+			12:0:WIDTH
+	57:TEXTAREA
+		15 attributes:
+			0:0:ACCEPT-CHARSET
+			1:0:ACCESSKEY
+			2:0:CLEAR
+			3:0:COLS
+			4:0:DISABLED
+			5:0:ERROR
+			6:0:NAME
+			7:0:NOTAB
+			8:0:ONBLUR
+			9:0:ONCHANGE
+			10:0:ONFOCUS
+			11:0:ONSELECT
+			12:0:READONLY
+			13:0:ROWS
+			14:0:TABINDEX
+	58:TR
+		3 attributes:
+			0:0:CLEAR
+			1:0:DP
+			2:0:NOWRAP
+	59:UL
+		8 attributes:
+			0:0:CLEAR
+			1:0:COMPACT
+			2:0:DINGBAT
+			3:0:MD
+			4:0:PLAIN
+			5:2:SRC
+			6:0:TYPE
+			7:0:WRAP
+128 tags
+	0:A
+		justify
+		25 attributes:
+			0:0:ACCESSKEY
+			1:0:CHARSET
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:COORDS
+			5:0:DIR
+			6:2:HREF
+			7:0:HREFLANG
+			8:1:ID
+			9:0:ISMAP
+			10:0:LANG
+			11:0:MD
+			12:1:NAME
+			13:0:NOTAB
+			14:0:ONBLUR
+			15:0:ONFOCUS
+			16:0:REL
+			17:0:REV
+			18:0:SHAPE
+			19:0:STYLE
+			20:0:TABINDEX
+			21:0:TARGET
+			22:0:TITLE
+			23:0:TYPE
+			24:0:URN
+		4 attr_types
+			core
+			events
+			i18n
+			A
+		contents: SGML_MIXED
+		tagclass: Alike
+		contains: FONTlike EMlike MATHlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike formula Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike SELECTlike APPLETlike HRlike same
+		flags: mafse nreie
+	1:ABBR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	2:ACRONYM
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	3:ADDRESS
+		justify
+		8 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:NOWRAP
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			ADDRESS
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike Plike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike DIVlike same
+		flags:
+	4:APPLET
+		justify
+		17 attributes:
+			0:0:ALIGN
+			1:0:ALT
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:CODE
+			5:2:CODEBASE
+			6:0:DIR
+			7:0:DOWNLOAD
+			8:0:HEIGHT
+			9:0:HSPACE
+			10:1:ID
+			11:0:LANG
+			12:1:NAME
+			13:0:STYLE
+			14:0:TITLE
+			15:0:VSPACE
+			16:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			APPLET
+		contents: SGML_MIXED
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike BRlike APPLETlike same
+		flags:
+	5:AREA
+		justify
+		18 attributes:
+			0:0:ACCESSKEY
+			1:0:ALT
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:COORDS
+			5:0:DIR
+			6:2:HREF
+			7:1:ID
+			8:0:LANG
+			9:0:NOHREF
+			10:0:NOTAB
+			11:0:ONBLUR
+			12:0:ONFOCUS
+			13:0:SHAPE
+			14:0:STYLE
+			15:0:TABINDEX
+			16:0:TARGET
+			17:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			AREA
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: MAPlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike ULlike
+		flags: endO
+	6:ARTICLE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	7:ASIDE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	8:AU
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	9:AUTHOR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	10:B
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	11:BANNER
+		nojustify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: outer BODYlike DELlike
+		icontained: outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags:
+	12:BASE
+		justify
+		6 attributes:
+			0:4:CLASS
+			1:2:HREF
+			2:1:ID
+			3:0:STYLE
+			4:0:TARGET
+			5:0:TITLE
+		2 attr_types
+			core
+			BASE
+		contents: SGML_EMPTY
+		tagclass: HEADstuff
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: outer HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike same
+		flags: endO
+	13:BASEFONT
+		justify
+		11 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COLOR
+			3:0:DIR
+			4:0:END
+			5:0:FACE
+			6:1:ID
+			7:0:LANG
+			8:0:SIZE
+			9:0:STYLE
+			10:0:TITLE
+		3 attr_types
+			core
+			i18n
+			FONT
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: BRlike APPLETlike HRlike MAPlike same
+		flags: endO
+	14:BDO
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike Plike DIVlike
+		flags:
+	15:BGSOUND
+		justify
+		9 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:LOOP
+			6:2:SRC
+			7:0:STYLE
+			8:0:TITLE
+		3 attr_types
+			core
+			i18n
+			BGSOUND
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike Plike DIVlike BRlike APPLETlike HRlike same
+		flags: endO
+	16:BIG
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	17:BLINK
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	18:BLOCKQUOTE
+		justify
+		9 attributes:
+			0:2:CITE
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NOWRAP
+			7:0:STYLE
+			8:0:TITLE
+		3 attr_types
+			core
+			i18n
+			BQ
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags:
+	19:BODY
+		justify
+		15 attributes:
+			0:0:ALINK
+			1:2:BACKGROUND
+			2:0:BGCOLOR
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:1:ID
+			7:0:LANG
+			8:0:LINK
+			9:0:ONLOAD
+			10:0:ONUNLOAD
+			11:0:STYLE
+			12:0:TEXT
+			13:0:TITLE
+			14:0:VLINK
+		4 attr_types
+			bgcolor
+			core
+			i18n
+			BODY
+		contents: SGML_MIXED
+		tagclass: BODYlike
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike DELlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike DELlike
+		contained: outer BODYlike
+		icontained: outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer HEADstuff same
+		flags: endO startO
+	20:BODYTEXT
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DATA
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NAME
+			7:0:OBJECT
+			8:0:REF
+			9:0:STYLE
+			10:0:TITLE
+			11:0:TYPE
+			12:0:VALUE
+			13:0:VALUETYPE
+		3 attr_types
+			core
+			i18n
+			BODYTEXT
+		contents: SGML_MIXED
+		tagclass: BODYlike
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike DELlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same DELlike
+		contained: DIVlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike BRlike APPLETlike HRlike MAPlike same
+		flags: endO startO
+	21:BQ
+		justify
+		9 attributes:
+			0:2:CITE
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NOWRAP
+			7:0:STYLE
+			8:0:TITLE
+		3 attr_types
+			core
+			i18n
+			BQ
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags:
+	22:BR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula BRlike same
+		flags: endO
+	23:BUTTON
+		justify
+		17 attributes:
+			0:0:ACCESSKEY
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:0:DISABLED
+			5:0:FORMACTION
+			6:1:ID
+			7:0:LANG
+			8:0:NAME
+			9:0:ONBLUR
+			10:0:ONFOCUS
+			11:0:READONLY
+			12:0:STYLE
+			13:0:TABINDEX
+			14:0:TITLE
+			15:0:TYPE
+			16:0:VALUE
+		4 attr_types
+			core
+			events
+			i18n
+			BUTTON
+		contents: SGML_MIXED
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Plike DIVlike ULlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike formula TRlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike BRlike same
+		flags:
+	24:CAPTION
+		justify
+		9 attributes:
+			0:0:ACCESSKEY
+			1:0:ALIGN
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:STYLE
+			8:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			CAPTION
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: DIVlike ULlike APPLETlike HRlike DELlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike same
+		flags:
+	25:CENTER
+		justify
+		8 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			align
+			core
+			i18n
+			DIV
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags:
+	26:CITE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: EMlike
+		flags: nreie
+	27:CODE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: EMlike
+		flags:
+	28:COL
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:1:ID
+			7:0:LANG
+			8:0:SPAN
+			9:0:STYLE
+			10:0:TITLE
+			11:0:VALIGN
+			12:0:WIDTH
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			COL
+		contents: SGML_EMPTY
+		tagclass: HRlike
+		contains:
+		icontains:
+		contained: TRlike ULlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike MAPlike same
+		flags: endO
+	29:COLGROUP
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:1:ID
+			7:0:LANG
+			8:0:SPAN
+			9:0:STYLE
+			10:0:TITLE
+			11:0:VALIGN
+			12:0:WIDTH
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			COL
+		contents: SGML_ELEMENT
+		tagclass: TRlike
+		contains: HRlike
+		icontains: HRlike
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike MAPlike same
+		flags: endO
+	30:COMMENT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_PCDATA
+		tagclass: MATHlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike
+		flags:
+	31:CREDIT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: DIVlike ULlike APPLETlike HRlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike Plike DIVlike same
+		flags:
+	32:DD
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags: endO
+	33:DEL
+		justify
+		8 attributes:
+			0:0:CITE
+			1:4:CLASS
+			2:0:DATETIME
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			DEL
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike DELlike
+		flags:
+	34:DEL!
+		justify
+		8 attributes:
+			0:0:CITE
+			1:4:CLASS
+			2:0:DATETIME
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			DEL
+		contents: SGML_MIXED
+		tagclass: DELlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike DELlike
+		flags:
+	35:DFN
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	36:DIR
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:PLAIN
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+			12:0:TYPE
+			13:0:WRAP
+		3 attr_types
+			core
+			i18n
+			UL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: LIlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike BRlike APPLETlike HRlike MAPlike
+		contained: FORMlike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike HRlike same
+		flags:
+	37:DIV
+		justify
+		8 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			align
+			core
+			i18n
+			DIV
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike DIVlike same
+		flags: mafse
+	38:DL
+		justify
+		8 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			DL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: FORMlike LIlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike formula SELECTlike Plike DIVlike LIlike
+		flags:
+	39:DLC
+		justify
+		8 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			DL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: FORMlike LIlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike
+		flags:
+	40:DT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike BRlike APPLETlike MAPlike
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags: endO
+	41:EM
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags: nreie
+	42:EMBED
+		justify
+		21 attributes:
+			0:0:ALIGN
+			1:0:ALT
+			2:0:BORDER
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:HEIGHT
+			7:1:ID
+			8:0:IMAGEMAP
+			9:0:ISMAP
+			10:0:LANG
+			11:0:MD
+			12:1:NAME
+			13:0:NOFLOW
+			14:0:PARAMS
+			15:2:SRC
+			16:0:STYLE
+			17:0:TITLE
+			18:0:UNITS
+			19:0:USEMAP
+			20:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			EMBED
+		contents: SGML_EMPTY
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Plike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer
+		flags: endO
+	43:FIELDSET
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike APPLETlike HRlike same DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike MAPlike same
+		flags:
+	44:FIG
+		justify
+		17 attributes:
+			0:0:ALIGN
+			1:0:BORDER
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:DIR
+			5:0:HEIGHT
+			6:1:ID
+			7:0:IMAGEMAP
+			8:0:ISOBJECT
+			9:0:LANG
+			10:0:MD
+			11:0:NOFLOW
+			12:2:SRC
+			13:0:STYLE
+			14:0:TITLE
+			15:0:UNITS
+			16:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			FIG
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike SELECTlike Plike DIVlike MAPlike same
+		flags:
+	45:FIGURE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	46:FN
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike SELECTlike Plike BRlike same
+		flags:
+	47:FONT
+		justify
+		11 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COLOR
+			3:0:DIR
+			4:0:END
+			5:0:FACE
+			6:1:ID
+			7:0:LANG
+			8:0:SIZE
+			9:0:STYLE
+			10:0:TITLE
+		3 attr_types
+			core
+			i18n
+			FONT
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	48:FOOTER
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	49:FORM
+		justify
+		17 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:2:ACTION
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:ENCTYPE
+			7:1:ID
+			8:0:LANG
+			9:0:METHOD
+			10:0:ONRESET
+			11:0:ONSUBMIT
+			12:0:SCRIPT
+			13:0:STYLE
+			14:0:SUBJECT
+			15:0:TARGET
+			16:0:TITLE
+		3 attr_types
+			core
+			i18n
+			FORM
+		contents: SGML_MIXED
+		tagclass: FORMlike
+		contains: FONTlike EMlike MATHlike Alike TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: FONTlike EMlike MATHlike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Plike DIVlike LIlike ULlike APPLETlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike LIlike ULlike MAPlike same
+		flags:
+	50:FRAME
+		justify
+		12 attributes:
+			0:4:CLASS
+			1:0:FRAMEBORDER
+			2:1:ID
+			3:2:LONGDESC
+			4:0:MARGINHEIGHT
+			5:0:MARGINWIDTH
+			6:0:NAME
+			7:0:NORESIZE
+			8:0:SCROLLING
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+		2 attr_types
+			core
+			FRAME
+		contents: SGML_EMPTY
+		tagclass: outer
+		contains:
+		icontains:
+		contained: outer
+		icontained: outer
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer same
+		flags: endO
+	51:FRAMESET
+		justify
+		4 attributes:
+			0:0:COLS
+			1:0:ONLOAD
+			2:0:ONUNLOAD
+			3:0:ROWS
+		1 attr_types
+			FRAMESET
+		contents: SGML_ELEMENT
+		tagclass: outer
+		contains: outer same
+		icontains: outer same
+		contained: outer same
+		icontained: BRlike APPLETlike outer same
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer same
+		flags:
+	52:H1
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	53:H2
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	54:H3
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	55:H4
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	56:H5
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	57:H6
+		nojustify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:NOWRAP
+			9:0:SEQNUM
+			10:0:SKIP
+			11:2:SRC
+			12:0:STYLE
+			13:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			H
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags:
+	58:HEAD
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_ELEMENT
+		tagclass: HEADstuff
+		contains: BRlike APPLETlike HRlike MAPlike HEADstuff
+		icontains: BRlike APPLETlike HRlike HEADstuff
+		contained: outer
+		icontained: outer
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer same
+		flags: endO startO mafse
+	59:HEADER
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	60:HR
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:MD
+			7:0:NOSHADE
+			8:0:SIZE
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+			12:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			HR
+		contents: SGML_EMPTY
+		tagclass: HRlike
+		contains:
+		icontains:
+		contained: FORMlike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike formula TRlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike same
+		flags: endO
+	61:HTML
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: outer
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff
+		contained:
+		icontained:
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer
+		flags: endO startO
+	62:HY
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula BRlike same
+		flags: endO
+	63:I
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	64:IFRAME
+		justify
+		14 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:FRAMEBORDER
+			3:0:HEIGHT
+			4:1:ID
+			5:2:LONGDESC
+			6:0:MARGINHEIGHT
+			7:0:MARGINWIDTH
+			8:0:NAME
+			9:0:SCROLLING
+			10:2:SRC
+			11:0:STYLE
+			12:0:TITLE
+			13:0:WIDTH
+		3 attr_types
+			align
+			core
+			IFRAME
+		contents: SGML_MIXED
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike APPLETlike HRlike outer BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike BRlike APPLETlike outer HEADstuff same
+		flags:
+	65:IMG
+		justify
+		22 attributes:
+			0:0:ALIGN
+			1:0:ALT
+			2:0:BORDER
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:HEIGHT
+			7:0:HSPACE
+			8:1:ID
+			9:0:ISMAP
+			10:0:ISOBJECT
+			11:0:LANG
+			12:2:LONGDESC
+			13:0:MD
+			14:0:NAME
+			15:2:SRC
+			16:0:STYLE
+			17:0:TITLE
+			18:0:UNITS
+			19:2:USEMAP
+			20:0:VSPACE
+			21:0:WIDTH
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			IMG
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: same
+		flags: endO
+	66:INPUT
+		justify
+		35 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:0:ACCESSKEY
+			3:0:ALIGN
+			4:0:ALT
+			5:0:CHECKED
+			6:4:CLASS
+			7:0:CLEAR
+			8:0:DIR
+			9:0:DISABLED
+			10:0:ERROR
+			11:0:HEIGHT
+			12:1:ID
+			13:0:ISMAP
+			14:0:LANG
+			15:0:MAX
+			16:0:MAXLENGTH
+			17:0:MD
+			18:0:MIN
+			19:0:NAME
+			20:0:NOTAB
+			21:0:ONBLUR
+			22:0:ONCHANGE
+			23:0:ONFOCUS
+			24:0:ONSELECT
+			25:0:READONLY
+			26:0:SIZE
+			27:2:SRC
+			28:0:STYLE
+			29:0:TABINDEX
+			30:0:TITLE
+			31:0:TYPE
+			32:0:USEMAP
+			33:0:VALUE
+			34:0:WIDTH
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			INPUT
+		contents: SGML_EMPTY
+		tagclass: SELECTlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike
+		icontained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike SELECTlike BRlike MAPlike same
+		flags: endO
+	67:INS
+		justify
+		8 attributes:
+			0:0:CITE
+			1:4:CLASS
+			2:0:DATETIME
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			DEL
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike DELlike
+		flags:
+	68:INS!
+		justify
+		8 attributes:
+			0:0:CITE
+			1:4:CLASS
+			2:0:DATETIME
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			DEL
+		contents: SGML_MIXED
+		tagclass: DELlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike DELlike
+		flags:
+	69:ISINDEX
+		justify
+		9 attributes:
+			0:2:ACTION
+			1:4:CLASS
+			2:0:DIR
+			3:2:HREF
+			4:1:ID
+			5:0:LANG
+			6:0:PROMPT
+			7:0:STYLE
+			8:0:TITLE
+		3 attr_types
+			core
+			i18n
+			ISINDEX
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike same
+		flags: endO
+	70:KBD
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike
+		flags:
+	71:KEYGEN
+		justify
+		8 attributes:
+			0:0:CHALLENGE
+			1:4:CLASS
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:NAME
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			KEYGEN
+		contents: SGML_EMPTY
+		tagclass: SELECTlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: formula TRlike SELECTlike same
+		flags: endO
+	72:LABEL
+		justify
+		11 attributes:
+			0:0:ACCESSKEY
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:0:FOR
+			5:1:ID
+			6:0:LANG
+			7:0:ONBLUR
+			8:0:ONFOCUS
+			9:0:STYLE
+			10:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			LABEL
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike APPLETlike HRlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike
+		flags:
+	73:LEGEND
+		justify
+		9 attributes:
+			0:0:ACCESSKEY
+			1:0:ALIGN
+			2:4:CLASS
+			3:0:CLEAR
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:STYLE
+			8:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			CAPTION
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: DIVlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike
+		flags:
+	74:LH
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike ULlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer same
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags: endO
+	75:LI
+		justify
+		13 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DINGBAT
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:MD
+			7:0:SKIP
+			8:2:SRC
+			9:0:STYLE
+			10:0:TITLE
+			11:0:TYPE
+			12:0:VALUE
+		4 attr_types
+			core
+			events
+			i18n
+			LI
+		contents: SGML_MIXED
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer same
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags: endO
+	76:LINK
+		justify
+		14 attributes:
+			0:0:CHARSET
+			1:4:CLASS
+			2:0:DIR
+			3:2:HREF
+			4:0:HREFLANG
+			5:1:ID
+			6:0:LANG
+			7:0:MEDIA
+			8:0:REL
+			9:0:REV
+			10:0:STYLE
+			11:0:TARGET
+			12:0:TITLE
+			13:0:TYPE
+		4 attr_types
+			core
+			events
+			i18n
+			LINK
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: outer HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		flags: endO
+	77:LISTING
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_LITTERAL
+		tagclass: ULlike
+		contains:
+		icontains:
+		contained: DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike LIlike ULlike same
+		flags:
+	78:MAIN
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	79:MAP
+		justify
+		8 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:1:NAME
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			MAP
+		contents: SGML_ELEMENT
+		tagclass: MAPlike
+		contains: MAPlike
+		icontains: MAPlike
+		contained: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike LIlike
+		flags:
+	80:MARQUEE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: HRlike
+		contains: FONTlike EMlike MATHlike Alike
+		icontains: FONTlike EMlike MATHlike Alike formula BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: MATHlike Alike formula BRlike APPLETlike same
+		flags:
+	81:MATH
+		justify
+		8 attributes:
+			0:0:BOX
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			MATH
+		contents: SGML_PCDATA
+		tagclass: MATHlike
+		contains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike MATHlike Alike formula
+		flags:
+	82:MENU
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:PLAIN
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+			12:0:TYPE
+			13:0:WRAP
+		3 attr_types
+			core
+			i18n
+			UL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: LIlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike BRlike APPLETlike HRlike MAPlike
+		contained: FORMlike DIVlike LIlike BRlike APPLETlike HRlike outer DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike MAPlike same
+		flags:
+	83:META
+		justify
+		5 attributes:
+			0:0:CHARSET
+			1:0:CONTENT
+			2:0:HTTP-EQUIV
+			3:0:NAME
+			4:0:SCHEME
+		1 attr_types
+			META
+		contents: SGML_EMPTY
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: outer HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		flags: endO
+	84:NAV
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	85:NEXTID
+		justify
+		1 attributes:
+			0:0:N
+		1 attr_types
+			NEXTID
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer
+		canclose: FONTlike
+		flags: endO
+	86:NOFRAMES
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: BODYlike
+		contains: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike BODYlike DELlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike DELlike
+		contained: BRlike APPLETlike HRlike outer
+		icontained: BRlike APPLETlike HRlike outer
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike HRlike MAPlike
+		flags:
+	87:NOTE
+		justify
+		10 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:MD
+			6:8:ROLE
+			7:2:SRC
+			8:0:STYLE
+			9:0:TITLE
+		3 attr_types
+			core
+			i18n
+			NOTE
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike ULlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: formula TRlike FORMlike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags:
+	88:OBJECT
+		justify
+		26 attributes:
+			0:0:ALIGN
+			1:0:ARCHIVE
+			2:0:BORDER
+			3:4:CLASS
+			4:2:CLASSID
+			5:2:CODEBASE
+			6:0:CODETYPE
+			7:2:DATA
+			8:0:DECLARE
+			9:0:DIR
+			10:0:HEIGHT
+			11:0:HSPACE
+			12:1:ID
+			13:0:ISMAP
+			14:0:LANG
+			15:0:NAME
+			16:0:NOTAB
+			17:0:SHAPES
+			18:0:STANDBY
+			19:0:STYLE
+			20:0:TABINDEX
+			21:0:TITLE
+			22:0:TYPE
+			23:2:USEMAP
+			24:0:VSPACE
+			25:0:WIDTH
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			OBJECT
+		contents: SGML_LITTERAL
+		tagclass: APPLETlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike APPLETlike HRlike outer BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike LIlike ULlike BRlike APPLETlike same
+		flags: frecyc
+	89:OL
+		justify
+		12 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:CONTINUE
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:SEQNUM
+			8:0:START
+			9:0:STYLE
+			10:0:TITLE
+			11:0:TYPE
+		3 attr_types
+			core
+			i18n
+			OL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: LIlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike MAPlike same
+		flags:
+	90:OPTION
+		justify
+		13 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:0:DISABLED
+			4:0:ERROR
+			5:1:ID
+			6:0:LABEL
+			7:0:LANG
+			8:0:SELECTED
+			9:0:SHAPE
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALUE
+		4 attr_types
+			core
+			events
+			i18n
+			OPTION
+		contents: SGML_PCDATA
+		tagclass: MAPlike
+		contains:
+		icontains:
+		contained: SELECTlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: endO
+	91:OVERLAY
+		justify
+		12 attributes:
+			0:4:CLASS
+			1:0:HEIGHT
+			2:1:ID
+			3:0:IMAGEMAP
+			4:0:MD
+			5:2:SRC
+			6:0:STYLE
+			7:0:TITLE
+			8:0:UNITS
+			9:0:WIDTH
+			10:0:X
+			11:0:Y
+		2 attr_types
+			core
+			OVERLAY
+		contents: SGML_PCDATA
+		tagclass: HRlike
+		contains:
+		icontains:
+		contained: DIVlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike DIVlike LIlike ULlike BRlike APPLETlike same
+		flags: endO
+	92:P
+		justify
+		9 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NOWRAP
+			7:0:STYLE
+			8:0:TITLE
+		4 attr_types
+			align
+			core
+			i18n
+			P
+		contents: SGML_MIXED
+		tagclass: Plike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike formula Plike same
+		flags: endO
+	93:PARAM
+		justify
+		18 attributes:
+			0:0:ACCEPT
+			1:0:ACCEPT-CHARSET
+			2:0:ACCEPT-ENCODING
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DATA
+			6:0:DIR
+			7:1:ID
+			8:0:LANG
+			9:0:NAME
+			10:0:OBJECT
+			11:0:REF
+			12:0:STYLE
+			13:0:TITLE
+			14:0:TYPE
+			15:0:VALUE
+			16:0:VALUEREF
+			17:0:VALUETYPE
+		3 attr_types
+			core
+			i18n
+			PARAM
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: Plike LIlike BRlike APPLETlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike
+		canclose: TRlike SELECTlike Plike LIlike BRlike same
+		flags: endO
+	94:PLAINTEXT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_LITTERAL
+		tagclass: outer
+		contains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike HEADstuff same
+		contained: outer same
+		icontained: outer same
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		flags: endO
+	95:PRE
+		nojustify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike HRlike MAPlike
+		icontains: EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike HRlike MAPlike
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: EMlike MATHlike Alike formula Plike DIVlike LIlike same
+		flags:
+	96:Q
+		justify
+		8 attributes:
+			0:2:CITE
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:STYLE
+			7:0:TITLE
+		3 attr_types
+			core
+			i18n
+			Q
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags:
+	97:S
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags:
+	98:SAMP
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: EMlike
+		flags: nreie
+	99:SCRIPT
+		justify
+		16 attributes:
+			0:0:CHARSET
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DEFER
+			4:0:DIR
+			5:0:EVENT
+			6:0:FOR
+			7:1:ID
+			8:0:LANG
+			9:0:LANGUAGE
+			10:0:NAME
+			11:0:SCRIPTENGINE
+			12:2:SRC
+			13:0:STYLE
+			14:0:TITLE
+			15:0:TYPE
+		3 attr_types
+			core
+			i18n
+			SCRIPT
+		contents: SGML_SCRIPT
+		tagclass: APPLETlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike LIlike ULlike BRlike APPLETlike HRlike same
+		flags:
+	100:SECTION
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:ROLE
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN5
+		contents: SGML_MIXED
+		tagclass: DIVlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike same DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike same
+		flags: mafse
+	101:SELECT
+		justify
+		22 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:0:DISABLED
+			5:0:ERROR
+			6:0:HEIGHT
+			7:1:ID
+			8:0:LANG
+			9:0:MD
+			10:0:MULTIPLE
+			11:0:NAME
+			12:0:NOTAB
+			13:0:ONBLUR
+			14:0:ONCHANGE
+			15:0:ONFOCUS
+			16:0:SIZE
+			17:0:STYLE
+			18:0:TABINDEX
+			19:0:TITLE
+			20:0:UNITS
+			21:0:WIDTH
+		4 attr_types
+			align
+			core
+			i18n
+			SELECT
+		contents: SGML_ELEMENT
+		tagclass: SELECTlike
+		contains: MAPlike
+		icontains: MAPlike
+		contained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike LIlike ULlike same
+		flags: strict
+	102:SHY
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula BRlike same
+		flags: endO
+	103:SMALL
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	104:SPAN
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike same
+		flags:
+	105:SPOT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: Alike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer BODYlike
+		canclose: Alike
+		flags: endO
+	106:STRIKE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags:
+	107:STRONG
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike
+		flags: nreie
+	108:STYLE
+		justify
+		9 attributes:
+			0:4:CLASS
+			1:0:DIR
+			2:1:ID
+			3:0:LANG
+			4:0:MEDIA
+			5:0:NOTATION
+			6:0:STYLE
+			7:0:TITLE
+			8:0:TYPE
+		3 attr_types
+			core
+			i18n
+			STYLE
+		contents: SGML_CDATA
+		tagclass: HEADstuff
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike APPLETlike HRlike outer BODYlike HEADstuff
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula same
+		flags:
+	109:SUB
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: MATHlike
+		contains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike MATHlike
+		flags:
+	110:SUP
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: MATHlike
+		contains: FONTlike EMlike MATHlike Alike formula SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike formula FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike EMlike MATHlike
+		flags:
+	111:TAB
+		justify
+		11 attributes:
+			0:0:ALIGN
+			1:4:CLASS
+			2:0:CLEAR
+			3:0:DIR
+			4:0:DP
+			5:1:ID
+			6:0:INDENT
+			7:0:LANG
+			8:0:STYLE
+			9:0:TITLE
+			10:0:TO
+		4 attr_types
+			align
+			core
+			i18n
+			TAB
+		contents: SGML_EMPTY
+		tagclass: BRlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer HEADstuff
+		canclose: FONTlike
+		flags: endO
+	112:TABLE
+		justify
+		22 attributes:
+			0:0:ALIGN
+			1:2:BACKGROUND
+			2:0:BORDER
+			3:0:CELLPADDING
+			4:0:CELLSPACING
+			5:4:CLASS
+			6:0:CLEAR
+			7:0:COLS
+			8:0:COLSPEC
+			9:0:DIR
+			10:0:DP
+			11:0:FRAME
+			12:1:ID
+			13:0:LANG
+			14:0:NOFLOW
+			15:0:NOWRAP
+			16:0:RULES
+			17:0:STYLE
+			18:0:SUMMARY
+			19:0:TITLE
+			20:0:UNITS
+			21:0:WIDTH
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			TABLE
+		contents: SGML_ELEMENT
+		tagclass: ULlike
+		contains: TRlike SELECTlike FORMlike Plike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike TRlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike Plike LIlike HRlike MAPlike same
+		flags:
+	113:TBODY
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:DP
+			7:1:ID
+			8:0:LANG
+			9:0:NOWRAP
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALIGN
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			TR
+		contents: SGML_ELEMENT
+		tagclass: TRlike
+		contains: TRlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike ULlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike HRlike MAPlike same
+		flags: endO startO
+	114:TD
+		justify
+		23 attributes:
+			0:0:ABBR
+			1:0:ALIGN
+			2:0:AXES
+			3:0:AXIS
+			4:2:BACKGROUND
+			5:0:CHAR
+			6:0:CHAROFF
+			7:4:CLASS
+			8:0:CLEAR
+			9:0:COLSPAN
+			10:0:DIR
+			11:0:DP
+			12:0:HEADERS
+			13:0:HEIGHT
+			14:1:ID
+			15:0:LANG
+			16:0:NOWRAP
+			17:0:ROWSPAN
+			18:0:SCOPE
+			19:0:STYLE
+			20:0:TITLE
+			21:0:VALIGN
+			22:0:WIDTH
+		4 attr_types
+			cellalign
+			core
+			i18n
+			TD
+		contents: SGML_MIXED
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike HRlike MAPlike same
+		flags: endO
+	115:TEXTAREA
+		justify
+		22 attributes:
+			0:0:ACCEPT-CHARSET
+			1:0:ACCESSKEY
+			2:0:ALIGN
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:COLS
+			6:0:DIR
+			7:0:DISABLED
+			8:0:ERROR
+			9:1:ID
+			10:0:LANG
+			11:0:NAME
+			12:0:NOTAB
+			13:0:ONBLUR
+			14:0:ONCHANGE
+			15:0:ONFOCUS
+			16:0:ONSELECT
+			17:0:READONLY
+			18:0:ROWS
+			19:0:STYLE
+			20:0:TABINDEX
+			21:0:TITLE
+		5 attr_types
+			align
+			core
+			events
+			i18n
+			TEXTAREA
+		contents: SGML_PCDATA
+		tagclass: SELECTlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike outer BODYlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike LIlike ULlike same
+		flags: nolyspcl
+	116:TEXTFLOW
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DATA
+			3:0:DIR
+			4:1:ID
+			5:0:LANG
+			6:0:NAME
+			7:0:OBJECT
+			8:0:REF
+			9:0:STYLE
+			10:0:TITLE
+			11:0:TYPE
+			12:0:VALUE
+			13:0:VALUETYPE
+		3 attr_types
+			core
+			i18n
+			BODYTEXT
+		contents: SGML_MIXED
+		tagclass: BODYlike
+		contains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike same DELlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike outer same DELlike
+		contained: formula TRlike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer same
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike BRlike APPLETlike MAPlike outer same
+		flags: endO startO
+	117:TFOOT
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:DP
+			7:1:ID
+			8:0:LANG
+			9:0:NOWRAP
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALIGN
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			TR
+		contents: SGML_ELEMENT
+		tagclass: TRlike
+		contains: TRlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike HRlike MAPlike same
+		flags: endO
+	118:TH
+		justify
+		23 attributes:
+			0:0:ABBR
+			1:0:ALIGN
+			2:0:AXES
+			3:0:AXIS
+			4:2:BACKGROUND
+			5:0:CHAR
+			6:0:CHAROFF
+			7:4:CLASS
+			8:0:CLEAR
+			9:0:COLSPAN
+			10:0:DIR
+			11:0:DP
+			12:0:HEADERS
+			13:0:HEIGHT
+			14:1:ID
+			15:0:LANG
+			16:0:NOWRAP
+			17:0:ROWSPAN
+			18:0:SCOPE
+			19:0:STYLE
+			20:0:TITLE
+			21:0:VALIGN
+			22:0:WIDTH
+		4 attr_types
+			cellalign
+			core
+			i18n
+			TD
+		contents: SGML_MIXED
+		tagclass: LIlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike FORMlike Plike DIVlike ULlike BRlike APPLETlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike
+		contained: TRlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike HRlike MAPlike same
+		flags: endO
+	119:THEAD
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:DP
+			7:1:ID
+			8:0:LANG
+			9:0:NOWRAP
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALIGN
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			TR
+		contents: SGML_ELEMENT
+		tagclass: TRlike
+		contains: TRlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: ULlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike ULlike HRlike MAPlike same
+		flags: endO
+	120:TITLE
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_PCDATA
+		tagclass: HEADstuff
+		contains:
+		icontains:
+		contained: outer HEADstuff
+		icontained: outer HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula Plike DIVlike
+		flags: mafse strict
+	121:TR
+		justify
+		13 attributes:
+			0:0:ALIGN
+			1:0:CHAR
+			2:0:CHAROFF
+			3:4:CLASS
+			4:0:CLEAR
+			5:0:DIR
+			6:0:DP
+			7:1:ID
+			8:0:LANG
+			9:0:NOWRAP
+			10:0:STYLE
+			11:0:TITLE
+			12:0:VALIGN
+		5 attr_types
+			cellalign
+			core
+			events
+			i18n
+			TR
+		contents: SGML_MIXED
+		tagclass: TRlike
+		contains: LIlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: TRlike ULlike
+		icontained: FONTlike EMlike MATHlike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike HRlike MAPlike same
+		flags: endO
+	122:TT
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: nreie
+	123:U
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: FONTlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags: mafse nreie
+	124:UL
+		justify
+		14 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:COMPACT
+			3:0:DINGBAT
+			4:0:DIR
+			5:1:ID
+			6:0:LANG
+			7:0:MD
+			8:0:PLAIN
+			9:2:SRC
+			10:0:STYLE
+			11:0:TITLE
+			12:0:TYPE
+			13:0:WRAP
+		3 attr_types
+			core
+			i18n
+			UL
+		contents: SGML_MIXED
+		tagclass: ULlike
+		contains: FORMlike LIlike HRlike MAPlike
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FORMlike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike same DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike same
+		flags:
+	125:VAR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_MIXED
+		tagclass: EMlike
+		contains: FONTlike EMlike MATHlike Alike SELECTlike BRlike APPLETlike MAPlike same
+		icontains: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike MAPlike same
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike BODYlike same
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff same
+		canclose: FONTlike
+		flags:
+	126:WBR
+		justify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_EMPTY
+		tagclass: FONTlike
+		contains:
+		icontains:
+		contained: FONTlike EMlike MATHlike Alike FORMlike Plike DIVlike LIlike BRlike APPLETlike HRlike outer BODYlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike FORMlike Plike DIVlike LIlike ULlike BRlike APPLETlike HRlike outer BODYlike HEADstuff
+		canclose: FONTlike EMlike MATHlike Alike formula BRlike same
+		flags: endO
+	127:XMP
+		nojustify
+		7 attributes:
+			0:4:CLASS
+			1:0:CLEAR
+			2:0:DIR
+			3:1:ID
+			4:0:LANG
+			5:0:STYLE
+			6:0:TITLE
+		4 attr_types
+			core
+			events
+			i18n
+			GEN
+		contents: SGML_LITTERAL
+		tagclass: ULlike
+		contains:
+		icontains:
+		contained: TRlike SELECTlike FORMlike Plike DIVlike LIlike APPLETlike HRlike outer BODYlike DELlike
+		icontained: FONTlike EMlike MATHlike Alike formula TRlike SELECTlike FORMlike Plike DIVlike LIlike ULlike APPLETlike HRlike outer BODYlike DELlike
+		canclose: FONTlike EMlike MATHlike Alike formula SELECTlike Plike DIVlike LIlike MAPlike
+		flags: endO
diff --git a/WWW/Library/Implementation/tidy_tls.h b/WWW/Library/Implementation/tidy_tls.h
new file mode 100644
index 0000000..56b3636
--- /dev/null
+++ b/WWW/Library/Implementation/tidy_tls.h
@@ -0,0 +1,147 @@
+/*
+ * $LynxId: tidy_tls.h,v 1.8 2015/10/12 00:28:18 tom Exp $
+ * Copyright 2008-2013,2015 Thomas E. Dickey
+ */
+#ifndef TIDY_TLS_H
+#define TIDY_TLS_H
+
+#include <gnutls/gnutls.h>
+
+#define OPENSSL_VERSION_NUMBER (0x0090604F)
+#define SSLEAY_VERSION_NUMBER OPENSSL_VERSION_NUMBER
+
+#define SSLeay_add_ssl_algorithms()   SSL_library_init()
+
+#define SSL_ST_OK       (1)
+
+#define SSL_OP_ALL      (0x000FFFFF)
+#define SSL_OP_NO_SSLv2 (0x00100000)
+#define SSL_OP_NO_SSLv3 (0x00200000)
+#define SSL_OP_NO_TLSv1 (0x00400000)
+
+#define SSL_get_cipher_name(ssl)    SSL_CIPHER_get_name(SSL_get_current_cipher(ssl))
+#define SSL_get_cipher(ssl)         SSL_get_cipher_name(ssl)
+#define SSL_get_cipher_bits(ssl,bp) SSL_CIPHER_get_bits(SSL_get_current_cipher(ssl),(bp))
+#define SSL_get_cipher_version(ssl) SSL_CIPHER_get_version(SSL_get_current_cipher(ssl))
+
+#define TIDY_TLS_BUFSIZE 256
+
+typedef struct {
+    char common_name[TIDY_TLS_BUFSIZE];
+    char country[TIDY_TLS_BUFSIZE];
+    char email[TIDY_TLS_BUFSIZE];
+    char locality_name[TIDY_TLS_BUFSIZE];
+    char organization[TIDY_TLS_BUFSIZE];
+    char organizational_unit_name[TIDY_TLS_BUFSIZE];
+    char state_or_province_name[TIDY_TLS_BUFSIZE];
+} X509_NAME;
+
+typedef struct _SSL SSL;
+
+typedef gnutls_datum_t X509;
+
+typedef struct {
+    unsigned connend;
+    struct {
+	int protocol[GNUTLS_MAX_ALGORITHM_NUM];
+	int encrypts[GNUTLS_MAX_ALGORITHM_NUM];
+	int compress[GNUTLS_MAX_ALGORITHM_NUM];
+	int key_xchg[GNUTLS_MAX_ALGORITHM_NUM];
+	int msg_code[GNUTLS_MAX_ALGORITHM_NUM];
+    } priority;
+} SSL_METHOD;
+
+typedef struct {
+    SSL *ssl;
+    int error;
+    const gnutls_datum_t *cert_list;
+#define current_cert cert_list
+} X509_STORE_CTX;
+
+typedef struct {
+    gnutls_certificate_type_t cert;
+    gnutls_cipher_algorithm_t encrypts;
+    gnutls_compression_method_t compress;
+    gnutls_kx_algorithm_t key_xchg;
+    gnutls_mac_algorithm_t msg_code;
+    gnutls_protocol_t protocol;
+} SSL_CIPHER;
+
+typedef struct _SSL_CTX {
+    SSL_METHOD *method;
+    char *certfile;
+    int certfile_type;
+    char *keyfile;
+    int keyfile_type;
+    unsigned long options;
+
+    int (*verify_callback) (int, X509_STORE_CTX *);
+    int verify_mode;
+
+    char *client_certfile;
+    int client_certfile_type;
+    char *client_keyfile;
+    int client_keyfile_type;
+
+} SSL_CTX;
+
+struct _SSL {
+    gnutls_session_t gnutls_state;
+
+    gnutls_certificate_client_credentials gnutls_cred;
+
+    SSL_CTX *ctx;
+    SSL_CIPHER ciphersuite;
+
+    int last_error;
+    int shutdown;
+    int state;
+    unsigned long options;
+
+    int (*verify_callback) (int, X509_STORE_CTX *);
+    int verify_mode;
+
+    gnutls_transport_ptr_t rfd;
+    gnutls_transport_ptr_t wfd;
+
+    void *sendbuffer;
+    size_t bytes_sent;
+};
+
+/* use either SSL_VERIFY_NONE or SSL_VERIFY_PEER, the last 2 options
+ * are 'ored' with SSL_VERIFY_PEER if they are desired */
+#define SSL_VERIFY_PEER			0x01
+/* *INDENT-OFF* */
+extern SSL *SSL_new(SSL_CTX * ctx);
+extern SSL_CIPHER *SSL_get_current_cipher(SSL * ssl);
+extern SSL_CTX *SSL_CTX_new(SSL_METHOD * method);
+extern SSL_METHOD *SSLv23_client_method(void);
+extern const X509 *SSL_get_peer_certificate(SSL * ssl);
+extern X509_NAME *X509_get_issuer_name(const X509 * cert);
+extern X509_NAME *X509_get_subject_name(const X509 * cert);
+extern char *X509_NAME_oneline(X509_NAME * name, char *buf, int len);
+extern const char *ERR_error_string(unsigned long e, char *buf);
+extern const char *RAND_file_name(char *buf, size_t len);
+extern const char *SSL_CIPHER_get_name(SSL_CIPHER * cipher);
+extern const char *SSL_CIPHER_get_version(SSL_CIPHER * cipher);
+extern int RAND_bytes(unsigned char *buf, int num);
+extern int RAND_load_file(const char *name, long maxbytes);
+extern int RAND_status(void);
+extern int RAND_write_file(const char *name);
+extern int SSL_CIPHER_get_bits(SSL_CIPHER * cipher, int *bits);
+extern int SSL_CTX_set_default_verify_paths(SSL_CTX * ctx);
+extern int SSL_connect(SSL * ssl);
+extern int SSL_library_init(void);
+extern int SSL_read(SSL * ssl, void *buf, int len);
+extern int SSL_set_fd(SSL * ssl, int fd);
+extern int SSL_write(SSL * ssl, const void *buf, int len);
+extern unsigned long ERR_get_error(void);
+extern unsigned long SSL_CTX_set_options(SSL_CTX * ctx, unsigned long options);
+extern void RAND_seed(const void *buf, int num);
+extern void SSL_CTX_free(SSL_CTX * ctx);
+extern void SSL_CTX_set_verify(SSL_CTX * ctx, int verify_mode, int (*verify_callback) (int, X509_STORE_CTX *));
+extern void SSL_free(SSL * ssl);
+extern void SSL_load_error_strings(void);
+/* *INDENT-ON* */
+
+#endif /* TIDY_TLS_H */
diff --git a/WWW/Library/Implementation/www_tcp.h b/WWW/Library/Implementation/www_tcp.h
new file mode 100644
index 0000000..ef754c8
--- /dev/null
+++ b/WWW/Library/Implementation/www_tcp.h
@@ -0,0 +1,1017 @@
+/*                System dependencies in the W3 library
+ * $LynxId: www_tcp.h,v 1.61 2018/12/26 12:30:14 tom Exp $
+ *
+                                   SYSTEM DEPENDENCIES
+
+   System-system differences for TCP include files and macros.  This
+   file includes for each system the files necessary for network and
+   file I/O.  It should be used in conjunction with HTUtils.h to help
+   ensure portability across as many platforms and flavors of platforms
+   as possible.
+
+  AUTHORS
+
+  TBL                Tim Berners-Lee, W3 project, CERN, <timbl@info.cern.ch>
+  EvA                     Eelco van Asperen <evas@cs.few.eur.nl>
+  MA                      Marc Andreessen NCSA
+  AT                      Aleksandar Totic <atotic@ncsa.uiuc.edu>
+  SCW                     Susan C. Weber <sweber@kyle.eitech.com>
+
+  HISTORY:
+  22 Feb 91               Written (TBL) as part of the WWW library.
+  16 Jan 92               PC code from EvA
+  22 Apr 93               Merged diffs bits from xmosaic release
+  29 Apr 93               Windows/NT code from SCW
+  20 May 94		  A.Harper Add support for VMS CMU TCP/IP transport
+   3 Oct 94		  A.Harper Add support for VMS SOCKETSHR/NETLIB
+  15 Jul 95               S. Bjorndahl Gnu C for VMS Globaldef/ref support
+
+*/
+
+#ifndef TCP_H
+#define TCP_H
+
+/*
+
+Default values
+
+   These values may be reset and altered by system-specific sections
+   later on.  there are also a bunch of defaults at the end .
+
+ */
+/* Default values of those: */
+	/* Routine to close a TCP-IP socket         */
+#define NETCLOSE close
+	/* Routine to read from a TCP-IP socket     */
+#define NETREAD(s,p,n) \
+	HTDoRead(s, p, (unsigned)(n))
+	/* Routine to write to a TCP-IP socket      */
+#define NETWRITE(s,p,n)		write(s, p, (size_t)(n))
+#define SOCKET_READ(s,b,l)	read(s,b,(size_t)(l))
+#define IOCTL(s,cmd,arg)	ioctl(s,(long)(cmd),arg)
+#define SOCKET_ERRNO errno	/* normal socket errno */
+
+/* Unless stated otherwise, */
+#define SELECT			/* Can handle >1 channel.               */
+#define GOT_SYSTEM		/* Can call shell with string           */
+
+#ifdef UNIX
+#define GOT_PIPE
+#endif /* UNIX */
+
+#define INVSOC (-1)		/* Unix invalid socket */
+		/* NB: newer libwww has something different for Windows */
+
+#ifndef VMS
+
+#include <sys/types.h>
+
+#if defined(__BORLANDC__)
+#define DECL_ERRNO
+#endif
+
+#if defined(__DJGPP__) || defined(__BORLANDC__)
+#undef HAVE_DIRENT_H
+#define HAVE_DIRENT_H
+#undef HAVE_SYS_FILIO_H
+#endif /* DJGPP or __BORLANDC__ */
+
+#if defined(_MSC_VER)
+#undef HAVE_DIRENT_H
+#define HAVE_DIRENT_H
+#undef HAVE_SYS_FILIO_H
+#endif /* _MSC_VER */
+
+#ifdef HAVE_DIRENT_H
+# include <dirent.h>
+# define D_NAMLEN(dirent) strlen((dirent)->d_name)
+# define STRUCT_DIRENT struct dirent
+#else
+# define D_NAMLEN(dirent) (dirent)->d_namlen
+# define STRUCT_DIRENT struct direct
+# ifdef HAVE_SYS_NDIR_H
+#  include <sys/ndir.h>
+# endif
+# ifdef HAVE_SYS_DIR_H
+#  include <sys/dir.h>
+# endif
+# ifdef HAVE_NDIR_H
+#  include <ndir.h>
+# endif
+#endif /* HAVE_DIRENT_H */
+
+#ifdef HAVE_STRUCT_DIRENT64
+# undef STRUCT_DIRENT
+# define STRUCT_DIRENT struct dirent64
+#endif
+
+#if !(defined(DOSPATH) || defined(__EMX__) || defined(__CYGWIN__))
+#define STRUCT_DIRENT__D_INO 1
+#endif
+
+#endif /* !VMS */
+
+#ifdef TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# ifdef HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+
+#if defined(_AIX) && !defined(AIX)
+#define AIX
+#endif /* _AIX */
+
+#ifndef __CYGWIN__
+#ifdef WIN_EX
+#define HAVE_FTIME 1
+#define HAVE_SYS_TIMEB_H 1
+#endif
+#endif /* __CYGWIN__ */
+
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#else
+#ifdef HAVE_SYS_FCNTL_H
+#include <sys/fcntl.h>
+#endif
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>		/* For bzero etc */
+#endif /* HAVE_STRING_H */
+
+/*
+
+  MACROS FOR CONVERTING CHARACTERS
+
+ */
+#ifndef TOASCII
+#ifdef EBCDIC			/* S/390 -- gil -- 1327 */
+
+extern const char un_IBM1047[];
+extern const unsigned char IBM1047[];
+
+/* For debugging
+#include <assert.h>
+#define   TOASCII(c) (assert((c)>=0 && (c)<256), un_IBM1047[c])
+*/
+/* for production */
+#define   TOASCII(c) (un_IBM1047[c])
+
+#define FROMASCII(c) (IBM1047[c])
+
+#else /* EBCDIC */
+
+#if '0' != 48
+error Host character set is not ASCII.
+#endif
+
+#define TOASCII(c) (c)
+#define FROMASCII(c) (c)
+
+#endif				/* EBCDIC */
+#endif				/* !TOASCII */
+
+/* convert a char to an unsigned, needed if we have signed characters for ctype.h */
+#define UCH(ch) ((unsigned char)(ch))
+
+/*
+ * These parameters were provided by Nigel Horne, using BeOS professional 5.0
+ */
+#ifdef  __BEOS__
+#undef NETREAD
+#undef NETWRITE
+#undef NETCLOSE
+#define NETREAD(s,b,l)  recv((s),(b),(l),0)
+#define NETWRITE(s,b,l) send((s),(b),(l),0)
+#define NETCLOSE(s)     closesocket(s)
+#endif
+
+/*
+IBM-PC running Windows NT
+
+	These parameters provided by  Susan C. Weber <sweber@kyle.eitech.com>.
+*/
+
+#ifdef _WINDOWS
+
+#ifndef _WINDOWS_NSL
+#define _WINDOWS_NSL
+#endif
+
+#include <fcntl.h>		/* For HTFile.c */
+#include <sys/types.h>		/* For HTFile.c */
+#include <sys/stat.h>		/* For HTFile.c */
+#undef NETREAD
+#undef NETWRITE
+#undef NETCLOSE
+#undef IOCTL
+extern int ws_netread(int fd, char *buf, int len);
+
+#define NETREAD(s,b,l)  ws_netread((s),(b),(l))		/* 1997/11/06 (Thu) */
+#define NETWRITE(s,b,l) send((s),(b),(l),0)
+#define NETCLOSE(s)     closesocket(s)
+#define IOCTL(s,cmd,arg)	ioctlsocket(s,cmd,arg)
+#include <io.h>
+#include <string.h>
+#include <process.h>
+#include <time.h>
+#include <errno.h>
+#include <direct.h>
+
+#ifdef ENABLE_IPV6
+#undef  USE_WINSOCK2_H
+#define USE_WINSOCK2_H
+
+/* Avoid including <winsock*.h> in <windows.h> */
+#ifndef WIN32_LEAN_AND_MEAN
+#error Define "WIN32_LEAN_AND_MEAN" in your makefile
+#endif
+
+#ifdef _WINSOCKAPI_
+#error windows.h included before winsock2.h
+#endif
+
+#if defined(_MSC_VER) && (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0501)
+/*
+ * Needed to pull in the real getaddrinfo() and not the inline version
+ * in <wspiAPI.H> which doesn't support IPv6 (IPv4 only). <wspiAPI.H> is
+ * included from <ws2tcpip.h> for <= 0x0500 SDKs.
+ */
+#undef  _WIN32_WINNT
+#define _WIN32_WINNT 0x0501
+#endif
+#endif /* ENABLE_IPV6 */
+
+#ifdef USE_WINSOCK2_H
+#include <winsock2.h>		/* normally included in windows.h */
+
+#ifdef ENABLE_IPV6
+#include <ws2tcpip.h>
+#endif
+
+#undef EINPROGRESS
+#undef EALREADY
+#undef EISCONN
+#undef EINTR
+#undef EAGAIN
+#undef ENOTCONN
+#undef ECONNRESET
+#undef ETIMEDOUT
+
+#define EINPROGRESS  WSAEINPROGRESS
+#define EALREADY     WSAEALREADY
+#define EISCONN      WSAEISCONN
+#define EINTR        WSAEINTR
+/* fine EAGAIN       WSAEAGAIN */
+#define ENOTCONN     WSAENOTCONN
+#define ECONNRESET   WSAECONNRESET
+#define ETIMEDOUT    WSAETIMEDOUT
+
+#else /* USE_WINSOCK2_H */
+
+#include <winsock.h>
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#undef EINTR
+#undef EAGAIN
+#endif /* _MSC_VER */
+
+#undef EINPROGRESS
+#define EINPROGRESS          (WSABASEERR+36)
+
+#undef EALREADY
+#define EALREADY             (WSABASEERR+37)
+
+#undef EISCONN
+#define EISCONN              (WSABASEERR+56)
+
+#undef EINTR
+#define EINTR                (WSABASEERR+4)
+
+#undef EAGAIN
+#define EAGAIN               (WSABASEERR+1002)
+
+#undef ENOTCONN
+#define ENOTCONN             (WSABASEERR+57)
+
+#undef ECONNRESET
+#define ECONNRESET           (WSABASEERR+54)
+
+#undef ETIMEDOUT
+#define ETIMEDOUT             WSAETIMEDOUT
+
+#endif /* USE_WINSOCK2_H */
+
+#undef  SOCKET_ERRNO
+#define SOCKET_ERRNO          WSAGetLastError()
+
+#define INCLUDES_DONE
+#define TCP_INCLUDES_DONE
+
+#define LYNX_FD	SOCKET		/* WINSOCK uses an unsigned value for FD_SET, etc */
+
+#else
+
+#define LYNX_FD	int		/* POSIX says FD_SET descriptor is int */
+
+#endif				/* WINDOWS */
+
+/*
+
+VAX/VMS
+
+   Under VMS, there are many versions of TCP-IP. Define one if you do
+   not use Digital's UCX product:
+
+  UCX                     DEC's "Ultrix connection" (default)
+  CMU_TCP                 Available via FTP from sacusr.mp.usbr.gov
+  SOCKETSHR               Eckhart Meyer's interface to NETLIB
+  WIN_TCP                 From Wollongong, now GEC software.
+  MULTINET                From SRI, became TGV, then Cisco.
+  DECNET                  Cern's TCP socket emulation over DECnet
+  TCPIP_SERVICES          TCP/IP Services (newer than UCX)
+
+   WIN_TCP, MULTINET and DECNET do not interfere with the
+   unix i/o library, and so they need special calls to read, write and
+   close sockets.  In these cases the socket number is a VMS channel
+   number, so we make the @@@ HORRIBLE @@@ assumption that a channel
+   number will be greater than 10 but a unix file descriptor less than
+   10.  It works.
+
+ */
+#ifdef VMS
+
+#ifdef UCX
+#undef IOCTL
+#define IOCTL(s,cmd,arg)	HTioctl(s,cmd,arg)
+#endif				/* UCX */
+
+#ifdef WIN_TCP
+#undef SOCKET_READ
+#undef NETWRITE
+#undef NETCLOSE
+#define SOCKET_READ(s,b,l)  ((s)>10 ? netread((s),(b),(l)) : read((s),(b),(l)))
+#define NETWRITE(s,b,l)     ((s)>10 ? netwrite((s),(b),(l)) : write((s),(b),(l)))
+#define NETCLOSE(s)         ((s)>10 ? netclose(s) : close(s))
+#undef IOCTL
+#define IOCTL(a,b,c) -1		/* disables ioctl function            */
+#define NO_IOCTL		/* flag to check if ioctl is disabled */
+#endif				/* WIN_TCP */
+
+#ifdef CMU_TCP
+#undef SOCKET_READ
+#undef NETREAD
+#undef NETWRITE
+#undef NETCLOSE
+#define SOCKET_READ(s,b,l) (cmu_get_sdc((s)) != 0 ? cmu_read((s),(b),(l)) : read((s),(b),(l)))
+#define NETREAD(s,b,l)     (cmu_get_sdc((s)) != 0 ? HTDoRead((s),(b),(l)) : read((s),(b),(l)))
+#define NETWRITE(s,b,l)    (cmu_get_sdc((s)) != 0 ? cmu_write((s),(b),(l)) : write((s),(b),(l)))
+#define NETCLOSE(s)        (cmu_get_sdc((s)) != 0 ? cmu_close((s)) : close((s)))
+#endif				/* CMU_TCP */
+
+#ifdef MULTINET
+#undef NETCLOSE
+#undef SOCKET_READ
+#undef NETWRITE
+#undef IOCTL
+#undef SOCKET_ERRNO
+/*
+ *  Delete these socket_foo() prototypes as MultiNet adds them
+ *  to it's socket library headers.  Compiler warnings due to
+ *  the absence of arguments in the generic prototypes here will
+ *  include the names of those which can be deleted. - FM
+ */
+extern int socket_read();
+extern int socket_write();
+extern int socket_close();
+extern int socket_ioctl();
+
+#define SOCKET_READ(s,b,l)  ((s)>10 ? socket_read((s),(b),(l)) : \
+				read((s),(b),(l)))
+#define NETWRITE(s,b,l)     ((s)>10 ? socket_write((s),(b),(l)) : \
+                                write((s),(b),(l)))
+#define NETCLOSE(s)         ((s)>10 ? socket_close(s) : close(s))
+#define IOCTL(s,cmd,arg)	socket_ioctl(s,cmd,arg)
+#define SOCKET_ERRNO socket_errno
+#endif /* MULTINET */
+
+#ifdef SOCKETSHR_TCP
+#undef SOCKET_READ
+#undef NETREAD
+#undef NETWRITE
+#undef NETCLOSE
+#undef IOCTL
+#define SOCKET_READ(s,b,l)  (si_get_sdc((s)) != 0 ? si_read((s),(b),(l)) : \
+                                read((s),(b),(l)))
+#define NETREAD(s,b,l)      (si_get_sdc((s)) != 0 ? HTDoRead((s),(b),(l)) : \
+                                read((s),(b),(l)))
+#define NETWRITE(s,b,l)     (si_get_sdc((s)) != 0 ? si_write((s),(b),(l)) : \
+                                write((s),(b),(l)))
+#define NETCLOSE(s)         (si_get_sdc((s)) != 0 ? si_close((s)) : close((s)))
+#define IOCTL(s,cmd,arg)	si_ioctl(s,cmd,arg)
+#endif /* SOCKETSHR_TCP */
+
+#ifdef TCPIP_SERVICES
+/*
+ * TCPIP Services has all of the entrypoints including ioctl().
+ */
+#undef NETWRITE
+#define NETWRITE(s,b,l) send((s),(char *)(b),(l),0)
+
+#define TYPE_FD_SET int
+
+#if 0				/* this should be declared via time.h */
+typedef TYPE_FD_SET fd_set;
+#endif
+
+#endif /* TCPIP_SERVICES */
+
+#include <string.h>
+
+#include <file.h>
+#include <stat.h>
+#include <unixio.h>
+#include <unixlib.h>
+
+#define INCLUDES_DONE
+
+#ifdef MULTINET			/* Include from standard Multinet directories */
+/*
+ *  Delete any of these multinet_foo() and associated prototypes
+ *  as MultiNet adds them to its socket library headers.  You'll
+ *  get compiler warnings about them, due the absence of arguments
+ *  in the generic prototyping here, and the warnings will include
+ *  the names of the functions whose prototype entries can be
+ *  deleted here. - FM
+ */
+extern int multinet_accept();
+extern int multinet_bind();
+extern int multinet_connect();
+extern int multinet_gethostname();
+extern int multinet_getsockname();
+extern unsigned short multinet_htons(unsigned short __val);
+extern unsigned short multinet_ntohs(unsigned short __val);
+extern int multinet_listen();
+extern int multinet_select();
+extern int multinet_socket();
+extern char *vms_errno_string();
+
+#ifndef __SOCKET_TYPEDEFS
+#define __SOCKET_TYPEDEFS 1
+#endif /* !__SOCKET_TYPEDEFS */
+
+#include <time.h>
+#include <types.h>
+/*
+ * DEC C before version 5.2 added some typedefs to <types.h> which happen
+ * to be suppressed if the version-4 compatibility define is set.  In
+ * particular, lynx uses "off_t".  VAX-C used "unsigned", DEC-C uses "int".
+ */
+#if defined(_DECC_V4_SOURCE) && !defined(____OFF_T)
+#undef off_t
+#define off_t int
+#endif
+
+#ifdef __TIME_T
+#undef  __TYPES
+#define __TYPES 1
+#define __TYPES_LOADED 1
+#endif /* __TIME_T */
+
+#ifdef __SOCKET_TYPEDEFS
+#undef __SOCKET_TYPEDEFS
+#endif /* __SOCKET_TYPEDEFS */
+
+#include "multinet_root:[multinet.include.sys]types.h"
+
+#ifndef __SOCKET_TYPEDEFS
+#define __SOCKET_TYPEDEFS 1
+#endif /* !__SOCKET_TYPEDEFS */
+
+#include "multinet_root:[multinet.include]errno.h"
+
+#ifdef __TYPES
+#undef  __TIME_T
+#define __TIME_T 1
+#endif /* __TYPE */
+
+#ifdef __TIME_LOADED
+#undef  __TIME
+#define __TIME 1		/* to avoid double definitions in in.h */
+#endif /* __TIME_LOADED */
+
+#include "multinet_root:[multinet.include.sys]time.h"
+
+#define MULTINET_NO_PROTOTYPES	/* DECC is compatible-but-different */
+#include "multinet_root:[multinet.include.sys]socket.h"
+#undef MULTINET_NO_PROTOTYPES
+#include "multinet_root:[multinet.include.netinet]in.h"
+#include "multinet_root:[multinet.include.arpa]inet.h"
+#include "multinet_root:[multinet.include]netdb.h"
+#include "multinet_root:[multinet.include.sys]ioctl.h"
+#define TCP_INCLUDES_DONE
+/*
+ *  Uncomment this if you get compiler messages
+ *  about struct timeval having no linkage. - FM
+ */
+/*#define NO_TIMEVAL*/
+#ifdef NO_TIMEVAL
+struct timeval {
+    long tv_sec;		/* seconds since Jan. 1, 1970 */
+    long tv_usec;		/* microseconds */
+};
+#endif /* NO_TIMEVAL */
+#endif /* MULTINET */
+
+#ifdef DECNET
+#include <types.h>
+#include <errno.h>
+#include <time.h>
+#include <types.h>		/* for socket.h */
+#include <socket.h>
+#include <dn>
+#include <dnetdb>
+/* #include "vms.h" */
+#define TCP_INCLUDES_DONE
+#endif /* DECNET */
+
+#ifdef UCX
+#include <types.h>
+#include <errno.h>
+#include <time.h>
+#include <socket.h>
+#include <in.h>
+#include <inet.h>
+#if defined(TCPWARE) && !defined(__DECC)
+#include "tcpware_include:netdb.h"
+#include "tcpware_include:ucx$inetdef.h"
+#else
+#include <netdb.h>
+#ifdef MUCX
+#include <multinet_root:[multinet.include.vms]ucx$inetdef.h>
+#else
+#include <ucx$inetdef.h>
+#endif /* MUCX */
+#endif /* TCPWARE */
+#define TCP_INCLUDES_DONE
+#endif /* UCX */
+
+#ifdef CMU_TCP
+#include <types.h>
+#include <errno.h>
+#include "cmuip_root:[syslib]time.h"
+#include "cmuip_root:[syslib]socket.h"
+#include <in.h>
+#include <inet.h>
+#include <netdb.h>
+#include "cmuip_root:[syslib]ioctl.h"
+#define TCP_INCLUDES_DONE
+#endif /* CMU_TCP */
+
+#ifdef SOCKETSHR_TCP
+#include <types.h>
+#include <errno.h>
+#include <time.h>
+#include <socket.h>
+#include <in.h>
+#include <inet.h>
+#include <netdb.h>
+#include "socketshr_library:socketshr.h"
+#include "socketshr_library:ioctl.h"
+#define TCP_INCLUDES_DONE
+#endif /* SOCKETSHR_TCP */
+
+#ifdef TCPIP_SERVICES
+#include <types.h>
+#include <errno.h>
+#include <time.h>
+#include <ioctl.h>
+#include <socket.h>
+#include <in.h>
+#include <inet.h>
+#include <netdb.h>
+#define TCP_INCLUDES_DONE
+#endif /* TCPIP_SERVICES */
+
+#ifdef WIN_TCP
+#include <types.h>
+#include <errno.h>
+#include <time.h>
+#include <socket.h>
+#include <in.h>
+#include <inet.h>
+#include <netdb.h>
+#ifndef NO_IOCTL
+#include <ioctl.h>
+#endif /* !NO_IOCTL */
+#define TCP_INCLUDES_DONE
+#endif /* WIN_TCP */
+
+#ifndef TCP_INCLUDES_DONE
+#include <types.h>
+#include <errno.h>
+#include <time.h>
+#ifdef VMS_SOCKET_HEADERS
+/*
+ *  Not all versions of VMS have the full set of headers
+ *  for socket library functions, because the TCP/IP
+ *  packages were layered products.  If we want these
+ *  specifically, instead of those for the above packages,
+ *  the module should be compiled with VMS_SOCKET_HEADERS
+ *  defined instead of layered product definitions, above.
+ *  If the module is not using socket library functions,
+ *  none of the definitions need be used, and we include
+ *  only the above three headers. - FM
+ */
+#include <socket.h>
+#include <in.h>
+#include <inet.h>
+#include <netdb.h>
+#include <ioctl.h>
+#endif /* VMS_SOCKET_HEADERS */
+#define TCP_INCLUDES_DONE
+#endif /* !TCP_INCLUDES_DONE */
+
+/*
+ * On VMS machines, the linker needs to be told to put global data sections
+ * into a data segment using these storage classes.  (MarkDonszelmann)
+ */
+#if defined(VAXC) && !defined(__DECC)
+#define GLOBALDEF globaldef
+#define GLOBALREF globalref
+#else
+#ifdef __GNUC__			/* this added by Sterling Bjorndahl */
+#define GLOBALREF_IS_MACRO 1
+#define GLOBALDEF_IS_MACRO 1
+#include <gnu_hacks.h>		/* defines GLOBALREF and GLOBALDEF for GNUC on VMS */
+#endif /* __GNUC__ */
+#endif /* VAXC && !DECC */
+
+#include <perror.h>
+#ifndef errno
+extern int errno;
+#endif /* !errno */
+
+#endif /* VMS */
+
+/*
+ * On non-VMS machines and for DECC on VMS, the GLOBALDEF and GLOBALREF
+ * storage types default to normal C storage types.
+ */
+#ifndef GLOBALREF
+#define GLOBALDEF
+#define GLOBALREF extern
+#endif /* !GLOBALREF */
+
+#ifdef __DJGPP__
+#undef SELECT
+#define TCP_INCLUDES_DONE
+#undef  IOCTL
+#define IOCTL(s,cmd,arg)	ioctlsocket(s,cmd,(char*)(arg))
+#define DECL_ERRNO
+#include <errno.h>
+#include <sys/types.h>
+#include <io.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <tcp.h>
+#ifdef word
+#undef word
+#endif /* word */
+#ifdef set_timeout
+#undef set_timeout
+#endif /* set_timeout */
+#define select select_s
+
+#undef NETWRITE
+#define NETWRITE write_s
+#undef NETREAD
+#define NETREAD read_s
+#undef NETCLOSE
+#define NETCLOSE close_s
+#ifdef UNIX
+#undef UNIX
+#endif /* UNIX */
+#ifdef HAVE_GETTEXT
+#define gettext gettext__
+#endif
+#if !defined(NCURSES) && !defined(USE_SLANG)
+#define HAVE_CBREAK 1
+#endif /* !NCURSES && !USE_SLANG */
+#if defined(USE_SLANG) && !defined(NO_DJ_KEYHANDLER) && defined(HAVE_CONFIG_H)
+#define DJGPP_KEYHANDLER
+#endif /* USE_SLANG && !NO_DJ_KEYHANDLER  && HAVE_CONFIG_H */
+#endif /* DJGPP */
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif /* HAVE_UNISTD_H */
+
+#ifdef HAVE_SYS_FILIO_H
+#include <sys/filio.h>
+#endif /* HAVE_SYS_FILIO_H */
+
+#if !defined(HAVE_LSTAT) && !defined(lstat)
+#define lstat(path,block) stat(path,block)
+#endif
+
+#if defined(DECL_ERRNO) && !defined(errno)
+extern int errno;
+#endif /* DECL_ERRNO */
+
+/*
+Regular BSD unix versions
+=========================
+   These are a default unix where not already defined specifically.
+ */
+#ifndef INCLUDES_DONE
+#include <sys/types.h>
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif /* HAVE_STRING_H */
+#include <errno.h>		/* independent */
+#ifdef __MVS__			/* S/390 -- gil -- 1361 */
+#include <time.h>
+#endif /* __MVS__ */
+#ifdef SCO
+#include <sys/timeb.h>
+#include <time.h>
+#endif /* SCO */
+#if defined(AIX) || defined(SVR4)
+#include <time.h>
+#endif /* AIX || SVR4 */
+#include <sys/time.h>		/* independent */
+#include <sys/stat.h>
+#ifndef __MVS__			/* S/390 -- gil -- 1373 */
+#include <sys/param.h>
+#endif /* __MVS__ */
+#include <sys/file.h>		/* For open() etc */
+
+#if defined(NeXT) || defined(sony_news)
+#ifndef mode_t
+typedef unsigned short mode_t;
+#endif /* !mode_t */
+
+#endif /* NeXT || sony_news */
+
+#define INCLUDES_DONE
+#endif /* Normal includes */
+
+/* FIXME: this should be autoconf'd */
+/* Interactive UNIX for i386 and i486 -- Thanks to jeffrey@itm.itm.org */
+#ifdef ISC
+#include <net/errno.h>
+#include <sys/types.h>
+#include <sys/tty.h>
+#include <sys/sioctl.h>
+#include <sys/bsdtypes.h>
+#ifndef MERGE
+#define MERGE
+#include <sys/pty.h>
+#undef MERGE
+#else
+#include <sys/pty.h>
+#endif /* !MERGE */
+#ifndef USE_DIRENT
+#define USE_DIRENT		/* sys V style directory open */
+#endif /* USE_DIRENT */
+#include <sys/dirent.h>
+#endif /* ISC */
+
+/*	Directory reading stuff - BSD or SYS V
+*/
+#ifdef HAVE_CONFIG_H
+
+# ifdef HAVE_LIMITS_H
+#  include <limits.h>
+# endif	/* HAVE_LIMITS_H */
+# if !defined(MAXINT) && defined(INT_MAX)
+#  define MAXINT INT_MAX
+# endif	/* !MAXINT && INT_MAX */
+
+#else
+
+#if !(defined(VM) || defined(VMS) || defined(THINK_C) || defined(PCNFS) || defined(_WINDOWS))
+#define DECL_SYS_ERRLIST 1
+#endif
+
+#if defined(VMS)
+#define socklen_t unsigned
+#else
+#define socklen_t int		/* used for default LY_SOCKLEN definition */
+#endif
+
+#endif /* !HAVE_CONFIG_H */
+
+#ifdef HAVE_LIBINTL_H
+#include <libintl.h>
+#endif
+
+#ifdef HAVE_LIBGETTEXT_H
+#include <libgettext.h>
+#endif
+
+#define N_(s) s
+
+#ifndef HAVE_GETTEXT
+#define gettext(s) s
+#endif
+
+#ifndef NLS_TEXTDOMAIN
+#define NLS_TEXTDOMAIN "lynx"
+#endif
+
+/*
+Defaults
+========
+  INCLUDE FILES FOR TCP
+ */
+#ifndef TCP_INCLUDES_DONE
+#ifndef NO_IOCTL
+#include <sys/ioctl.h>		/* EJB */
+#endif /* !NO_IOCTL */
+#include <sys/socket.h>
+#include <netinet/in.h>
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>		/* Must be after netinet/in.h */
+#endif
+#include <netdb.h>
+#endif /* TCP includes */
+
+typedef unsigned short PortNumber;
+
+#ifndef S_ISLNK
+#define S_ISLNK(m)	(((m) & S_IFMT) == S_IFLNK)
+#endif /* S_ISLNK */
+
+#ifndef S_ISDIR
+#define S_ISDIR(m)	(((m) & S_IFMT) == S_IFDIR)
+#endif /* S_ISDIR */
+
+#ifndef S_ISREG
+#define S_ISREG(m)	(((m) & S_IFMT) == S_IFREG)
+#endif /* S_ISREG */
+
+#ifndef S_ISUID
+#define S_ISUID  0004000
+#endif
+#ifndef S_ISGID
+#define S_ISGID  0002000
+#endif
+#ifndef S_ISVTX
+#define S_ISVTX  0001000
+#endif
+
+#ifndef S_IRWXU
+#define S_IRWXU 00700
+#endif
+
+#ifndef S_IRUSR
+#define S_IRUSR 00400
+#endif
+#ifndef S_IWUSR
+#define S_IWUSR 00200
+#endif
+#ifndef S_IXUSR
+#define S_IXUSR 00100
+#endif
+
+#ifndef S_IRWXG
+#define S_IRWXG 00070
+#endif
+
+#ifndef S_IRGRP
+#define S_IRGRP 00040
+#endif
+#ifndef S_IWGRP
+#define S_IWGRP 00020
+#endif
+#ifndef S_IXGRP
+#define S_IXGRP 00010
+#endif
+
+#ifndef S_IRWXO
+#define S_IRWXO 00007
+#endif
+
+#ifndef S_IROTH
+#define S_IROTH 00004
+#endif
+#ifndef S_IWOTH
+#define S_IWOTH 00002
+#endif
+#ifndef S_IXOTH
+#define S_IXOTH 00001
+#endif
+
+/*
+
+ROUGH ESTIMATE OF MAX PATH LENGTH
+
+*/
+#ifndef HT_MAX_PATH
+#ifdef MAXPATHLEN
+#define HT_MAX_PATH MAXPATHLEN
+#else
+#ifdef PATH_MAX
+#define HT_MAX_PATH PATH_MAX
+#else
+#define HT_MAX_PATH 1024	/* Any better ideas? */
+#endif
+#endif
+#endif /* HT_MAX_PATH */
+
+#if HT_MAX_PATH < 256
+#undef HT_MAX_PATH
+#define HT_MAX_PATH 256
+#endif
+
+/*
+  MACROS FOR MANIPULATING MASKS FOR SELECT()
+ */
+#ifdef SELECT
+#ifndef FD_SET
+#ifndef TYPE_FD_SET
+#define TYPE_FD_SET unsigned
+typedef TYPE_FD_SET fd_set;
+#endif /* !TYPE_FD_SET */
+
+#define FD_SET(fd,pmask)   (*(pmask)) |=  (1 << (fd))
+#define FD_CLR(fd,pmask)   (*(pmask)) &= ~(1 << (fd))
+#define FD_ZERO(pmask)     (*(pmask)) = 0
+#define FD_ISSET(fd,pmask) (*(pmask) & (1 << (fd)))
+#endif /* !FD_SET */
+#endif /* SELECT */
+
+/*
+ * Macro for setting errno - only define this if you really can do it.
+ */
+#if defined(CAN_SET_ERRNO) || (!defined(errno) && (!defined(VMS) || defined(UCX)))
+#define set_errno(value) errno = value
+#else
+#define set_errno(value)	/* we do not know how */
+#endif
+
+/*
+ * IPv6 support
+ */
+#if defined(HAVE_GETADDRINFO) && defined(ENABLE_IPV6)
+#if defined(HAVE_GAI_STRERROR)
+#define INET6
+#elif defined(_WINDOWS)
+#define INET6
+#ifndef WIN_EX
+#error Define "WIN_EX" in your makefile.
+#endif
+#ifndef _MSC_VER		/* MSVC has this inlined in <ws2tcpip.h> */
+#undef  gai_strerror
+#define gai_strerror(err) w32_strerror (err)
+#endif
+#endif
+#endif /* HAVE_GETADDRINFO && ENABLE_IPV6 */
+
+typedef union {
+    struct sockaddr_in soc_in;
+    struct sockaddr soc_address;
+#ifdef INET6
+    struct sockaddr_storage soc_storage;
+#endif
+} LY_SOCKADDR;
+
+#ifdef INET6
+typedef struct sockaddr_storage SockA;
+
+#define SOCKADDR_OF(param) (&((param).soc_address))
+
+#ifndef SA_LEN
+#define SA_LEN(x) (((x)->sa_family == AF_INET6) \
+		   ? sizeof(struct sockaddr_in6) \
+		   : (((x)->sa_family == AF_INET) \
+		      ? sizeof(struct sockaddr_in) \
+		      : sizeof(struct sockaddr)))	/* AF_UNSPEC? */
+#endif
+
+#ifdef SIN6_LEN
+#define SOCKADDR_LEN(param) (SOCKADDR_OF(param)->sa_len)
+#else
+#define SOCKADDR_LEN(param) (socklen_t) SA_LEN(SOCKADDR_OF(param))
+#endif /* SIN6_LEN */
+#else
+typedef struct sockaddr_in SockA;
+
+#define SOCKADDR_OF(param) ((struct sockaddr *)&(param))
+#define SOCKADDR_LEN(param) sizeof(param)
+#endif /* INET6 */
+
+#ifndef MAXHOSTNAMELEN
+#define MAXHOSTNAMELEN 128	/* Max label is 63. Should handle 2 of those */
+#endif /* MAXHOSTNAMELEN */
+
+#endif /* TCP_H */
diff --git a/WWW/Library/Implementation/www_wait.h b/WWW/Library/Implementation/www_wait.h
new file mode 100644
index 0000000..3e40e88
--- /dev/null
+++ b/WWW/Library/Implementation/www_wait.h
@@ -0,0 +1,34 @@
+#ifndef WWW_WAIT_H
+#define WWW_WAIT_H 1
+
+#include <HTUtils.h>
+
+#ifdef HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#endif
+
+#ifndef WEXITSTATUS
+# ifdef HAVE_TYPE_UNIONWAIT
+#  define	WEXITSTATUS(status)	(status.w_retcode)
+# else
+#  define	WEXITSTATUS(status)	(((status) & 0xff00) >> 8)
+# endif
+#endif
+
+#ifndef WTERMSIG
+# ifdef HAVE_TYPE_UNIONWAIT
+#  define	WTERMSIG(status)	(status.w_termsig)
+# else
+#  define	WTERMSIG(status)	((status) & 0x7f)
+# endif
+#endif
+
+#ifndef WSTOPSIG
+# ifdef HAVE_TYPE_UNIONWAIT
+#  define	WSTOPSIG(status)	(status.w_stopsig)
+# else
+#  define	WSTOPSIG(status)	WEXITSTATUS(status)
+# endif
+#endif
+
+#endif /* WWW_WAIT_H */
diff --git a/WWW/Library/djgpp/CommonMakefile b/WWW/Library/djgpp/CommonMakefile
new file mode 100644
index 0000000..d8d8d20
--- /dev/null
+++ b/WWW/Library/djgpp/CommonMakefile
@@ -0,0 +1,334 @@
+#	Common Makefile for W3 Library Code
+#	-----------------------------------
+#
+#	(c) CERN 1990, 1991 -- see Copyright.html for conditions
+#
+# This file should be invariant between systems.
+#	DEPENDENCIES NOT COMPLETE @@
+#
+#	make		Compile and link the software (private version)
+#	make install	Copy it into the system (implies make)
+#	make update	Copy installed version into installed version
+#	make uninstall	Unlink installed version from the system
+#	make clean	Remove intermediate files
+#	make cleanall	Remove intremediate files and products
+#
+# Macros required to be defined already for make:
+#
+# CC		The C compiler
+# CFLAGS	Flags for $(CC) -- except the -I which are below
+# LFLAGS	Flags for ld
+# LYFLAGS	Flags for Lynx
+#
+# WWW		The WWW source tree directory
+#
+# Macros needed for make install:
+#
+# LIBDIR	Directory for installed library
+#______________________________________________________________________
+
+#  If this env var is set to something else Some makes will use that instead
+SHELL = /bin/sh
+
+#	.h files are distributed but originally are made from the
+#	self-documenting hypertext files.
+
+.SUFFIXES: .h .html .htm
+.html.h:
+#	- chmod +w $*.h
+#	www -w90 -na -to text/x-c $*.html > $*.h
+#	chmod -w $*.h
+
+# If this is actually run in a subdirectory,
+#
+WWW = ../..
+# WWW = ../..	For [cernlib] build in this directory
+
+WC = $(WWW)/Library
+CMN = $(WWW)/Library/Implementation/
+VMS = $(CMN)vms
+# Where shall we put the objects and built library?
+
+LOB = $(WTMP)/Library/$(WWW_MACH)
+
+# Only needed if HTWAIS.c is to be compiled. Put into your Makefile.include
+#  uncomment these and fill in WAISINC for adding direct wais access
+#  to Lynx.
+#HTWAIS = $(LOB)/HTWAIS.o
+#WAIS = YES
+#WAISINC = -I../../../../freeWAIS-0.202/ir
+#WAISCFLAGS = -DDIRECT_WAIS
+#
+
+# This path, if relative, is taken relative to the directory
+# in which this makefile is, not the pwd.  This screws up the
+# recursive invocation
+# include $(CMN)Version.make
+include $(ABS)$(WWW)/Library/Implementation/Version.make
+
+# XMOsAIC hack is only for server to cope with xmosaic kludge for mmedia
+#
+# add -DNEW_GATEWAY here for the new gateway config stuff
+CFLAGS2 = $(CFLAGS) $(LYFLAGS) $(WAISCFLAGS) -I$(CMN) -DACCESS_AUTH
+
+CERNLIBBIN = $(WWW)/bin
+
+COMMON = $(LOB)/HTParse.o $(LOB)/HTAccess.o $(LOB)/HTTP.o \
+	$(LOB)/HTFile.o	$(LOB)/HTBTree.o $(LOB)/HTFTP.o $(LOB)/HTTCP.o \
+	$(LOB)/SGML.o $(LOB)/HTMLDTD.o $(LOB)/HTChunk.o \
+	$(LOB)/HTPlain.o \
+	$(LOB)/HTMLGen.o \
+	$(LOB)/HTAtom.o $(LOB)/HTAnchor.o $(LOB)/HTStyle.o \
+	$(LOB)/HTList.o $(LOB)/HTString.o $(LOB)/HTDOS.o \
+	$(LOB)/HTRules.o $(LOB)/HTFormat.o  $(LOB)/HTMIME.o \
+	$(LOB)/HTNews.o $(LOB)/HTGopher.o \
+	$(LOB)/HTTelnet.o $(LOB)/HTFinger.o $(LOB)/HTWSRC.o $(HTWAIS) \
+	$(LOB)/HTAAUtil.o $(LOB)/HTAABrow.o \
+	$(LOB)/HTGroup.o  \
+	$(LOB)/HTAAProt.o \
+	$(LOB)/HTAssoc.o  $(LOB)/HTLex.o    $(LOB)/HTUU.o
+
+CFILES = $(CMN)HTParse.c $(CMN)HTAccess.c $(CMN)HTTP.c $(CMN)HTFile.c \
+	$(CMN)HTBTree.c \
+	$(CMN)HTFTP.c	 $(CMN)HTTCP.c	   $(CMN)SGML.c \
+	$(CMN)HTMLDTD.c \
+	$(CMN)HTPlain.c	 \
+	$(CMN)HTDOS.c	 $(CMN)HTMLGen.c \
+	$(CMN)HTChunk.c	 $(CMN)HTAtom.c	  $(CMN)HTAnchor.c $(CMN)HTStyle.c \
+	$(CMN)HTList.c	 $(CMN)HTString.c $(CMN)HTRules.c \
+	$(CMN)HTFormat.c $(CMN)HTMIME.c \
+	$(CMN)HTNews.c	 $(CMN)HTGopher.c $(CMN)HTTelnet.c \
+	$(CMN)HTFinger.c $(CMN)HTWAIS.c	  $(CMN)HTWSRC.c \
+	$(CMN)HTAAUtil.c $(CMN)HTAABrow.c \
+	$(CMN)HTGroup.c  \
+	$(CMN)HTAAProt.c \
+	$(CMN)HTAssoc.c  $(CMN)HTLex.c    $(CMN)HTUU.c
+
+HFILES = $(CMN)HTParse.h $(CMN)HTAccess.h $(CMN)HTTP.h $(CMN)HTFile.h \
+	$(CMN)HTBTree.h $(CMN)HTFTP.h $(CMN)HTTCP.h \
+	$(CMN)SGML.h $(CMN)HTML.h $(CMN)HTMLDTD.h $(CMN)HTChunk.h \
+	$(CMN)HTPlain.h	\
+	$(CMN)HTFWriter.h	$(CMN)HTMLGen.h $(CMN)HTDOS.h \
+	$(CMN)HTStream.h \
+	$(CMN)HTAtom.h $(CMN)HTAnchor.h $(CMN)HTStyle.h \
+	$(CMN)HTList.h \
+	$(CMN)HTString.h $(CMN)HTRules.h \
+	$(CMN)HTFormat.h $(CMN)HTInit.h \
+	$(CMN)HTMIME.h $(CMN)HTNews.h \
+	$(CMN)HTGopher.h \
+	$(CMN)HTUtils.h $(CMN)www_tcp.h $(CMN)HText.h \
+	$(CMN)HTTelnet.h $(CMN)HTFinger.h \
+	$(CMN)HTWAIS.h  $(CMN)HTWSRC.h \
+	$(CMN)HTAAUtil.h $(CMN)HTAABrow.h \
+	$(CMN)HTGroup.h  \
+	$(CMN)HTAAProt.h \
+	$(CMN)HTAssoc.h  $(CMN)HTLex.h    $(CMN)HTUU.h
+
+SOURCES = $(CFILES) $(HFILES) $(CMN)Version.make \
+	$(CMN)CommonMakefile $(CMN)Makefile \
+	$(WWW)/README.txt $(WWW)/Copyright.txt $(WWW)/BUILD $(WWW)/Makefile
+SPECIFIC = $(WWW)/All/*/Makefile.include $(WWW)/All/Implementation/Makefile* \
+	$(VMS)/descrip.mms $(VMS)/build_multinet.com \
+	$(VMS)/COPYING.LIB $(VMS)/setup.com $(VMS)/multinet.opt \
+	$(VMS)/HTVMSUtils.h $(VMS)/HTVMSUtils.c
+
+
+#	Library
+#
+#  On SGI, ranlib is unnecessary and does not exist so we ignore errors
+# for that step
+$(LOB)/libwww.a : $(COMMON)
+	ar r $(LOB)/libwww.a $(COMMON)
+	-ranlib $(LOB)/libwww.a
+
+#	Clean up everything generatable except final products
+clean :
+	rm -f $(LOB)/*.o
+
+#	Clean up everything generatable including final products
+
+cleanall : clean
+	rm -f $(LOB)/libwww.a
+
+#	Install W3 library into system space (not normally necessary)
+
+install : libwww.a
+	if [ ! -r $(LIBDIR) ] mkdir $(LIBDIR)
+	cp libwww.a $(LIBDIR)/libwww.a
+
+uninstall :
+	rm $(LIBDIR)/libwww.a
+
+#		Distribution use only:
+#		----------------------
+
+#	Needs www version 2.4 or later to do this
+inc : $(HFILES)
+	echo Include files generated from hypertext.
+
+binary : /pub/www/bin/$(WWW_MACH)/libwww_$(VC).a
+	echo FTP archive binary Library $(VC) for $(WWW_MACH) up to date.
+
+
+/pub/www/bin/$(WWW_MACH)/libwww_$(VC).a : libwww.a
+	-mkdir /pub/www/bin/$(WWW_MACH)
+	cp libwww.a /pub/www/bin/$(WWW_MACH)/libwww_$(VC).a
+
+#	Source Distribution:
+
+distribute :  /pub/www/README.txt /pub/www/Copyright.txt
+	(cd $(WWW)/..; WWW=WWW ABS=`pwd`/ make $(MFLAGS) \
+		-f WWW/Library/Implementation/CommonMakefile \
+		/pub/www/src/WWWLibrary_$(VC).tar.Z)
+	(cd ../Implementation; cvs tag \
+	    `sed -e 's/VC = /v/' Version.make | sed -e 's?\.?/?'` )
+	echo Distribution of Library version $(VC) up to date.
+
+/pub/www/src/WWWLibrary_$(VC).tar.Z : $(SOURCES)
+	tar cf /pub/www/src/WWWLibrary_$(VC).tar \
+	    $(SOURCES)  $(SPECIFIC) $(WC)/*/Makefile
+	compress /pub/www/src/WWWLibrary_$(VC).tar
+
+
+#	Hypertext supplied in text format
+#	---------------------------------
+
+$(WWW)/README.txt : $(WWW)/../README.html
+	www -n -p66 http://www.w3.org/hypertext/README.html \
+		> $(WWW)/README.txt
+/pub/www/README.txt : $(WWW)/README.txt
+	cp $(WWW)/README.txt /pub/www/README.txt
+
+$(WWW)/Copyright.txt : $(WWW)/../Copyright.html
+	www -n -p66 http://www.w3.org/hypertext/Copyright.html \
+		> $(WWW)/Copyright.txt
+/pub/www/Copyright.txt : $(WWW)/Copyright.txt
+	cp $(WWW)/Copyright.txt /pub/www/Copyright.txt
+
+#			Common code
+#			-----------
+
+#	Directory for object files
+
+$(LOB)/HTList.o : $(OE) $(CMN)HTList.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTList.c
+
+$(LOB)/HTAnchor.o : $(OE) $(CMN)HTAnchor.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTAnchor.c
+
+$(LOB)/HTFormat.o : $(OE) $(CMN)HTFormat.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTFormat.c
+
+$(LOB)/HTMIME.o : $(OE) $(CMN)HTMIME.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTMIME.c
+
+$(LOB)/HTDOS.o : $(OE) $(CMN)HTDOS.c $(CMN)HTUtils.h $(CMN)../../../userdefs.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTDOS.c
+
+$(LOB)/HTNews.o : $(OE) $(CMN)HTNews.c $(CMN)HTUtils.h $(CMN)HTList.h\
+	 $(CMN)HTMLDTD.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTNews.c
+
+$(LOB)/HTGopher.o : $(OE) $(CMN)HTGopher.c $(CMN)HTUtils.h $(CMN)HTList.h \
+	 $(CMN)HTMLDTD.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTGopher.c
+
+$(LOB)/HTTelnet.o : $(OE) $(CMN)HTTelnet.c $(CMN)HTUtils.h $(CMN)HTTelnet.h $(CMN)../../../userdefs.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTTelnet.c
+
+$(LOB)/HTFinger.o : $(OE) $(CMN)HTFinger.c $(CMN)HTUtils.h $(CMN)HTList.h \
+	$(CMN)HTMLDTD.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTFinger.c
+
+$(LOB)/HTStyle.o : $(OE) $(CMN)HTStyle.c $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTStyle.c
+
+$(LOB)/HTAtom.o : $(OE) $(CMN)HTAtom.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTAtom.c
+
+$(LOB)/HTChunk.o : $(OE) $(CMN)HTChunk.c $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTChunk.c
+
+$(LOB)/HTString.o : $(OE) $(CMN)HTString.c $(CMN)HTUtils.h $(CMN)Version.make
+	$(CC) -c  $(CFLAGS2) -DVC=\"$(VC)\" $(CMN)HTString.c
+
+$(LOB)/HTRules.o : $(OE) $(CMN)HTRules.c $(CMN)HTUtils.h $(CMN)Version.make \
+	 $(CMN)HTAAProt.h
+	$(CC) -c  $(CFLAGS2) -DVC=\"$(VC)\" $(CMN)HTRules.c
+
+$(LOB)/SGML.o : $(OE) $(CMN)SGML.c $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)SGML.c
+
+$(LOB)/HTMLGen.o : $(OE) $(CMN)HTMLGen.c $(CMN)HTUtils.h $(CMN)HTMLDTD.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTMLGen.c
+
+$(LOB)/HTMLDTD.o : $(OE) $(CMN)HTMLDTD.c $(CMN)SGML.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTMLDTD.c
+
+$(LOB)/HTPlain.o : $(OE) $(CMN)HTPlain.c $(CMN)HTPlain.h $(CMN)HTStream.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTPlain.c
+
+$(LOB)/HTWAIS.o : $(OE) $(CMN)HTWAIS.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(CC) -c  $(CFLAGS2) $(WAISINC) $(CMN)HTWAIS.c
+
+$(LOB)/HTWSRC.o : $(OE) $(CMN)HTWSRC.c $(CMN)HTUtils.h $(CMN)HTList.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTWSRC.c
+
+#	Access Authorization
+
+$(LOB)/HTAAUtil.o : $(OE) $(CMN)HTAAUtil.c $(CMN)HTAAUtil.h \
+	 $(CMN)HTUtils.h $(CMN)HTString.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTAAUtil.c
+
+$(LOB)/HTGroup.o : $(OE) $(CMN)HTGroup.c $(CMN)HTGroup.h \
+	 $(CMN)HTAAUtil.h \
+	 $(CMN)HTAssoc.h $(CMN)HTLex.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTGroup.c
+
+$(LOB)/HTAABrow.o : $(OE) $(CMN)HTAABrow.c $(CMN)HTAABrow.h \
+	 $(CMN)HTAAUtil.h $(CMN)HTUU.h \
+	 $(CMN)HTUtils.h $(CMN)HTString.h \
+	 $(CMN)HTParse.h $(CMN)HTList.h \
+	 $(CMN)HTAssoc.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTAABrow.c
+
+$(LOB)/HTAAProt.o : $(OE) $(CMN)HTAAProt.c $(CMN)HTAAProt.h \
+	 $(CMN)HTUtils.h $(CMN)HTAAUtil.h \
+	 $(CMN)HTAssoc.h $(CMN)HTLex.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTAAProt.c
+
+$(LOB)/HTAssoc.o : $(OE) $(CMN)HTAssoc.c $(CMN)HTAssoc.h \
+	$(CMN)HTUtils.h $(CMN)HTString.h $(CMN)HTList.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTAssoc.c
+
+$(LOB)/HTLex.o : $(OE) $(CMN)HTLex.c $(CMN)HTLex.h $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTLex.c
+
+$(LOB)/HTUU.o : $(OE) $(CMN)HTUU.c $(CMN)HTUU.h $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTUU.c
+
+
+#	Communications & Files
+
+$(LOB)/HTTP.o : $(OE) $(CMN)HTTP.c $(CMN)HTUtils.h $(CMN)HTAABrow.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTTP.c
+
+$(LOB)/HTTCP.o : $(OE) $(CMN)HTTCP.c $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTTCP.c
+
+$(LOB)/HTFile.o : $(OE) $(CMN)HTFile.c $(CMN)HTUtils.h \
+	 $(CMN)HTMLDTD.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTFile.c
+
+$(LOB)/HTBTree.o : $(OE) $(CMN)HTBTree.c $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTBTree.c
+
+$(LOB)/HTFTP.o : $(OE) $(CMN)HTFTP.c $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTFTP.c
+
+$(LOB)/HTAccess.o : $(OE)  $(CMN)HTAccess.c $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTAccess.c
+
+$(LOB)/HTParse.o : $(OE) $(CMN)HTParse.c $(CMN)HTUtils.h
+	$(CC) -c  $(CFLAGS2) $(CMN)HTParse.c
+
diff --git a/WWW/Library/djgpp/makefile b/WWW/Library/djgpp/makefile
new file mode 100644
index 0000000..f46ad1f
--- /dev/null
+++ b/WWW/Library/djgpp/makefile
@@ -0,0 +1,59 @@
+#  Make WWW under unix for a.n.other unix system (bsd)
+#   Use this as a template
+
+# For W3 distribution, machine type for subdirectories
+WWW_MACH = djgpp
+
+# The ASIS repository's name for the machine we are on
+#ASIS_MACH = hardware/os
+
+# Use this option to enable optional and *experimental* color style.
+#ENABLE_COLOR_STYLE = -DUSE_COLOR_STYLE
+
+# comment this line to suppress DIRED support
+DIRED_DEFS = -DDIRED_SUPPORT
+
+CFLAGS= -O2 $(MCFLAGS) $(INTLFLAGS) $(SSLFLAGS) $(SSLINC)
+
+MCFLAGS = \
+ $(DIRED_DEFS) \
+ $(ENABLE_COLOR_STYLE) \
+ -DDISP_PARTIAL \
+ -DDOSPATH \
+ -DUSE_FILE_UPLOAD \
+ -DNOUSERS \
+ -DUSE_SOURCE_CACHE \
+ -DUSE_PRETTYSRC \
+ -DUSE_ZLIB \
+ -I../Implementation \
+ -I../../../src \
+ -I../../.. \
+ -I/djgpp/pdcur26 \
+ -I/djgpp/watt32/inc
+
+LFLAGS =
+CC = gcc
+
+# Uncomment the following to enable Internationalization.
+#INTLFLAGS = -DHAVE_GETTEXT -DHAVE_LIBINTL_H
+
+# Uncomment the following to enable SSL.
+#SSLFLAGS = -DUSE_SSL
+#SSLINC = -I/dev/env/DJDIR/include/openssl
+
+# Directory for installed binary:
+!BINDIR = /usr/local/bin
+
+# Where is the W3 object library to be installed (not normally done)?
+LIBDIR = $(WWW)/Library/Implementation/$(WWW_MACH)
+
+#_________________ OK if normal W3 distribution
+# Where is the WWW source root?
+WWW = ../..
+
+#  Where should temporary (object) files go?
+WTMP = ../..
+
+include $(WWW)/Library/Implementation/Version.make
+#include $(WWW)/Library/Implementation/CommonMakefile
+include ./CommonMakefile
diff --git a/WWW/Library/djgpp/makefile.sla b/WWW/Library/djgpp/makefile.sla
new file mode 100644
index 0000000..79e87b8
--- /dev/null
+++ b/WWW/Library/djgpp/makefile.sla
@@ -0,0 +1,40 @@
+#  Make WWW under unix for a.n.other unix system (bsd)
+#   Use this as a template
+
+# For W3 distribution, machine type for subdirectories
+WWW_MACH = djgpp
+
+# The ASIS repository's name for the machine we are on
+#ASIS_MACH = hardware/os
+
+CFLAGS = -O2 -DUSE_SLANG -DUSE_ZLIB -DDOSPATH -DNOUSERS -DDISP_PARTIAL \
+-DDIRED_SUPPORT -DUSE_SOURCE_CACHE -DUSE_PRETTYSRC \
+-I../Implementation \
+-I/dev/env/DJDIR/watt32/inc \
+-I../../../src \
+-I../../.. $(SLANGINC) $(INTLFLAGS) $(SSLFLAGS) $(SSLINC)
+
+LFLAGS =
+CC = gcc
+#INTLFLAGS = -DHAVE_GETTEXT -DHAVE_LIBINTL_H
+
+# Uncomment the following to enable SSL.
+#SSLFLAGS = -DUSE_SSL
+#SSLINC = -I/dev/env/DJDIR/include/openssl
+
+# Directory for installed binary:
+!BINDIR = /usr/local/bin
+
+# Where is the W3 object library to be installed (not normally done)?
+LIBDIR = $(WWW)/Library/Implementation/$(WWW_MACH)
+
+#_________________ OK if normal W3 distribution
+# Where is the WWW source root?
+WWW = ../..
+
+#  Where should temporary (object) files go?
+WTMP = ../..
+
+include $(WWW)/Library/Implementation/Version.make
+#include $(WWW)/Library/Implementation/CommonMakefile
+include ./CommonMakefile
diff --git a/WWW/Library/vms/COPYING.LIB b/WWW/Library/vms/COPYING.LIB
new file mode 100644
index 0000000..5bc8fb2
--- /dev/null
+++ b/WWW/Library/vms/COPYING.LIB
@@ -0,0 +1,481 @@
+                  GNU LIBRARY GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if
+you distribute copies of the library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+                  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/WWW/Library/vms/descrip.mms b/WWW/Library/vms/descrip.mms
new file mode 100644
index 0000000..fe275bb
--- /dev/null
+++ b/WWW/Library/vms/descrip.mms
@@ -0,0 +1,206 @@
+!	Make WorldWideWeb LIBRARY under VMS
+!       =======================================================
+!
+! History:
+!  14 Aug 91 (TBL)	Reconstituted
+!  25 Jun 92 (JFG)	Added TCP socket emulation over DECnet
+!  07 Sep 93 (MD)	Remade for version 2.09a
+!  10 Dec 93 (FM)	Upgrade for version 2.14 with Lynx v2.1
+!  13 Dec 93 (FM)	Added conditional compilations for VAXC vs. DECC
+!			(MMS can't handle a MODULE list as large as the
+!			 WWWLibrary has become, so this just illustrates
+!			 how you'd set it up if it could 8-).
+!  26 Oct 94 (RLD)	Updated to work with VAX/VMS v5.5-1 and AXP/VMS v6.1
+!  31 Oct 94 (RLD)      Updated for Lynx v2.3.4, supporting OpenCMU and
+!                       TCPWare
+!  18 Nov 94 (FM)	Updated for SOCKETSHR/NETLIB
+!  07 Dec 94 (FM)	Updated for DECC/VAX, VAXC/VAX and DECC/AXP
+!  03 May 95 (FM)	Include /NoMember for DECC (not the default on AXP,
+!			and the code assumes byte alignment).
+!  07 Jul 95 (FM)	Added GNUC support.
+!  15 Sep 06 (TD)	Cleanup...
+!
+! Bugs:
+!	The dependencies are anything but complete - they were
+!	just enough to allow the files to be compiled.
+!
+! Instructions:
+! 	Copy [WWW.LIBRARY.VMS]DESCRIP.MMS into [WWW.LIBRARY.IMPLEMENTATION]
+!	Use the correct command line for your TCP/IP implementation,
+!	inside the IMPLEMENTATION directory:
+!
+!	$ MMS/MACRO=(MULTINET=1)		for VAXC - MultiNet
+!	$ MMS/MACRO=(WIN_TCP=1)			for VAXC - Wollongong TCP/IP
+!	$ MMS/MACRO=(UCX=1)			for VAXC - UCX
+!	$ MMS/MACRO=(CMU_TCP=1)			for VAXC - OpenCMU TCP/IP
+!	$ MMS/MACRO=(SOCKETSHR_TCP=1)		for VAXC - SOCKETSHR/NETLIB
+!	$ MMS/MACRO=(TCPWARE=1)			for VAXC - TCPWare TCP/IP
+!	$ MMS/MACRO=(DECNET=1)		for VAXC - socket emulation over DECnet
+!
+!	$ MMS/MACRO=(MULTINET=1,DEC_C=1)	for DECC - MultiNet
+!	$ MMS/MACRO=(WIN_TCP=1,DEC_C=1)		for DECC - Wollongong TCP/IP
+!	$ MMS/MACRO=(UCX=1,DEC_C=1)		for DECC - UCX
+!	$ MMS/MACRO=(CMU_TCP=1,DEC_C=1)		for DECC - OpenCMU TCP/IP
+!	$ MMS/MACRO=(SOCKETSHR_TCP=1,DEC_C=1)	for DECC - SOCKETSHR/NETLIB
+!	$ MMS/MACRO=(TCPWARE=1,DEC_C=1)		for DECC - TCPWare TCP/IP
+!	$ MMS/MACRO=(DECNET=1,DEC_C=1)	for DECC - socket emulation over DECnet
+!
+!	$ MMS/MACRO=(MULTINET=1,GNU_C=1)	for GNUC - MultiNet
+!	$ MMS/MACRO=(WIN_TCP=1,GNU_C=1)		for GNUC - Wollongong TCP/IP
+!	$ MMS/MACRO=(UCX=1,GNU_C=1)		for GNUC - UCX
+!	$ MMS/MACRO=(CMU_TCP=1,GNU_C=1)		for GNUC - OpenCMU TCP/IP
+!	$ MMS/MACRO=(SOCKETSHR_TCP=1,GNU_C=1)	for GNUC - SOCKETSHR/NETLIB
+!	$ MMS/MACRO=(TCPWARE=1,GNU_C=1)		for GNUC - TCPWare TCP/IP
+!	$ MMS/MACRO=(DECNET=1,GNU_C=1)	for GNUC - socket emulation over DECnet
+!
+! To compile with debug mode:
+!
+!	$ MMS/MACRO=(MULTINET=1, DEBUG=1)	for Multinet
+!
+!
+! If you are on HEP net and want to build using the really latest sources on
+! PRIAM:: then define an extra macro U=PRIAM::, e.g.
+!
+!	$ MMS/MACRO=(MULTINET=1, U=PRIAM::)	for Multinet
+!
+! This will copy the sources from PRIAM as necessary. You can also try
+!
+!	$ MMS/MACRO=(U=PRIAM::) descrip.mms
+!
+! to update this file.
+
+
+.include Version.make
+
+! debug flags
+.ifdef DEBUG
+DEBUGFLAGS = /Debug /NoOptimize
+.endif
+
+INCLUDES = /Include=([-.Implementation],[---.src],[---])
+
+! defines valid for all compilations
+EXTRADEFINES = ACCESS_AUTH, VC="""$(VC)"""
+
+.ifdef WIN_TCP
+NETWORK_DEF = WIN_TCP
+.else
+.ifdef CMU_TCP
+NETWORK_DEF = CMU_TCP
+.else
+.ifdef SOCKETSHR_TCP
+NETWORK_DEF = SOCKETSHR_TCP
+.else
+.ifdef UCX
+NETWORK_DEF = UCX
+.else
+.ifdef TCPWARE
+NETWORK_DEF = TCPWARE,UCX
+.else
+.ifdef DECnet
+NETWORK_DEF = DECNET
+.else !  Default to MultiNet
+NETWORK_DEF = MULTINET
+.endif !  DECnet
+.endif !  TCPWARE
+.endif !  UCX
+.endif !  SOCKETSHR_TCP
+.endif !  CMU_TCP
+.endif !  WIN_TCP
+
+! DECC flags for all compilations
+.ifdef DEC_C
+MY_CFLAGS = /decc/Prefix=All /NoMember /Warning=(disable=implicitfunc) $(INCLUDES)
+.else
+MY_CFLAGS = $(INCLUDES)
+.endif
+
+CFLAGS = $(DEBUGFLAGS) $(MY_CFLAGS) /Define=($(EXTRADEFINES), $(NETWORK_DEF))
+
+.ifdef GNU_C
+CC = gcc
+.endif
+
+!HEADERS = HTUtils.h, HTStream.h, www_tcp.h, HText.h -
+!        HTParse.h, HTAccess.h, HTTP.h, HTFile.h, -
+!	HTBTree.h, HTTCP.h, SGML.h, -
+!	HTML.h, HTMLDTD.h, HTChunk.h, HTPlain.h, -
+!	HTFwriter.h, HTMLGen.h, -
+!	HTAtom.h, HTAnchor.h, HTStyle.h, -
+!	HTList.h, HTString.h, HTAlert.h, -
+!	HTRules.h, HTFormat.h, HTInit.h, -
+!	HTMIME.h, HTTelnet.h, -
+!	HTFinger.h, HTAABrow.h, -
+!	HTAAProt.h, HTAAUtil.h, -
+!	HTAssoc.h, HTUU.h, -
+!	HTVMSUtils.h,
+
+MODULES = HTParse, HTAccess, HTTP, HTFile, HTBTree, HTFTP, HTTCP, HTString, -
+	SGML, HTMLDTD, HTChunk, HTPlain, HTMLGen, -
+	HTAtom, HTAnchor, HTStyle, HTList, HTRules, HTFormat, -
+	HTMIME, HTNews, HTGopher, HTTelnet, HTFinger, -
+	HTWSRC, HTAAUtil, HTAABrow, HTGroup, -
+	HTAAProt, HTAssoc, HTLex, HTUU, HTVMSUtils, -
+	HTWAIS, HTVMS_WaisUI, HTVMS_WaisProt
+
+!.ifdef DECNET  ! Strip FTP, Gopher, News, WAIS
+!HEADERS = $(COMMON_HEADERS)
+!MODULES = $(COMMON_MODULES)
+!.else
+!HEADERS = $(COMMON_HEADERS), $(EXTRA_HEADERS), $(WAIS_HEADER)
+!MODULES = $(COMMON_MODULES), $(EXTRA_MODULES), $(WAIS_MODULE)
+!.endif
+
+!___________________________________________________________________
+! WWW Library
+
+!library : $(HEADERS)  wwwlib($(MODULES))
+library : wwwlib($(MODULES))
+ 	@ Continue
+
+build_www.com : descrip.mms
+	$(MMS) /NoAction /From_Sources /Output = build_www.com /Macro = ($(NETWORK_DEF)=1)
+
+clean :
+	- Set Protection = (Owner:RWED) *.*;-1
+	- Purge /NoLog /NoConfirm
+	- Delete /NoLog /NoConfirm *.obj;,*.olb;
+
+!___________________________________________________________________
+! Simple Dependencies
+
+
+!HTString.obj :	HTString.c HTString.h www_tcp.h Version.make HTUtils.h
+!HTAtom.obj :	HTAtom.c HTAtom.h HTUtils.h HTString.h
+!HTChunk.obj :	HTChunk.c HTChunk.h HTUtils.h
+!HTList.obj :	HTList.c HTList.h HTUtils.h
+!HTBTree.obj :	HTBTree.c HTBTree.h HTUtils.h
+!HTMLDTD.obj :	HTMLDTD.c HTMLDTD.h SGML.h
+!HTPlain.obj :	HTPlain.c HTPlain.h HTStream.h
+!HTMLGen.obj :	HTMLGen.c HTMLGen.h HTUtils.h HTMLDTD.h
+!HTRules.obj :	HTRules.c HTRules.h HTUtils.h Version.make
+!HTMIME.obj :	HTMIME.c HTMIME.h HTUtils.h HTList.h
+!HTTelnet.obj :	HTTelnet.c HTTelnet.h HTUtils.h
+!HTWAIS.obj :	HTWAIS.c HTWAIS.h HTUtils.h HTList.h
+!HTWSRC.obj :	HTWSRC.c HTWSRC.h HTUtils.h HTList.h
+!HTAccess.obj :	HTAccess.c HTAccess.h HTUtils.h
+!HTAnchor.obj :	HTAnchor.c HTAnchor.h HTUtils.h HTList.h
+!HTFile.obj :	HTFile.c HTFile.h HTUtils.h HTVMSUtils.h
+!HTFormat.obj :	HTFormat.c HTFormat.h HTUtils.h HTML.h SGML.h HTPlain.h HTMLGen.h HTList.h
+!HTFTP.obj :	HTFTP.c HTFTP.h HTUtils.h
+!HTGopher.obj :	HTGopher.c HTGopher.h HTUtils.h HTList.h
+!HTFinger.obj :	HTFinger.c HTFinger.h HTUtils.h HTList.h
+!HTNews.obj :	HTNews.c HTNews.h HTUtils.h HTList.h
+!HTParse.obj :	HTParse.c HTParse.h HTUtils.h
+!HTStyle.obj :	HTStyle.c HTStyle.h HTUtils.h
+!HTTCP.obj :	HTTCP.c HTTCP.h HTUtils.h www_tcp.h
+!HTTP.obj :	HTTP.c HTTP.h HTUtils.h
+!SGML.obj :	SGML.c SGML.h HTUtils.h
+!HTAABrow.obj :	HTAABrow.c HTUtils.h
+!HTAAProt.obj :	HTAAProt.c HTUtils.h
+!HTAAUtil.obj :	HTAAUtil.c HTUtils.h
+!HTGroup.obj :	HTGroup.c HTUtils.h
+!HTLex.obj :	HTLex.c HTUtils.h
+!HTAssoc.obj :	HTAssoc.c HTAssoc.h HTAAUtil.h HTString.h
+!HTUU.obj :	HTUU.c HTUU.h HTUtils.h
+!HTVMSUtils.obj :	HTVMSUtils.c HTVMSUtils.h HTUtils.h
diff --git a/WWW/Library/vms/libmake.com b/WWW/Library/vms/libmake.com
new file mode 100644
index 0000000..6ef7c07
--- /dev/null
+++ b/WWW/Library/vms/libmake.com
@@ -0,0 +1,233 @@
+$ v0 = 0
+$ v = f$verify(v0)
+$! $LynxId: libmake.com,v 1.15 2011/05/23 23:58:48 tom Exp $
+$!			LIBMAKE.COM
+$!
+$!   Command file to build the WWWLibrary on VMS systems.
+$!
+$!   11-Jul-2010	Ch. Gartmann
+$!	add support for "MULTINETUCX"
+$!   01-Jul-2007	T.Dickey
+$!	add support for "TCPIP" (TCPIP Services)
+$!   23-Oct-2004	T.Dickey
+$!	cleanup, remove duplication, etc.
+$!   08-Oct-1997	F.Macrides		macrides@sci.wfeb.edu
+$!	Added comments and minor tweaks for convenient addition of
+$!	compiler definitions and compiler and linker options.
+$!   26-Jul-1995	F.Macrides		macrides@sci.wfeb.edu
+$!	Adding support for GNUC.
+$!   03-May-1995	F.Macrides		macrides@sci.wfeb.edu
+$!	Include /nomember for compilations with DECC.  It's not the
+$!	default on AXP and the code assumes byte alignment.
+$!   07-Dec-1994	F.Macrides		macrides@sci.wfeb.edu
+$!	Updated for DECC/VAX, VAXC/VAX and DECC/AXP
+$!   03-NOV-1994	A.Harper		A.Harper@kcl.ac.uk
+$!	Mods to support SOCKETSHR/NETLIB and add a /DEBUG/NOOPT option
+$!   02-Jun-1994	F.Macrides		macrides@sci.wfeb.edu
+$!	Mods to support TCPWare (To use non-blocking connects, you need
+$!	the DRIVERS_V405B.INC patch from FTP.PROCESS.COM for TCPware for
+$!	OpenVMS Version 4.0-5, or a higher version of TCPWare, which will
+$!	have that bug in the TCPDRIVER fixed.  Otherwise, add NO_IOCTL to
+$!	the /define=(...) list.)
+$!   20-May-1994	Andy Harper		A.Harper@bay.cc.kcl.ac.uk
+$!	Added support for the CMU TCP/IP transport
+$!   13-Dec-1993	F.Macrides		macrides@sci.wfeb.edu
+$!	Mods for conditional compilations with VAXC versus DECC
+$!   10-Dec-1993	F.Macrides		macrides@sci.wfeb.edu
+$!	Initial version, for WWWLibrary v2.14 with Lynx v2.1
+$!
+$ ON CONTROL_Y THEN GOTO CLEANUP
+$ ON ERROR THEN GOTO CLEANUP
+$!
+$!	Compiler definitions can be added here as a comma separated
+$!	list with a lead comma, e.g., ",HAVE_FOO_H,DO_BLAH".  They
+$!	will apply only to the libwww-FM modules. - FM
+$!
+$ extra_defs = ",ACCESS_AUTH"
+$!
+$!	Include-paths can be added here as a comma separated
+$!	list with a lead comma, e.g., ",foo".
+$!
+$ extra_incs = ""
+$!
+$ extra_libs = ""
+$!
+$!	If no TCP/IP agent is specified (as the first argument),
+$!	prompt for a number from the list.   Note that the agent
+$!	must be the first argument if the debugger mode is to be
+$!	set via a second argument (see below). - FM
+$!
+$ agent = 0
+$ IF P1 .EQS. ""
+$ THEN
+$ 	write sys$output "Acceptable TCP/IP agents are"
+$ 	write sys$output " [1] MultiNet (default)"
+$ 	write sys$output " [2] UCX"
+$ 	write sys$output " [3] WIN_TCP"
+$	write sys$output " [4] CMU_TCP"
+$	write sys$output " [5] SOCKETSHR_TCP"
+$	write sys$output " [6] TCPWARE"
+$ 	write sys$output " [7] DECNET"
+$ 	write sys$output " [8] TCPIP"
+$ 	write sys$output " [9] Multinet UCX emulation"
+$ 	read sys$command/prompt="Agent [1,2,3,4,5,6,7,8,9] (RETURN = [1]) " agent
+$ ENDIF
+$ if agent .eq. 1 .or. agent .eqs. "" .or. p1 .eqs. "MULTINET" then -
+    transport = "MULTINET"
+$ if agent .eq. 2 .or. p1 .eqs. "UCX"           then transport = "UCX"
+$ if agent .eq. 3 .or. p1 .eqs. "WIN_TCP"       then transport = "WIN_TCP"
+$ if agent .eq. 4 .or. p1 .eqs. "CMU_TCP"       then transport = "CMU_TCP"
+$ if agent .eq. 5 .or. p1 .eqs. "SOCKETSHR_TCP" then transport = "SOCKETSHR_TCP"
+$ if agent .eq. 6 .or. p1 .eqs. "TCPWARE"       then transport = "TCPWARE"
+$ if agent .eq. 7 .or. p1 .eqs. "DECNET"        then transport = "DECNET"
+$ if agent .eq. 8 .or. p1 .eqs. "TCPIP"         then transport = "TCPIP"
+$ IF agent .EQ. 9 .OR. P1 .EQS. "MULTINETUCX"
+$    THEN
+$    transport = "UCX"
+$    extra_defs = extra_defs + ",MUCX"
+$ ENDIF
+$!
+$ if transport .eqs. "SOCKETSHR_TCP" then extra_defs = extra_defs + ",_DECC_V4_SOURCE"
+$ if transport .eqs. "TCPIP"         then extra_defs = extra_defs + ",TCPIP_SERVICES"
+$ if transport .eqs. "TCPWARE"       then extra_defs = extra_defs + ",UCX"
+$!
+$  if option .eqs. "TCPIP"
+$  then
+$     if f$trnlnm("TCPIP$IPC_SHR") .eqs. "" then define TCPIP$IPC_SHR SYS$LIBRARY:TCPIP$IPC_SHR
+$  endif
+$!
+$ if P2 .nes. ""
+$ then
+$   count_parm = 0
+$ parse_p2:
+$   value_parm = f$element('count_parm, ",", "''p2'")
+$   if value_parm .nes. ","
+$   then
+$      if value_parm .eqs. "BZLIB"
+$      then
+$         write sys$output "** adding BZlib to build."
+$         extra_defs = extra_defs + ",USE_BZLIB"
+$         extra_incs = extra_incs + "," + BZLIB_INC
+$         extra_libs = extra_libs + "," + BZLIB_LIB + "libbz2/LIB"
+$      endif
+$      if value_parm .eqs. "SLANG"
+$      then
+$         write sys$output "** adding SLang to build."
+$         extra_defs = extra_defs + ",USE_SLANG"
+$         extra_incs = extra_incs + "," + SLANG_INC
+$         extra_libs = extra_libs + "," + SLANG_LIB + "slang.olb/lib"
+$      endif
+$      if value_parm .eqs. "SSL"
+$      then
+$         write sys$output "** adding SSL to build."
+$         IF F$TYPE( ssl_lib ) .EQS. "" THEN ssl_lib = F$TRNLNM("SSLLIB")
+$         IF F$TYPE( ssl_inc ) .EQS. "" THEN ssl_inc = F$TRNLNM("SSLINCLUDE")
+$         extra_defs = extra_defs + ",USE_SSL,USE_OPENSSL_INCL"
+$         extra_libs = extra_libs + "," + SSL_LIB + "libssl/LIB," + SSL_LIB + "libcrypto/LIB"
+$!
+$!	The "#include <openssl/ssl.h>" requires a logical variable "openssl".
+$!
+$         define/nolog openssl 'SSL_INC
+$      endif
+$      if value_parm .eqs. "ZLIB"
+$      then
+$         write sys$output "** adding Zlib to build."
+$         extra_defs = extra_defs + ",USE_ZLIB"
+$         extra_incs = extra_incs + "," + ZLIB_INC
+$         extra_libs = extra_libs + "," + ZLIB_LIB + "libz/LIB"
+$      endif
+$      count_parm = count_parm + 1
+$      goto parse_p2
+$   endif
+$ endif
+$!
+$!	Compiler options can be specified here.  If there was
+$!	a second argument (with any value), then debugger mode
+$!	with no optimization will be specified as well. - FM
+$!
+$ cc_opts = ""
+$ if p3 .nes. "" then cc_opts = cc_opts + "/DEBUG/NOOPT"
+$!
+$ all_defs = transport + extra_defs
+$ all_incs = "[-.Implementation],[---.src],[---.src.chrtrans],[---]" + extra_incs
+$!
+$ IF f$getsyi("ARCH_NAME") .eqs. "Alpha" .or. -
+     f$getsyi("ARCH_NAME") .eqs. "IA64" .or. -
+     f$trnlnm("VAXCMSG") .eqs. "DECC$MSG" .or. -
+     f$trnlnm("DECC$CC_DEFAULT") .eqs. "/DECC" .or. -
+     f$trnlnm("DECC$CC_DEFAULT") .eqs. "/VAXC"
+$ THEN
+$! DECC:
+$  If transport .eqs. "UCX" .or. transport .eqs. "TCPWARE"
+$  Then
+$    cc := cc/decc/prefix=all /nomember 'cc_opts'-
+	  /warning=(disable=implicitfunc)-
+	  /DEFINE=('all_defs) -
+	  /INCLUDE=('all_incs)
+$  Else
+$    if transport .eqs. "MULTINET" then -
+	extra_defs = extra_defs + ",_DECC_V4_SOURCE,__SOCKET_TYPEDEFS"
+$    cc := cc/decc/prefix=all /nomember 'cc_opts'-
+	  /warning=(disable=implicitfunc)-
+	  /DEFINE=('all_defs) -
+	  /INCLUDE=('all_incs)
+$  EndIf
+$ ELSE
+$  IF f$search("gnu_cc:[000000]gcclib.olb") .nes. ""
+$  THEN
+$! GNUC:
+$    cc := gcc/DEFINE=('all_defs) 'cc_opts' /INCLUDE=('all_incs)
+$  ELSE
+$! VAXC:
+$    cc := cc/DEFINE=('all_defs) 'cc_opts' /INCLUDE=('all_incs)
+$  ENDIF
+$ ENDIF
+$ v1 = f$verify(1)
+$ show sym cc
+$ cc [-.Implementation]HTString.c
+$ cc [-.Implementation]HTParse.c
+$ cc [-.Implementation]HTAccess.c
+$ cc [-.Implementation]HTTP.c
+$ cc [-.Implementation]HTFile.c
+$ cc [-.Implementation]HTBTree.c
+$ cc [-.Implementation]HTFTP.c
+$ cc [-.Implementation]HTTCP.c
+$ cc [-.Implementation]SGML.c
+$ cc [-.Implementation]HTMLDTD.c
+$ cc [-.Implementation]HTChunk.c
+$ cc [-.Implementation]HTPlain.c
+$ cc [-.Implementation]HTMLGen.c
+$ cc [-.Implementation]HTAtom.c
+$ cc [-.Implementation]HTAnchor.c
+$ cc [-.Implementation]HTStyle.c
+$ cc [-.Implementation]HTList.c
+$ cc [-.Implementation]HTRules.c
+$ cc [-.Implementation]HTFormat.c
+$ cc [-.Implementation]HTMIME.c
+$ cc [-.Implementation]HTNews.c
+$ cc [-.Implementation]HTGopher.c
+$ cc [-.Implementation]HTTelnet.c
+$ cc [-.Implementation]HTFinger.c
+$ cc [-.Implementation]HTWSRC.c
+$ cc [-.Implementation]HTAAUtil.c
+$ cc [-.Implementation]HTAABrow.c
+$ cc [-.Implementation]HTGroup.c
+$ cc [-.Implementation]HTAAProt.c
+$ cc [-.Implementation]HTAssoc.c
+$ cc [-.Implementation]HTLex.c
+$ cc [-.Implementation]HTUU.c
+$ cc [-.Implementation]HTVMSUtils.c
+$ cc [-.Implementation]HTWAIS.c
+$ cc [-.Implementation]HTVMS_WaisUI.c
+$ cc [-.Implementation]HTVMS_WaisProt.c
+$!
+$ result = "[-.Implementation]WWWLib_''transport'.olb"
+$ If f$search("''result'") .eqs. "" Then -
+    LIBRARY/Create 'result
+$ LIBRARY/Replace 'result *.obj
+$ Delete/nolog/noconf *.obj;*
+$!
+$ v1 = f$verify(v0)
+$ CLEANUP:
+$    v1 = f$verify(v)
+$exit