tools/tools.h

   1 /*
   2  * Helper functions for the Wine tools
   3  *
   4  * Copyright 2021 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifndef __WINE_TOOLS_H
  22 #define __WINE_TOOLS_H
  23
  24 #ifndef __WINE_CONFIG_H
  25 # error You must include config.h to use this header
  26 #endif
  27
  28 #include <limits.h>
  29 #include <stdarg.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <signal.h>
  36 #include <fcntl.h>
  37 #include <time.h>
  38 #include <errno.h>
  39 #ifdef HAVE_SYS_SYSCTL_H
  40 # include <sys/sysctl.h>
  41 #endif
  42
  43 #ifdef _WIN32
  44 # include <direct.h>
  45 # include <io.h>
  46 # include <process.h>
  47 # define mkdir(path,mode) mkdir(path)
  48 # ifndef S_ISREG
  49 #  define S_ISREG(mod) (((mod) & _S_IFMT) == _S_IFREG)
  50 # endif
  51 # ifdef _MSC_VER
  52 #  define popen _popen
  53 #  define pclose _pclose
  54 #  define strtoll _strtoi64
  55 #  define strtoull _strtoui64
  56 #  define strncasecmp _strnicmp
  57 #  define strcasecmp _stricmp
  58 # endif
  59 #else
  60 # include <sys/wait.h>
  61 # include <unistd.h>
  62 # ifndef O_BINARY
  63 #  define O_BINARY 0
  64 # endif
  65 # ifndef __int64
  66 #   if defined(__x86_64__) || defined(__aarch64__) || defined(__powerpc64__)
  67 #     define __int64 long
  68 #   else
  69 #     define __int64 long long
  70 #   endif
  71 # endif
  72 #endif
  73
  74 #if !defined(__GNUC__) && !defined(__attribute__)
  75 #define __attribute__(x)
  76 #endif
  77
  78 #ifndef max
  79 #define max(a,b) (((a) > (b)) ? (a) : (b))
  80 #endif
  81 #ifndef min
  82 #define min(a,b) (((a) < (b)) ? (a) : (b))
  83 #endif
  84
  85 #ifndef ARRAY_SIZE
  86 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
  87 #endif
  88
  89 struct target
  90 {
  91     enum { CPU_i386, CPU_x86_64, CPU_ARM, CPU_ARM64 } cpu;
  92
  93     enum
  94     {
  95         PLATFORM_UNSPECIFIED,
  96         PLATFORM_APPLE,
  97         PLATFORM_ANDROID,
  98         PLATFORM_LINUX,
  99         PLATFORM_FREEBSD,
 100         PLATFORM_SOLARIS,
 101         PLATFORM_WINDOWS,
 102         PLATFORM_MINGW,
 103         PLATFORM_CYGWIN
 104     } platform;
 105 };
 106
 107 static inline void *xmalloc( size_t size )
 108 {
 109     void *res = malloc( size ? size : 1 );
 110
 111     if (res == NULL)
 112     {
 113         fprintf( stderr, "Virtual memory exhausted.\n" );
 114         exit(1);
 115     }
 116     return res;
 117 }
 118
 119 static inline void *xrealloc (void *ptr, size_t size)
 120 {
 121     void *res = realloc( ptr, size );
 122
 123     if (size && res == NULL)
 124     {
 125         fprintf( stderr, "Virtual memory exhausted.\n" );
 126         exit(1);
 127     }
 128     return res;
 129 }
 130
 131 static inline char *xstrdup( const char *str )
 132 {
 133     return strcpy( xmalloc( strlen(str)+1 ), str );
 134 }
 135
 136 static inline int strendswith( const char *str, const char *end )
 137 {
 138     int l = strlen( str );
 139     int m = strlen( end );
 140     return l >= m && !strcmp( str + l - m, end );
 141 }
 142
 143 static char *strmake( const char* fmt, ... ) __attribute__ ((__format__ (__printf__, 1, 2)));
 144 static inline char *strmake( const char* fmt, ... )
 145 {
 146     int n;
 147     size_t size = 100;
 148     va_list ap;
 149
 150     for (;;)
 151     {
 152         char *p = xmalloc( size );
 153         va_start( ap, fmt );
 154         n = vsnprintf( p, size, fmt, ap );
 155         va_end( ap );
 156         if (n == -1) size *= 2;
 157         else if ((size_t)n >= size) size = n + 1;
 158         else return p;
 159         free( p );
 160     }
 161 }
 162
 163 /* string array functions */
 164
 165 struct strarray
 166 {
 167     unsigned int count;  /* strings in use */
 168     unsigned int size;   /* total allocated size */
 169     const char **str;
 170 };
 171
 172 static const struct strarray empty_strarray;
 173
 174 static inline void strarray_add( struct strarray *array, const char *str )
 175 {
 176     if (array->count == array->size)
 177     {
 178         if (array->size) array->size *= 2;
 179         else array->size = 16;
 180         array->str = xrealloc( array->str, sizeof(array->str[0]) * array->size );
 181     }
 182     array->str[array->count++] = str;
 183 }
 184
 185 static inline void strarray_addall( struct strarray *array, struct strarray added )
 186 {
 187     unsigned int i;
 188
 189     for (i = 0; i < added.count; i++) strarray_add( array, added.str[i] );
 190 }
 191
 192 static inline int strarray_exists( const struct strarray *array, const char *str )
 193 {
 194     unsigned int i;
 195
 196     for (i = 0; i < array->count; i++) if (!strcmp( array->str[i], str )) return 1;
 197     return 0;
 198 }
 199
 200 static inline void strarray_add_uniq( struct strarray *array, const char *str )
 201 {
 202     if (!strarray_exists( array, str )) strarray_add( array, str );
 203 }
 204
 205 static inline void strarray_addall_uniq( struct strarray *array, struct strarray added )
 206 {
 207     unsigned int i;
 208
 209     for (i = 0; i < added.count; i++) strarray_add_uniq( array, added.str[i] );
 210 }
 211
 212 static inline struct strarray strarray_fromstring( const char *str, const char *delim )
 213 {
 214     struct strarray array = empty_strarray;
 215     char *buf = xstrdup( str );
 216     const char *tok;
 217
 218     for (tok = strtok( buf, delim ); tok; tok = strtok( NULL, delim ))
 219         strarray_add( &array, xstrdup( tok ));
 220     free( buf );
 221     return array;
 222 }
 223
 224 static inline struct strarray strarray_frompath( const char *path )
 225 {
 226     if (!path) return empty_strarray;
 227 #ifdef _WIN32
 228     return strarray_fromstring( path, ";" );
 229 #else
 230     return strarray_fromstring( path, ":" );
 231 #endif
 232 }
 233
 234 static inline char *strarray_tostring( struct strarray array, const char *sep )
 235 {
 236     char *str;
 237     unsigned int i, len = 1 + (array.count - 1) * strlen(sep);
 238
 239     if (!array.count) return xstrdup("");
 240     for (i = 0; i < array.count; i++) len += strlen( array.str[i] );
 241     str = xmalloc( len );
 242     strcpy( str, array.str[0] );
 243     for (i = 1; i < array.count; i++)
 244     {
 245         strcat( str, sep );
 246         strcat( str, array.str[i] );
 247     }
 248     return str;
 249 }
 250
 251 static inline void strarray_qsort( struct strarray *array, int (*func)(const char **, const char **) )
 252 {
 253     if (array->count) qsort( array->str, array->count, sizeof(*array->str), (void *)func );
 254 }
 255
 256 static inline const char *strarray_bsearch( const struct strarray *array, const char *str,
 257                                             int (*func)(const char **, const char **) )
 258 {
 259     char **res = NULL;
 260
 261     if (array->count) res = bsearch( &str, array->str, array->count, sizeof(*array->str), (void *)func );
 262     return res ? *res : NULL;
 263 }
 264
 265 static inline void strarray_trace( struct strarray args )
 266 {
 267     unsigned int i;
 268
 269     for (i = 0; i < args.count; i++)
 270     {
 271         if (strpbrk( args.str[i], " \t\n\r")) printf( "\"%s\"", args.str[i] );
 272         else printf( "%s", args.str[i] );
 273         putchar( i < args.count - 1 ? ' ' : '\n' );
 274     }
 275 }
 276
 277 static inline int strarray_spawn( struct strarray args )
 278 {
 279 #ifdef _WIN32
 280     strarray_add( &args, NULL );
 281     return _spawnvp( _P_WAIT, args.str[0], args.str );
 282 #else
 283     pid_t pid, wret;
 284     int status;
 285
 286     if (!(pid = fork()))
 287     {
 288         strarray_add( &args, NULL );
 289         execvp( args.str[0], (char **)args.str );
 290         _exit(1);
 291     }
 292     if (pid == -1) return -1;
 293
 294     while (pid != (wret = waitpid( pid, &status, 0 )))
 295         if (wret == -1 && errno != EINTR) break;
 296
 297     if (pid == wret && WIFEXITED(status)) return WEXITSTATUS(status);
 298     return 255; /* abnormal exit with an abort or an interrupt */
 299 #endif
 300 }
 301
 302 static inline char *get_basename( const char *file )
 303 {
 304     const char *ret = strrchr( file, '/' );
 305     return xstrdup( ret ? ret + 1 : file );
 306 }
 307
 308 static inline char *get_basename_noext( const char *file )
 309 {
 310     char *ext, *ret = get_basename( file );
 311     if ((ext = strrchr( ret, '.' ))) *ext = 0;
 312     return ret;
 313 }
 314
 315 static inline char *get_dirname( const char *file )
 316 {
 317     const char *end = strrchr( file, '/' );
 318     if (!end) return xstrdup( "." );
 319     if (end == file) end++;
 320     return strmake( "%.*s", (int)(end - file), file );
 321 }
 322
 323 static inline char *replace_extension( const char *name, const char *old_ext, const char *new_ext )
 324 {
 325     int name_len = strlen( name );
 326
 327     if (strendswith( name, old_ext )) name_len -= strlen( old_ext );
 328     return strmake( "%.*s%s", name_len, name, new_ext );
 329 }
 330
 331 /* temp files management */
 332
 333 extern const char *temp_dir;
 334 extern struct strarray temp_files;
 335
 336 static inline char *make_temp_dir(void)
 337 {
 338     unsigned int value = time(NULL) + getpid();
 339     int count;
 340     char *name;
 341     const char *tmpdir = NULL;
 342
 343     for (count = 0; count < 0x8000; count++)
 344     {
 345         if (tmpdir)
 346             name = strmake( "%s/tmp%08x", tmpdir, value );
 347         else
 348             name = strmake( "tmp%08x", value );
 349         if (!mkdir( name, 0700 )) return name;
 350         value += 7777;
 351         if (errno == EACCES && !tmpdir)
 352         {
 353             if (!(tmpdir = getenv("TMPDIR"))) tmpdir = "/tmp";
 354         }
 355         free( name );
 356     }
 357     fprintf( stderr, "failed to create directory for temp files\n" );
 358     exit(1);
 359 }
 360
 361 static inline char *make_temp_file( const char *prefix, const char *suffix )
 362 {
 363     static unsigned int value;
 364     int fd, count;
 365     char *name;
 366
 367     if (!temp_dir) temp_dir = make_temp_dir();
 368     if (!suffix) suffix = "";
 369     if (!prefix) prefix = "tmp";
 370     else prefix = get_basename_noext( prefix );
 371
 372     for (count = 0; count < 0x8000; count++)
 373     {
 374         name = strmake( "%s/%s-%08x%s", temp_dir, prefix, value++, suffix );
 375         fd = open( name, O_RDWR | O_CREAT | O_EXCL, 0600 );
 376         if (fd >= 0)
 377         {
 378 #ifdef HAVE_SIGPROCMASK /* block signals while manipulating the temp files list */
 379             sigset_t mask_set, old_set;
 380
 381             sigemptyset( &mask_set );
 382             sigaddset( &mask_set, SIGHUP );
 383             sigaddset( &mask_set, SIGTERM );
 384             sigaddset( &mask_set, SIGINT );
 385             sigprocmask( SIG_BLOCK, &mask_set, &old_set );
 386             strarray_add( &temp_files, name );
 387             sigprocmask( SIG_SETMASK, &old_set, NULL );
 388 #else
 389             strarray_add( &temp_files, name );
 390 #endif
 391             close( fd );
 392             return name;
 393         }
 394         free( name );
 395     }
 396     fprintf( stderr, "failed to create temp file for %s%s in %s\n", prefix, suffix, temp_dir );
 397     exit(1);
 398 }
 399
 400 static inline void remove_temp_files(void)
 401 {
 402     unsigned int i;
 403
 404     for (i = 0; i < temp_files.count; i++) if (temp_files.str[i]) unlink( temp_files.str[i] );
 405     if (temp_dir) rmdir( temp_dir );
 406 }
 407
 408
 409 static inline void init_signals( void (*cleanup)(int) )
 410 {
 411     signal( SIGTERM, cleanup );
 412     signal( SIGINT, cleanup );
 413 #ifdef SIGHUP
 414     signal( SIGHUP, cleanup );
 415 #endif
 416 }
 417
 418
 419 static inline void *read_file( const char *name, size_t *size )
 420 {
 421     struct stat st;
 422     int res, fd;
 423     void *data;
 424
 425     if ((fd = open( name, O_RDONLY | O_BINARY )) == -1) return NULL;
 426     fstat( fd, &st );
 427     data = xmalloc( st.st_size );
 428     res = read( fd, data, st.st_size );
 429     if (res == -1)
 430     {
 431         free( data );
 432         data = NULL;
 433         *size = 0;
 434     }
 435     else *size = res;
 436     close( fd );
 437     return data;
 438 }
 439
 440
 441 static inline struct target get_default_target(void)
 442 {
 443     struct target target;
 444 #ifdef __i386__
 445     target.cpu = CPU_i386;
 446 #elif defined(__x86_64__)
 447     target.cpu = CPU_x86_64;
 448 #elif defined(__arm__)
 449     target.cpu = CPU_ARM;
 450 #elif defined(__aarch64__)
 451     target.cpu = CPU_ARM64;
 452 #else
 453 #error Unsupported CPU
 454 #endif
 455
 456 #ifdef __APPLE__
 457     target.platform = PLATFORM_APPLE;
 458 #elif defined(__ANDROID__)
 459     target.platform = PLATFORM_ANDROID;
 460 #elif defined(__linux__)
 461     target.platform = PLATFORM_LINUX;
 462 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 463     target.platform = PLATFORM_FREEBSD;
 464 #elif defined(__sun)
 465     target.platform = PLATFORM_SOLARIS;
 466 #elif defined(__CYGWIN__)
 467     target.platform = PLATFORM_CYGWIN;
 468 #elif defined(_WIN32)
 469     target.platform = PLATFORM_MINGW;
 470 #else
 471     target.platform = PLATFORM_UNSPECIFIED;
 472 #endif
 473
 474     return target;
 475 }
 476
 477
 478 static inline unsigned int get_target_ptr_size( struct target target )
 479 {
 480     static const unsigned int sizes[] =
 481     {
 482         [CPU_i386]      = 4,
 483         [CPU_x86_64]    = 8,
 484         [CPU_ARM]       = 4,
 485         [CPU_ARM64]     = 8,
 486     };
 487     return sizes[target.cpu];
 488 }
 489
 490
 491 static inline void set_target_ptr_size( struct target *target, unsigned int size )
 492 {
 493     switch (target->cpu)
 494     {
 495     case CPU_i386:
 496         if (size == 8) target->cpu = CPU_x86_64;
 497         break;
 498     case CPU_x86_64:
 499         if (size == 4) target->cpu = CPU_i386;
 500         break;
 501     case CPU_ARM:
 502         if (size == 8) target->cpu = CPU_ARM64;
 503         break;
 504     case CPU_ARM64:
 505         if (size == 4) target->cpu = CPU_ARM;
 506         break;
 507     }
 508 }
 509
 510
 511 static inline int get_cpu_from_name( const char *name )
 512 {
 513     static const struct
 514     {
 515         const char *name;
 516         int         cpu;
 517     } cpu_names[] =
 518     {
 519         { "i386",      CPU_i386 },
 520         { "i486",      CPU_i386 },
 521         { "i586",      CPU_i386 },
 522         { "i686",      CPU_i386 },
 523         { "i786",      CPU_i386 },
 524         { "x86_64",    CPU_x86_64 },
 525         { "amd64",     CPU_x86_64 },
 526         { "aarch64",   CPU_ARM64 },
 527         { "arm64",     CPU_ARM64 },
 528         { "arm",       CPU_ARM },
 529     };
 530     unsigned int i;
 531
 532     for (i = 0; i < ARRAY_SIZE(cpu_names); i++)
 533         if (!strncmp( cpu_names[i].name, name, strlen(cpu_names[i].name) )) return cpu_names[i].cpu;
 534     return -1;
 535 }
 536
 537
 538 static inline int get_platform_from_name( const char *name )
 539 {
 540     static const struct
 541     {
 542         const char *name;
 543         int         platform;
 544     } platform_names[] =
 545     {
 546         { "macos",       PLATFORM_APPLE },
 547         { "darwin",      PLATFORM_APPLE },
 548         { "android",     PLATFORM_ANDROID },
 549         { "linux",       PLATFORM_LINUX },
 550         { "freebsd",     PLATFORM_FREEBSD },
 551         { "solaris",     PLATFORM_SOLARIS },
 552         { "mingw32",     PLATFORM_MINGW },
 553         { "windows-gnu", PLATFORM_MINGW },
 554         { "winnt",       PLATFORM_MINGW },
 555         { "windows",     PLATFORM_WINDOWS },
 556         { "cygwin",      PLATFORM_CYGWIN },
 557     };
 558     unsigned int i;
 559
 560     for (i = 0; i < ARRAY_SIZE(platform_names); i++)
 561         if (!strncmp( platform_names[i].name, name, strlen(platform_names[i].name) ))
 562             return platform_names[i].platform;
 563     return -1;
 564 };
 565
 566
 567 static inline const char *get_arch_dir( struct target target )
 568 {
 569     static const char *cpu_names[] =
 570     {
 571         [CPU_i386]   = "i386",
 572         [CPU_x86_64] = "x86_64",
 573         [CPU_ARM]    = "arm",
 574         [CPU_ARM64]  = "aarch64"
 575     };
 576
 577     if (!cpu_names[target.cpu]) return "";
 578
 579     switch (target.platform)
 580     {
 581     case PLATFORM_WINDOWS:
 582     case PLATFORM_CYGWIN:
 583     case PLATFORM_MINGW:
 584         return strmake( "/%s-windows", cpu_names[target.cpu] );
 585     default:
 586         return strmake( "/%s-unix", cpu_names[target.cpu] );
 587     }
 588 }
 589
 590 static inline int parse_target( const char *name, struct target *target )
 591 {
 592     int res;
 593     char *p, *spec = xstrdup( name );
 594
 595     /* target specification is in the form CPU-MANUFACTURER-OS or CPU-MANUFACTURER-KERNEL-OS */
 596
 597     /* get the CPU part */
 598
 599     if ((p = strchr( spec, '-' )))
 600     {
 601         *p++ = 0;
 602         if ((res = get_cpu_from_name( spec )) == -1)
 603         {
 604             free( spec );
 605             return 0;
 606         }
 607         target->cpu = res;
 608     }
 609     else if (!strcmp( spec, "mingw32" ))
 610     {
 611         target->cpu = CPU_i386;
 612         p = spec;
 613     }
 614     else
 615     {
 616         free( spec );
 617         return 0;
 618     }
 619
 620     /* get the OS part */
 621
 622     target->platform = PLATFORM_UNSPECIFIED;  /* default value */
 623     for (;;)
 624     {
 625         if ((res = get_platform_from_name( p )) != -1)
 626         {
 627             target->platform = res;
 628             break;
 629         }
 630         if (!(p = strchr( p, '-' ))) break;
 631         p++;
 632     }
 633
 634     free( spec );
 635     return 1;
 636 }
 637
 638
 639 static inline struct target init_argv0_target( const char *argv0 )
 640 {
 641     char *name = get_basename( argv0 );
 642     struct target target;
 643
 644     if (!strchr( name, '-' ) || !parse_target( name, &target ))
 645         target = get_default_target();
 646
 647     free( name );
 648     return target;
 649 }
 650
 651
 652 static inline char *get_argv0_dir( const char *argv0 )
 653 {
 654 #ifndef _WIN32
 655     char *dir = NULL;
 656
 657 #if defined(__linux__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__)
 658     dir = realpath( "/proc/self/exe", NULL );
 659 #elif defined (__FreeBSD__) || defined(__DragonFly__)
 660     static int pathname[] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
 661     size_t path_size = PATH_MAX;
 662     char *path = xmalloc( path_size );
 663     if (!sysctl( pathname, ARRAY_SIZE(pathname), path, &path_size, NULL, 0 ))
 664         dir = realpath( path, NULL );
 665     free( path );
 666 #endif
 667     if (!dir && !(dir = realpath( argv0, NULL ))) return NULL;
 668     return get_dirname( dir );
 669 #else
 670     return get_dirname( argv0 );
 671 #endif
 672 }
 673
 674
 675 /* output buffer management */
 676
 677 extern unsigned char *output_buffer;
 678 extern size_t output_buffer_pos;
 679 extern size_t output_buffer_size;
 680
 681 static inline void check_output_buffer_space( size_t size )
 682 {
 683     if (output_buffer_pos + size >= output_buffer_size)
 684     {
 685         output_buffer_size = max( output_buffer_size * 2, output_buffer_pos + size );
 686         output_buffer = xrealloc( output_buffer, output_buffer_size );
 687     }
 688 }
 689
 690 static inline void init_output_buffer(void)
 691 {
 692     output_buffer_size = 1024;
 693     output_buffer_pos = 0;
 694     output_buffer = xmalloc( output_buffer_size );
 695 }
 696
 697 static inline void put_data( const void *data, size_t size )
 698 {
 699     check_output_buffer_space( size );
 700     memcpy( output_buffer + output_buffer_pos, data, size );
 701     output_buffer_pos += size;
 702 }
 703
 704 static inline void put_byte( unsigned char val )
 705 {
 706     check_output_buffer_space( 1 );
 707     output_buffer[output_buffer_pos++] = val;
 708 }
 709
 710 static inline void put_word( unsigned short val )
 711 {
 712     check_output_buffer_space( 2 );
 713     output_buffer[output_buffer_pos++] = val;
 714     output_buffer[output_buffer_pos++] = val >> 8;
 715 }
 716
 717 static inline void put_dword( unsigned int val )
 718 {
 719     check_output_buffer_space( 4 );
 720     output_buffer[output_buffer_pos++] = val;
 721     output_buffer[output_buffer_pos++] = val >> 8;
 722     output_buffer[output_buffer_pos++] = val >> 16;
 723     output_buffer[output_buffer_pos++] = val >> 24;
 724 }
 725
 726 static inline void put_qword( unsigned int val )
 727 {
 728     put_dword( val );
 729     put_dword( 0 );
 730 }
 731
 732 static inline void align_output( unsigned int align )
 733 {
 734     size_t size = align - (output_buffer_pos % align);
 735
 736     if (size == align) return;
 737     check_output_buffer_space( size );
 738     memset( output_buffer + output_buffer_pos, 0, size );
 739     output_buffer_pos += size;
 740 }
 741
 742 static inline void flush_output_buffer( const char *name )
 743 {
 744     int fd = open( name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666 );
 745
 746     if (fd == -1 || write( fd, output_buffer, output_buffer_pos ) != output_buffer_pos)
 747     {
 748         perror( name );
 749         exit(1);
 750     }
 751     close( fd );
 752     free( output_buffer );
 753 }
 754
 755 /* command-line option parsing */
 756 /* partly based on the Glibc getopt() implementation */
 757
 758 struct long_option
 759 {
 760     const char *name;
 761     int has_arg;
 762     int val;
 763 };
 764
 765 static inline struct strarray parse_options( int argc, char **argv, const char *short_opts,
 766                                              const struct long_option *long_opts, int long_only,
 767                                              void (*callback)( int, char* ) )
 768 {
 769     struct strarray ret = empty_strarray;
 770     const char *flag;
 771     char *start, *end;
 772     int i;
 773
 774 #define OPT_ERR(fmt) { callback( '?', strmake( fmt, argv[1] )); continue; }
 775
 776     for (i = 1; i < argc; i++)
 777     {
 778         if (argv[i][0] != '-' || !argv[i][1])  /* not an option */
 779         {
 780             strarray_add( &ret, argv[i] );
 781             continue;
 782         }
 783         if (!strcmp( argv[i], "--" ))
 784         {
 785             /* add remaining args */
 786             while (++i < argc) strarray_add( &ret, argv[i] );
 787             break;
 788         }
 789         start = argv[i] + 1 + (argv[i][1] == '-');
 790
 791         if (argv[i][1] == '-' || (long_only && (argv[i][2] || !strchr( short_opts, argv[i][1] ))))
 792         {
 793             /* handle long option */
 794             const struct long_option *opt, *found = NULL;
 795             int count = 0;
 796
 797             if (!(end = strchr( start, '=' ))) end = start + strlen(start);
 798             for (opt = long_opts; opt && opt->name; opt++)
 799             {
 800                 if (strncmp( opt->name, start, end - start )) continue;
 801                 if (!opt->name[end - start])  /* exact match */
 802                 {
 803                     found = opt;
 804                     count = 1;
 805                     break;
 806                 }
 807                 if (!found)
 808                 {
 809                     found = opt;
 810                     count++;
 811                 }
 812                 else if (long_only || found->has_arg != opt->has_arg || found->val != opt->val)
 813                 {
 814                     count++;
 815                 }
 816             }
 817
 818             if (count > 1) OPT_ERR( "option '%s' is ambiguous" );
 819
 820             if (found)
 821             {
 822                 if (*end)
 823                 {
 824                     if (!found->has_arg) OPT_ERR( "argument not allowed in '%s'" );
 825                     end++;  /* skip '=' */
 826                 }
 827                 else if (found->has_arg == 1)
 828                 {
 829                     if (i == argc - 1) OPT_ERR( "option '%s' requires an argument" );
 830                     end = argv[++i];
 831                 }
 832                 else end = NULL;
 833
 834                 callback( found->val, end );
 835                 continue;
 836             }
 837             if (argv[i][1] == '-' || !long_only || !strchr( short_opts, argv[i][1] ))
 838                 OPT_ERR( "unrecognized option '%s'" );
 839         }
 840
 841         /* handle short option */
 842         for ( ; *start; start++)
 843         {
 844             if (!(flag = strchr( short_opts, *start ))) OPT_ERR( "invalid option '%s'" );
 845             if (flag[1] == ':')
 846             {
 847                 end = start + 1;
 848                 if (!*end) end = NULL;
 849                 if (flag[2] != ':' && !end)
 850                 {
 851                     if (i == argc - 1) OPT_ERR( "option '%s' requires an argument" );
 852                     end = argv[++i];
 853                 }
 854                 callback( *start, end );
 855                 break;
 856             }
 857             callback( *start, NULL );
 858         }
 859     }
 860     return ret;
 861 #undef OPT_ERR
 862 }
 863
 864 #endif /* __WINE_TOOLS_H */