/*
	WARNING: This file was generated by dkct.
	Changes you make here will be lost if dkct is run again!
	You should modify the original source and run dkct on it.
	Original source: dk-t2h.ctr
*/

/*
Copyright (C) 2015-2017, Dirk Krause

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice,
  this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above opyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of the author nor the names of contributors may be used
  to endorse or promote products derived from this software without specific
  prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/


#line 9 "dk-t2h.ctr"

/**	@file	dk-th2.c	The dk-t2h program.
	See dk_t2h_help_text for details.
*/

#include "dk4conf.h"

#if DK4_HAVE_STRING_H
#ifndef STRING_H_INCLUDED
#include <string.h>
#define	STRING_H_INCLUDED 1
#endif
#endif

#if DK4_HAVE_STDLIB_H
#ifndef STDLIB_H_INCLUDED
#include <stdlib.h>
#define	STDLIB_H_INCLUDED 1
#endif
#endif

#if DK4_HAVE_UNISTD_H
#ifndef UNISTD_H_INCLUDED
#include <unistd.h>
#define	UNISTD_H_INCLUDED 1
#endif
#endif

#if DK4_HAVE_SYS_TYPES_H
#ifndef SYS_TYPES_H_INCLUDED
#include <sys/types.h>
#define SYS_TYPES_H_INCLUDED 1
#endif
#endif

#if DK4_HAVE_SIGNAL_H
#ifndef SIGNAL_H_INCLUDED
#include <signal.h>
#define SIGNAL_H_INCLUDED 1
#endif
#endif

#if DK4_HAVE_PROCESS_H
#ifndef PROCESS_H_INCLUDED
#include <process.h>
#define	PROCESS_H_INCLUDED 1
#endif
#endif

#if DK4_HAVE_IO_H
#ifndef IO_H_INCLUDED
#include <io.h>
#define IO_H_INCLUDED 1
#endif
#endif

#if DK4_HAVE_FCNTL_H
#ifndef FCNTL_H_INCLUDED
#include <fcntl.h>
#define FCNTL_H_INCLUDED 1
#endif
#endif

#if DK4_HAVE_ERRNO_H
#ifndef ERRNO_H_INCLUDED
#include <errno.h>
#define	ERRNO_H_INCLUDED 1
#endif
#endif

#include "dk4types.h"
#include "dk4const.h"
#include "dk4enc.h"
#include "dk4mem.h"
#include "dk4app.h"
#include "dk4aopt.h"
#include "dk4fopda.h"
#include "dk4fput.h"
#include "dk4vers.h"
#include "dk4tsp32.h"
#include "dk4maodd.h"
#include "dk4mao8d.h"
#include "dk4mao8h.h"
#include "dk4utf8.h"
#include "dk4utf16.h"
#include "dk4ansi.h"
#include "dk4mpl.h"
#include "dk4strd.h"
#include "dk4pathd.h"





#line 102 "dk-t2h.ctr"



/**	Default help text, shown if no help text file is found.
*/
static const dkChar * const	dk_t2h_help_text[] = {
dkT(""),
dkT("Text to HTML converter"),
dkT(""),
dkT("dk-t2h [<options>] [<file(s)>]"),
dkT(""),
dkT("Options:"),
dkT("-i <encoding>\t--input-encoding=<encoding>\tExpected input encoding."),
dkT("-l\t\t--code-lines\t\t\tInput lines are code lines."),
dkT("-e\t\t--echo\t\t\t\tProcess command line arguments."),
dkT("-f\t\t--full\t\t\t\tWrite full HTML file."),
dkT("-t <string>\t--title=<string>\t\tTitle for full HTML file."),
dkT("\t\t--verbose\t\t\tShow error message on SIGPIPE."),
dkT(""),
dkT("--help\t\t\t\t\t\tShow this short help text."),
dkT("--manual\t\t\t\t\t*** SHOW FULL MANUAL. ***"),
dkT("--version\t\t\t\t\tShow version information."),
dkT("--license\t\t\t\t\tShow license information."),
dkT(""),
dkT("http://dktools.sourceforge.net"),
dkT(""),
NULL


#line 130 "dk-t2h.ctr"
};



/**	License text.
*/
static const dkChar * const	dk_t2h_license_text[] = {
dkT(""),
dkT("This software uses code from the following projects, either directly or as"),
dkT("a library:"),
dkT(""),
dkT("dktools\t\tDirk Krause's tools and libraries."),
dkT("\t\tSee http://dktools.sourceforge.net/ for more information."),
#if DK4_HAVE_ZLIB_H
dkT(""),
dkT("zlib\t\tData compression library."),
dkT("\t\tSee http://www.zlib.net/ for more information."),
#endif
#if DK4_HAVE_BZLIB_H
dkT(""),
dkT("bzip2\t\tData compression program and library."),
dkT("\t\tSee http://www.bzip.org/ for more information."),
#endif
dkT(""),
dkT("All the licenses below apply to the program."),
dkT("Licenses for used libraries are shown as found on my Scientific Linux 6.x"),
dkT("computer in the /usr/share/doc directory on 2015-04-01. Check the project"),
dkT("homepages of the used libraries for additional information and/or updated"),
dkT("license terms."),
dkT(""),
dkT(""),
dkT("DK tools and libraries license"),
dkT("=============================="),
dkT("Copyright (c) 2015-2016, Dirk Krause"),
dkT("All rights reserved."),
dkT(""),
dkT("Redistribution and use in source and binary forms, with or without"),
dkT("modification, are permitted provided that the following conditions are met:"),
dkT(""),
dkT("* Redistributions of source code must retain the above copyright notice,"),
dkT("  this list of conditions and the following disclaimer."),
dkT("* Redistributions in binary form must reproduce the above copyright"),
dkT("  notice, this list of conditions and the following disclaimer in the"),
dkT("  documentation and/or other materials provided with the distribution."),
dkT("* Neither the name of the Dirk Krause nor the names of contributors may be"),
dkT("  used to endorse or promote products derived from this software without"),
dkT("  specific prior written permission."),
dkT(""),
dkT("THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\""),
dkT("AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE"),
dkT("IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE"),
dkT("ARE DISCLAIMED."),
dkT(""),
dkT("IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,"),
dkT("INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,"),
dkT("BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,"),
dkT("DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY"),
dkT("OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING"),
dkT("NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,"),
dkT("EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."),
#if DK4_HAVE_ZLIB_H
dkT(""),
dkT(""),
dkT("Zlib license"),
dkT("============"),
dkT("(C) 1995-2004 Jean-loup Gailly and Mark Adler"),
dkT(""),
dkT("This software is provided 'as-is', without any express or implied"),
dkT("warranty.  In no event will the authors be held liable for any damages"),
dkT("arising from the use of this software."),
dkT(""),
dkT("Permission is granted to anyone to use this software for any purpose,"),
dkT("including commercial applications, and to alter it and redistribute it"),
dkT("freely, subject to the following restrictions:"),
dkT(""),
dkT("1. The origin of this software must not be misrepresented; you must not"),
dkT("   claim that you wrote the original software. If you use this software"),
dkT("   in a product, an acknowledgment in the product documentation would be"),
dkT("   appreciated but is not required."),
dkT("2. Altered source versions must be plainly marked as such, and must not be"),
dkT("   misrepresented as being the original software."),
dkT("3. This notice may not be removed or altered from any source distribution."),
dkT(""),
dkT("Jean-loup Gailly        Mark Adler"),
dkT("jloup@gzip.org          madler@alumni.caltech.edu"),
#endif
#if DK4_HAVE_BZLIB_H
dkT(""),
dkT(""),
dkT("Bzip2 and libbzip2 library license"),
dkT("=================================="),
dkT("This program, \"bzip2\", the associated library \"libbzip2\", and all"),
dkT("documentation, are copyright (C) 1996-2007 Julian R Seward.  All"),
dkT("rights reserved."),
dkT(""),
dkT("Redistribution and use in source and binary forms, with or without"),
dkT("modification, are permitted provided that the following conditions"),
dkT("are met:"),
dkT(""),
dkT("1. Redistributions of source code must retain the above copyright"),
dkT("   notice, this list of conditions and the following disclaimer."),
dkT(""),
dkT("2. The origin of this software must not be misrepresented; you must "),
dkT("   not claim that you wrote the original software.  If you use this "),
dkT("   software in a product, an acknowledgment in the product "),
dkT("   documentation would be appreciated but is not required."),
dkT(""),
dkT("3. Altered source versions must be plainly marked as such, and must"),
dkT("   not be misrepresented as being the original software."),
dkT(""),
dkT("4. The name of the author may not be used to endorse or promote "),
dkT("   products derived from this software without specific prior written "),
dkT("   permission."),
dkT(""),
dkT("THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS"),
dkT("OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED"),
dkT("WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE"),
dkT("ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY"),
dkT("DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL"),
dkT("DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE"),
dkT("GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS"),
dkT("INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,"),
dkT("WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING"),
dkT("NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS"),
dkT("SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."),
dkT(""),
dkT("Julian Seward, jseward@bzip.org"),
dkT("bzip2/libbzip2 version 1.0.5 of 10 December 2007"),
#endif
dkT(""),
NULL


#line 262 "dk-t2h.ctr"
};



/**	Constant text keywords used by the program, not localized.
*/
static const dkChar * const	dk_t2h_kwnl[] = {
/* 0 */
dkT("dktools"),

/* 1 */
dkT("dk-t2h.txt"),

/* 2 */
dkT("dk-t2h.str"),

/* 3 */
dkT("rb"),

/* 4 */
dkT("stdin"),

/* 5 */
dkT("\\"),

/* 6 */
dkT("verbose"),

NULL


#line 299 "dk-t2h.ctr"
};



/**	Constant keywords used by the program, replaced by localized texts.
*/
static const dkChar * const	dk_t2h_kw_def[] = {
/* 0 */
dkT("Failed to set up signal handlers!"),

/* 1 */
dkT("Failed to restore signal handlers!"),

/* 2 */
dkT("Illegal encoding: \""),

/* 3 */
dkT("\"!"),

/* 4 */
dkT("Conversion from number to text failed, probably bug!"),

/* 5 */
dkT("Failed to decode string from UTF-16!"),

/* 6 */
dkT("Failed to decode string from ANSI!"),

/* 7 */
dkT("Failed to decode string from UTF-8!"),

/* 8 */
dkT("Too many input lines, line number overflow!"),

/* 9 */
dkT("No command line arguments specified!"),

/* 10 */
dkT("Aborted by SIGINT signal!"),

/* 11 */
dkT("Aborted by SIGTERM signal!"),

/* 12 */
dkT("Aborted by SIGPIPE signal!"),

/* 13 */
dkT("Failed to write to standard output!"),

/* 14 */
dkT("Option -t ignored, only full pages can have a title!"),

/* 15 */
dkT("Decoding failed!\n\tByte: "),

/* 16 */
dkT("Encoding failed!\n\tByte: "),

/* 17 */
dkT("Processing failed!\n\tByte: "),

/* 18 */
dkT(",\n\tCharacter: "),

/* 19 */
dkT(",\n\tPosition in line: "),

/* 20 */
dkT("."),

/* 21 */
dkT("Decoding failed!"),

/* 22 */
dkT("Encoding failed!"),

/* 23 */
dkT("Processing failed!"),

/* 24 */
dkT("Further decoding failures!"),

/* 25 */
dkT("Further encoding failures!"),

/* 26 */
dkT("Further processing failures!"),

NULL


#line 374 "dk-t2h.ctr"
};



/**	Constant 8 bit text keywords used by the program, not localized.
*/
static const char * const	dk_t2h_kw8[] = {
/* 0 */
"<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n",

/* 1 */
"<html>\n",

/* 2 */
"<head>\n",

/* 3 */
"<meta name=\"generator\" content=\"dk-t2h, see http://dktools.sourceforge.net\">\n",

/* 4 */
"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=us-ascii\">\n",

/* 5 */
"<title>__TITLE__</title>\n",

/* 6 */
"<!--\tstyle sheet\t-->\n",

/* 7 */
"<!-- link rel=\"StyleSheet\" type=\"text/css\" href=\"__URL__\" -->\n",

/* 8 */
"<!--\tParent node of current document node\t-->\n",

/* 9 */
"<!-- link rel=\"Parent\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 10 */
"<!--\tDocument author\t-->\n",

/* 11 */
"<!-- link rel=\"Made\" title=\"\" rev=\"\" href=\"mailto:__MAIL__\" -->\n",

/* 12 */
"<!--\tLink to homepage\t-->\n",

/* 13 */
"<!-- link rel=\"Home\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 14 */
"<!--\tLink to table of contents\t-->\n",

/* 15 */
"<!-- link rel=\"ToC\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 16 */
"<!--\tLink to index\t-->\n",

/* 17 */
"<!-- link rel=\"Index\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 18 */
"<!--\tLink to glossary\t-->\n",

/* 19 */
"<!-- link rel=\"Glossary\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 20 */
"<!--\tLink to copyright\t-->\n",

/* 21 */
"<!-- link rel=\"Copyright\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 22 */
"<!--\tLink to upper document node (same as parent?)\t-->\n",

/* 23 */
"<!-- link rel=\"Up\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 24 */
"<!--\tLink to next document\t-->\n",

/* 25 */
"<!-- link rel=\"Next\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 26 */
"<!--\tLink to previous document\t-->\n",

/* 27 */
"<!-- link rel=\"Previous\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 28 */
"<!--\tLink to help page\t-->\n",

/* 29 */
"<!-- link rel=\"Help\" title=\"\" rev=\"\" href=\"__URL__\" -->\n",

/* 30 */
"<!--\tLink to a document node serving as bookmark\t-->\n",

/* 31 */
"<!-- link rel=\"Bookmark\" title=\"\" rev=\"\" href=\"\" -->\n",

/* 32 */
"</head>\n",

/* 33 */
"<body>\n",

/* 34 */
"</body>\n",

/* 35 */
"</html>\n",

/* 36 */
"<title>",

/* 37 */
"</title>\n",

/* 38 */
"<p>\n",

/* 39 */
"</p>\n",

/* 40 */
"<pre>\n",

/* 41 */
"</pre>\n",

/* 42 */
"<code title=\"",

/* 43 */
"\">",

/* 44 */
"</code>",

/* 45 */
"&#x",

/* 46 */
";",

NULL


#line 457 "dk-t2h.ctr"
};



/**	Options for the program.
*/
static const dk4_option_specification_t dk_t2h_options[] = {
  { dkT('i'),	dkT("input-encoding"),	DK4_OPT_ARG_STRING },
  { dkT('l'),	dkT("code-lines"),	DK4_OPT_ARG_NONE },
  { dkT('e'),	dkT("echo"),		DK4_OPT_ARG_NONE },
  { dkT('f'),	dkT("full"),		DK4_OPT_ARG_NONE },
  { dkT('t'),	dkT("title"),		DK4_OPT_ARG_STRING },
  { dkT('\0'),	dkT("verbose"),		DK4_OPT_ARG_STRING }
};



/**	Translation table for ASCII characters.
*/
static char const * const dk_t2h_translation_table[] = {
/*   0 00 */	 NULL,
/*   1 01 */	 NULL,
/*   2 02 */	 NULL,
/*   3 03 */	 NULL,
/*   4 04 */	 NULL,
/*   5 05 */	 NULL,
/*   6 06 */	 NULL,
/*   7 07 */	 NULL,
/*   8 08 */	 NULL,
/*   9 09 */	"\t",
/*  10 0a */	 NULL,
/*  11 0b */	 NULL,
/*  12 0c */	 NULL,
/*  13 0d */	 NULL,
/*  14 0e */	 NULL,
/*  15 0f */	 NULL,
/*  16 10 */	 NULL,
/*  17 11 */	 NULL,
/*  18 12 */	 NULL,
/*  19 13 */	 NULL,
/*  20 14 */	 NULL,
/*  21 15 */	 NULL,
/*  22 16 */	 NULL,
/*  23 17 */	 NULL,
/*  24 18 */	 NULL,
/*  25 19 */	 NULL,
/*  26 1a */	 NULL,
/*  27 1b */	 NULL,
/*  28 1c */	 NULL,
/*  29 1d */	 NULL,
/*  30 1e */	 NULL,
/*  31 1f */	 NULL,
/*  32 20 */	" ",
/*  33 21 */	"!",
/*  34 22 */	"&quot;",
/*  35 23 */	"#",
/*  36 24 */	"$",
/*  37 25 */	"%",
/*  38 26 */	"&amp;",
/*  39 27 */	"'",
/*  40 28 */	"(",
/*  41 29 */	")",
/*  42 2a */	"*",
/*  43 2b */	"+",
/*  44 2c */	",",
/*  45 2d */	"-",
/*  46 2e */	".",
/*  47 2f */	"/",
/*  48 30 */	"0",
/*  49 31 */	"1",
/*  50 32 */	"2",
/*  51 33 */	"3",
/*  52 34 */	"4",
/*  53 35 */	"5",
/*  54 36 */	"6",
/*  55 37 */	"7",
/*  56 38 */	"8",
/*  57 39 */	"9",
/*  58 3a */	":",
/*  59 3b */	";",
/*  60 3c */	"&lt;",
/*  61 3d */	"=",
/*  62 3e */	"&gt;",
/*  63 3f */	"?",
/*  64 40 */	"@",
/*  65 41 */	"A",
/*  66 42 */	"B",
/*  67 43 */	"C",
/*  68 44 */	"D",
/*  69 45 */	"E",
/*  70 46 */	"F",
/*  71 47 */	"G",
/*  72 48 */	"H",
/*  73 49 */	"I",
/*  74 4a */	"J",
/*  75 4b */	"K",
/*  76 4c */	"L",
/*  77 4d */	"M",
/*  78 4e */	"N",
/*  79 4f */	"O",
/*  80 50 */	"P",
/*  81 51 */	"Q",
/*  82 52 */	"R",
/*  83 53 */	"S",
/*  84 54 */	"T",
/*  85 55 */	"U",
/*  86 56 */	"V",
/*  87 57 */	"W",
/*  88 58 */	"X",
/*  89 59 */	"Y",
/*  90 5a */	"Z",
/*  91 5b */	"[",
/*  92 5c */	"\\",
/*  93 5d */	"]",
/*  94 5e */	"^",
/*  95 5f */	"_",
/*  96 60 */	"`",
/*  97 61 */	"a",
/*  98 62 */	"b",
/*  99 63 */	"c",
/* 100 64 */	"d",
/* 101 65 */	"e",
/* 102 66 */	"f",
/* 103 67 */	"g",
/* 104 68 */	"h",
/* 105 69 */	"i",
/* 106 6a */	"j",
/* 107 6b */	"k",
/* 108 6c */	"l",
/* 109 6d */	"m",
/* 110 6e */	"n",
/* 111 6f */	"o",
/* 112 70 */	"p",
/* 113 71 */	"q",
/* 114 72 */	"r",
/* 115 73 */	"s",
/* 116 74 */	"t",
/* 117 75 */	"u",
/* 118 76 */	"v",
/* 119 77 */	"w",
/* 120 78 */	"x",
/* 121 79 */	"y",
/* 122 7a */	"z",
/* 123 7b */	"{",
/* 124 7c */	"|",
/* 125 7d */	"}",
/* 126 7e */	"~",
/* 127 7f */	 NULL,
/* 128 80 */	 NULL,
/* 129 81 */	 NULL,
/* 130 82 */	 NULL,
/* 131 83 */	 NULL,
/* 132 84 */	 NULL,
/* 133 85 */	 NULL,
/* 134 86 */	 NULL,
/* 135 87 */	 NULL,
/* 136 88 */	 NULL,
/* 137 89 */	 NULL,
/* 138 8a */	 NULL,
/* 139 8b */	 NULL,
/* 140 8c */	 NULL,
/* 141 8d */	 NULL,
/* 142 8e */	 NULL,
/* 143 8f */	 NULL,
/* 144 90 */	 NULL,
/* 145 91 */	 NULL,
/* 146 92 */	 NULL,
/* 147 93 */	 NULL,
/* 148 94 */	 NULL,
/* 149 95 */	 NULL,
/* 150 96 */	 NULL,
/* 151 97 */	 NULL,
/* 152 98 */	 NULL,
/* 153 99 */	 NULL,
/* 154 9a */	 NULL,
/* 155 9b */	 NULL,
/* 156 9c */	 NULL,
/* 157 9d */	 NULL,
/* 158 9e */	 NULL,
/* 159 9f */	 NULL,
/* 160 a0 */	"&nbsp;",
/* 161 a1 */	"&iexcl;",
/* 162 a2 */	"&cent;",
/* 163 a3 */	"&pound;",
/* 164 a4 */	"&curren;",
/* 165 a5 */	"&yen;",
/* 166 a6 */	"&brvbar;",
/* 167 a7 */	"&sect;",
/* 168 a8 */	"&uml;",
/* 169 a9 */	"&copy;",
/* 170 aa */	"&ordf;",
/* 171 ab */	"&laquo;",
/* 172 ac */	"&not;",
/* 173 ad */	"&shy;",
/* 174 ae */	"&reg;",
/* 175 af */	"&macr;",
/* 176 b0 */	"&deg;",
/* 177 b1 */	"&plusmn;",
/* 178 b2 */	"&sup2;",
/* 179 b3 */	"&sup3;",
/* 180 b4 */	"&acute;",
/* 181 b5 */	"&micro;",
/* 182 b6 */	"&para;",
/* 183 b7 */	"&middot;",
/* 184 b8 */	"&cedil;",
/* 185 b9 */	"&sup1;",
/* 186 ba */	"&ordm;",
/* 187 bb */	"&raquo;",
/* 188 bc */	"&frac14;",
/* 189 bd */	"&frac12;",
/* 190 be */	"&frac34;",
/* 191 bf */	"&iquest;",
/* 192 c0 */	"&Agrave;",
/* 193 c1 */	"&Aacute;",
/* 194 c2 */	"&Acirc;",
/* 195 c3 */	"&Atilde;",
/* 196 c4 */	"&Auml;",
/* 197 c5 */	"&Aring;",
/* 198 c6 */	"&AElig;",
/* 199 c7 */	"&Ccedil;",
/* 200 c8 */	"&Egrave;",
/* 201 c9 */	"&Eacute;",
/* 202 ca */	"&Ecirc;",
/* 203 cb */	"&Euml;",
/* 204 cc */	"/Igrave;",
/* 205 cd */	"&Iacute;",
/* 206 ce */	"&Icirc;",
/* 207 cf */	"&Iuml;",
/* 208 d0 */	"&ETH;",
/* 209 d1 */	"&Ntilde;",
/* 210 d2 */	"&Ograve;",
/* 211 d3 */	"&Oacute;",
/* 212 d4 */	"&Ocirc;",
/* 213 d5 */	"&Otilde;",
/* 214 d6 */	"&Ouml;",
/* 215 d7 */	"&times;",
/* 216 d8 */	"&Oslash;",
/* 217 d9 */	"&Ugrave;",
/* 218 da */	"&Uacute;",
/* 219 db */	"&Ucirc;",
/* 220 dc */	"&Uuml;",
/* 221 dd */	"&Yacute;",
/* 222 de */	"&THORN;",
/* 223 df */	"&szlig;",
/* 224 e0 */	"&agrave;",
/* 225 e1 */	"&aacute;",
/* 226 e2 */	"&acirc;",
/* 227 e3 */	"&atilde;",
/* 228 e4 */	"&auml;",
/* 229 e5 */	"&aring;",
/* 230 e6 */	"&aelig;",
/* 231 e7 */	"&ccedil;",
/* 232 e8 */	"&egrave;",
/* 233 e9 */	"&eacute;",
/* 234 ea */	"&ecirc;",
/* 235 eb */	"&euml;",
/* 236 ec */	"&igrave;",
/* 237 ed */	"&iacute;",
/* 238 ee */	"&icirc;",
/* 239 ef */	"&iuml;",
/* 240 f0 */	"&eth;",
/* 241 f1 */	"&ntilde;",
/* 242 f2 */	"&ograve;",
/* 243 f3 */	"&oacute;",
/* 244 f4 */	"&ocirc;",
/* 245 f5 */	"&otilde;",
/* 246 f6 */	"&ouml;",
/* 247 f7 */	"&divide;",
/* 248 f8 */	"&oslash;",
/* 249 f9 */	"&ugrave;",
/* 250 fa */	"&uacute;",
/* 251 fb */	"&ucirc;",
/* 252 fc */	"&uuml;",
/* 253 fd */	"&yacute;",
/* 254 fe */	"&thorn;",
/* 255 ff */	"&yuml;"
};


/**	Pointer to localized or not localized texts.
*/
static const dkChar * const	*dk_t2h_msg	=	dk_t2h_kw_def;



/**	Application structure.
*/
static dk4_app_t	*app	=	NULL;



/**	Page title for full HTML page, if specified on command line.
*/
static const dkChar	*dk_t2h_title	=	NULL;



/**	Current line number.
*/
static dk4_um_t		dk_t2h_lineno	=	(dk4_um_t)1UL;



/**	Number of elements in the dk_t2h_options array.
*/
static const size_t dk_t2h_sz_options =
sizeof(dk_t2h_options)/sizeof(dk4_option_specification_t);



/**	Number of elements in dk_t2h_msg array.
*/
static size_t		 dk_t2h_sz_msg	=
sizeof(dk_t2h_kw_def)/sizeof(DK4_PCDKCHAR) - 1;


/**	Program exit status.
*/
static int		 exval	=	EXIT_FAILURE;



/**	Flag: Error occured while writing to stdout.
*/
static int		 output_error	=	0;



/**	Flag: Verbose output (report SIGPIPE).
*/
static int		 verbose	=	0;



/**	Flag: Echo command line arguments instead of processing files.
*/
static int		 dk_t2h_echo	=	0;



/**	Flag: Produce full HTML page, not just a fragment.
*/
static int		 dk_t2h_full	=	0;



/**	Flag: Wrap all lines in code environments.
*/
static int		 dk_t2h_code	=	0;



/**	Input encoding expected when processing stdin.
*/
static int		 dk_t2h_i_std	=	DK4_FILE_ENCODING_ASCII;



/**	Input encoding expected when processing files.
*/
static int		 dk_t2h_i_file	=	DK4_FILE_ENCODING_ASCII;



/**	Number of decoding errors in current file.
*/
static int		 dk_t2h_dec_err	=	0;



/**	Number of encoding errors in current file.
*/
static int		 dk_t2h_enc_err	=	0;



/**	Number of processing errors in current file.
*/
static int		 dk_t2h_pro_err	=	0;



/**	Flag: Previous character was carriage return.
*/
static int		 dk_t2h_last_cr	=	0;



/**	Flag: Previous character was newline.
*/
static int		 dk_t2h_last_nl	=	0;



/**	Flag: Have text in line, newline needed.
*/
static int		 dk_t2h_lhtx	=	0;




#ifdef SIGPIPE
/**	Indicator: SIGPIPE signal received.
*/
static
DK4_VOLATILE
dk4_sig_atomic_t	sig_had_pipe	=	0;
#endif

/**	Indicator: SIGINT signal received.
*/
static
DK4_VOLATILE
dk4_sig_atomic_t	sig_had_int	=	0;

/**	Indicator: SIGTERM signal received.
*/
static
DK4_VOLATILE
dk4_sig_atomic_t	sig_had_term	=	0;



/**	Pass a volatile pointer to an atomic integer.
	This function is necessary as some compilers mis-optimize
	direct access to volatile variables (at least if you believe
	one of the coding standards).
	@param	ptr	Address of atomic integer variable.
	@return	The unmodified pointer.
*/
static
DK4_VOLATILE
dk4_sig_atomic_t *
sig_pass_pointer(DK4_VOLATILE dk4_sig_atomic_t *ptr)
{
  return ptr;
}



#ifdef SIGPIPE
/**	Handler for SIGPIPE signal.
	@param	signo	Signal number (always SIGPIPE, ignored).
*/
static
void
sig_handler_pipe(int signo)
{
  *sig_pass_pointer(&sig_had_pipe) = 1;
}
#endif

/**	Handler for SIGINT signal.
	@param	signo	Signal number (always SIGINT, ignored).
*/
static
void
sig_handler_int(int signo)
{
  *sig_pass_pointer(&sig_had_int) = 1;
}

/**	Handler for SIGTERM signal.
	@param	signo	Signal number (always SIGTERM, ignored).
*/
static
void
sig_handler_term(int signo)
{
  *sig_pass_pointer(&sig_had_term) = 1;
}

/**	Read value from volatile atomic type.
	This function is necessary as some compilers mis-optimize
	direct access to volatile variables (at least if you believe
	one of the coding standards).
	@param	ap	Pointer to volatile atomic variable.
	@return	Contents of the variable.
*/
static
dk4_sig_atomic_t
sig_read_atomic(DK4_VOLATILE dk4_sig_atomic_t *ap)
{
  return (*ap);
}

/**	Check whether we can continue or if a signal was received.
	@param	check_pipe	Flag: Check for occured SIGPIPE signal too.
	@return	1 if the program can continue, 0 if a signal was received.
*/
static
int
sig_can_continue(int check_pipe)
{
  int		back = 1;
#ifdef SIGPIPE
  if (0 != check_pipe) {
    if (0 != sig_read_atomic(&sig_had_pipe)) { back = 0; }
  }
#endif
  if (0 != sig_read_atomic(&sig_had_int )) { back = 0; }
  if (0 != sig_read_atomic(&sig_had_term)) { back = 0; }
  return back;
}



/**	Check whether we can continue.
	@return	1 for yes, 0 for no.
*/
static
int
dk_t2h_can_continue(void)
{
  int		back	=	1;
  if (0 == sig_can_continue(1)) {
    back = 0;
  }
  return back;
}



/**	Process command line options.
	@return	1 on success, 0 on error.
*/
static
int
dk_t2h_process_options(void)
{
  const dkChar	*oaptr;
  int		 encval = 0;
  int		 bomval = 0;
  int		 back = 1;
  if (0 != dk4app_opt_is_set_long(app, dk_t2h_kwnl[6], NULL)) {
    verbose = 1;
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('i'), NULL)) {
    oaptr = dk4app_opt_get_string_ptr_short(app, dkT('i'), NULL);
    if (NULL != oaptr) {
      if (0 != dk4enc_find(&encval, &bomval, oaptr, NULL)) {
        dk_t2h_i_std = dk_t2h_i_file = encval;
      } else {
        /* ERROR: Illegal encoding */
	back = 0;
	dk4app_log_3(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 2, 3, oaptr);
      }
    } else {							

#line 1005 "dk-t2h.ctr"
      /* ERROR: Failed to obtain option argument, bug! */
    }
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('e'), NULL)) {
    dk_t2h_echo = 1;
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('l'), NULL)) {
    dk_t2h_code = 1;
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('f'), NULL)) {
    dk_t2h_full = 1;
    if (0 != dk4app_opt_is_set_short(app, dkT('t'), NULL)) {
      dk_t2h_title = dk4app_opt_get_string_ptr_short(app, dkT('t'), NULL);
    }
  } else {
    if (0 != dk4app_opt_is_set_short(app, dkT('t'), NULL)) {
      back = 0;
      /* ERROR: Title only for full pages */
      dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 14);
    }
  }
  return back;
}



/**	Handler function after processing CR/NL sequences.
	Here we do the real output.
	@param	c	Character to process.
	@return Result code:
	- DK4_TSP_RES_OK if the character was processed successfully,
	- DK4_TSP_RES_ERROR if there was an error but we can continue,
	- DK4_TSP_RES_FATAL if there was a fatal error so we
	  should abort processing.
*/
static
int
dk_t2h_c32_after_cr_nl_check(
  dk4_c32_t			 c
)
{
  char		 buf[16*sizeof(dk4_um_t)];
  size_t	 i;
  int		 back = DK4_TSP_RES_OK;
  int		 res  = 0;
  int		 done = 0;
  

#line 1052 "dk-t2h.ctr"
  if (dkC32(0x0A) == c) {		

#line 1053 "dk-t2h.ctr"
    /*
    	Newline, finish line and write newline to output.
    */
    if (0 != dk_t2h_code) {		

#line 1057 "dk-t2h.ctr"
      if (0 == dk_t2h_lhtx) {
        if (EOF == fputs(dk_t2h_kw8[42], stdout)) { output_error = 1; }
        res = dk4ma_write_c8_decimal_unsigned(
          buf, sizeof(buf), dk_t2h_lineno, 0, NULL
        );
        if (0 != res) {
          i = strlen(buf);
	  while (3 > i++) {
	    if (EOF == fputc('0', stdout)) { output_error = 1; }
	  }
	  if (EOF == fputs(buf, stdout)) { output_error = 1; }
        }
        if (EOF == fputs(dk_t2h_kw8[43], stdout)) { output_error = 1; }
        dk_t2h_lhtx = 1;
      }
      if (0 != dk_t2h_lhtx) {		

#line 1073 "dk-t2h.ctr"
        if (EOF == fputs(dk_t2h_kw8[44], stdout)) { output_error = 1; }
      } else {				

#line 1075 "dk-t2h.ctr"
      }
    } else {				

#line 1077 "dk-t2h.ctr"
    }
    if (EOF == fputc('\n', stdout)) { output_error = 1; }
  } else {				

#line 1080 "dk-t2h.ctr"
    if (0 != dk_t2h_code) {		

#line 1081 "dk-t2h.ctr"
      if (0 == dk_t2h_lhtx) {		

#line 1082 "dk-t2h.ctr"
        /*
	  Start new line.
        */
        if (EOF == fputs(dk_t2h_kw8[42], stdout)) { output_error = 1; }
        res = dk4ma_write_c8_decimal_unsigned(
          buf, sizeof(buf), dk_t2h_lineno, 0, NULL
        );
        if (0 != res) {
          i = strlen(buf);
	  while (3 > i++) {
	    if (EOF == fputc('0', stdout)) { output_error = 1; }
	  }
	  if (EOF == fputs(buf, stdout)) { output_error = 1; }
        }
        if (EOF == fputs(dk_t2h_kw8[43], stdout)) { output_error = 1; }
	dk_t2h_lhtx = 1;
      } else {				

#line 1099 "dk-t2h.ctr"
      }
    } else {				

#line 1101 "dk-t2h.ctr"
    }
    /*
	Write character to output.
    */
    if (dkC32(0x00000100) > c) {
      i =  (size_t)c;
      i &= 0x0000FFU;
      if (NULL != dk_t2h_translation_table[i]) {
        if (EOF == fputs(dk_t2h_translation_table[i], stdout)) {
	  output_error = 1;
	}
        done = 1;
      }
    }
    if (0 == done) {
      res = dk4ma_write_c8_hex_unsigned(
        buf, sizeof(buf), (dk4_um_t)c, 0, NULL
      );
      if (0 != res) {
        i = strlen(buf);
	if (EOF == fputs(dk_t2h_kw8[45], stdout)) { output_error = 1; }
	if (0 != (i % 2)) {
	  if (EOF == fputc('0', stdout)) { output_error = 1; }
	}
	if (EOF == fputs(buf, stdout)) { output_error = 1; }
	if (EOF == fputs(dk_t2h_kw8[46], stdout)) { output_error = 1; }
      } else {
        exval = EXIT_FAILURE;
        /* ERROR: Conversion */
	dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 4);
      }
    }
  } 

#line 1134 "dk-t2h.ctr"
  return back;
}



#if DK4_CHAR_SIZE > 1
#if DK4_CHAR_SIZE > 2
/* +++++ 4 +++++ */

/**	Write 32 bit character string.
	@param	str	String to write.
*/
static
void
dk_t2h_output_c32(const dk4_c32_t *str)
{
  while (dkC32(0x00) != *str) {
    switch (dk_t2h_c32_after_cr_nl_check(*(str++))) {
      case DK4_TSP_RES_ERROR : case DK4_TSP_RES_FATAL : {
        exval = EXIT_FAILURE;
      } break;
    }
  }
}

/* ----- 4 ----- */
#else
/* +++++ 2 +++++ */

/**	Write UTF-16 encoded text string.
	@param	str	String to write.
*/
static
void
dk_t2h_output_utf16(const dk4_c16_t *str)
{
  dk4_utf16_decoder_t	dec;
  int			cc;

  dk4utf16_init(&dec);
  cc = 1;
  while (1 == cc) {
    if (dkC16(0) != *str) {
      switch (dk4utf16_add(&dec, *(str++))) {
        case DK4_EDSTM_ERROR : {
	  cc = -1;
	  /* ERROR: Decoding error */
	  dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 5);
	} break;
	case DK4_EDSTM_FINISHED : {
	  switch (dk_t2h_c32_after_cr_nl_check(dk4utf16_get(&dec))) {
	    case DK4_TSP_RES_ERROR : case DK4_TSP_RES_FATAL : {
	      exval = EXIT_FAILURE;
	    } break;
	  }
	} break;
      }
    } else {
      cc = 0;
    }
  }
  if (0 == cc) {
    if (0 == dk4utf16_is_empty(&dec)) {
      /* Decoding error */
      dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 5);
      exval = EXIT_FAILURE;
    }
  }
}

/* ----- 2 ----- */
#endif
#else
/* +++++ 1 +++++ */

/**	Write ASCII encoded text string.
	@param	str	String to write.
*/
static
void
dk_t2h_output_ascii(const char *str)
{
  dk4_c32_t	c32;
  while ('\0' != *str) {
    c32 = dkC32(0xFF) & ((dk4_c32_t)((unsigned char)(*(str++))));
    switch (dk_t2h_c32_after_cr_nl_check(c32)) {
      case DK4_TSP_RES_ERROR : case DK4_TSP_RES_FATAL : {
        exval = EXIT_FAILURE;
      } break;
    }
  }
}



/**	Write ANSI encoded text string.
	@param	str	String to write.
*/
static
void
dk_t2h_output_ansi(const char *str)
{
  dk4_c32_t	c32;
  char		c;
  while ('\0' != *str) {
    c = *(str++);
    if (0 != dk4ansi_decode(&c32, (unsigned char)c)) {
      switch (dk_t2h_c32_after_cr_nl_check(c32)) {
        case DK4_TSP_RES_ERROR : case DK4_TSP_RES_FATAL : {
	  exval = EXIT_FAILURE;
	}
      }
    } else {
      exval = EXIT_FAILURE;
      /* ERROR: Decoding error */
      dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 6);
    }
  }
}



/**	Write UTF-8 encoded string.
	@param	str	String to write.
*/
static
void
dk_t2h_output_utf8(const char *str)
{
  dk4_utf8_decoder_t	dec;
  int			cc;

  cc = 1;
  dk4utf8_init(&dec);
  while (1 == cc) {
    if ('\0' != *str) {
      switch (dk4utf8_add(&dec, *(str++))) {
        case DK4_EDSTM_ERROR : {
	  cc = -1;
	  exval = EXIT_FAILURE;
	  /* Decoding error */
	  dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 7);
	} break;
	case DK4_EDSTM_FINISHED : {
	  switch (dk_t2h_c32_after_cr_nl_check(dk4utf8_get(&dec))) {
	    case DK4_TSP_RES_ERROR : case DK4_TSP_RES_FATAL : {
	      exval = EXIT_FAILURE;
	    }
	  }
	} break;
      }
    } else {
      cc = 0;
    }
  }
  if (0 == cc) {
    if (0 == dk4utf8_is_empty(&dec)) {
      exval = EXIT_FAILURE;
      /* ERROR: Decoding error */
      dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 7);
    }
  }
}

/* ----- 1 ----- */
#endif



static
void
dk_t2h_output_dkstring(const dkChar *str)
{
#if DK4_CHAR_SIZE > 1
#if DK4_CHAR_SIZE > 2
  dk_t2h_output_c32(str);
#else
  dk_t2h_output_utf16(str);
#endif
#else
  switch (dk4app_get_encoding(app)) {
    case DK4_FILE_ENCODING_UTF8 : {
      dk_t2h_output_utf8(str);
    } break;
    case DK4_FILE_ENCODING_ANSI : {
      dk_t2h_output_ansi(str);
    } break;
    default : {
      dk_t2h_output_ascii(str);
    } break;
  }
#endif
}



/**	Start output page.
*/
static
void
dk_t2h_output_start_page(void)
{
  size_t i;
  if (0 != dk_t2h_full) {
    if (NULL != dk_t2h_title) {
      for (i = 0; i < 5; i++) {
        if (EOF == fputs(dk_t2h_kw8[i], stdout)) { output_error = 1; }
      }
      if (EOF == fputs(dk_t2h_kw8[36], stdout)) { output_error = 1; }
      dk_t2h_output_dkstring(dk_t2h_title);
      if (EOF == fputs(dk_t2h_kw8[37], stdout)) { output_error = 1; }
      for (i = 6; i < 34; i++) {
        if (EOF == fputs(dk_t2h_kw8[i], stdout)) { output_error = 1; }
      }
    } else {
      for (i = 0; i < 34; i++) {
        if (EOF == fputs(dk_t2h_kw8[i], stdout)) { output_error = 1; }
      }
    }
  }
}



/**	Finish output page.
*/
static
void
dk_t2h_output_finish_page(void)
{
  size_t i;

  if (0 != dk_t2h_full) {
    for (i = 34; i < 36; i++) {
      if (EOF == fputs(dk_t2h_kw8[i], stdout)) { output_error = 1; }
    }
  }
}



/**	Start processing of one file.
*/
static
void
dk_t2h_output_start_file(void)
{
  

#line 1382 "dk-t2h.ctr"
  /*	No errors in this file yet.
  */
  dk_t2h_dec_err = 0;
  dk_t2h_enc_err = 0;
  dk_t2h_pro_err = 0;
  dk_t2h_last_cr = 0;
  dk_t2h_last_nl = 0;
  dk_t2h_lhtx    = 0;
  dk_t2h_lineno  = (dk4_um_t)1UL;
  dk4app_set_log_source_line(app, dk_t2h_lineno);
  if (0 != dk_t2h_full) {		

#line 1393 "dk-t2h.ctr"
    if (0 != dk_t2h_code) {		

#line 1394 "dk-t2h.ctr"
      if (EOF == fputs(dk_t2h_kw8[40], stdout)) { output_error = 1; }
    } else {				

#line 1396 "dk-t2h.ctr"
      if (EOF == fputs(dk_t2h_kw8[38], stdout)) { output_error = 1; }
    }
  }
  

#line 1400 "dk-t2h.ctr"
}



/**	Finish processing of one file.
*/
static
void
dk_t2h_output_finish_file(void)
{
  

#line 1411 "dk-t2h.ctr"
  if (0 != dk_t2h_full) {		

#line 1412 "dk-t2h.ctr"
    if (0 != dk_t2h_code) {		

#line 1413 "dk-t2h.ctr"
      if (EOF == fputs(dk_t2h_kw8[41], stdout)) { output_error = 1; }
    } else {				

#line 1415 "dk-t2h.ctr"
      if (EOF == fputs(dk_t2h_kw8[39], stdout)) { output_error = 1; }
    }
  }
  

#line 1419 "dk-t2h.ctr"
}



/**	Handler function for single characters.
	@param	obj	Object to modify while processing the character.
	@param	c	Character to process.
	@param	pos	Current position in file or data stream.
	@param	erp	Error report, may be NULL.
	@return Result code:
	- DK4_TSP_RES_OK if the character was processed successfully,
	- DK4_TSP_RES_ERROR if there was an error but we can continue,
	- DK4_TSP_RES_FATAL if there was a fatal error so we
	  should abort processing.
*/
static
int
dk_t2h_c32_handler(
  void				*obj,
  dk4_c32_t			 c,
  dk4_text_stream_position_t	*pos,
  dk4_er_t			*erp
)
{
  int		 back = DK4_TSP_RES_OK;
  if (dkC32(0x0A) == c) {
    /*
    	For a newline clear CR and TXT flag, set NL flag.
    */
    back = dk_t2h_c32_after_cr_nl_check(c);
    dk_t2h_lineno++;
    if ((dk4_um_t)0UL == dk_t2h_lineno) {
      /* ERROR: Overflow in line number counting */
      dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 8);
      exval = EXIT_FAILURE;
    }
    dk4app_set_log_source_line(app, dk_t2h_lineno);
    dk_t2h_last_cr = 0;
    dk_t2h_last_nl = 1;
    dk_t2h_lhtx    = 0;
  } else {
    if (dkC32(0x0D) == c) {
      /*
	For a cr if CR flag is set, pass the cr and set TXT flag, clear nl flag.
	Otherwise simply set CR flag.
      */
      if (0 != dk_t2h_last_cr) {
        back = dk_t2h_c32_after_cr_nl_check(dkC32(0x0D));
	dk_t2h_lhtx    = 1;
	dk_t2h_last_nl = 0;
      } else {
        dk_t2h_last_cr = 1;
      }
    } else {
      /*
	For any other character:
	If the CR flag is set, pass cr and current character.
	Otherwise pass the current character.
	Reset NL and CR flag, set TXT flag.
      */
      if (0 != dk_t2h_last_cr) {
        back = dk_t2h_c32_after_cr_nl_check(dkC32(0x0D));
	switch (dk_t2h_c32_after_cr_nl_check(c)) {
	  case DK4_TSP_RES_FATAL: {
	    back = DK4_TSP_RES_FATAL;
	  } break;
	  case DK4_TSP_RES_ERROR: {
	    if (DK4_TSP_RES_OK == back) {
	      back = DK4_TSP_RES_ERROR;
	    }
	  } break;
	}
      } else {
        back = dk_t2h_c32_after_cr_nl_check(c);
      }
      dk_t2h_lhtx    = 1;
      dk_t2h_last_nl = 0;
      dk_t2h_last_cr = 0;
    }
  }
  return back;
}



/**	Process command line arguments.
*/
static
void
dk_t2h_process_cmdline(void)
{
  const dkChar	*xargv;
  int		 xargc;
  int		 i;
  xargc = dk4app_get_argc(app);
  if (0 < xargc) {
    dk_t2h_output_start_file();
    for (i = 0; i < xargc; i++) {
      xargv = dk4app_get_argv(app, i);
      if (0 != i) {
        if (EOF == fputc(' ', stdout)) { output_error = 1; }
      }
      if (NULL != xargv) {
        dk_t2h_output_dkstring(xargv);
      }
    }
    dk_t2h_c32_after_cr_nl_check(dkC32(0x0A));
    dk_t2h_output_finish_file();
  } else {
    exval = EXIT_FAILURE;
    /* ERROR: No command line arguments */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 9);
  }
}



/**	Report an error with position in source line.
	@param	i1		Index of first message part in array.
	@param	i2		Index of alternative first message part.
	@param	bno		Byte processed.
	@param	lno		Current line number.
	@param	cno		Current character number.
	@param	cil	Current character number in line.
*/
static
void
dk_t2h_report_with_position(
  size_t		i1,
  size_t		i2,
  dk4_um_t		bno,
  dk4_um_t		lno,
  dk4_um_t		cno,
  dk4_um_t		cil
)
{
  dkChar	 b1[8*(1+sizeof(dk4_um_t))];
  dkChar         b2[8*(1+sizeof(dk4_um_t))];
  dkChar         b3[8*(1+sizeof(dk4_um_t))];
  dk4_um_t	 oldlogline			= (dk4_um_t)0UL;
  int		 allbuffersok			= 0;

  oldlogline =	dk4app_get_log_source_line(app);
  dk4app_set_log_source_line(app, lno);
  if (0 != dk4ma_write_decimal_unsigned(b3,DK4_SIZEOF(b3,dkChar),cil,0,NULL)) {
  if (0 != dk4ma_write_decimal_unsigned(b2,DK4_SIZEOF(b2,dkChar),cno,0,NULL)) {
  if (0 != dk4ma_write_decimal_unsigned(b1,DK4_SIZEOF(b1,dkChar),bno,0,NULL)) {
        allbuffersok = 1;
  }
  }
  }
  if (0 != allbuffersok) {
    dk4app_log_7(
      app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, i1, 18, 19, 20, b1, b2, b3
    );
  } else {
    dk4app_log_1(
      app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, i2
    );
  }
  dk4app_set_log_source_line(app, oldlogline);
}



static
void
dk_t2h_report_errors(dk4_er_t *er_en, dk4_er_t *er_pr)
{
  if (NULL != er_en) {
    switch (er_en->ec) {
      case DK4_E_DECODING_FAILED: {
        switch (dk_t2h_dec_err) {
	  case 0: case 1: {
	    /* ERROR: Decoding failed */
	    dk_t2h_report_with_position(
	      15, 21, 
	      er_en->dt.fpos.byteno,
	      er_en->dt.fpos.lineno,
	      er_en->dt.fpos.charno,
	      er_en->dt.fpos.charinline
	    );
	  } break;
	  case 2: {
	    /* ERROR: Further decoding errors */
	    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 24);
	  } break;
	}
	if (3 > dk_t2h_dec_err) { dk_t2h_dec_err++; }
      } break;
      case DK4_E_ENCODING_FAILED: {
        switch (dk_t2h_enc_err) {
	  case 0: case 1: {
	    /* ERROR: Encoding failed */
	    dk_t2h_report_with_position(
	      16, 22,
	      er_en->dt.fpos.byteno,
	      er_en->dt.fpos.lineno,
	      er_en->dt.fpos.charno,
	      er_en->dt.fpos.charinline
	    );
	  } break;
	  case 2: {
	    /* ERROR: Further encoding erros */
	    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 25);
	  } break;
	}
	if (3 > dk_t2h_enc_err) { dk_t2h_enc_err++; }
      } break;
    }
  }
  if (NULL != er_pr) {
    if (DK4_E_NONE != er_pr->ec) {
      switch (dk_t2h_pro_err) {
        case 0: case 1: {
	  /* ERROR: Processing error */
	  dk_t2h_report_with_position(
	    17, 23,
	    er_pr->dt.fpos.byteno,
	    er_pr->dt.fpos.lineno,
	    er_pr->dt.fpos.charno,
	    er_pr->dt.fpos.charinline
	  );
	} break;
	case 2: {
	  /* ERROR: Further processing errors */
	  dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 26);
	} break;
      }
      if (3 > dk_t2h_pro_err) { dk_t2h_pro_err++; }
    }
  }
}



/**	Process an opened file with file name.
	@param	fipo		Opened file.
	@param	fn		File name.
	@param	ienc_def	Expected input encoding.
*/
static
void
dk_t2h_process_named_file(FILE *fipo, const dkChar *fn, int ienc_def)
{
  dk4_tsp32_t	 tsp32;
  dk4_er_t	 er;
  dk4_er_t	 er_en;
  dk4_er_t	 er_pr;
  const dkChar	*oldsourcefile;
  dk4_um_t	 oldsourceline;
  int		 c;
  int		 cc;
  int		 res;
  unsigned char	 ub;

  oldsourcefile = dk4app_get_log_source_file(app);
  oldsourceline = dk4app_get_log_source_line(app);
  dk4app_set_log_source_file(app, fn);
  dk4app_set_log_source_line(app, (dk4_um_t)0UL);
  dk_t2h_output_start_file();
  dk4error_init(&er);
  res = dk4tsp32_setup_char(
    &tsp32, NULL, dk_t2h_c32_handler, ienc_def, &er
  );
  if (0 != res) {
    cc = 1;
    while (1 == cc) {
      if (0 != dk_t2h_can_continue()) {
        c = fgetc(fipo);
	if (EOF != c) {
	  ub = (unsigned char)c;
	  res = dk4tsp32_add_one_byte(&tsp32, ub);
	  switch (res) {
	    case DK4_TSP_RES_ERROR: {
	      exval = EXIT_FAILURE;
	      dk4tsp32_get_errors(&er_en, &er_pr, &tsp32);
	      dk_t2h_report_errors(&er_en, &er_pr);
	    } break;
	    case DK4_TSP_RES_FATAL: {
	      cc = -1;
	      exval = EXIT_FAILURE;
	      dk4tsp32_get_errors(&er_en, &er_pr, &tsp32);
	      dk_t2h_report_errors(&er_en, &er_pr);
	    } break;
	    default: {
	    } break;
	  }
	} else {
	  cc = 0;
	}
	if (0 != feof(fipo)) { if (1 == cc) { cc = 0; } }
      } else {
        cc = -1;
      }
    }
    if (0 == cc) {
      res = dk4tsp32_finish(&tsp32);
      switch (res) {
        case DK4_TSP_RES_ERROR: case DK4_TSP_RES_FATAL: {
	  exval = EXIT_FAILURE;
	  dk4tsp32_get_errors(&er_en, &er_pr, &tsp32);
	  dk_t2h_report_errors(&er_en, &er_pr);
	} break;
      }
    }
    if (0 != dk_t2h_can_continue()) {
      if ((0 == dk_t2h_last_nl) && (0 != dk_t2h_lhtx)) {
        (void)dk_t2h_c32_after_cr_nl_check(dkC32(0x0A));
      }
    }
  } else {
    exval = EXIT_FAILURE;
    /* ERROR: Setup failed, should not happen, bug */
  }
  dk_t2h_output_finish_file();
  dk4app_set_log_source_file(app, oldsourcefile);
  dk4app_set_log_source_line(app, oldsourceline);
}



/**	Process standard input.
*/
static
void
dk_t2h_process_stdin(void)
{
#if DK4_ON_WINDOWS
  int		oldmode;

  oldmode = _setmode(_fileno(stdin), _O_BINARY);
#endif
  dk_t2h_process_named_file(stdin, dk_t2h_kwnl[4], dk_t2h_i_std);
#if DK4_ON_WINDOWS
  _setmode(_fileno(stdin), oldmode);
#endif
}



/**	Process one real file name.
	@param	infname	File name to process.
*/
static
void
dk_t2h_process_one_file_name(const dkChar *infname)
{
  FILE		*fipo	=	NULL;
  int		 tests	=	DK4_FOPEN_SC_IS_REGULAR;
  fipo = dk4fopen_app(infname, dk_t2h_kwnl[3], tests, app);
  if (NULL != fipo) {
    dk_t2h_process_named_file(fipo, infname, dk_t2h_i_file);
    fclose(fipo);
  } else {
    exval = EXIT_FAILURE;
  }
}



#if DK4_ON_WINDOWS

/**	Expand file name pattern and process the files.
	@pattern	File name pattern to expand.
	@return		1 if files were found, 0 otherwise.
*/
static
int
dk_t2h_expand_and_process(const dkChar *pattern)
{
  dkChar	 buf[DK4_MAX_PATH];
  dk4_dir_t	*fne;
  const dkChar	*shf;
  const	dkChar	*pth;
  int		 cc;
  int		 back = 0;
  fne = dk4app_fne_open(pattern, app);
  if (NULL != fne) {
    cc = 1;
    while (1 == cc) {
      if (0 != dk_t2h_can_continue()) {
        shf = dk4dir_next_file(fne);
	if (NULL != shf) {
	  back = 1;
	  pth = dk4dir_get_path(fne);
	  if (NULL != pth) {
	    if (0 != dk4str_cpy_s(buf, DK4_SIZEOF(buf,dkChar), pth, NULL)) {
	    if(0!=dk4str_cat_s(buf,DK4_SIZEOF(buf,dkChar),dk_t2h_kwnl[5],NULL))
	    {
	      if(0 != dk4str_cat_s(buf, DK4_SIZEOF(buf,dkChar), shf, NULL)) {
	        dk_t2h_process_one_file_name(buf);
	      } else {
	        exval = EXIT_FAILURE;
		/* ERROR: Path too long */
		dk4app_log_base3(app, DK4_LL_ERROR, 98, 99, pth);
	      }
	    }
	    else
	    {
	      exval = EXIT_FAILURE;
	      /* ERROR: Path too long */
	      dk4app_log_base3(app, DK4_LL_ERROR, 98, 99, pth);
	    }
	    } else {
	      exval = EXIT_FAILURE;
	      /* ERROR: Path too long */
	      dk4app_log_base3(app, DK4_LL_ERROR, 98, 99, pth);
	    }
	  } else {
	    dk_t2h_process_one_file_name(shf);
	  }
	} else {
	  cc = 0;
	}
      } else {
        cc = -1;
      }
    }
    dk4dir_close(fne);
  } else {
    exval = EXIT_FAILURE;
  }
  return back;
}

#endif



/**	Process one file name, check whether expansion is necessary.
	@param	infname	Input file name to process, may be NULL.
*/
static
void
dk_t2h_process_filename(const dkChar *infname)
{
  if (NULL != infname) {
#if DK4_ON_WINDOWS
    if (0 != dk4path_must_expand(infname)) {
      if (0 == dk_t2h_expand_and_process(infname)) {
        exval = EXIT_FAILURE;
	/* ERROR: No such file */
	dk4app_log_base3(app, DK4_LL_ERROR, 100, 107, infname);
      }
    } else {
#endif
      dk_t2h_process_one_file_name(infname);
#if DK4_ON_WINDOWS
    }
#endif
  }
}



/**	Run after installing the signal handlers.
*/
static
void
dk_t2h_normal_run(void)
{
  int	argc;
  int	i;
  if (0 != dk_t2h_process_options()) {
    exval = EXIT_SUCCESS;
    dk_t2h_output_start_page();
    if (0 != dk_t2h_echo) {
      dk_t2h_process_cmdline();
    } else {
      argc = dk4app_get_argc(app);
      if (0 < argc) {
        for (i = 0; ((0 != dk_t2h_can_continue()) && (i < argc)); i++) {
	  dk_t2h_process_filename(dk4app_get_argv(app, i));
	}
      } else {
        dk_t2h_process_stdin();
      }
    }
    dk_t2h_output_finish_page();
  }
}



#if	DK4_HAVE_SIGACTION
/**	Set signal handlers and run.
*/
static
void
dk_t2h_run_with_signal_handlers(void)
{
#ifdef SIGPIPE
  struct sigaction opipe;
#endif
  struct sigaction oint;
#ifdef SIGPIPE
  struct sigaction npipe;
#endif
  struct sigaction nint;
  struct sigaction oterm;
  struct sigaction nterm;
  int	 success = 0;

#ifdef SIGPIPE
  /*	Set up signal handling for SIGPIPE.
  */
  DK4_MEMRES(&npipe, sizeof(npipe));
  npipe.sa_handler = sig_handler_pipe;
  npipe.sa_flags = 0;
  if (0 != sigemptyset(&npipe.sa_mask)) {
    /* ERROR: Failed to set up masked signal set for SIGPIPE */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto finished;
  }
  if (0 != sigaddset(&npipe.sa_mask, SIGPIPE)) {
    /* ERROR: Failed to set up masked signal set for SIGPIPE */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto finished;
  }
  if (0 != sigaction(SIGPIPE, &npipe, &opipe)) {
    /* ERROR: Failed to set up signal handler for SIGPIPE */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto finished;
  }
#endif

  /*	Set up signal handling for SIGINT.
  */
  DK4_MEMRES(&nint, sizeof(nint));
  nint.sa_handler = sig_handler_int;
  nint.sa_flags = 0;
  if (0 != sigemptyset(&nint.sa_mask)) {
    /* ERROR: Failed to set up masked signal set for SIGINT */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto restore_old_pipe;
  }
  if (0 != sigaddset(&nint.sa_mask, SIGINT)) {
    /* ERROR: Failed to set up masked signal set for SIGINT */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto restore_old_pipe;
  }
  if (0 != sigaction(SIGINT, &nint, &oint)) {
    /* ERROR: Failed to set up signal handler for SIGINT */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto restore_old_pipe;
  }

  /*	Set up signal handling for SIGTERM
  */
  DK4_MEMRES(&nterm, sizeof(nterm));
  nterm.sa_handler = sig_handler_term;
  nterm.sa_flags = 0;
  if (0 != sigemptyset(&nterm.sa_mask)) {
    /* ERROR: Failed to set up masked signal set for SIGTERM */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto restore_old_int;
  }
  if (0 != sigaddset(&nterm.sa_mask, SIGTERM)) {
    /* ERROR: Failed to set up masked signal set for SIGTERM */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto restore_old_int;
  }
  if (0 != sigaction(SIGTERM, &nterm, &oterm)) {
    /* ERROR: Failed to set up signal handler for SIGTERM */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 0);
    goto restore_old_int;
  }

  success = 1;
  dk_t2h_normal_run();

  /*	Restore signal handling for SIGTERM.
  */
  if (0 != sigaction(SIGTERM, &oterm, NULL)) {
    /* ERROR: Failed to restore old SIGTERM settings */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 1);
    success = 0;
  }

  /*	Restore signal handling for SIGINT.
  */
  restore_old_int:
  if (0 != sigaction(SIGINT, &oint, NULL)) {
    /* ERROR: Failed to restore old SIGPIPE settings */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 1);
    success = 0;
  }

#ifdef SIGPIPE
  /*	Restore signal handling for SIGPIPE.
  */
  restore_old_pipe:
  if (0 != sigaction(SIGPIPE, &opipe, NULL)) {
    /* ERROR: Failed to restore old SIGPIPE settings */
    dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 1);
    success = 0;
  }
#endif

  /*	Set exit status code if error occured.
  */
  finished:
  if (0 == success) { exval = EXIT_FAILURE; }
}
#else
#if	DK4_HAVE_SIGSET
/**	Set signal handlers and run.
*/
static
void
dk_t2h_run_with_signal_handlers(void)
{
#ifdef SIGPIPE
  dk4_sig_handler_t	*oldpipe = NULL;
#endif
  dk4_sig_handler_t	*oldint  = NULL;
  dk4_sig_handler_t	*oldterm = NULL;

#ifdef SIGPIPE
  oldpipe = sigset(SIGPIPE, sig_handler_pipe);
#endif
  oldint  = sigset(SIGINT,  sig_handler_int);
  oldterm = sigset(SIGTERM, sig_handler_term);
  dk_t2h_normal_run();
  sigset(SIGTERM, oldterm);
  sigset(SIGINT,  oldint);
#ifdef SIGPIPE
  sigset(SIGPIPE, oldpipe);
#endif
}
#else
#if	DK4_HAVE_SIGNAL
/**	Set signal handlers and run.
*/
static
void
dk_t2h_run_with_signal_handlers(void)
{
#ifdef SIGPIPE
  dk4_sig_handler_t	*oldpipe = NULL;
#endif
  dk4_sig_handler_t	*oldint  = NULL;
  dk4_sig_handler_t	*oldterm = NULL;

#ifdef SIGPIPE
  oldpipe = signal(SIGPIPE, sig_handler_pipe);
#endif
  oldint  = signal(SIGINT,  sig_handler_int);
  oldterm = signal(SIGTERM, sig_handler_term);
  dk_t2h_normal_run();
  signal(SIGTERM, oldterm);
  signal(SIGINT,  oldint);
#ifdef SIGPIPE
  signal(SIGPIPE, oldpipe);
#endif
}
#else
/**	Set signal handlers and run.
*/
static
void
dk_t2h_run_with_signal_handlers(void)
{
  dk_t2h_normal_run();
}
#endif
#endif
#endif



/**	Main function.
	@param	argc	Number of command line arguments.
	@param	argv	Command line arguments array.
	@return	0 on success, all other values indicate errors.
*/
#if DK4_CHAR_SIZE > 1
int wmain(int argc, wchar_t *argv[])
#else
int main(int argc, char *argv[])
#endif
{
  int	shp;
  

#line 2104 "dk-t2h.ctr"
  

#line 2105 "dk-t2h.ctr"
  dk4fput_initialize_stderr();
  app = dk4app_open_cmd(
    argc, argv, dk_t2h_options, dk_t2h_sz_options,
    dk_t2h_kwnl[0], DKT_VERSION_DK,
    dk_t2h_kwnl[1], dk_t2h_help_text, dk_t2h_license_text
  );
  if (NULL != app) {
    dk_t2h_i_std =  dk4app_get_stdin_encoding(app);
    dk_t2h_i_file = dk4app_get_file_in_encoding(app);
    dk_t2h_sz_msg = dk4app_string_table_size(dk_t2h_kw_def);
    dk_t2h_msg    = dk4app_string_table(app, dk_t2h_kwnl[2], dk_t2h_kw_def);
    if (0 != dk4app_can_run_normally(app)) {
      dk_t2h_run_with_signal_handlers();
    } else {
      dk4fput_initialize_stdout();
      if (0 != dk4app_help_version_license(app)) {
        exval = EXIT_SUCCESS;
      }
      fflush(stdout);
      fflush(stderr);
      dk4fput_cleanup_stdout();
    }
    if (0 != sig_read_atomic(&sig_had_int )) {
      exval = EXIT_FAILURE;
      /* ERROR: Interrupted by SIGINT */
      dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 10);
    }
    if (0 != sig_read_atomic(&sig_had_term)) {
      exval = EXIT_FAILURE;
      /* ERROR: Interrupted by SIGTERM */
      dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 11);
    }
#ifdef SIGPIPE
    if (0 != sig_read_atomic(&sig_had_pipe)) {
      exval = EXIT_FAILURE;
      shp = 1;
      /* ERROR: Interrupted by SIGPIPE */
      if (0 != verbose) {
        dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 12);
      }
    } else {
      shp = 0;
    }
#else
    shp = 0;
#endif
    if ((0 == shp) && (0 != output_error)) {
      exval = EXIT_FAILURE;
      /* ERROR: Output to stdout failed */
      dk4app_log_1(app, dk_t2h_msg, dk_t2h_sz_msg, DK4_LL_ERROR, 13);
    }
    dk4app_close(app);
  }
  fflush(stdout);
  if (0 != sig_read_atomic(&sig_had_int )) { exval = EXIT_FAILURE; }
  if (0 != sig_read_atomic(&sig_had_term)) { exval = EXIT_FAILURE; }
#ifdef SIGPIPE
  if (0 != sig_read_atomic(&sig_had_pipe)) { exval = EXIT_FAILURE; }
#endif
  if (0 != output_error) { exval = EXIT_FAILURE; }
  fflush(stderr);
  dk4fput_cleanup_stderr();
  

#line 2168 "dk-t2h.ctr"
  

#line 2169 "dk-t2h.ctr"
  exit(exval); return exval;
}