mirror of
https://github.com/avrdudes/avrdude.git
synced 2026-07-18 07:29:15 +03:00
759 lines
17 KiB
C
759 lines
17 KiB
C
// (‑●‑●)> dual licensed under the WTFPL v2 and MIT licenses
|
|
// without any warranty.
|
|
// by Gregory Pakosz (@gpakosz)
|
|
// https://github.com/gpakosz/whereami
|
|
|
|
// In case you want to #include "whereami.c" in a larger compilation unit
|
|
|
|
#if !defined(WHEREAMI_H)
|
|
#include <whereami.h>
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#if defined(__linux__) || defined(__CYGWIN__)
|
|
#undef _DEFAULT_SOURCE
|
|
#define _DEFAULT_SOURCE
|
|
#elif defined(__APPLE__)
|
|
#undef _DARWIN_C_SOURCE
|
|
#define _DARWIN_C_SOURCE
|
|
#define _DARWIN_BETTER_REALPATH
|
|
#endif
|
|
|
|
#if !defined(WAI_MALLOC) || !defined(WAI_FREE) || !defined(WAI_REALLOC)
|
|
#include <stdlib.h>
|
|
#include "avrdude.h"
|
|
#include "libavrdude.h"
|
|
|
|
#ifndef PATH_MAX
|
|
#define PATH_MAX _MAX_PATH
|
|
#endif
|
|
#endif
|
|
|
|
#if !defined(WAI_MALLOC)
|
|
#define WAI_MALLOC(size) mmt_malloc(size)
|
|
#endif
|
|
|
|
#if !defined(WAI_FREE)
|
|
#define WAI_FREE(p) mmt_free(p)
|
|
#endif
|
|
|
|
#if !defined(WAI_REALLOC)
|
|
#define WAI_REALLOC(p, size) mmt_realloc(p, size)
|
|
#endif
|
|
|
|
#ifndef WAI_NOINLINE
|
|
|
|
#if defined(_MSC_VER)
|
|
#define WAI_NOINLINE __declspec(noinline)
|
|
#elif defined(__GNUC__)
|
|
#define WAI_NOINLINE __attribute__((noinline))
|
|
#else
|
|
#error unsupported compiler
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(_MSC_VER)
|
|
#define WAI_RETURN_ADDRESS() _ReturnAddress()
|
|
#elif defined(__GNUC__)
|
|
#define WAI_RETURN_ADDRESS() __builtin_extract_return_addr(__builtin_return_address(0))
|
|
#else
|
|
#error unsupported compiler
|
|
#endif
|
|
|
|
#if defined(_WIN32)
|
|
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(push, 3)
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
#include <intrin.h>
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#if (_MSC_VER >= 1900)
|
|
#include <stdbool.h>
|
|
#else
|
|
#ifndef bool
|
|
#define bool int
|
|
#endif
|
|
#define false 0
|
|
#define true 1
|
|
#endif
|
|
|
|
static int WAI_PREFIX(getModulePath_) (HMODULE module, char *out, int capacity, int *dirname_length) {
|
|
wchar_t buffer1[MAX_PATH];
|
|
wchar_t buffer2[MAX_PATH];
|
|
wchar_t *path = NULL;
|
|
int length = -1;
|
|
bool ok;
|
|
|
|
for(ok = false; !ok; ok = true) {
|
|
DWORD size;
|
|
int length_, length__;
|
|
|
|
size = GetModuleFileNameW(module, buffer1, sizeof(buffer1)/sizeof(buffer1[0]));
|
|
|
|
if(size == 0)
|
|
break;
|
|
else if(size == (DWORD) (sizeof(buffer1)/sizeof(buffer1[0]))) {
|
|
DWORD size_ = size;
|
|
do {
|
|
wchar_t *path_;
|
|
|
|
path_ = (wchar_t *) WAI_REALLOC(path, sizeof(wchar_t)*size_*2);
|
|
if(!path_)
|
|
break;
|
|
size_ *= 2;
|
|
path = path_;
|
|
size = GetModuleFileNameW(module, path, size_);
|
|
}
|
|
while(size == size_);
|
|
|
|
if(size == size_)
|
|
break;
|
|
} else
|
|
path = buffer1;
|
|
|
|
if(!_wfullpath(buffer2, path, MAX_PATH))
|
|
break;
|
|
length_ = (int) wcslen(buffer2);
|
|
length__ = WideCharToMultiByte(CP_UTF8, 0, buffer2, length_, out, capacity, NULL, NULL);
|
|
|
|
if(length__ == 0)
|
|
length__ = WideCharToMultiByte(CP_UTF8, 0, buffer2, length_, NULL, 0, NULL, NULL);
|
|
if(length__ == 0)
|
|
break;
|
|
|
|
if(length__ <= capacity && dirname_length) {
|
|
int i;
|
|
|
|
for(i = length__ - 1; i >= 0; --i) {
|
|
if(out[i] == '\\') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
length = length__;
|
|
}
|
|
|
|
if(path != buffer1)
|
|
WAI_FREE(path);
|
|
|
|
return ok? length: -1;
|
|
}
|
|
|
|
WAI_NOINLINE WAI_FUNCSPEC int WAI_PREFIX(getExecutablePath) (char *out, int capacity, int *dirname_length) {
|
|
return WAI_PREFIX(getModulePath_) (NULL, out, capacity, dirname_length);
|
|
}
|
|
|
|
WAI_NOINLINE WAI_FUNCSPEC int WAI_PREFIX(getModulePath) (char *out, int capacity, int *dirname_length) {
|
|
HMODULE module;
|
|
int length = -1;
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(push)
|
|
#pragma warning(disable: 4054)
|
|
#endif
|
|
|
|
if(GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
|
|
(LPCTSTR) WAI_RETURN_ADDRESS(), &module))
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
{
|
|
length = WAI_PREFIX(getModulePath_) (module, out, capacity, dirname_length);
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
#elif defined(__linux__) || defined(__CYGWIN__) || defined(__sun) || defined(WAI_USE_PROC_SELF_EXE)
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#if defined(__linux__)
|
|
#include <linux/limits.h>
|
|
#else
|
|
#include <limits.h>
|
|
#endif
|
|
|
|
#ifndef __STDC_FORMAT_MACROS
|
|
#define __STDC_FORMAT_MACROS
|
|
#endif
|
|
|
|
#include <inttypes.h>
|
|
#include <stdbool.h>
|
|
|
|
#if !defined(WAI_PROC_SELF_EXE)
|
|
|
|
#if defined(__sun)
|
|
#define WAI_PROC_SELF_EXE "/proc/self/path/a.out"
|
|
#else
|
|
#define WAI_PROC_SELF_EXE "/proc/self/exe"
|
|
#endif
|
|
#endif
|
|
|
|
WAI_FUNCSPEC int WAI_PREFIX(getExecutablePath) (char *out, int capacity, int *dirname_length) {
|
|
char buffer[PATH_MAX];
|
|
char *resolved = NULL;
|
|
int length = -1;
|
|
bool ok;
|
|
|
|
for(ok = false; !ok; ok = true) {
|
|
resolved = realpath(WAI_PROC_SELF_EXE, buffer);
|
|
if(!resolved)
|
|
break;
|
|
|
|
length = (int) strlen(resolved);
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}}
|
|
}
|
|
} return ok? length: -1;
|
|
}
|
|
|
|
#if !defined(WAI_PROC_SELF_MAPS_RETRY)
|
|
#define WAI_PROC_SELF_MAPS_RETRY 5
|
|
#endif
|
|
|
|
#if !defined(WAI_PROC_SELF_MAPS)
|
|
|
|
#if defined(__sun)
|
|
#define WAI_PROC_SELF_MAPS "/proc/self/map"
|
|
#else
|
|
#define WAI_PROC_SELF_MAPS "/proc/self/maps"
|
|
#endif
|
|
#endif
|
|
|
|
#if !defined(WAI_STRINGIZE)
|
|
#define WAI_STRINGIZE(s)
|
|
#define WAI_STRINGIZE_(s) #s
|
|
#endif
|
|
|
|
#if defined(__ANDROID__) || defined(ANDROID)
|
|
#include <fcntl.h>
|
|
#include <sys/mman.h>
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include <stdbool.h>
|
|
|
|
WAI_NOINLINE WAI_FUNCSPEC int WAI_PREFIX(getModulePath) (char *out, int capacity, int *dirname_length) {
|
|
int length = -1;
|
|
FILE *maps = NULL;
|
|
|
|
for(int r = 0; r < WAI_PROC_SELF_MAPS_RETRY; ++r) {
|
|
maps = fopen(WAI_PROC_SELF_MAPS, "r");
|
|
if(!maps)
|
|
break;
|
|
|
|
for(;;) {
|
|
char buffer[128 + PATH_MAX];
|
|
uintptr_t low, high;
|
|
char perms[5];
|
|
uint64_t offset;
|
|
uint32_t major, minor, inode;
|
|
char path[PATH_MAX + 1];
|
|
|
|
if(!fgets(buffer, sizeof(buffer), maps))
|
|
break;
|
|
|
|
if(sscanf(buffer, "%" SCNxPTR "-%" SCNxPTR " %s %" SCNx64 " %x:%x %u %" WAI_STRINGIZE(PATH_MAX) "[^\n]\n", &low, &high,
|
|
perms, &offset, &major, &minor, &inode, path) == 8) {
|
|
void *_addr = WAI_RETURN_ADDRESS();
|
|
uintptr_t addr = (uintptr_t) _addr;
|
|
|
|
if(low <= addr && addr <= high) {
|
|
char *resolved;
|
|
|
|
resolved = realpath(path, buffer);
|
|
if(!resolved)
|
|
break;
|
|
|
|
length = (int) strlen(resolved);
|
|
|
|
#if defined(__ANDROID__) || defined(ANDROID)
|
|
if(length > 4
|
|
&& buffer[length - 1] == 'k'
|
|
&& buffer[length - 2] == 'p' && buffer[length - 3] == 'a' && buffer[length - 4] == '.') {
|
|
int fd = open(path, O_RDONLY);
|
|
|
|
if(fd == -1) {
|
|
length = -1; // Retry
|
|
break;
|
|
}
|
|
|
|
char *begin = (char *) mmap(0, offset, PROT_READ, MAP_SHARED, fd, 0);
|
|
|
|
if(begin == MAP_FAILED) {
|
|
close(fd);
|
|
length = -1; // Retry
|
|
break;
|
|
}
|
|
|
|
char *p = begin + offset - 30; // Minimum size of local file header
|
|
|
|
while(p >= begin) // Scan backwards
|
|
{
|
|
if(*((uint32_t *) p) == 0x04034b50UL) // Local file header signature found
|
|
{
|
|
uint16_t length_ = *((uint16_t *) (p + 26));
|
|
|
|
if(length + 2 + length_ < (int) sizeof(buffer)) {
|
|
memcpy(&buffer[length], "!/", 2);
|
|
memcpy(&buffer[length + 2], p + 30, length_);
|
|
length += 2 + length_;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
--p;
|
|
}
|
|
|
|
munmap(begin, offset);
|
|
close(fd);
|
|
}
|
|
#endif
|
|
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
fclose(maps);
|
|
maps = NULL;
|
|
|
|
if(length != -1)
|
|
break;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
#elif defined(__APPLE__)
|
|
|
|
#include <mach-o/dyld.h>
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <dlfcn.h>
|
|
#include <stdbool.h>
|
|
|
|
WAI_FUNCSPEC int WAI_PREFIX(getExecutablePath) (char *out, int capacity, int *dirname_length) {
|
|
char buffer1[PATH_MAX];
|
|
char buffer2[PATH_MAX];
|
|
char *path = buffer1;
|
|
char *resolved = NULL;
|
|
int length = -1;
|
|
bool ok;
|
|
|
|
for(ok = false; !ok; ok = true) {
|
|
uint32_t size = (uint32_t) sizeof(buffer1);
|
|
if(_NSGetExecutablePath(path, &size) == -1) {
|
|
path = (char *) WAI_MALLOC(size);
|
|
if(!_NSGetExecutablePath(path, &size))
|
|
break;
|
|
}
|
|
|
|
resolved = realpath(path, buffer2);
|
|
|
|
if(!resolved)
|
|
break;
|
|
|
|
length = (int) strlen(resolved);
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(path != buffer1)
|
|
WAI_FREE(path);
|
|
|
|
return ok? length: -1;
|
|
}
|
|
|
|
WAI_NOINLINE WAI_FUNCSPEC int WAI_PREFIX(getModulePath) (char *out, int capacity, int *dirname_length) {
|
|
char buffer[PATH_MAX];
|
|
char *resolved = NULL;
|
|
int length = -1;
|
|
|
|
for(;;) {
|
|
Dl_info info;
|
|
|
|
if(dladdr(WAI_RETURN_ADDRESS(), &info)) {
|
|
resolved = realpath(info.dli_fname, buffer);
|
|
if(!resolved)
|
|
break;
|
|
|
|
length = (int) strlen(resolved);
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
#elif defined(__QNXNTO__)
|
|
|
|
#include <limits.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <dlfcn.h>
|
|
#include <stdbool.h>
|
|
|
|
#if !defined(WAI_PROC_SELF_EXE)
|
|
#define WAI_PROC_SELF_EXE "/proc/self/exefile"
|
|
#endif
|
|
|
|
WAI_FUNCSPEC int WAI_PREFIX(getExecutablePath) (char *out, int capacity, int *dirname_length) {
|
|
char buffer1[PATH_MAX];
|
|
char buffer2[PATH_MAX];
|
|
char *resolved = NULL;
|
|
FILE *self_exe = NULL;
|
|
int length = -1;
|
|
bool ok;
|
|
|
|
for(ok = false; !ok; ok = true) {
|
|
self_exe = fopen(WAI_PROC_SELF_EXE, "r");
|
|
if(!self_exe)
|
|
break;
|
|
|
|
if(!fgets(buffer1, sizeof(buffer1), self_exe))
|
|
break;
|
|
|
|
resolved = realpath(buffer1, buffer2);
|
|
if(!resolved)
|
|
break;
|
|
|
|
length = (int) strlen(resolved);
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}}
|
|
}
|
|
} fclose(self_exe);
|
|
|
|
return ok? length: -1;
|
|
}
|
|
|
|
WAI_FUNCSPEC int WAI_PREFIX(getModulePath) (char *out, int capacity, int *dirname_length) {
|
|
char buffer[PATH_MAX];
|
|
char *resolved = NULL;
|
|
int length = -1;
|
|
|
|
for(;;) {
|
|
Dl_info info;
|
|
|
|
if(dladdr(WAI_RETURN_ADDRESS(), &info)) {
|
|
resolved = realpath(info.dli_fname, buffer);
|
|
if(!resolved)
|
|
break;
|
|
|
|
length = (int) strlen(resolved);
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
#elif defined(__DragonFly__) || defined(__FreeBSD__) || \
|
|
defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
|
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/sysctl.h>
|
|
#include <dlfcn.h>
|
|
#include <stdbool.h>
|
|
|
|
#if defined(__OpenBSD__)
|
|
#include <unistd.h>
|
|
|
|
WAI_FUNCSPEC int WAI_PREFIX(getExecutablePath) (char *out, int capacity, int *dirname_length) {
|
|
char buffer1[4096];
|
|
char buffer2[PATH_MAX];
|
|
char buffer3[PATH_MAX];
|
|
char **argv = (char **) buffer1;
|
|
char *resolved = NULL;
|
|
int length = -1;
|
|
bool ok;
|
|
|
|
for(ok = false; !ok; ok = true) {
|
|
int mib[4] = { CTL_KERN, KERN_PROC_ARGS, getpid(), KERN_PROC_ARGV };
|
|
size_t size;
|
|
|
|
if(sysctl(mib, 4, NULL, &size, NULL, 0) != 0)
|
|
break;
|
|
|
|
if(size > sizeof(buffer1)) {
|
|
argv = (char **) WAI_MALLOC(size);
|
|
if(!argv)
|
|
break;
|
|
}
|
|
|
|
if(sysctl(mib, 4, argv, &size, NULL, 0) != 0)
|
|
break;
|
|
|
|
if(strchr(argv[0], '/')) {
|
|
resolved = realpath(argv[0], buffer2);
|
|
if(!resolved)
|
|
break;
|
|
} else {
|
|
const char *PATH = getenv("PATH");
|
|
|
|
if(!PATH)
|
|
break;
|
|
|
|
size_t argv0_length = strlen(argv[0]);
|
|
|
|
const char *begin = PATH;
|
|
|
|
while(1) {
|
|
const char *separator = strchr(begin, ':');
|
|
const char *end = separator? separator: begin + strlen(begin);
|
|
|
|
if(end - begin > 0) {
|
|
if(*(end - 1) == '/')
|
|
--end;
|
|
|
|
if(((end - begin) + 1 + argv0_length + 1) <= sizeof(buffer2)) {
|
|
memcpy(buffer2, begin, end - begin);
|
|
buffer2[end - begin] = '/';
|
|
memcpy(buffer2 + (end - begin) + 1, argv[0], argv0_length + 1);
|
|
|
|
resolved = realpath(buffer2, buffer3);
|
|
if(resolved)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!separator)
|
|
break;
|
|
|
|
begin = ++separator;
|
|
}
|
|
|
|
if(!resolved)
|
|
break;
|
|
}
|
|
|
|
length = (int) strlen(resolved);
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(argv != (char **) buffer1)
|
|
WAI_FREE(argv);
|
|
|
|
return ok? length: -1;
|
|
}
|
|
|
|
#else
|
|
|
|
WAI_FUNCSPEC int WAI_PREFIX(getExecutablePath) (char *out, int capacity, int *dirname_length) {
|
|
char buffer1[PATH_MAX];
|
|
char buffer2[PATH_MAX];
|
|
char *path = buffer1;
|
|
char *resolved = NULL;
|
|
int length = -1;
|
|
bool ok;
|
|
|
|
for(ok = false; !ok; ok = true) {
|
|
|
|
#if defined(__NetBSD__)
|
|
int mib[4] = { CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME };
|
|
#else
|
|
int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
|
|
#endif
|
|
|
|
size_t size = sizeof(buffer1);
|
|
|
|
if(sysctl(mib, 4, path, &size, NULL, 0) != 0)
|
|
break;
|
|
|
|
resolved = realpath(path, buffer2);
|
|
if(!resolved)
|
|
break;
|
|
|
|
length = (int) strlen(resolved);
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ok? length: -1;
|
|
}
|
|
#endif
|
|
|
|
WAI_NOINLINE WAI_FUNCSPEC int WAI_PREFIX(getModulePath) (char *out, int capacity, int *dirname_length) {
|
|
char buffer[PATH_MAX];
|
|
char *resolved = NULL;
|
|
int length = -1;
|
|
|
|
for(;;) {
|
|
Dl_info info;
|
|
|
|
if(dladdr(WAI_RETURN_ADDRESS(), &info)) {
|
|
resolved = realpath(info.dli_fname, buffer);
|
|
if(!resolved)
|
|
break;
|
|
|
|
length = (int) strlen(resolved);
|
|
if(length <= capacity) {
|
|
memcpy(out, resolved, length);
|
|
|
|
if(dirname_length) {
|
|
int i;
|
|
|
|
for(i = length - 1; i >= 0; --i) {
|
|
if(out[i] == '/') {
|
|
*dirname_length = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
#else
|
|
|
|
WAI_FUNCSPEC int WAI_PREFIX(getExecutablePath)(char *out, int capacity, int *dirname_length) {
|
|
if(dirname_length)
|
|
*dirname_length = -1;
|
|
return -1;
|
|
}
|
|
|
|
WAI_NOINLINE WAI_FUNCSPEC int WAI_PREFIX(getModulePath)(char *out, int capacity, int *dirname_length) {
|
|
if(dirname_length)
|
|
*dirname_length = -1;
|
|
return -1;
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|