tools.h File Reference

#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <fcntl.h>
#include <time.h>
#include <errno.h>
#include <spawn.h>
#include <sys/wait.h>
#include <unistd.h>

Include dependency graph for tools.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	target
struct	strarray
struct	long_option

Macros
#define	O_BINARY   0
#define	__int64   long long
#define	__attribute__(x)
#define	max(a, b)   (((a) > (b)) ? (a) : (b))
#define	min(a, b)   (((a) < (b)) ? (a) : (b))
#define	ARRAY_SIZE(x)   (sizeof(x) / sizeof((x)[0]))
#define	OPT_ERR(fmt)   { callback( '?', strmake( fmt, argv[i] )); continue; }

Functions
static void *	xmalloc (size_t size)
static void *	xrealloc (void *ptr, size_t size)
static char *	xstrdup (const char *str)
static int	strendswith (const char *str, const char *end)
static char *	strmake (const char *fmt,...) __attribute__((__format__(__printf__
static void	strarray_add (struct strarray *array, const char *str)
static void	strarray_addall (struct strarray *array, struct strarray added)
static int	strarray_exists (const struct strarray *array, const char *str)
static void	strarray_add_uniq (struct strarray *array, const char *str)
static void	strarray_addall_uniq (struct strarray *array, struct strarray added)
static struct strarray	strarray_fromstring (const char *str, const char *delim)
static struct strarray	strarray_frompath (const char *path)
static char *	strarray_tostring (struct strarray array, const char *sep)
static void	strarray_qsort (struct strarray *array, int(*func)(const char **, const char **))
static const char *	strarray_bsearch (const struct strarray *array, const char *str, int(*func)(const char **, const char **))
static void	strarray_trace (struct strarray args)
static int	strarray_spawn (struct strarray args)
static char *	get_basename (const char *file)
static char *	get_basename_noext (const char *file)
static char *	get_dirname (const char *file)
static char *	replace_extension (const char *name, const char *old_ext, const char *new_ext)
static char *	build_relative_path (const char *base, const char *from, const char *dest)
static char *	make_temp_dir (void)
static char *	make_temp_file (const char *prefix, const char *suffix)
static void	remove_temp_files (void)
static void	init_signals (void(*cleanup)(int))
static void *	read_file (const char *name, size_t *size)
static struct target	get_default_target (void)
static unsigned int	get_target_ptr_size (struct target target)
static void	set_target_ptr_size (struct target *target, unsigned int size)
static int	get_cpu_from_name (const char *name)
static int	get_platform_from_name (const char *name)
static const char *	get_arch_dir (struct target target)
static int	parse_target (const char *name, struct target *target)
static struct target	init_argv0_target (const char *argv0)
static char *	get_bindir (const char *argv0)
static const char *	get_nlsdir (const char *bindir, const char *srcdir)
static void	check_output_buffer_space (size_t size)
static void	init_output_buffer (void)
static void	put_data (const void *data, size_t size)
static void	put_byte (unsigned char val)
static void	put_word (unsigned short val)
static void	put_dword (unsigned int val)
static void	put_qword (unsigned int val)
static void	align_output (unsigned int align)
static void	flush_output_buffer (const char *name)
static struct strarray	parse_options (int argc, char **argv, const char *short_opts, const struct long_option *long_opts, int long_only, void(*callback)(int, char *))

Variables
char **	environ
static const struct strarray	empty_strarray
const char *	temp_dir
struct strarray	temp_files
unsigned char *	output_buffer
size_t	output_buffer_pos
size_t	output_buffer_size

Macro Definition Documentation

__attribute__

#define __attribute__

(

x

)

Definition at line 84 of file tools.h.

__int64

#define __int64   long long

Definition at line 78 of file tools.h.

ARRAY_SIZE

#define ARRAY_SIZE

(

x

)

(sizeof(x) / sizeof((x)[0]))

Definition at line 95 of file tools.h.

max

#define max	(		a,
			b
	)		(((a) > (b)) ? (a) : (b))

Definition at line 88 of file tools.h.

min

#define min	(		a,
			b
	)		(((a) < (b)) ? (a) : (b))

Definition at line 91 of file tools.h.

O_BINARY

#define O_BINARY   0

Definition at line 72 of file tools.h.

OPT_ERR

#define OPT_ERR

(

fmt

)

{ callback( '?', strmake( fmt, argv[i] )); continue; }

Function Documentation

align_output()

static void align_output ( unsigned int  align )

inlinestatic

Definition at line 833 of file tools.h.

{
    size_t size = align - (output_buffer_pos % align);
 
    if (size == align) return;
    check_output_buffer_space( size );
    memset( output_buffer + output_buffer_pos, 0, size );
    output_buffer_pos += size;
}

Referenced by add_output_to_resources().

build_relative_path()

static char * build_relative_path ( const char *  base, const char *  from, const char *  dest  )

inlinestatic

Definition at line 337 of file tools.h.

{
    const char *start;
    char *ret;
    unsigned int dotdots = 0;
 
    for (;;)
    {
        while (*from == '/') from++;
        while (*dest == '/') dest++;
        start = dest;  /* save start of next path element */
        if (!*from) break;
 
        while (*from && *from != '/' && *from == *dest) { from++; dest++; }
        if ((!*from || *from == '/') && (!*dest || *dest == '/')) continue;
 
        do  /* count remaining elements in 'from' */
        {
            dotdots++;
            while (*from && *from != '/') from++;
            while (*from == '/') from++;
        }
        while (*from);
        break;
    }
 
    ret = xmalloc( strlen(base) + 3 * dotdots + strlen(start) + 2 );
    strcpy( ret, base );
    while (dotdots--) strcat( ret, "/.." );
 
    if (!start[0]) return ret;
    strcat( ret, "/" );
    strcat( ret, start );
    return ret;
}

check_output_buffer_space()

static void check_output_buffer_space ( size_t  size )

inlinestatic

Definition at line 782 of file tools.h.

{
    if (output_buffer_pos + size >= output_buffer_size)
    {
        output_buffer_size = max( output_buffer_size * 2, output_buffer_pos + size );
        output_buffer = xrealloc( output_buffer, output_buffer_size );
    }
}

Referenced by add_output_to_resources(), align_output(), put_byte(), put_data(), put_dword(), put_str(), and put_word().

flush_output_buffer()

static void flush_output_buffer ( const char *  name )

inlinestatic

Definition at line 843 of file tools.h.

{
    int fd = open( name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666 );
 
    if (fd == -1 || write( fd, output_buffer, output_buffer_pos ) != output_buffer_pos)
    {
        perror( name );
        exit(1);
    }
    close( fd );
    free( output_buffer );
}

get_arch_dir()

static const char * get_arch_dir ( struct target  target )

inlinestatic

Definition at line 616 of file tools.h.

{
    static const char *cpu_names[] =
    {
        [CPU_i386]    = "i386",
        [CPU_x86_64]  = "x86_64",
        [CPU_ARM]     = "arm",
        [CPU_ARM64]   = "aarch64",
        [CPU_ARM64EC] = "aarch64",
    };
 
    if (!cpu_names[target.cpu]) return "";
 
    switch (target.platform)
    {
    case PLATFORM_WINDOWS:
    case PLATFORM_CYGWIN:
    case PLATFORM_MINGW:
        return strmake( "/%s-windows", cpu_names[target.cpu] );
    default:
        return strmake( "/%s-unix", cpu_names[target.cpu] );
    }
}

Referenced by open_typelib().

get_basename()

static char * get_basename ( const char *  file )

inlinestatic

Definition at line 307 of file tools.h.

{
    const char *ret = strrchr( file, '/' );
    return xstrdup( ret ? ret + 1 : file );
}

Referenced by dup_basename_token(), get_basename_noext(), init_argv0_target(), main(), make_token(), write_dlldata(), and write_import().

get_basename_noext()

static char * get_basename_noext ( const char *  file )

inlinestatic

Definition at line 313 of file tools.h.

{
    char *ext, *ret = get_basename( file );
    if ((ext = strrchr( ret, '.' ))) *ext = 0;
    return ret;
}

Referenced by make_temp_file().

get_bindir()

static char * get_bindir ( const char *  argv0 )

inlinestatic

Definition at line 702 of file tools.h.

{
#ifdef __REACTOS__
    return NULL;
#else
#ifndef _WIN32
    char *dir = NULL;
 
#if defined(__linux__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) \
        || defined(__CYGWIN__) || defined(__MSYS__)
    dir = realpath( "/proc/self/exe", NULL );
#elif defined (__FreeBSD__) || defined(__DragonFly__)
    static int pathname[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
    size_t path_size = PATH_MAX;
    char *path = xmalloc( path_size );
    if (!sysctl( pathname, ARRAY_SIZE(pathname), path, &path_size, NULL, 0 ))
        dir = realpath( path, NULL );
    free( path );
#endif
    if (!dir && !(dir = realpath( argv0, NULL ))) return NULL;
    return get_dirname( dir );
#else
    char path[MAX_PATH], *p;
    GetModuleFileNameA( NULL, path, ARRAYSIZE(path) );
    for (p = path; *p; p++) if (*p == '\\') *p = '/';
    return get_dirname( path );
#endif
#endif
}

Referenced by main().

get_cpu_from_name()

static int get_cpu_from_name ( const char *  name )

inlinestatic

Definition at line 559 of file tools.h.

{
    static const struct
    {
        const char *name;
        int         cpu;
    } cpu_names[] =
    {
        { "i386",      CPU_i386 },
        { "i486",      CPU_i386 },
        { "i586",      CPU_i386 },
        { "i686",      CPU_i386 },
        { "i786",      CPU_i386 },
        { "x86_64",    CPU_x86_64 },
        { "amd64",     CPU_x86_64 },
        { "aarch64",   CPU_ARM64 },
        { "arm64ec",   CPU_ARM64EC },
        { "arm64",     CPU_ARM64 },
        { "arm",       CPU_ARM },
    };
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(cpu_names); i++)
        if (!strncmp( cpu_names[i].name, name, strlen(cpu_names[i].name) )) return cpu_names[i].cpu;
    return -1;
}

Referenced by parse_target().

get_default_target()

static struct target get_default_target ( void  )

inlinestatic

Definition at line 487 of file tools.h.

{
    struct target target;
#ifdef __i386__
    target.cpu = CPU_i386;
#elif defined(__x86_64__)
    target.cpu = CPU_x86_64;
#elif defined(__arm__)
    target.cpu = CPU_ARM;
#elif defined(__aarch64__)
    target.cpu = CPU_ARM64;
#else
#error Unsupported CPU
#endif
 
#ifdef __APPLE__
    target.platform = PLATFORM_APPLE;
#elif defined(__ANDROID__)
    target.platform = PLATFORM_ANDROID;
#elif defined(__linux__)
    target.platform = PLATFORM_LINUX;
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
    target.platform = PLATFORM_FREEBSD;
#elif defined(__sun)
    target.platform = PLATFORM_SOLARIS;
#elif defined(__CYGWIN__)
    target.platform = PLATFORM_CYGWIN;
#elif defined(_WIN32)
    target.platform = PLATFORM_MINGW;
#else
    target.platform = PLATFORM_UNSPECIFIED;
#endif
 
    return target;
}

Referenced by init_argv0_target().

get_dirname()

static char * get_dirname ( const char *  file )

inlinestatic

Definition at line 320 of file tools.h.

{
    const char *end = strrchr( file, '/' );
    if (!end) return xstrdup( "." );
    if (end == file) end++;
    return strmake( "%.*s", (int)(end - file), file );
}

Referenced by get_bindir(), and wpp_lookup().

get_nlsdir()

static const char * get_nlsdir ( const char *  bindir, const char *  srcdir  )

inlinestatic

Definition at line 762 of file tools.h.

{
    if (bindir && strendswith( bindir, srcdir )) return strmake( "%s/../../nls", bindir );
#ifdef DATADIR
    else
    {
        const char *datadir = get_datadir( bindir );
        if (datadir) return strmake( "%s/wine/nls", datadir );
    }
#endif
    return NULL;
}

get_platform_from_name()

static int get_platform_from_name ( const char *  name )

inlinestatic

Definition at line 587 of file tools.h.

{
    static const struct
    {
        const char *name;
        int         platform;
    } platform_names[] =
    {
        { "macos",       PLATFORM_APPLE },
        { "darwin",      PLATFORM_APPLE },
        { "android",     PLATFORM_ANDROID },
        { "linux",       PLATFORM_LINUX },
        { "freebsd",     PLATFORM_FREEBSD },
        { "solaris",     PLATFORM_SOLARIS },
        { "mingw32",     PLATFORM_MINGW },
        { "windows-gnu", PLATFORM_MINGW },
        { "winnt",       PLATFORM_MINGW },
        { "windows",     PLATFORM_WINDOWS },
        { "cygwin",      PLATFORM_CYGWIN },
    };
    unsigned int i;
 
    for (i = 0; i < ARRAY_SIZE(platform_names); i++)
        if (!strncmp( platform_names[i].name, name, strlen(platform_names[i].name) ))
            return platform_names[i].platform;
    return -1;
};

Referenced by parse_target().

get_target_ptr_size()

static unsigned int get_target_ptr_size ( struct target  target )

inlinestatic

Definition at line 524 of file tools.h.

{
    static const unsigned int sizes[] =
    {
        [CPU_i386]      = 4,
        [CPU_x86_64]    = 8,
        [CPU_ARM]       = 4,
        [CPU_ARM64]     = 8,
        [CPU_ARM64EC]   = 8,
    };
    return sizes[target.cpu];
}

Referenced by main().

init_argv0_target()

static struct target init_argv0_target ( const char *  argv0 )

inlinestatic

Definition at line 689 of file tools.h.

{
    char *name = get_basename( argv0 );
    struct target target;
 
    if (!strchr( name, '-' ) || !parse_target( name, &target ))
        target = get_default_target();
 
    free( name );
    return target;
}

Referenced by main().

init_output_buffer()

static void init_output_buffer ( void  )

inlinestatic

Definition at line 791 of file tools.h.

{
    output_buffer_size = 1024;
    output_buffer_pos = 0;
    output_buffer = xmalloc( output_buffer_size );
}

Referenced by add_output_to_resources(), create_writer_output(), MXWriter_create(), save_all_changes(), and write_regscript().

init_signals()

static void init_signals ( void(*)(int)  cleanup )

inlinestatic

Definition at line 455 of file tools.h.

{
    signal( SIGTERM, cleanup );
    signal( SIGINT, cleanup );
#ifdef SIGHUP
    signal( SIGHUP, cleanup );
#endif
}

Referenced by main().

make_temp_dir()

static char * make_temp_dir ( void  )

inlinestatic

Definition at line 378 of file tools.h.

{
    unsigned int value = time(NULL) + getpid();
    int count;
    char *name;
    const char *tmpdir = NULL;
 
    for (count = 0; count < 0x8000; count++)
    {
        if (tmpdir)
            name = strmake( "%s/tmp%08x", tmpdir, value );
        else
            name = strmake( "tmp%08x", value );
        if (!mkdir( name, 0700 )) return name;
        value += 7777;
        if (errno == EACCES && !tmpdir)
        {
#if defined(__REACTOS__) && defined(_WIN32)
            if (!(tmpdir = getenv("TEMP"))) tmpdir = "temp";
#else
            if (!(tmpdir = getenv("TMPDIR"))) tmpdir = "/tmp";
#endif
        }
        free( name );
    }
    fprintf( stderr, "failed to create directory for temp files\n" );
    exit(1);
}

Referenced by make_temp_file().

make_temp_file()

static char * make_temp_file ( const char *  prefix, const char *  suffix  )

inlinestatic

Definition at line 407 of file tools.h.

{
    static unsigned int value;
    int fd, count;
    char *name;
 
    if (!temp_dir) temp_dir = make_temp_dir();
    if (!suffix) suffix = "";
    if (!prefix) prefix = "tmp";
    else prefix = get_basename_noext( prefix );
 
    for (count = 0; count < 0x8000; count++)
    {
        name = strmake( "%s/%s-%08x%s", temp_dir, prefix, value++, suffix );
        fd = open( name, O_RDWR | O_CREAT | O_EXCL, 0600 );
        if (fd >= 0)
        {
#ifdef HAVE_SIGPROCMASK /* block signals while manipulating the temp files list */
            sigset_t mask_set, old_set;
 
            sigemptyset( &mask_set );
            sigaddset( &mask_set, SIGHUP );
            sigaddset( &mask_set, SIGTERM );
            sigaddset( &mask_set, SIGINT );
            sigprocmask( SIG_BLOCK, &mask_set, &old_set );
            strarray_add( &temp_files, name );
            sigprocmask( SIG_SETMASK, &old_set, NULL );
#else
            strarray_add( &temp_files, name );
#endif
            close( fd );
            return name;
        }
        free( name );
    }
    fprintf( stderr, "failed to create temp file for %s%s in %s\n", prefix, suffix, temp_dir );
    exit(1);
}

Referenced by open_input_file().

parse_options()

static struct strarray parse_options ( int  argc, char **  argv, const char *  short_opts, const struct long_option *  long_opts, int  long_only, void(*)(int, char *)  callback  )

inlinestatic

Definition at line 866 of file tools.h.

{
    struct strarray ret = empty_strarray;
    const char *flag;
    char *start, *end;
    int i;
 
#define OPT_ERR(fmt) { callback( '?', strmake( fmt, argv[i] )); continue; }
 
    for (i = 1; i < argc; i++)
    {
        if (argv[i][0] != '-' || !argv[i][1])  /* not an option */
        {
            strarray_add( &ret, argv[i] );
            continue;
        }
        if (!strcmp( argv[i], "--" ))
        {
            /* add remaining args */
            while (++i < argc) strarray_add( &ret, argv[i] );
            break;
        }
        start = argv[i] + 1 + (argv[i][1] == '-');
 
        if (argv[i][1] == '-' || (long_only && (argv[i][2] || !strchr( short_opts, argv[i][1] ))))
        {
            /* handle long option */
            const struct long_option *opt, *found = NULL;
            int count = 0;
 
            if (!(end = strchr( start, '=' ))) end = start + strlen(start);
            for (opt = long_opts; opt && opt->name; opt++)
            {
                if (strncmp( opt->name, start, end - start )) continue;
                if (!opt->name[end - start])  /* exact match */
                {
                    found = opt;
                    count = 1;
                    break;
                }
                if (!found)
                {
                    found = opt;
                    count++;
                }
                else if (long_only || found->has_arg != opt->has_arg || found->val != opt->val)
                {
                    count++;
                }
            }
 
            if (count > 1) OPT_ERR( "option '%s' is ambiguous" );
 
            if (found)
            {
                if (*end)
                {
                    if (!found->has_arg) OPT_ERR( "argument not allowed in '%s'" );
                    end++;  /* skip '=' */
                }
                else if (found->has_arg == 1)
                {
                    if (i == argc - 1) OPT_ERR( "option '%s' requires an argument" );
                    end = argv[++i];
                }
                else end = NULL;
 
                callback( found->val, end );
                continue;
            }
            if (argv[i][1] == '-' || !long_only || !strchr( short_opts, argv[i][1] ))
                OPT_ERR( "unrecognized option '%s'" );
        }
 
        /* handle short option */
        for ( ; *start; start++)
        {
            if (!(flag = strchr( short_opts, *start ))) OPT_ERR( "invalid option '%s'" );
            if (flag[1] == ':')
            {
                end = start + 1;
                if (!*end) end = NULL;
                if (flag[2] != ':' && !end)
                {
                    if (i == argc - 1) OPT_ERR( "option '%s' requires an argument" );
                    end = argv[++i];
                }
                callback( *start, end );
                break;
            }
            callback( *start, NULL );
        }
    }
    return ret;
#undef OPT_ERR
}

parse_target()

static int parse_target ( const char *  name, struct target *  target  )

inlinestatic

Definition at line 640 of file tools.h.

{
    int res;
    char *p, *spec = xstrdup( name );
 
    /* target specification is in the form CPU-MANUFACTURER-OS or CPU-MANUFACTURER-KERNEL-OS */
 
    /* get the CPU part */
 
    if ((p = strchr( spec, '-' )))
    {
        *p++ = 0;
        if ((res = get_cpu_from_name( spec )) == -1)
        {
            free( spec );
            return 0;
        }
        target->cpu = res;
    }
    else if (!strcmp( spec, "mingw32" ))
    {
        target->cpu = CPU_i386;
        p = spec;
    }
    else
    {
        free( spec );
        return 0;
    }
 
    /* get the OS part */
 
    target->platform = PLATFORM_UNSPECIFIED;  /* default value */
    for (;;)
    {
        if ((res = get_platform_from_name( p )) != -1)
        {
            target->platform = res;
            break;
        }
        if (!(p = strchr( p, '-' ))) break;
        p++;
    }
 
    free( spec );
    return 1;
}

Referenced by init_argv0_target(), and option_callback().

put_byte()

static void put_byte ( unsigned char  val )

inlinestatic

Definition at line 805 of file tools.h.

{
    check_output_buffer_space( 1 );
    output_buffer[output_buffer_pos++] = val;
}

put_data()

static void put_data ( const void *  data, size_t  size  )

inlinestatic

Definition at line 798 of file tools.h.

{
    check_output_buffer_space( size );
    memcpy( output_buffer + output_buffer_pos, data, size );
    output_buffer_pos += size;
}

Referenced by ctl2_write_segment(), ctl2_write_typeinfos(), flush_output_resources(), save_all_changes(), sltg_write_header(), sltg_write_helpstrings(), sltg_write_nametable(), sltg_write_remainder(), and sltg_write_typeinfo().

put_dword()

static void put_dword ( unsigned int  val )

inlinestatic

Definition at line 818 of file tools.h.

{
    check_output_buffer_space( 4 );
    output_buffer[output_buffer_pos++] = val;
    output_buffer[output_buffer_pos++] = val >> 8;
    output_buffer[output_buffer_pos++] = val >> 16;
    output_buffer[output_buffer_pos++] = val >> 24;
}

Referenced by put_qword().

put_qword()

static void put_qword ( unsigned int  val )

inlinestatic

Definition at line 827 of file tools.h.

{
    put_dword( val );
    put_dword( 0 );
}

Referenced by put_pword().

put_word()

static void put_word ( unsigned short  val )

inlinestatic

Definition at line 811 of file tools.h.

{
    check_output_buffer_space( 2 );
    output_buffer[output_buffer_pos++] = val;
    output_buffer[output_buffer_pos++] = val >> 8;
}

Referenced by add_output_to_resources(), flush_output_resources(), and put_resource_id().

read_file()

static void * read_file ( const char *  name, size_t *  size  )

inlinestatic

Definition at line 465 of file tools.h.

{
    struct stat st;
    int res, fd;
    void *data;
 
    if ((fd = open( name, O_RDONLY | O_BINARY )) == -1) return NULL;
    fstat( fd, &st );
    data = xmalloc( st.st_size );
    res = read( fd, data, st.st_size );
    if (res == -1)
    {
        free( data );
        data = NULL;
        *size = 0;
    }
    else *size = res;
    close( fd );
    return data;
}

remove_temp_files()

static void remove_temp_files ( void  )

inlinestatic

Definition at line 446 of file tools.h.

{
    unsigned int i;
 
    for (i = 0; i < temp_files.count; i++) if (temp_files.str[i]) unlink( temp_files.str[i] );
    if (temp_dir) rmdir( temp_dir );
}

Referenced by rm_tempfile().

replace_extension()

static char * replace_extension ( const char *  name, const char *  old_ext, const char *  new_ext  )

inlinestatic

Definition at line 328 of file tools.h.

{
    int name_len = strlen( name );
 
    if (strendswith( name, old_ext )) name_len -= strlen( old_ext );
    return strmake( "%.*s%s", name_len, name, new_ext );
}

Referenced by dup_basename_token(), main(), write_dlldata(), and write_import().

set_target_ptr_size()

static void set_target_ptr_size ( struct target *  target, unsigned int  size  )

inlinestatic

Definition at line 538 of file tools.h.

{
    switch (target->cpu)
    {
    case CPU_i386:
        if (size == 8) target->cpu = CPU_x86_64;
        break;
    case CPU_x86_64:
        if (size == 4) target->cpu = CPU_i386;
        break;
    case CPU_ARM:
        if (size == 8) target->cpu = CPU_ARM64;
        break;
    case CPU_ARM64:
    case CPU_ARM64EC:
        if (size == 4) target->cpu = CPU_ARM;
        break;
    }
}

Referenced by main().

strarray_add()

static void strarray_add ( struct strarray *  array, const char *  str  )

inlinestatic

Definition at line 183 of file tools.h.

{
    if (array->count == array->size)
    {
    if (array->size) array->size *= 2;
        else array->size = 16;
    array->str = xrealloc( array->str, sizeof(array->str[0]) * array->size );
    }
    array->str[array->count++] = str;
}

Referenced by main(), make_temp_file(), option_callback(), parse_options(), strarray_add_uniq(), strarray_addall(), strarray_fromstring(), strarray_spawn(), wpp_add_include_path(), and write_dlldata().

strarray_add_uniq()

static void strarray_add_uniq ( struct strarray *  array, const char *  str  )

inlinestatic

Definition at line 209 of file tools.h.

{
    if (!strarray_exists( array, str )) strarray_add( array, str );
}

Referenced by strarray_addall_uniq().

strarray_addall()

static void strarray_addall ( struct strarray *  array, struct strarray  added  )

inlinestatic

Definition at line 194 of file tools.h.

{
    unsigned int i;
 
    for (i = 0; i < added.count; i++) strarray_add( array, added.str[i] );
}

strarray_addall_uniq()

static void strarray_addall_uniq ( struct strarray *  array, struct strarray  added  )

inlinestatic

Definition at line 214 of file tools.h.

{
    unsigned int i;
 
    for (i = 0; i < added.count; i++) strarray_add_uniq( array, added.str[i] );
}

strarray_bsearch()

static const char * strarray_bsearch ( const struct strarray *  array, const char *  str, int(*)(const char **, const char **)  func  )

inlinestatic

Definition at line 265 of file tools.h.

{
    char **res = NULL;
 
    if (array->count) res = bsearch( &str, array->str, array->count, sizeof(*array->str), (void *)func );
    return res ? *res : NULL;
}

strarray_exists()

static int strarray_exists ( const struct strarray *  array, const char *  str  )

inlinestatic

Definition at line 201 of file tools.h.

{
    unsigned int i;
 
    for (i = 0; i < array->count; i++) if (!strcmp( array->str[i], str )) return 1;
    return 0;
}

Referenced by strarray_add_uniq(), and write_dlldata().

strarray_frompath()

static struct strarray strarray_frompath ( const char *  path )

inlinestatic

Definition at line 233 of file tools.h.

{
    if (!path) return empty_strarray;
#ifdef _WIN32
    return strarray_fromstring( path, ";" );
#else
    return strarray_fromstring( path, ":" );
#endif
}

strarray_fromstring()

static struct strarray strarray_fromstring ( const char *  str, const char *  delim  )

inlinestatic

Definition at line 221 of file tools.h.

{
    struct strarray array = empty_strarray;
    char *buf = xstrdup( str );
    const char *tok;
 
    for (tok = strtok( buf, delim ); tok; tok = strtok( NULL, delim ))
        strarray_add( &array, xstrdup( tok ));
    free( buf );
    return array;
}

Referenced by strarray_frompath().

strarray_qsort()

static void strarray_qsort ( struct strarray *  array, int(*)(const char **, const char **)  func  )

inlinestatic

Definition at line 260 of file tools.h.

{
    if (array->count) qsort( array->str, array->count, sizeof(*array->str), (void *)func );
}

strarray_spawn()

static int strarray_spawn ( struct strarray  args )

inlinestatic

Definition at line 286 of file tools.h.

{
#ifdef _WIN32
    strarray_add( &args, NULL );
    return _spawnvp( _P_WAIT, args.str[0], args.str );
#else
    pid_t pid, wret;
    int status;
 
    strarray_add( &args, NULL );
    if (posix_spawnp( &pid, args.str[0], NULL, NULL, (char **)args.str, environ ))
        return -1;
 
    while (pid != (wret = waitpid( pid, &status, 0 )))
        if (wret == -1 && errno != EINTR) break;
 
    if (pid == wret && WIFEXITED(status)) return WEXITSTATUS(status);
    return 255; /* abnormal exit with an abort or an interrupt */
#endif
}

strarray_tostring()

static char * strarray_tostring ( struct strarray  array, const char *  sep  )

inlinestatic

Definition at line 243 of file tools.h.

{
    char *str;
    unsigned int i, len = 1 + (array.count - 1) * strlen(sep);
 
    if (!array.count) return xstrdup("");
    for (i = 0; i < array.count; i++) len += strlen( array.str[i] );
    str = xmalloc( len );
    strcpy( str, array.str[0] );
    for (i = 1; i < array.count; i++)
    {
        strcat( str, sep );
        strcat( str, array.str[i] );
    }
    return str;
}

strarray_trace()

static void strarray_trace ( struct strarray  args )

inlinestatic

Definition at line 274 of file tools.h.

{
    unsigned int i;
 
    for (i = 0; i < args.count; i++)
    {
        if (strpbrk( args.str[i], " \t\n\r")) printf( "\"%s\"", args.str[i] );
        else printf( "%s", args.str[i] );
        putchar( i < args.count - 1 ? ' ' : '\n' );
    }
}

strendswith()

static int strendswith ( const char *  str, const char *  end  )

inlinestatic

Definition at line 145 of file tools.h.

{
    int l = strlen( str );
    int m = strlen( end );
    return l >= m && !strcmp( str + l - m, end );
}

Referenced by get_nlsdir(), main(), open_typelib(), read_importlib(), replace_extension(), save_all_changes(), write_import(), write_regscript(), and write_typelib_regscript().

strmake()

static char static char * strmake ( const char *  fmt,   ...  )

inlinestatic

Definition at line 153 of file tools.h.

{
    int n;
    size_t size = 100;
    va_list ap;
 
    for (;;)
    {
        char *p = xmalloc( size );
        va_start( ap, fmt );
    n = vsnprintf( p, size, fmt, ap );
    va_end( ap );
        if (n == -1) size *= 2;
        else if ((size_t)n >= size) size = n + 1;
        else return p;
        free( p );
    }
}

Referenced by get_arch_dir(), get_dirname(), get_nlsdir(), make_temp_dir(), make_temp_file(), and replace_extension().

xmalloc()

static void * xmalloc ( size_t  size )

inlinestatic

Definition at line 116 of file tools.h.

{
    void *res = malloc( size ? size : 1 );
 
    if (res == NULL)
    {
        fprintf( stderr, "Virtual memory exhausted.\n" );
        exit(1);
    }
    return res;
}

Referenced by build_relative_path(), get_bindir(), init_output_buffer(), read_file(), strarray_tostring(), strmake(), and xstrdup().

xrealloc()

static void * xrealloc ( void *  ptr, size_t  size  )

inlinestatic

Definition at line 128 of file tools.h.

{
    void *res = realloc( ptr, size );
 
    if (size && res == NULL)
    {
        fprintf( stderr, "Virtual memory exhausted.\n" );
        exit(1);
    }
    return res;
}

Referenced by check_output_buffer_space(), and strarray_add().

xstrdup()

static char * xstrdup ( const char *  str )

inlinestatic

Definition at line 140 of file tools.h.

{
    return strcpy( xmalloc( strlen(str)+1 ), str );
}

Referenced by get_basename(), get_dirname(), parse_target(), strarray_fromstring(), and strarray_tostring().

Variable Documentation

empty_strarray

const struct strarray empty_strarray

static

Definition at line 181 of file tools.h.

Referenced by main(), parse_options(), strarray_frompath(), strarray_fromstring(), and write_dlldata().

environ

char** environ

extern

Referenced by strarray_spawn().

output_buffer

unsigned char* output_buffer

extern

Definition at line 163 of file utils.c.

Referenced by add_output_to_resources().

output_buffer_pos

size_t output_buffer_pos

extern

Definition at line 164 of file utils.c.

Referenced by add_output_to_resources(), align_output(), check_output_buffer_space(), flush_output_buffer(), flush_output_resources(), init_output_buffer(), put_byte(), put_data(), put_dword(), put_str(), put_word(), save_all_changes(), sltg_write_header(), and write_regscript().

output_buffer_size

size_t output_buffer_size

extern

Definition at line 165 of file utils.c.

Referenced by check_output_buffer_space(), init_output_buffer(), and put_str().

temp_dir

const char* temp_dir

extern

Definition at line 134 of file widl.c.

Referenced by create_file(), make_temp_file(), and remove_temp_files().

temp_files

struct strarray temp_files

extern

Definition at line 133 of file widl.c.

Referenced by make_temp_file(), and remove_temp_files().