%%	options

copyright owner	=	Dirk Krause
copyright year	=	2015-xxxx
SPDX-License-Identifier:	BSD-3-Clause



%%	header

/**	@file
	Find name of executed file.
*/

#ifndef DK4CONF_H_INCLUDED
#if DK4_BUILDING_DKTOOLS4
#include "dk4conf.h"
#else
#include <dktools-4/dk4conf.h>
#endif
#endif

#ifndef DK4TYPES_H_INCLUDED
#if DK4_BUILDING_DKTOOLS4
#include "dk4types.h"
#else
#include <dktools-4/dk4types.h>
#endif
#endif

#ifndef DK4ERROR_H_INCLUDED
#if DK4_BUILDING_DKTOOLS4
#include "dk4error.h"
#else
#include <dktools-4/dk4error.h>
#endif
#endif

#if DK4_HAVE_WCHAR_H
#ifndef WCHAR_H_INCLUDED
#include <wchar.h>
#define	WCHAR_H_INCLUDED 1
#endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

/**	Retrieve path to executable file.
	CRT on Windows: Not used.
	@param	buffer	Buffer to store the file name.
	@param	sz	Buffer size (number of wchar_t).
	@param	argv0	First command line word.
	@param	erp	Error report, may be NULL.
	@return	1 on success, 0 on error.
*/
int
dk4execpath_wc(wchar_t *buffer, size_t sz, const wchar_t *argv0, dk4_er_t *erp);

#ifdef __cplusplus
}
#endif

%%	module

#include "dk4conf.h"

#ifndef	DK4USE_H_INCLUDED
#include "dk4use.h"
#endif

#ifndef	DK4EXEPW_H_INCLUDED
#include "dk4exepw.h"
#endif

#ifndef DK4STRW_H_INCLUDED
#include "dk4strw.h"
#endif

#ifndef DK4MEM_H_INCLUDED
#include "dk4mem.h"
#endif

#ifndef DK4PATHW_H_INCLUDED
#include "dk4pathw.h"
#endif

#ifndef DK4STATW_H_INCLUDED
#include "dk4statw.h"
#endif

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

#if DK4_ON_WINDOWS
#ifndef WINDOWS_H_INCLUDED
#include <windows.h>
#define	WINDOWS_H_INCLUDED 1
#endif
#ifndef WINBASE_H_INCLUDED
#include <winbase.h>
#define	WINBASE_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_SYS_STAT_H
#ifndef SYS_STAT_H_INCLUDED
#include <sys/stat.h>
#define	SYS_STAT_H_INCLUDED 1
#endif
#endif

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

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

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

#include "dk4unused.h"

#if DK4_HAVE_ASSERT_H
#ifndef	ASSERT_H_INCLUDED
#include <assert.h>
#define	ASSERT_H_INCLUDED 1
#endif
#endif


$!trace-include



#if 0
static const wchar_t * const	dk4execpath_wc_kw[] = {
/*  0 */	L"PATH",
#if DK4_HAVE_BACKSLASH_AS_SEP
/*  1 */	L"\\",
#else
/*  1 */	L"/",
#endif
NULL
};
#endif



#if DK4_USE_PRAGMA_WARNING_DISABLE
#pragma warning( push )
#pragma warning( disable: 4100 )
#endif

int
dk4execpath_wc(
#if DK4_ON_WINDOWS
  wchar_t	*buffer,
  size_t	 sz,
  const wchar_t	* DK4_ARG_UNUSED(argv0),
#else
  wchar_t	* DK4_ARG_UNUSED(buffer),
  size_t	 DK4_ARG_UNUSED(sz),
  const wchar_t	* DK4_ARG_UNUSED(argv0),
#endif
  dk4_er_t	*erp
)
{
#if DK4_ON_WINDOWS
  DWORD	res;
  DWORD	dwsz;
#endif
  int		back	=	0;
#if DK4_ON_WINDOWS
  DK4_UNUSED_ARG(argv0)
  $? "+ dk4execpath_wc"
#if	DK4_USE_ASSERT
  assert(NULL != buffer);
  assert(0 < sz);
#endif
  if ((NULL != buffer) && (0 < sz)) {
    if ((dk4_um_t)0xFFFFFFFFUL >= (dk4_um_t)sz) {
      dwsz = (DWORD)sz;
    } else {
      dwsz = (DWORD)0xFFFFFFFFUL;
    }
    res = GetModuleFileNameW(GetModuleHandle(NULL), buffer, dwsz);
    if (0 < res) {
      if ((dk4_um_t)res < (dk4_um_t)sz) {
        back = 1;			$? ". success"
	buffer[res] = L'\0';
      } else {				$? "! buffer too small"
        dk4error_set_simple_error_code(erp, DK4_E_BUFFER_TOO_SMALL);
      }
    } else {				$? "! GetModuleFileNameW"
      /* ERROR: Not found */
      dk4error_set_simple_error_code(erp, DK4_E_NOT_FOUND);
    }
  } else {				$? "! invalid arguments"
    dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
  }
#else
  $? "! not supported"
  DK4_UNUSED_ARG(buffer)
  DK4_UNUSED_ARG(sz)
  DK4_UNUSED_ARG(argv0)
  dk4error_set_simple_error_code(erp, DK4_E_NOT_SUPPORTED);
#endif
  $? "- dk4execpath_wc %d", back
  return back;
}


#if DK4_USE_PRAGMA_WARNING_DISABLE
#pragma warning( pop )
#endif