path: root/support/dktools/dk-t2db.c

/*
	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-t2db.ctr
*/

/*
Copyright (C) 2016-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.
*/

/**	@file dk-t2db.c The dk-t2db module.
*/


#line 10 "dk-t2db.ctr"

/*
	Convert text to database.

	See help_text below.
*/

#include "dk4conf.h"

#include <stdio.h>

#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_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_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

#include "dk4const.h"
#include "dk4mem.h"
#include "dk4mema.h"
#include "dk4error.h"
#include "dk4dbi.h"
#include "dk4dbit8.h"
#include "dk4dbitw.h"
#include "dk4dbit.h"
#include "dk4dbia.h"
#include "dk4fput.h"
#include "dk4vers.h"
#include "dk4app.h"
#include "dk4aopt.h"
#include "dk4maasz.h"
#include "dk4enc.h"
#include "dk4fopt.h"
#include "dk4fopda.h"
#include "dk4tspdk.h"
#include "dk4strd.h"
#include "dk4maodd.h"
#include "dk4mpl.h"
#include "dk4pathd.h"





#line 96 "dk-t2db.ctr"



static const dkChar * const	help_text[]  = {
dkT(""),
dkT("dk-t2db - Convert text to simple database"),
dkT("-----------------------------------------"),
dkT(""),
dkT("dk-t2db [<option>] [<file>...] <database>"),
dkT(""),
dkT("Options:"),
dkT(""),
dkT("-a\t\t--add\t\t\t\tAppend to existing database."),
dkT("-l <size>\t--line-size=<size>\t\tLine buffer size."),
dkT("-k <size>\t--key-buffer-size=<size>\tKey buffer size."),
dkT("-v <size>\t--value-buffer-size=<size>\tValue buffer size."),
dkT("-i <string>\t--input-encoding=<string>\tExpected input encoding."),
dkT(""),
dkT("--help\t\t\t\t\t\tShow 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(""),
NULL


#line 121 "dk-t2db.ctr"
};


/**	License conditions.
*/
static const dkChar * const	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) 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_DB_H		&& (DK4_CHAR_SIZE == 1)
dkT(""),
dkT(""),
dkT("Berkeley DB license"),
dkT("==================="),
dkT("This package was debianized by Clint Adams <schizo@debian.org> on"),
dkT("Wed, 25 Jul 2007 20:37:51 +0700"),
dkT(""),
dkT("It was downloaded from"),
dkT("http://www.oracle.com/technology/software/products/berkeley-db/db/index.html"),
dkT(""),
dkT("Copyright and license:"),
dkT(""),
dkT("The following is the license that applies to this copy of the Berkeley DB"),
dkT("software.  For a license to use the Berkeley DB software under conditions"),
dkT("other than those described here, or to purchase support for this software,"),
dkT("please contact Oracle at berkeleydb-info_us@oracle.com."),
dkT(""),
dkT("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="),
dkT("/*"),
dkT(" * Copyright (c) 1990, 2010 Oracle and/or its affiliates.  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"),
dkT(" * are met:"),
dkT(" * 1. Redistributions of source code must retain the above copyright"),
dkT(" *    notice, this list of conditions and the following disclaimer."),
dkT(" * 2. 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(" * 3. Redistributions in any form must be accompanied by information on"),
dkT(" *    how to obtain complete source code for the DB software and any"),
dkT(" *    accompanying software that uses the DB software.  The source code"),
dkT(" *    must either be included in the distribution or be available for no"),
dkT(" *    more than the cost of distribution plus a nominal fee, and must be"),
dkT(" *    freely redistributable under reasonable conditions.  For an"),
dkT(" *    executable file, complete source code means the source code for all"),
dkT(" *    modules it contains.  It does not include source code for modules or"),
dkT(" *    files that typically accompany the major components of the operating"),
dkT(" *    system on which the executable file runs."),
dkT(" *"),
dkT(" * THIS SOFTWARE IS PROVIDED BY ORACLE ``AS IS'' AND ANY EXPRESS OR"),
dkT(" * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED"),
dkT(" * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR"),
dkT(" * NON-INFRINGEMENT, ARE DISCLAIMED.  IN NO EVENT SHALL ORACLE BE LIABLE"),
dkT(" * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR"),
dkT(" * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF"),
dkT(" * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR"),
dkT(" * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,"),
dkT(" * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE"),
dkT(" * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN"),
dkT(" * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."),
dkT(" */"),
dkT("/*"),
dkT(" * Copyright (c) 1990, 1993, 1994, 1995"),
dkT(" *\tThe Regents of the University of California.  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"),
dkT(" * are met:"),
dkT(" * 1. Redistributions of source code must retain the above copyright"),
dkT(" *    notice, this list of conditions and the following disclaimer."),
dkT(" * 2. 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(" * 3. Neither the name of the University nor the names of its contributors"),
dkT(" *    may be used to endorse or promote products derived from this software"),
dkT(" *    without specific prior written permission."),
dkT(" *"),
dkT(" * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND"),
dkT(" * 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.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE"),
dkT(" * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL"),
dkT(" * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS"),
dkT(" * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)"),
dkT(" * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT"),
dkT(" * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY"),
dkT(" * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF"),
dkT(" * SUCH DAMAGE."),
dkT(" */"),
dkT("/*"),
dkT(" * Copyright (c) 1995, 1996"),
dkT(" *\tThe President and Fellows of Harvard University.  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"),
dkT(" * are met:"),
dkT(" * 1. Redistributions of source code must retain the above copyright"),
dkT(" *    notice, this list of conditions and the following disclaimer."),
dkT(" * 2. 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(" * 3. Neither the name of the University nor the names of its contributors"),
dkT(" *    may be used to endorse or promote products derived from this software"),
dkT(" *    without specific prior written permission."),
dkT(" *"),
dkT(" * THIS SOFTWARE IS PROVIDED BY HARVARD AND ITS CONTRIBUTORS ``AS IS'' AND"),
dkT(" * 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.  IN NO EVENT SHALL HARVARD OR ITS CONTRIBUTORS BE LIABLE"),
dkT(" * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL"),
dkT(" * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS"),
dkT(" * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)"),
dkT(" * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT"),
dkT(" * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY"),
dkT(" * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF"),
dkT(" * SUCH DAMAGE."),
dkT(" */"),
dkT("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="),
dkT("/***"),
dkT(" * ASM: a very small and fast Java bytecode manipulation framework"),
dkT(" * Copyright (c) 2000-2005 INRIA, France Telecom"),
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"),
dkT(" * are met:"),
dkT(" * 1. Redistributions of source code must retain the above copyright"),
dkT(" *    notice, this list of conditions and the following disclaimer."),
dkT(" * 2. 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(" * 3. Neither the name of the copyright holders nor the names of its"),
dkT(" *    contributors may be used to endorse or promote products derived from"),
dkT(" *    this software without 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. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE"),
dkT(" * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR"),
dkT(" * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF"),
dkT(" * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS"),
dkT(" * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN"),
dkT(" * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)"),
dkT(" * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF"),
dkT(" * THE POSSIBILITY OF SUCH DAMAGE."),
dkT(" */"),
#endif
#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
NULL


#line 391 "dk-t2db.ctr"
};



/**	Version text.
*/
static const dkChar version_text[] = {
  DKT_VERSION_DK
#if DK4_HAVE_DB_H		&& (DK4_CHAR_SIZE == 1)
  dkT(" bdb")
#endif
#if DK4_HAVE_NDBM_H		&& (DK4_CHAR_SIZE == 1)
  dkT(" ndbm")
#endif
  dkT(" mem")
};



/**	Constant texts used by the module, not localized.
*/
const dkChar * const	dk_t2db_kwnl[] = {
/* 0 */
dkT("dktools"),

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

/* 2 */
dkT("ERROR: Application startup failed!\n"),

/* 3 */
dkT("dk-t2db.str"),

/* 4 */
dkT("line.size"),

/* 5 */
dkT("text-db.key.max-size"),

/* 6 */
dkT("text-db.value.max-size"),

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

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

NULL


#line 445 "dk-t2db.ctr"
};



/**	Constant string used by the module, replaced by localized
	texts if available.
*/
const dkChar * const	dk_t2db_kw_def[] = {
/* 0 */
dkT("Failed to set up signal handlers!"),

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

/* 2 */
dkT("<standard input>"),

/* 3 */
dkT("Failed to set database entry\n\""),

/* 4 */
dkT("\"=\""),

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

/* 6 */
dkT("Failed to delete database entry\n\""),

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

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

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

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

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

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

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

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

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

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

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

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

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

/* 20 */
dkT("Failed to read from file!"),

/* 21 */
dkT("Failed to set up text stream processor!"),

/* 22 */
dkT("Path too long for pattern\n\""),

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

/* 24 */
dkT("No such file:\n\""),

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

/* 26 */
dkT("Failed to close database!"),

/* 27 */
dkT("Database name is required!"),

/* 28 */
dkT("Illegal text encoding: \""),

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

/* 30 */
dkT("Aborted by signal!"),

NULL


#line 531 "dk-t2db.ctr"
};



/**	Options.
*/
static const dk4_option_specification_t dk_t2db_options[] = {
  { dkT('a'),	dkT("add"),			DK4_OPT_ARG_NONE	} ,
  { dkT('R'),	dkT("reset"),			DK4_OPT_ARG_NONE	} ,
  { dkT('l'),	dkT("line-size"),		DK4_OPT_ARG_SIZE	} ,
  { dkT('k'),	dkT("key-buffer-size"),		DK4_OPT_ARG_SIZE	} ,
  { dkT('v'),	dkT("value-buffer-size"),	DK4_OPT_ARG_SIZE	} ,
  { dkT('i'),	dkT("input-encoding"),		DK4_OPT_ARG_STRING	} ,
  { dkT('c'),	dkT("comment"),			DK4_OPT_ARG_STRING	}
};



/**	Input line buffer.
*/
static dkChar		 linebuf[1024];



/**	Localized or default messages.
*/
static const dkChar * const *	dk_t2db_msg	=	dk_t2db_kw_def;



/**	Pointer to input buffer to use.
*/
static dkChar		*pibuf	=	linebuf;



/**	Allocated input buffer, if necessary.
*/
static dkChar		*abuf	=	NULL;



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



/**	String containing the comment character.
*/
static const dkChar	*comment	=	NULL;




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



/**	Input buffer size.
*/
static size_t	szpibuf	=	DK4_SIZEOF(linebuf,dkChar);



/**	Database key size.
*/
static size_t	szkey	=	DK4_SIZEOF(linebuf,dkChar) / 2;



/**	Database value size.
*/
static size_t	szval	=	DK4_SIZEOF(linebuf,dkChar) / 2;



/**	Number of elements in the dk_t2db_msg array.
*/
static size_t	dk_t2db_sz_msg =
(sizeof(dk_t2db_kw_def)/sizeof(DK4_PDKCHAR) - 1);



/**	Exit status code.
*/
static int	exval	=	EXIT_FAILURE;



/**	Flag: Truncate existing database.
*/
static int	trunc	=	1;



/**	Expected encoding when processing an input file.
*/
static int	efe	=	DK4_FILE_ENCODING_ASCII;



/**	Expected encoding when processing standard input.
*/
static int	ese	=	DK4_FILE_ENCODING_ASCII;



/**	Number of decoding errors already occured.
*/
static int	dk_t2db_dec_err	= 0;



/**	Number of encoding errors already occured.
*/
static int	dk_t2db_enc_err	= 0;



/**	Number of processing errors already occured.
*/
static int	dk_t2db_pro_err	= 0;



/**	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;
}



/**	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(void)
{
  int		back = 1;
  if (0 != sig_read_atomic(&sig_had_int )) { back = 0; }
  if (0 != sig_read_atomic(&sig_had_term)) { back = 0; }
  return back;
}



static
void
dk_t2db_remove_crnl(dkChar *lptr)
{
  while (dkT('\0') != *lptr) {
    if (dkT('\n') == *lptr) {
      *lptr = dkT('\0');
    } else {
      if (dkT('\r') == *lptr) {
        *lptr = dkT('\0');
      } else {
        lptr++;
      }
    }
  }
}



/**	Handler function to process one text line.
	@param	obj	Object to modify.
	@param	line	Text line to process.
	@param	lineno	Line number of text line.
	@param	erp	Error report, may be NULL.
	@return	One from:
	- DK4_TSP_RES_OK	for successful processing,
	- DK4_TSP_RES_ERROR	on errors we can recover from,
	- DK4_TSP_RES_FATAL	on errors requiring to abort processing.
*/
int
dk_t2db_line_handler(
  void		*obj,
  dkChar	*line,
  dk4_um_t	 lineno,
  dk4_er_t	*erp
)
{
  dk4_er_t	 er;
  dk4_dbi_t	*dbiptr;
  dkChar	*p1;
  dkChar	*p2;
  int		 back	=	DK4_TSP_RES_OK;
  int		 must	=	1;			/* Must process line */
  

#line 793 "dk-t2db.ctr"
  p1 = dk4str_start(line, NULL);
  if (NULL != p1) {			

#line 795 "dk-t2db.ctr"
    if (NULL != comment) {		

#line 796 "dk-t2db.ctr"
      if (*comment == *p1) {
        must = 0;			

#line 798 "dk-t2db.ctr"
      }
#if TRACE_DEBUG
      else {				

#line 801 "dk-t2db.ctr"
      }
#endif
    }
    if (0 != must) {
      /* Not a comment line */
      dk_t2db_remove_crnl(p1);
      dbiptr = (dk4_dbi_t *)obj;
      dk4error_init(&er);
      p2 = dk4str_next(p1, NULL);
      if (NULL != p2) {			

#line 811 "dk-t2db.ctr"
        /* Add or change entry */
        if (0 == dk4dbi_text_set(dbiptr, p1, p2, &er)) {
	  dk4error_copy(erp, &er);	

#line 814 "dk-t2db.ctr"
	  back = DK4_TSP_RES_ERROR;
	  exval = EXIT_FAILURE;
	  dk4app_log_5(
	    app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 3, 4, 5, p1, p2
	  );
	}
      } else {				

#line 821 "dk-t2db.ctr"
        /* Delete entry */
        if (0 == dk4dbi_text_del(dbiptr, p1, &er)) {
	  dk4error_copy(erp, &er);	

#line 824 "dk-t2db.ctr"
	  back = DK4_TSP_RES_ERROR;
	  exval = EXIT_FAILURE;
	  dk4app_log_3(
	    app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 6, 7, p1
	  );
	}
      }
    }
  }
  

#line 834 "dk-t2db.ctr"
  return back;
}


/**	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_t2db_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_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR,
      i1, 17, 18, 19, b1, b2, b3
    );
  } else {
    dk4app_log_1(
      app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, i2
    );
  }
  dk4app_set_log_source_line(app, oldlogline);
}


/**	Report errors from encoding/decoding or processing.
*/
static
void
dk_t2db_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_t2db_dec_err) {
	  case 0: case 1: {
	    dk_t2db_report_with_position(
	      14, 8, 
	      er_en->dt.fpos.byteno,
	      er_en->dt.fpos.lineno,
	      er_en->dt.fpos.charno,
	      er_en->dt.fpos.charinline
	    );
	  } break;
	  case 2: {
	    dk4app_log_1(
	      app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 11
	    );
	  } break;
	}
	if (3 > dk_t2db_dec_err) { dk_t2db_dec_err++; }
      } break;
      case DK4_E_ENCODING_FAILED: {
        switch (dk_t2db_enc_err) {
	  case 0: case 1: {
	    dk_t2db_report_with_position(
	      15, 9, 
	      er_en->dt.fpos.byteno,
	      er_en->dt.fpos.lineno,
	      er_en->dt.fpos.charno,
	      er_en->dt.fpos.charinline
	    );
	  } break;
	  case 2: {
	    dk4app_log_1(
	      app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 12
	    );
	  } break;
	}
	if (3 > dk_t2db_enc_err) { dk_t2db_enc_err++; }
      } break;
    }
  }
  if (NULL != er_pr) {
    if (DK4_E_NONE != er_pr->ec) {
      switch (dk_t2db_pro_err) {
        case 0: case 1: {
	  dk_t2db_report_with_position(
	    16, 10, 
	    er_pr->dt.fpos.byteno,
	    er_pr->dt.fpos.lineno,
	    er_pr->dt.fpos.charno,
	    er_pr->dt.fpos.charinline
	  );
	} break;
	case 2: {
	  dk4app_log_1(
	    app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 13
	  );
	} break;
      }
      if (3 > dk_t2db_pro_err) { dk_t2db_pro_err++; }
    }
  }


}



/**	Process one input file.
	@param	dbiptr		Database to modify.
	@param	infile		Input file to process, must be in binary mode.
	@param	filename	File name of input file.
	@param	eie		Expected input encoding.
*/
static
void
dk_t2db_run_for_file(
  dk4_dbi_t	*dbiptr,
  FILE 		*infile,
  const dkChar	*filename,
  int		 eie
)
{
  dk4_tspdk_t		 tspdk;
  dk4_er_t		 er_en;
  dk4_er_t		 er_pr;
  const dkChar		*oldsourcefile;
  int			 res;
  int			 cc;
  int			 c;
  unsigned char		 ub;

  dk_t2db_dec_err = 0;
  dk_t2db_enc_err = 0;
  dk_t2db_pro_err = 0;
  oldsourcefile = dk4app_get_log_source_file(app);
  res = dk4tspdk_setup_line(
    &tspdk, dbiptr, dk_t2db_line_handler, pibuf, szpibuf,
    dk4app_get_encoding(app), eie, NULL
  );
  if (0 != res) {
    if (DK4_ENCODING_UTF8 == dk4app_get_encoding(app)) {
      dk4tspdk_enable_utf8_pass_through(&tspdk, 1);
    }
    dk4error_init(&er_en);
    dk4error_init(&er_pr);
    cc = 1;
    do {
      if (0 != sig_can_continue()) {
        c = fgetc(infile);
	if (EOF != c) {
	  ub = (unsigned char)c;
	  switch (dk4tspdk_add_one_byte(&tspdk, ub)) {
	    case DK4_TSP_RES_FATAL : {
	      cc = -1;
	      exval = EXIT_FAILURE;
	      dk4tspdk_get_errors(&er_en, &er_pr, &tspdk);
	      dk_t2db_report_errors(&er_en, &er_pr);
	    } break;
	    case DK4_TSP_RES_ERROR : {
	      exval = EXIT_FAILURE;
	      dk4tspdk_get_errors(&er_en, &er_pr, &tspdk);
	      dk_t2db_report_errors(&er_en, &er_pr);
	    } break;
	  }
	} else {
	  cc = 0;
	  if (0 != ferror(infile)) {
	    cc = -1;
	    /* ERROR: Failed to read from file */
	    dk4app_log_1(
	      app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 20
	    );
	    exval = EXIT_FAILURE;
	  }
	}
      } else {
        cc = -1;
      }
    } while (1 == cc);
    if (0 == cc) {
      switch (dk4tspdk_finish(&tspdk)) {
        case DK4_TSP_RES_FATAL : {
	  exval = EXIT_FAILURE;
	  dk4tspdk_get_errors(&er_en, &er_pr, &tspdk);
	  dk_t2db_report_errors(&er_en, &er_pr);
	} break;
	case DK4_TSP_RES_ERROR : {
	  exval = EXIT_FAILURE;
	  dk4tspdk_get_errors(&er_en, &er_pr, &tspdk);
	  dk_t2db_report_errors(&er_en, &er_pr);
	} break;
      }
    }
  } else {
    /* ERROR: Failed to set up text stream processor */
    dk4app_log_1(
      app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 21
    );
    exval = EXIT_FAILURE;
  }
  dk4app_set_log_source_file(app, oldsourcefile);
}



/**	Process one input file specified by file name.
	@param	dbiptr		Database to modify.
	@param	filename	Name of file to process.
*/
static
void
dk_t2db_process_name(dk4_dbi_t *dbiptr, const dkChar *filename)
{
#if DK4_ON_WINDOWS
  dkChar	 buf[DK4_MAX_PATH];
#endif
  FILE *fipo;
#if DK4_ON_WINDOWS
  dk4_dir_t	*fne;
  const dkChar	*expfn;
  const dkChar	*expth;
  size_t	 szbuf		= DK4_SIZEOF(buf,dkChar);
  int		 any_file_found	= 0;
  int		 cc;
#endif

  if (NULL != filename) {
#if DK4_ON_WINDOWS
    if (0 != dk4path_must_expand(filename)) {
      fne = dk4app_fne_open(filename, app);
      if (NULL != fne) {
        cc = 1;
        do {
	  if (0 != sig_can_continue()) {
	    expfn = dk4dir_next_file(fne);
	    if (NULL != expfn) {
	      any_file_found = 1;
	      expth = dk4dir_get_path(fne);
	      if (NULL != expth) {
	        if (0 != dk4str_cpy_s(buf, szbuf, expth, NULL)) {
		  if (0 != dk4str_cat_s(buf, szbuf, dk_t2db_kwnl[8], NULL)) {
		    if (0 != dk4str_cat_s(buf, szbuf, expfn, NULL)) {
                      fipo = dk4fopen_app(
                        buf, dk_t2db_kwnl[7], DK4_FOPEN_SC_IS_REGULAR, app
                      );
                      if (NULL != fipo) {
                        dk_t2db_run_for_file(dbiptr, fipo, buf, efe);
                        fclose(fipo);
                      } else {
                        exval = EXIT_FAILURE;
                      }
		    } else {
		      /* ERROR: Path too long */
		      dk4app_log_3(
			app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR,
			22, 23, filename
		      );
		      exval = EXIT_FAILURE;
		    }
		  } else {
		    /* ERROR: Path too long */
		    dk4app_log_3(
		      app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR,
		      22, 23, filename
		    );
		    exval = EXIT_FAILURE;
		  }
		} else {
		  /* ERROR: Path too long */
		  dk4app_log_3(
		    app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR,
		    22, 23, filename
		  );
		  exval = EXIT_FAILURE;
		}
	      } else {
                fipo = dk4fopen_app(
                  expfn, dk_t2db_kwnl[7], DK4_FOPEN_SC_IS_REGULAR, app
                );
                if (NULL != fipo) {
                  dk_t2db_run_for_file(dbiptr, fipo, expfn, efe);
                  fclose(fipo);
                } else {
                  exval = EXIT_FAILURE;
                }
	      }
	    } else {
	      cc = 0;
	    }
	  } else {
	    cc = -1;
	  }
	} while (1 == cc);
        dk4dir_close(fne);
	if (0 == any_file_found) {
	  /* ERROR: No such file */
	  dk4app_log_3(
	    app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR,
	    24, 25, filename
	  );
	  exval = EXIT_FAILURE;
	}
      } else {
        exval = EXIT_FAILURE;
      }
    } else {
#endif
      fipo = dk4fopen_app(
        filename, dk_t2db_kwnl[7], DK4_FOPEN_SC_IS_REGULAR, app
      );
      if (NULL != fipo) {
        dk_t2db_run_for_file(dbiptr, fipo, filename, efe);
        fclose(fipo);
      } else {
        exval = EXIT_FAILURE;
      }
#if DK4_ON_WINDOWS
    }
#endif
  }
}



/**	Run for opened database.
	@param	dbiptr	Database to modify.
*/
static
void
dk_t2db_run_with_dbi(dk4_dbi_t *dbiptr)
{
  int	xargc;
  int	i;
#if DK4_ON_WINDOWS
  int	oldmode;
#endif

  xargc = dk4app_get_argc(app);
  if (1 < xargc) {
    for (i = 0; ((i < (xargc - 1)) && (0 != sig_can_continue())); i++) {
      dk_t2db_process_name(dbiptr, dk4app_get_argv(app, i));
    }
  } else {
#if DK4_ON_WINDOWS
    oldmode = _setmode(_fileno(stdin), _O_BINARY);
#endif
    dk_t2db_run_for_file(dbiptr, stdin, dk_t2db_msg[2], ese);
#if DK4_ON_WINDOWS
    _setmode(_fileno(stdin), oldmode);
#endif
  }
}



/**	Open database and do processing.
*/
static
void
dk_t2db_run_with_buffers(void)
{
  dk4_er_t	 er;
  dk4_dbi_t	*dbiptr;
  const dkChar	*fn;

  fn = dk4app_get_argv(app, (dk4app_get_argc(app)-1));
  if ((0 != sig_can_continue()) && (NULL != fn)) {
    dbiptr = dk4dbi_open_sizes_app(fn, 1, trunc, szkey, szval, NULL, app);
    if (NULL != dbiptr) {
      exval = EXIT_SUCCESS;
      dk_t2db_run_with_dbi(dbiptr);
      dk4error_init(&er);
      if (0 == dk4dbi_close(dbiptr, &er)) {
        /* ERROR: Failed to close database */
	dk4app_log_1(
	  app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 26
	);
	exval = EXIT_FAILURE;
      }
    }
  }
}



/**	Process preferences and command line options,
	allocate buffer if necessary and do processing.
*/
static
void
dk_t2db_normal_run(void)
{
  dk4_er_t	 er;
  const dkChar	*oaptr;
  size_t	 i;
  int		 enc	= DK4_FILE_ENCODING_ASCII;
  int		 bom	= 0;

  /*	Check cmd line arguments, must have at least a database name.
  */
  if (0 == dk4app_get_argc(app)) {
    /* ERROR: Database name required. */
    dk4app_log_1(
      app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 27
    );
    goto finished;
  }

  /*	Process preferences and options.
  */
  if (0 == dk4app_opt_is_set_short(app, dkT('R'), NULL)) {
    if (0 != dk4app_pref_get_size(&i, app, dk_t2db_kwnl[4], 0)) {
      szpibuf = i;
    }
    if (0 != dk4app_pref_get_size(&i, app, dk_t2db_kwnl[5], 0)) {
      szkey = i;
    }
    if (0 != dk4app_pref_get_size(&i, app, dk_t2db_kwnl[6], 0)) {
      szval = i;
    }
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('a'), NULL)) {
    trunc = 0;
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('l'), NULL)) {
    if (0 != dk4app_opt_get_size_short(&i, app, dkT('l'), NULL)) {
      szpibuf = i;
    }
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('k'), NULL)) {
    if (0 != dk4app_opt_get_size_short(&i, app, dkT('k'), NULL)) {
      szkey = i;
    }
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('v'), NULL)) {
    if (0 != dk4app_opt_get_size_short(&i, app, dkT('v'), NULL)) {
      szval = i;
    }
  }
  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(&enc, &bom, oaptr, NULL)) {
        efe = ese = enc;
      } else {
        /* ERROR: Encoding not found */
	dk4app_log_3(
	  app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 28, 29, oaptr
	);
	goto finished;
      }
    }
  }
  if (0 != dk4app_opt_is_set_short(app, dkT('c'), NULL)) {
    

#line 1310 "dk-t2db.ctr"
    oaptr = dk4app_opt_get_string_ptr_short(app, dkT('c'), NULL);
    if (NULL != oaptr) {	

#line 1312 "dk-t2db.ctr"
      comment = oaptr;	

#line 1313 "dk-t2db.ctr"
    }
#if TRACE_DEBUG
    else {			

#line 1316 "dk-t2db.ctr"
    }
#endif
  }
  if (0 == szpibuf) { szpibuf = DK4_SIZEOF(linebuf,dkChar); }
  if (0 == szkey) { szkey = DK4_SIZEOF(linebuf,dkChar) / 2; }
  if (0 == szval) { szval = DK4_SIZEOF(linebuf,dkChar) / 2; }

  /*	Calculate key and value buffer size in bytes.
  */
  dk4error_init(&er);
  szkey = dk4ma_size_t_mul(szkey, sizeof(dkChar), &er);
  szval = dk4ma_size_t_mul(szval, sizeof(dkChar), &er);
  if (DK4_E_NONE != er.ec) {
    /* ERROR: Mathematical overflow in size calculation */
    dk4app_log_base1(app, DK4_LL_ERROR, 82);
    goto finished;
  }

  /*	Allocate larger buffer if necessary.
  */
  if (DK4_SIZEOF(linebuf,dkChar) < szpibuf) {
    abuf = dk4mem_new_app(dkChar,szpibuf,app);
    if (NULL != abuf) {
      pibuf = abuf;
    } else {
      goto finished;
    }
  }

  /*	Now do the processing.
  */
  dk_t2db_run_with_buffers();

  /*	Clean up.
  */
  finished:
  dk4mem_release(abuf) ;
}



#if	DK4_HAVE_SIGACTION
/**	Set signal handlers and run.
*/
static
void
dk_t2db_run_with_signal_handlers(void)
{
  struct sigaction oint;
  struct sigaction nint;
  struct sigaction oterm;
  struct sigaction nterm;
  int	 success = 0;

  /*	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_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 0);
    goto finished;
  }
  if (0 != sigaddset(&nint.sa_mask, SIGINT)) {
    /* ERROR: Failed to set up masked signal set for SIGINT */
    dk4app_log_1(app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 0);
    goto finished;
  }
  if (0 != sigaction(SIGINT, &nint, &oint)) {
    /* ERROR: Failed to set up signal handler for SIGINT */
    dk4app_log_1(app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 0);
    goto finished;
  }

  /*	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_t2db_msg, dk_t2db_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_t2db_msg, dk_t2db_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_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 0);
    goto restore_old_int;
  }

  success = 1;
  dk_t2db_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_t2db_msg, dk_t2db_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_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 1);
    success = 0;
  }

  /*	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_t2db_run_with_signal_handlers(void)
{
  dk4_sig_handler_t	*oldint  = NULL;
  dk4_sig_handler_t	*oldterm = NULL;

  oldint  = sigset(SIGINT,  sig_handler_int);
  oldterm = sigset(SIGTERM, sig_handler_term);
  dk_t2db_normal_run();
  sigset(SIGTERM, oldterm);
  sigset(SIGINT,  oldint);
}
#else
#if	DK4_HAVE_SIGNAL
/**	Set signal handlers and run.
*/
static
void
dk_t2db_run_with_signal_handlers(void)
{
  dk4_sig_handler_t	*oldint  = NULL;
  dk4_sig_handler_t	*oldterm = NULL;

  oldint  = signal(SIGINT,  sig_handler_int);
  oldterm = signal(SIGTERM, sig_handler_term);
  dk_t2db_normal_run();
  signal(SIGTERM, oldterm);
  signal(SIGINT,  oldint);
}
#else
/**	Set signal handlers and run.
*/
static
void
dk_t2db_run_with_signal_handlers(void)
{
  dk_t2db_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
{
  

#line 1498 "dk-t2db.ctr"
  

#line 1499 "dk-t2db.ctr"
  dk4fput_initialize_stderr();
  app = dk4app_open_cmd(
    argc, argv,
    dk_t2db_options, dk_t2db_sz_options,
    dk_t2db_kwnl[0], version_text,
    dk_t2db_kwnl[1], help_text, license_text
  );
  if (NULL != app) {
    ese = dk4app_get_stdin_encoding(app);
    efe = dk4app_get_file_in_encoding(app);
    dk_t2db_sz_msg = dk4app_string_table_size(dk_t2db_kw_def);
    dk_t2db_msg    = dk4app_string_table(app, dk_t2db_kwnl[3], dk_t2db_kw_def);
    if (0 != dk4app_can_run_normally(app)) {
      dk_t2db_run_with_signal_handlers();
      if (0 != sig_read_atomic(&sig_had_int)) {
        /* ERROR: Aborted by SIGINT */
	dk4app_log_1(
	  app, dk_t2db_msg, dk_t2db_sz_msg, DK4_LL_ERROR, 30
	);
	exval = EXIT_FAILURE;
      }
      if (0 != sig_read_atomic(&sig_had_term)) {
        exval = EXIT_FAILURE;
      }
    } else {
      if (0 != dk4app_help_version_license(app)) {
        exval = EXIT_SUCCESS;
      }
    }
    dk4app_close(app);
  } else {
    dk4fputs(dk_t2db_kwnl[2], stderr, NULL);
  }
  fflush(stderr);
  dk4fput_cleanup_stderr();
  

#line 1535 "dk-t2db.ctr"
  

#line 1536 "dk-t2db.ctr"
  exit(exval); return exval;
}