path: root/support/dktools/dk4fs.ctr

%%	options

copyright owner	=	Dirk Krause
copyright year	=	2015-xxxx
license		=	bsd


%%	header

/**	@file
	File search for configuration and data files.
	Specify short file name and a number of directories:
	- shared data directory (i.e. /usr/share) or system
	  configuration directory (i.e. /etc),
	- users home directory,
	- program name,
	- program group name,
	- language,
	- region

	Use dk4fs_config_one() or dk4fs_data_one() multiple times to
	find the file best matching
	program name, group name, language and region. See below.
	
	CRT on Windows: Optional.
*/

#ifndef DK4CONF_H_INCLUDED
#include "dk4conf.h"
#endif

#ifndef DK4TYPES_H_INCLUDED
#include "dk4types.h"
#endif

#ifndef DK4ERROR_H_INCLUDED
#include "dk4error.h"
#endif



/**	Pass numbers for configuration file search.

	The group name passed as name_group is used instead of group,
	the program name passed as name_prog is used instead of prog.
*/
enum {
  DK4_FS_CONF_SHARE_LIB	= 0,		/**< /usr/share/dk4app */
  DK4_FS_CONF_ETC_LIB ,			/**< /etc/dk4app */
  DK4_FS_CONF_SHARE_LIB_SITE ,		/**< /usr/share/dk4app-site */
  DK4_FS_CONF_ETC_LIB_SITE ,		/**< /etc/dk4app-site */
  DK4_FS_CONF_SHARE_GROUP ,		/**< /usr/share/group */
  DK4_FS_CONF_ETC_GROUP ,		/**< /etc/group */
  DK4_FS_CONF_SHARE_GROUP_SITE ,	/**< /usr/share/group-site */
  DK4_FS_CONF_ETC_GROUP_SITE ,		/**< /etc/group-site */
  DK4_FS_CONF_SHARE_APP ,		/**< /usr/share/prog */
  DK4_FS_CONF_ETC_APP ,			/**< /etc/prog */
  DK4_FS_CONF_SHARE_APP_SITE ,		/**< /usr/share/prog-site */
  DK4_FS_CONF_ETC_APP_SITE ,		/**< /etc/prog-site */
  DK4_FS_CONF_HOME_LIB ,		/**< HOME/.dk4app */
  DK4_FS_CONF_HOME_GROUP ,		/**< HOME/.dk4app/group */
  DK4_FS_CONF_HOME_APP ,		/**< HOME/.dk4app/prog */
  DK4_FS_CONF_CURRENT_DIR ,		/**< Current directory */

					/**  Maximum value.
					*/
  DK4_FS_CONF_MAX = DK4_FS_CONF_CURRENT_DIR ,

					/**  Maximum value to search
					     system directories only.
					*/
  DK4_FS_CONF_SYS_MAX = DK4_FS_CONF_ETC_APP_SITE
};



/**	Pass numbers for data file search.

	The group name passed as name_group is used instead of group,
	the program name passed as name_prog is used instead of prog.
*/
enum {
  DK4_FS_DATA_SHARE_LIB	= 0,			/**< /usr/share/dk4app */
  DK4_FS_DATA_SHARE_LIB_SITE ,			/**< /usr/share/dk4app-site */
  DK4_FS_DATA_SHARE_GROUP ,			/**< /usr/share/group */
  DK4_FS_DATA_SHARE_GROUP_SITE ,		/**< /usr/share/group-site */
  DK4_FS_DATA_SHARE_APP ,			/**< /usr/share/prog */
  DK4_FS_DATA_SHARE_APP_SITE ,			/**< /usr/share/prog-site */
  DK4_FS_DATA_SHARE_LIB_LANG ,			/**< /usr/share/dk4app/l */
  DK4_FS_DATA_SHARE_LIB_SITE_LANG ,		/**< /usr/share/dk4app-site/l */
  DK4_FS_DATA_SHARE_GROUP_LANG ,		/**< /usr/share/group/l */
  DK4_FS_DATA_SHARE_GROUP_SITE_LANG ,		/**< /usr/share/group-site/l */
  DK4_FS_DATA_SHARE_APP_LANG ,			/**< /usr/share/prog/l */
  DK4_FS_DATA_SHARE_APP_SITE_LANG ,		/**< /usr/share/prog-site/l */
  DK4_FS_DATA_SHARE_LIB_REG ,		/**< /usr/share/dk4app */
  DK4_FS_DATA_SHARE_LIB_SITE_REG ,	/**< /usr/share/dk4app-site */
  DK4_FS_DATA_SHARE_GROUP_REG ,		/**< /usr/share/group */
  DK4_FS_DATA_SHARE_GROUP_SITE_REG ,	/**< /usr/share/group-site */
  DK4_FS_DATA_SHARE_APP_REG ,		/**< /usr/share/prog/no-language/r */
  DK4_FS_DATA_SHARE_APP_SITE_REG , /**< /usr/share/prog-site/no-language/r */
  DK4_FS_DATA_SHARE_LIB_LANG_REG ,		/**< /usr/share/dk4app/l/r */
  DK4_FS_DATA_SHARE_LIB_SITE_LANG_REG ,	      /**< /usr/share/dk4app-site/l/r */
  DK4_FS_DATA_SHARE_GROUP_LANG_REG ,		/**< /usr/share/group/l/r */
  DK4_FS_DATA_SHARE_GROUP_SITE_LANG_REG ,      /**< /usr/share/group-site/l/r */
  DK4_FS_DATA_SHARE_APP_LANG_REG ,		/**< /usr/share/prog/l/r */
  DK4_FS_DATA_SHARE_APP_SITE_LANG_REG ,		/**< /usr/share/prog-site/l/r */
  DK4_FS_DATA_HOME_LIB ,			/**< HOME/.dk4app */
  DK4_FS_DATA_HOME_GROUP ,			/**< HOME/.dk4app/group */
  DK4_FS_DATA_HOME_APP ,			/**< HOME/.dk4app/prog */
  DK4_FS_DATA_CURRENT_DIR ,			/**< Current directory */

			/**	Maximum system data file.
			*/
  DK4_FS_DATA_MAX_SYS	= DK4_FS_DATA_SHARE_APP_SITE_LANG_REG,

			/**	Maximum data file.
			*/
  DK4_FS_DATA_MAX	= DK4_FS_DATA_CURRENT_DIR
};


#ifdef __cplusplus
extern "C" {
#endif

/**	Check presence of one file, optionally with compression suffixes.
	CRT on Windows: Optional.
	@param	dptr		Buffer containing file name.
	@param	szdptr		Buffer size.
	@param	compressed	Flag: Search for compressed files too.
	@param	erp		Error report, may be NULL.
	@return	1 if file or optionally compressed file found, 0 otherwise.
	
	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if dptr is NULL or szdptr is 0,
	- DK4_E_NOT_SUPPORTED<br>
	  if wchar_t are used as dkChar on non-Windows systems,
	- DK4_E_NOT_FOUND<br>
	  if the file was not found.
*/
int
dk4fs_attempt_file_name(
  dkChar	 *dptr,
  size_t	  szdptr,
  int		  compressed,
  dk4_er_t	 *erp
);

/**	Attempt to construct one file name from multiple parts.
	CRT on Windows: Optional.
	@param	dptr		Destination buffer address.
	@param	szdptr		Destination buffer size (number of dkChar).
	@param	comp		Components array.
	@param	ncomp		Number of components.
	@param	site		Flag: Add -site after second component.
	@param	erp		Error report, may be NULL.
	@return	1 on success (path constructed and file exists), 0 otherwise.
	
	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if dptr or comp is NULL or szdptr or ncomp is 0,
	- DK4_E_BUFFER_TOO_SMALL<br>
	  if the dptr buffer is too small,
	- DK4_E_MATH_OVERFLOW<br>
	  if a mathematical overflow happened during
				a size calculation.
*/
int
dk4fs_construct_from_parts(
  dkChar	 *dptr,
  size_t	  szdptr,
  const dkChar	**comp,
  size_t	  ncomp,
  int		  site,
  dk4_er_t	 *erp
);

/**	Attempt to construct one path name for a configuration file.
	CRT on Windows: Optional.
	@param	dptr		Buffer for result file name.
	@param	szdptr		Size of buffer (number of dkChar).
	@param	shortname	Short configuration file name.
	@param	dir_share	The data directory.
	@param	dir_etc		The system configuration directory.
	@param	dir_home	Users home directory.
	@param	name_prog	Application name.
	@param	name_group	Application group name.
	@param	passno		Number of current pass.
	@param	co3		Flag: Compatible to DK tools 3.
	@param	erp		Error report, may be NULL.
	@return	1 on success, 0 on error.
	
	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if dptr or shortname is NULL or szdptr is 0 or passno is an invalid
	  number or one of the used strings (dir_share, dir_etc, dir_home,
	  name_prog, or name_group) is NULL,
	- DK4_E_BUFFER_TOO_SMALL<br>
	  if the dptr buffer is too small,
	- DK4_E_MATH_OVERFLOW<br>
	  if a mathematical overflow happened during a size calculation.
*/
int
dk4fs_config_construct_compat_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_etc,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  int		 co3,
  dk4_er_t	*erp
);

/**	Attempt to construct one path name for a configuration file.
	CRT on Windows: Optional.
	@param	dptr		Buffer for result file name.
	@param	szdptr		Size of buffer (number of dkChar).
	@param	shortname	Short configuration file name.
	@param	dir_share	The data directory.
	@param	dir_etc		The system configuration directory.
	@param	dir_home	Users home directory.
	@param	name_prog	Application name.
	@param	name_group	Application group name.
	@param	passno		Number of current pass.
	@param	erp		Error report, may be NULL.
	@return	1 on success, 0 on error.
	
	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if dptr or shortname is NULL or szdptr is 0 or passno is an invalid
	  number or one of the used strings (dir_share, dir_etc, dir_home,
	  name_prog, or name_group) is NULL,
	- DK4_E_BUFFER_TOO_SMALL<br>
	  if the dptr buffer is too small,
	- DK4_E_MATH_OVERFLOW<br>
	  if a mathematical overflow happened during a size calculation.
*/
int
dk4fs_config_construct_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_etc,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  dk4_er_t	*erp
);

/**	Check one path candidate for configuration file name
	(construct name and check presence of file).

	To search for a file matching your needs run this function
	multiple times with differenct passno values.
	- To search for one file best matching:
	  - Start with pass number DK4_FS_CONF_MAX or DK4_FS_CONF_SYS_MAX
	    and decrease the number down to DK4_FS_CONF_SHARE_LIB,
	    use the first file found.
	  - Start with pass number DK4_FS_CONF_MAX to allow both user
	    and system configuration files.
	  - Start with pass number DK4_FS_CONF_SYS_MAX to process system
	    configuration files only.
	- To process multiple files, each file may overwrite settings
	  made by previous files:
	  - Start with pass number DK4_FS_CONF_SHARE_LIB (0) and increase
	    the pass number up to DK4_FS_CONF_SYS_MAX or DK4_FS_CONF_MAX.
	  - Stopping after DK4_FS_CONF_SYS_MAX will process system
	    configuration files only, stopping after DK4_FS_CONF_MAX
	    processes both system and user configuration files.
	
	CRT on Windows: Optional.
	@param	dptr		Buffer for result file name.
	@param	szdptr		Size of buffer (number of dkChar).
	@param	shortname	Short configuration file name.
	@param	dir_share	The data directory.
	@param	dir_etc		The system configuration directory.
	@param	dir_home	Users home directory.
	@param	name_prog	Application name.
	@param	name_group	Application group name.
	@param	passno		Number of current pass.
	@param	co3		Flag: Compatible mode to DK tools 3.
	@param	compressed	Flag: Allow gzip and bzip2 compressed files
				too, if the library was build with gzip
				and/or bzip2 support.
	@param	erp		Error report, may be NULL.
	@return	1 on success, 0 on error.
	
	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if dptr or shortname is NULL or szdptr is 0 or passno is an invalid
	  number or one of the used strings (dir_share, dir_etc, dir_home,
	  name_prog, or name_group) is NULL,
	- DK4_E_BUFFER_TOO_SMALL<br>
	  if the dptr buffer is too small,
	- DK4_E_MATH_OVERFLOW<br>
	  if a mathematical overflow happened during a size calculation,
	- DK4_E_NOT_FOUND<br>
	  if no file was found,
	- DK4_E_NOT_SUPPORTED<br>
	  if wchar_t are used as dkChar on non-Windows systems.
*/
int
dk4fs_config_compat_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_etc,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  int		 co3,
  int		 compressed,
  dk4_er_t	*erp
);

/**	Check one path candidate for configuration file name
	(construct name and check presence of file).

	To search for a file matching your needs run this function
	multiple times with differenct passno values.
	- To search for one file best matching:
	  - Start with pass number DK4_FS_CONF_MAX or DK4_FS_CONF_SYS_MAX
	    and decrease the number down to DK4_FS_CONF_SHARE_LIB,
	    use the first file found.
	  - Start with pass number DK4_FS_CONF_MAX to allow both user
	    and system configuration files.
	  - Start with pass number DK4_FS_CONF_SYS_MAX to process system
	    configuration files only.
	- To process multiple files, each file may overwrite settings
	  made by previous files:
	  - Start with pass number DK4_FS_CONF_SHARE_LIB (0) and increase
	    the pass number up to DK4_FS_CONF_SYS_MAX or DK4_FS_CONF_MAX.
	  - Stopping after DK4_FS_CONF_SYS_MAX will process system
	    configuration files only, stopping after DK4_FS_CONF_MAX
	    processes both system and user configuration files.
	
	CRT on Windows: Optional.
	@param	dptr		Buffer for result file name.
	@param	szdptr		Size of buffer (number of dkChar).
	@param	shortname	Short configuration file name.
	@param	dir_share	The data directory.
	@param	dir_etc		The system configuration directory.
	@param	dir_home	Users home directory.
	@param	name_prog	Application name.
	@param	name_group	Application group name.
	@param	passno		Number of current pass.
	@param	compressed	Flag: Allow gzip and bzip2 compressed files
				too, if the library was build with gzip
				and/or bzip2 support.
	@param	erp		Error report, may be NULL.
	@return	1 on success, 0 on error.
	
	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if dptr or shortname is NULL or szdptr is 0 or passno is an invalid
	  number or one of the used strings (dir_share, dir_etc, dir_home,
	  name_prog, or name_group) is NULL,
	- DK4_E_BUFFER_TOO_SMALL<br>
	  if the dptr buffer is too small,
	- DK4_E_MATH_OVERFLOW<br>
	  if a mathematical overflow happened during a size calculation,
	- DK4_E_NOT_FOUND<br>
	  if no file was found,
	- DK4_E_NOT_SUPPORTED<br>
	  if wchar_t are used as dkChar on non-Windows systems.
*/
int
dk4fs_config_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_etc,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  int		 compressed,
  dk4_er_t	*erp
);

/**	Attempt to construct one path name for a data file.
	CRT on Windows: Optional.
	@param	dptr		Buffer for result file name.
	@param	szdptr		Size of buffer (number of dkChar).
	@param	shortname	Short configuration file name.
	@param	dir_share	The data directory.
	@param	language	Users language.
	@param	region		Users region.
	@param	dir_home	Users home directory.
	@param	name_prog	Application name.
	@param	name_group	Application group name.
	@param	passno		Number of current pass.
	@param	erp		Error report, may be NULL.
	@return	1 on success, 0 on error.
	
	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if dptr or shortname is NULL or szdptr is 0 or passno is an invalid
	  number or one of the used strings (dir_share, dir_home, language,
	  region, name_prog, or name_group) is NULL,
	- DK4_E_BUFFER_TOO_SMALL<br>
	  if the dptr buffer is too small,
	- DK4_E_MATH_OVERFLOW<br>
	  if a mathematical overflow happened during a size calculation.
*/
int
dk4fs_data_construct_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*language,
  const dkChar	*region,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  dk4_er_t	*erp
);

/**	Check one path candidate for data file name
	(construct file name and check presence).

	To search for a file, use this function multiple times with different
	passno values:
	- Start with DK4_F_DATA_MAX, DK4_FS_DATA_CURRENT_DIR,
	  DK4_FS_DATA_HOME_APP or DK4_FS_DATA_MAX_SYS.
	- Decrease the pass number down to DK4_FS_DATA_SHARE_LIB.
	- Use the first file found.
	
	CRT on Windows: Optional.
	@param	dptr		Buffer for result file name.
	@param	szdptr		Size of buffer (number of dkChar).
	@param	shortname	Short configuration file name.
	@param	dir_share	The data directory.
	@param	dir_home	Users home directory.
	@param	name_prog	Application name.
	@param	name_group	Application group name.
	@param	language	Users preferred language.
	@param	region		Users region (country code).
	@param	passno		Number of current pass.
	@param	compressed	Flag: Allow compressed files too.
	@param	erp		Error report, may be NULL.
	@return	1 on success, 0 on error.
	
	Error codes:
	- DK4_E_INVALID_ARGUMENTS<br>
	  if dptr or shortname is NULL or szdptr is 0 or passno is an invalid
	  number or one of the used strings (dir_share, dir_home, language,
	  region, name_prog, or name_group) is NULL,
	- DK4_E_BUFFER_TOO_SMALL<br>
	  if the dptr buffer is too small,
	- DK4_E_MATH_OVERFLOW<br>
	  if a mathematical overflow happened during a size calculation,
	- DK4_E_NOT_FOUND<br>
	  if no file was found,
	- DK4_E_NOT_SUPPORTED<br>
	  if wchar_t are used as dkChar on non-Windows systems.
*/
int
dk4fs_data_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  const dkChar	*language,
  const dkChar	*region,
  int		 passno,
  int		 compressed,
  dk4_er_t	*erp
);

#ifdef __cplusplus
}
#endif



%%	module

#include "dk4fs.h"

#if 0

#ifndef DK4STAT_H_INCLUDED
#include "dk4stat.h"
#endif

#ifndef DK4STATD_H_INCLUDED
#include "dk4statd.h"
#endif

#endif

#ifndef DK4FILED_H_INCLUDED
#include "dk4filed.h"
#endif

#ifndef DK4STRD_H_INCLUDED
#include "dk4strd.h"
#endif




$!trace-include



/**	Constant strings used by this module.
*/
static const dkChar * const	dk4fs_kw[] = {
$!string-table macro=dkT
#
#	0 ... 1		Directory names
#
dk4app
.dk4app
#
#	2		Directory name appendix for site-specific directories
#
-site
#
#	3 ... 4		Compression suffixes
#
.gz
.bz2
#
#	5		Language: No language
#
no-language
#
#	6 ... 7		Directory names for compatibility mode.
#
dk3app
.dk3app
$!end
};



#if DK4_HAVE_BACKSLASH_AS_SEP
/**	Path name separator.
*/
static const dkChar	dk4fs_sep[] = { dkT("\\") };
#else
/**	Path name separator.
*/
static const dkChar	dk4fs_sep[] = { dkT("/") };
#endif



#if 0
/**	Check presence of regular file.
	CRT on Windows: Optional.
	@param	fn	File name.
	@param	erp	Error report, may be NULL.
	@return	1 on success (file exists and is a  regular file), 0 otherwise.
*/
static
int
dk4fs_check_regular_file(
  const dkChar	*fn,
  dk4_er_t	*erp
)
{
#if DK4_ON_WINDOWS && (DK4_WIN_AVOID_CRT || DK4_WIN_DENY_CRT)
#if DK4_CHAR_SIZE > 1
  WIN32_FIND_DATAW	ffdata;
#els
  WIN32_FIND_DATAA	ffdata;
#endif
  HANDLE		ha;
  DWORD		 	dwattr;
  int		 	back = 0;
#if DK4_CHAR_SIZE > 1
  dwattr = GetFileAttributesW(fn);
#else
  dwattr = GetFileAttributesA(fn);
#endif
  if (INVALID_FILE_ATTRIBUTES == dwattr) {
#if DK4_CHAR_SIZE > 1
    ha = FindFirstFileW(fn, &ffdata);
#else
    ha = FindFirstFileA(fn, &ffdata);
#endif
    if (INVALID_HANDLE_VALUE != ha) {
      dwattr = ffdata.dwFileAttributes;
      FindClose(ha);
    }
  }
  if (INVALID_FILE_ATTRIBUTES != dwattr) {
    if ((DWORD)0UL == (FILE_ATTRIBUTE_DIRECTORY & dwattr)) {
      if ((DWORD)0UL == (FILE_ATTRIBUTE_DEVICE & dwattr)) {
        back = 1;
      }
    }
  }
  return back;
#else
  dk4_stat_t	 stb;
  int		 back = 0;
  if (0 != dk4stat(&stb, fn, erp)) {
    if (0 != dk4stat_is_regular(&stb, erp)) {
      back = 1;
    }
  }
  return back;
#endif
}
#endif



int
dk4fs_attempt_file_name(
  dkChar	 *dptr,
  size_t	  szdptr,
  int		  compressed,
  dk4_er_t	 *erp
)
{
  dkChar	*eptr;			/* End of name */
  int		 back = 0;
  $? "+ dk4fs_attempt_file_name"
  if ((NULL != dptr) && (0 < szdptr)) {
#if DK4_ON_WINDOWS && DK4_WIN_DENY_CRT
    /*	Compression/decompression libraries depend on CRT.
    */
    compressed = 0;
#endif
    $? ". checking \"%!ds\"", dptr
    back = dk4file_is_regular(dptr, erp);
    $? ". result %d", back
    if ((0 == back) && (0 != compressed)) {
      eptr = dptr;
      while (dkT('\0') != *eptr) { eptr++; }
#if DK4_HAVE_ZLIB_H
      if (0 != dk4str_cat_s(dptr, szdptr, dk4fs_kw[3], erp)) {
        $? ". checking \"%!ds\"", dptr
	back = dk4file_is_regular(dptr, erp);
	$? ". result %d", back
      }
#endif
#if DK4_HAVE_BZLIB_H
      if (0 == back) {
        *eptr = dkT('\0');
        if (0 != dk4str_cat_s(dptr, szdptr, dk4fs_kw[4], erp)) {
          $? ". checking \"%!ds\"", dptr
	  back = dk4file_is_regular(dptr, erp);
	  $? ". result %d", back
        }
        if (0 == back) {
          *eptr = dkT('\0');
        }
      }
#endif
    }
  } else {
    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
  } $? "- dk4fs_attempt_file_name %d", back
  return back;
}



int
dk4fs_construct_from_parts(
  dkChar	 *dptr,
  size_t	  szdptr,
  const dkChar	**comp,
  size_t	  ncomp,
  int		  site,
  dk4_er_t	 *erp
)
{
  size_t	 i;			/* Traverse comp */
  int		 back	=	0;	/* Function result */
  $? "+ dk4fs_construct_from_parts"
  if ((NULL != dptr) && (0 < szdptr) && (NULL != comp) && (0 < ncomp)) {
    for (i = 0; i < ncomp; i++) {
      if (0 == i) {
        if (0 == dk4str_cpy_s(dptr, szdptr, comp[0], erp)) {
	  goto finished;
        }
      } else {
        if (0 != dk4str_cat_s(dptr, szdptr, dk4fs_sep, erp)) {
          if (0 != dk4str_cat_s(dptr, szdptr, comp[i], erp)) {
	    if ((1 == i) && (0 != site)) {
	      if (0 == dk4str_cat_s(dptr, szdptr, dk4fs_kw[2], erp)) {
	        goto finished;
	      }
	    }
	  } else {
	    goto finished;
	  }
        } else {
	  goto finished;
        }
      }
    }
  } else {
    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
  }
  back = 1;
  finished:
  if (0 == back) { *dptr = dkT('\0'); }
  $? "- dk4fs_construct_from_parts %d", back
  return back;
}



int
dk4fs_config_construct_compat_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_etc,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  int		 co3,
  dk4_er_t	*erp
)
{
  const dkChar	*ptrs[8];
  int		 back = 0;
  $? "+ dk4fs_config_construct_compact_one"
  if ((NULL != dptr) && (0 < szdptr) && (NULL != shortname)) {
    switch (passno) {
      case DK4_FS_CONF_SHARE_LIB: {
        if (NULL != dir_share) {
          ptrs[0] = dir_share;
	  ptrs[1] = dk4fs_kw[(co3) ? (6) : (0)];
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_ETC_LIB: {
        if (NULL != dir_etc) {
          ptrs[0] = dir_etc;
	  ptrs[1] = dk4fs_kw[(co3) ? (6) : (0)];
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_SHARE_LIB_SITE: {
        if (NULL != dir_share) {
          ptrs[0] = dir_share;
	  ptrs[1] = dk4fs_kw[(co3) ? (6) : (0)];
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_ETC_LIB_SITE: {
        if (NULL != dir_etc) {
          ptrs[0] = dir_etc;
	  ptrs[1] = dk4fs_kw[(co3) ? (6) : (0)];
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_SHARE_GROUP: {
        if ((NULL != dir_share) && (NULL != name_group)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_group;
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_ETC_GROUP: {
        if ((NULL != dir_etc) && (NULL != name_group)) {
          ptrs[0] = dir_etc;
	  ptrs[1] = name_group;
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_SHARE_GROUP_SITE: {
        if ((NULL != dir_share) && (NULL != name_group)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_group;
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_ETC_GROUP_SITE: {
        if ((NULL != dir_etc) && (NULL != name_group)) {
          ptrs[0] = dir_etc;
	  ptrs[1] = name_group;
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_SHARE_APP: {
        if ((NULL != dir_share) && (NULL != name_prog)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_prog;
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_ETC_APP: {
        if ((NULL != dir_etc) && (NULL != name_prog)) {
          ptrs[0] = dir_etc;
	  ptrs[1] = name_prog;
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_SHARE_APP_SITE: {
        if ((NULL != dir_share) && (NULL != name_prog)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_prog;
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_ETC_APP_SITE: {
        if ((NULL != dir_etc) && (NULL != name_prog)) {
          ptrs[0] = dir_etc;
	  ptrs[1] = name_prog;
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_HOME_LIB: {
        if (NULL != dir_home) {
	  ptrs[0] = dir_home;
	  ptrs[1] = dk4fs_kw[(co3) ? (7) : (1)];
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_HOME_GROUP: {
        if ((NULL != dir_home) && (NULL != name_group)) {
	  ptrs[0] = dir_home;
	  ptrs[1] = dk4fs_kw[(co3) ? (7) : (1)];
	  ptrs[2] = name_group;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_HOME_APP: {
        if ((NULL != dir_home) && (NULL != name_prog)) {
	  ptrs[0] = dir_home;
	  ptrs[1] = dk4fs_kw[(co3) ? (7) : (1)];
	  ptrs[2] = name_prog;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_CONF_CURRENT_DIR: {
        ptrs[0] = shortname;
	back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,1,0,erp);
      } break;
      default: {
        dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
      } break;
    }
  } else {
    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
  }
  $? "- dk4fs_config_construct_compact_one %d", back
  return back;
}



int
dk4fs_config_construct_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_etc,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  dk4_er_t	*erp
)
{
  return(
    dk4fs_config_construct_compat_one(
      dptr, szdptr, shortname, dir_share, dir_etc, dir_home,
      name_prog, name_group, passno, 0, erp
    )
  );
}



int
dk4fs_config_compat_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_etc,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  int		 co3,
  int		 compressed,
  dk4_er_t	*erp
)
{
  int		 back;
  $? "+ dk4fs_config_compat_one \"%!ds\" %d", shortname, passno
  back = dk4fs_config_construct_compat_one(
    dptr, szdptr, shortname,
    dir_share, dir_etc, dir_home,
    name_prog, name_group, passno, co3, erp
  );
  if (0 != back) {
    $? ". file name = \"%!ds\"", TR_DKSTR(dptr)
    back = dk4fs_attempt_file_name(dptr, szdptr, compressed, erp);
    if (0 != back) { $? ". file found = \"%!ds\"", TR_DKSTR(dptr)
    }
  } $? "- dk4fs_config_compat_one %d", back
  return  back;
}



int
dk4fs_config_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_etc,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  int		 compressed,
  dk4_er_t	*erp
)
{
  return (
    dk4fs_config_compat_one(
      dptr, szdptr, shortname,
      dir_share, dir_etc, dir_home, name_prog, name_group,
      passno, 0, compressed, erp
    )
  );
}



int
dk4fs_data_construct_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*language,
  const dkChar	*region,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  int		 passno,
  dk4_er_t	*erp
)
{
  const dkChar	*ptrs[8];
  int		 back = 0;
  $? "+ dk4fs_data_construct_one"
  $? ". short name = \"%!ds\"", TR_DKSTR(shortname)
  $? ". /.../share = \"%!ds\"", TR_DKSTR(dir_share)
  $? ". language   = \"%!ds\"", TR_DKSTR(language)
  $? ". region     = \"%!ds\"", TR_DKSTR(region)
  $? ". HOME       = \"%!ds\"", TR_DKSTR(dir_home)
  $? ". prog name  = \"%!ds\"", TR_DKSTR(name_prog)
  $? ". prog group = \"%!ds\"", TR_DKSTR(name_group)
  $? ". pass no    = %d", passno
  if ((NULL != dptr) && (0 < szdptr) && (NULL != shortname)) {
    switch (passno) {

      case DK4_FS_DATA_SHARE_LIB: {
        back = dk4fs_config_construct_one(
	  dptr, szdptr, shortname,
	  dir_share, NULL, dir_home,
	  name_prog, name_group, DK4_FS_CONF_SHARE_LIB, erp
	);
      } break;
      case DK4_FS_DATA_SHARE_LIB_SITE: {
        back = dk4fs_config_construct_one(
	  dptr, szdptr, shortname,
	  dir_share, NULL, dir_home,
	  name_prog, name_group, DK4_FS_CONF_SHARE_LIB_SITE, erp
	);
      } break;
      case DK4_FS_DATA_SHARE_GROUP: {
        back = dk4fs_config_construct_one(
	  dptr, szdptr, shortname,
	  dir_share, NULL, dir_home,
	  name_prog, name_group, DK4_FS_CONF_SHARE_GROUP, erp
	);
      } break;
      case DK4_FS_DATA_SHARE_GROUP_SITE: {
        back = dk4fs_config_construct_one(
	  dptr, szdptr, shortname,
	  dir_share, NULL, dir_home,
	  name_prog, name_group, DK4_FS_CONF_SHARE_GROUP_SITE, erp
	);
      } break;
      case DK4_FS_DATA_SHARE_APP: {
        back = dk4fs_config_construct_one(
	  dptr, szdptr, shortname,
	  dir_share, NULL, dir_home,
	  name_prog, name_group, DK4_FS_CONF_SHARE_APP, erp
	);
      } break;
      case DK4_FS_DATA_SHARE_APP_SITE: {
        back = dk4fs_config_construct_one(
	  dptr, szdptr, shortname,
	  dir_share, NULL, dir_home,
	  name_prog, name_group, DK4_FS_CONF_SHARE_APP_SITE, erp
	);
      } break;
      case DK4_FS_DATA_SHARE_LIB_LANG: {
        if ((NULL != dir_share) && (NULL != language)) {
          ptrs[0] = dir_share;
	  ptrs[1] = dk4fs_kw[0];
	  ptrs[2] = language;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_LIB_SITE_LANG: {
        if ((NULL != dir_share) && (NULL != language)) {
          ptrs[0] = dir_share;
	  ptrs[1] = dk4fs_kw[0];
	  ptrs[2] = language;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_GROUP_LANG: {
        if ((NULL != dir_share) && (NULL != language) && (NULL != name_group)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_group;
	  ptrs[2] = language;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_GROUP_SITE_LANG: {
        if ((NULL != dir_share) && (NULL != language) && (NULL != name_group)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_group;
	  ptrs[2] = language;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_APP_LANG: {
        if ((NULL != dir_share) && (NULL != language) && (NULL != name_prog)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_prog;
	  ptrs[2] = language;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_APP_SITE_LANG: {
        if ((NULL != dir_share) && (NULL != language) && (NULL != name_prog)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_prog;
	  ptrs[2] = language;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_LIB_REG: {
        if ((NULL != dir_share) && (NULL != region)) {
          ptrs[0] = dir_share;
	  ptrs[1] = dk4fs_kw[0];
	  ptrs[2] = dk4fs_kw[5];
	  ptrs[3] = region;
	  ptrs[4] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_LIB_SITE_REG: {
        if ((NULL != dir_share) && (NULL != region)) {
          ptrs[0] = dir_share;
	  ptrs[1] = dk4fs_kw[0];
	  ptrs[2] = dk4fs_kw[5];
	  ptrs[3] = region;
	  ptrs[4] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_GROUP_REG: {
        if ((NULL != dir_share) && (NULL != name_group) && (NULL != region)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_group;
	  ptrs[2] = dk4fs_kw[5];
	  ptrs[3] = region;
	  ptrs[4] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_GROUP_SITE_REG: {
        if ((NULL != dir_share) && (NULL != name_group) && (NULL != region)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_group;
	  ptrs[2] = dk4fs_kw[5];
	  ptrs[3] = region;
	  ptrs[4] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_APP_REG: {
        if ((NULL != dir_share) && (NULL != name_prog) && (NULL != region)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_prog;
	  ptrs[2] = dk4fs_kw[5];
	  ptrs[3] = region;
	  ptrs[4] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_APP_SITE_REG: {
        if ((NULL != dir_share) && (NULL != name_prog) && (NULL != region)) {
          ptrs[0] = dir_share;
	  ptrs[1] = name_prog;
	  ptrs[2] = dk4fs_kw[5];
	  ptrs[3] = region;
	  ptrs[4] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_LIB_LANG_REG: {
        if ((NULL != dir_share) && (NULL != language) && (NULL != region)) {
          ptrs[0] = dir_share;
	  ptrs[1] = dk4fs_kw[0];
	  ptrs[2] = language;
	  ptrs[3] = region;
	  ptrs[4] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_LIB_SITE_LANG_REG: {
        if ((NULL != dir_share) && (NULL != language) && (NULL != region)) {
          ptrs[0] = dir_share;
	  ptrs[1] = dk4fs_kw[0];
	  ptrs[2] = language;
	  ptrs[3] = region;
	  ptrs[4] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,1,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_GROUP_LANG_REG: {
        if ((NULL != dir_share) && (NULL != language)) {
	  if ((NULL != region) && (NULL != name_group)) {
            ptrs[0] = dir_share;
	    ptrs[1] = name_group;
	    ptrs[2] = language;
	    ptrs[3] = region;
	    ptrs[4] = shortname;
	    back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,0,erp);
	  } else {
	    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	  }
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_GROUP_SITE_LANG_REG: {
        if ((NULL != dir_share) && (NULL != language)) {
	  if ((NULL != region) && (NULL != name_group)) {
            ptrs[0] = dir_share;
	    ptrs[1] = name_group;
	    ptrs[2] = language;
	    ptrs[3] = region;
	    ptrs[4] = shortname;
	    back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,1,erp);
	  } else {
	    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	  }
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_APP_LANG_REG: {
        if ((NULL != dir_share) && (NULL != language)) {
	  if ((NULL != region) && (NULL != name_prog)) {
            ptrs[0] = dir_share;
	    ptrs[1] = name_prog;
	    ptrs[2] = language;
	    ptrs[3] = region;
	    ptrs[4] = shortname;
	    back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,0,erp);
	  } else {
	    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	  }
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_SHARE_APP_SITE_LANG_REG: {
        if ((NULL != dir_share) && (NULL != language)) {
	  if ((NULL != region) && (NULL != name_prog)) {
            ptrs[0] = dir_share;
	    ptrs[1] = name_prog;
	    ptrs[2] = language;
	    ptrs[3] = region;
	    ptrs[4] = shortname;
	    back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,5,1,erp);
	  } else {
	    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	  }
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_HOME_LIB: {
        if (NULL != dir_home) {
	  ptrs[0] = dir_home;
	  ptrs[1] = dk4fs_kw[1];
	  ptrs[2] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,3,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_HOME_GROUP: {
        if ((NULL != dir_home) && (NULL != name_group)) {
	  ptrs[0] = dir_home;
	  ptrs[1] = dk4fs_kw[1];
	  ptrs[2] = name_group;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_HOME_APP: {
        if ((NULL != dir_home) && (NULL != name_prog)) {
	  ptrs[0] = dir_home;
	  ptrs[1] = dk4fs_kw[1];
	  ptrs[2] = name_prog;
	  ptrs[3] = shortname;
	  back = dk4fs_construct_from_parts(dptr,szdptr,ptrs,4,0,erp);
	} else {
	  dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
	}
      } break;
      case DK4_FS_DATA_CURRENT_DIR: {
        back = dk4str_cpy_s(dptr, szdptr, shortname, erp);
      } break;
    }
  } else {
    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
  }
  $? "- dk4fs_data_construct_one %d", back
  return back;
}



int
dk4fs_data_one(
  dkChar	*dptr,
  size_t	 szdptr,
  const dkChar	*shortname,
  const dkChar	*dir_share,
  const dkChar	*dir_home,
  const dkChar	*name_prog,
  const dkChar	*name_group,
  const dkChar	*language,
  const dkChar	*region,
  int		 passno,
  int		 compressed,
  dk4_er_t	*erp
)
{
  int		 back;
  $? "+ dk4fs_data_one %!ds %d", shortname, passno
  back = dk4fs_data_construct_one(
    dptr, szdptr, shortname,
    dir_share, language, region, dir_home,
    name_prog, name_group, passno, erp
  );
  if (0 != back) {	$? ". test \"%!ds\"", TR_DKSTR(dptr)
    back = dk4fs_attempt_file_name(dptr, szdptr, compressed, erp);
  } $? "- dk4fs_data_one %d", back
  return back;
}