git.oblomov.eu Git - wine/blob - tools/winegcc/winegcc.c

   1 /*
   2  * MinGW wrapper: makes gcc behave like MinGW.
   3  *
   4  * Copyright 2000 Manuel Novoa III
   5  * Copyright 2000 Francois Gouget
   6  * Copyright 2002 Dimitrie O. Paun
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  * DESCRIPTION
  23  *
  24  * all options for gcc start with '-' and are for the most part
  25  * single options (no parameters as separate argument).
  26  * There are of course exceptions to this rule, so here is an
  27  * exhaustive list of options that do take parameters (potentially)
  28  * as a separate argument:
  29  *
  30  * Compiler:
  31  * -x language
  32  * -o filename
  33  * -aux-info filename
  34  *
  35  * Preprocessor:
  36  * -D name
  37  * -U name
  38  * -I dir
  39  * -MF file
  40  * -MT target
  41  * -MQ target
  42  * (all -i.* arg)
  43  * -include file
  44  * -imacros file
  45  * -idirafter dir
  46  * -iwithprefix dir
  47  * -iwithprefixbefore dir
  48  * -isystem dir
  49  * -A predicate=answer
  50  *
  51  * Linking:
  52  * -l library
  53  * -Xlinker option
  54  * -u symbol
  55  *
  56  * Misc:
  57  * -b machine
  58  * -V version
  59  * -G num  (see NOTES below)
  60  *
  61  * NOTES
  62  * There is -G option for compatibility with System V that
  63  * takes no parameters. This makes "-G num" parsing ambiguous.
  64  * This option is synonymous to -shared, and as such we will
  65  * not support it for now.
  66  *
  67  * Special interest options
  68  *
  69  *      Assembler Option
  70  *          -Wa,option
  71  *
  72  *      Linker Options
  73  *          object-file-name  -llibrary -nostartfiles  -nodefaultlibs
  74  *          -nostdlib -s  -static  -static-libgcc  -shared  -shared-libgcc
  75  *          -symbolic -Wl,option  -Xlinker option -u symbol --image-base
  76  *
  77  *      Directory Options
  78  *          -Bprefix  -Idir  -I-  -Ldir  -specs=file
  79  *
  80  *      Target Options
  81  *          -b machine  -V version
  82  *
  83  * Please note that the Target Options are relevant to everything:
  84  *   compiler, linker, assembler, preprocessor.
  85  *
  86  */
  87
  88 #include "config.h"
  89 #include "wine/port.h"
  90
  91 #include <assert.h>
  92 #include <stdio.h>
  93 #include <stdlib.h>
  94 #include <signal.h>
  95 #include <stdarg.h>
  96 #include <string.h>
  97 #include <errno.h>
  98
  99 #include "utils.h"
 100
 101 static const char* app_loader_template =
 102     "#!/bin/sh\n"
 103     "\n"
 104     "appname=\"%s\"\n"
 105     "# determine the application directory\n"
 106     "appdir=''\n"
 107     "case \"$0\" in\n"
 108     "  */*)\n"
 109     "    # $0 contains a path, use it\n"
 110     "    appdir=`dirname \"$0\"`\n"
 111     "    ;;\n"
 112     "  *)\n"
 113     "    # no directory in $0, search in PATH\n"
 114     "    saved_ifs=$IFS\n"
 115     "    IFS=:\n"
 116     "    for d in $PATH\n"
 117     "    do\n"
 118     "      IFS=$saved_ifs\n"
 119     "      if [ -x \"$d/$appname\" ]; then appdir=\"$d\"; break; fi\n"
 120     "    done\n"
 121     "    ;;\n"
 122     "esac\n"
 123     "\n"
 124     "# figure out the full app path\n"
 125     "if [ -n \"$appdir\" ]; then\n"
 126     "    apppath=\"$appdir/$appname\"\n"
 127     "    WINEDLLPATH=\"$appdir:$WINEDLLPATH\"\n"
 128     "    export WINEDLLPATH\n"
 129     "else\n"
 130     "    apppath=\"$appname\"\n"
 131     "fi\n"
 132     "\n"
 133     "# determine the WINELOADER\n"
 134     "if [ ! -x \"$WINELOADER\" ]; then WINELOADER=\"wine\"; fi\n"
 135     "\n"
 136     "# and try to start the app\n"
 137     "exec \"$WINELOADER\" \"$apppath\" \"$@\"\n"
 138 ;
 139
 140 static int keep_generated = 0;
 141 static strarray* tmp_files;
 142 #ifdef HAVE_SIGSET_T
 143 static sigset_t signal_mask;
 144 #endif
 145
 146 enum processor { proc_cc, proc_cxx, proc_cpp, proc_as };
 147
 148 static const struct
 149 {
 150     const char *name;
 151     enum target_cpu cpu;
 152 } cpu_names[] =
 153 {
 154     { "i386",    CPU_x86 },
 155     { "i486",    CPU_x86 },
 156     { "i586",    CPU_x86 },
 157     { "i686",    CPU_x86 },
 158     { "i786",    CPU_x86 },
 159     { "x86_64",  CPU_x86_64 },
 160     { "sparc",   CPU_SPARC },
 161     { "alpha",   CPU_ALPHA },
 162     { "powerpc", CPU_POWERPC },
 163     { "arm",     CPU_ARM }
 164 };
 165
 166 static const struct
 167 {
 168     const char *name;
 169     enum target_platform platform;
 170 } platform_names[] =
 171 {
 172     { "macos",   PLATFORM_APPLE },
 173     { "darwin",  PLATFORM_APPLE },
 174     { "solaris", PLATFORM_SOLARIS },
 175     { "mingw32", PLATFORM_WINDOWS },
 176     { "windows", PLATFORM_WINDOWS },
 177     { "winnt",   PLATFORM_WINDOWS }
 178 };
 179
 180 struct options
 181 {
 182     enum processor processor;
 183     enum target_cpu target_cpu;
 184     enum target_platform target_platform;
 185     const char *target;
 186     int shared;
 187     int use_msvcrt;
 188     int nostdinc;
 189     int nostdlib;
 190     int nostartfiles;
 191     int nodefaultlibs;
 192     int noshortwchar;
 193     int gui_app;
 194     int unicode_app;
 195     int compile_only;
 196     int force_pointer_size;
 197     int large_address_aware;
 198     int unwind_tables;
 199     const char* wine_objdir;
 200     const char* output_name;
 201     const char* image_base;
 202     const char* section_align;
 203     const char* lib_suffix;
 204     strarray* prefix;
 205     strarray* lib_dirs;
 206     strarray* linker_args;
 207     strarray* compiler_args;
 208     strarray* winebuild_args;
 209     strarray* files;
 210 };
 211
 212 #ifdef __i386__
 213 static const enum target_cpu build_cpu = CPU_x86;
 214 #elif defined(__x86_64__)
 215 static const enum target_cpu build_cpu = CPU_x86_64;
 216 #elif defined(__sparc__)
 217 static const enum target_cpu build_cpu = CPU_SPARC;
 218 #elif defined(__ALPHA__)
 219 static const enum target_cpu build_cpu = CPU_ALPHA;
 220 #elif defined(__powerpc__)
 221 static const enum target_cpu build_cpu = CPU_POWERPC;
 222 #elif defined(__arm__)
 223 static const enum target_cpu build_cpu = CPU_ARM;
 224 #else
 225 #error Unsupported CPU
 226 #endif
 227
 228 #ifdef __APPLE__
 229 static enum target_platform build_platform = PLATFORM_APPLE;
 230 #elif defined(__sun)
 231 static enum target_platform build_platform = PLATFORM_SOLARIS;
 232 #elif defined(_WIN32)
 233 static enum target_platform build_platform = PLATFORM_WINDOWS;
 234 #else
 235 static enum target_platform build_platform = PLATFORM_UNSPECIFIED;
 236 #endif
 237
 238 static void clean_temp_files(void)
 239 {
 240     unsigned int i;
 241
 242     if (keep_generated) return;
 243
 244     for (i = 0; i < tmp_files->size; i++)
 245         unlink(tmp_files->base[i]);
 246 }
 247
 248 /* clean things up when aborting on a signal */
 249 static void exit_on_signal( int sig )
 250 {
 251     exit(1);  /* this will call the atexit functions */
 252 }
 253
 254 static char* get_temp_file(const char* prefix, const char* suffix)
 255 {
 256     int fd;
 257     char* tmp = strmake("%s-XXXXXX%s", prefix, suffix);
 258
 259 #ifdef HAVE_SIGPROCMASK
 260     sigset_t old_set;
 261     /* block signals while manipulating the temp files list */
 262     sigprocmask( SIG_BLOCK, &signal_mask, &old_set );
 263 #endif
 264     fd = mkstemps( tmp, strlen(suffix) );
 265     if (fd == -1)
 266     {
 267         /* could not create it in current directory, try in /tmp */
 268         free(tmp);
 269         tmp = strmake("/tmp/%s-XXXXXX%s", prefix, suffix);
 270         fd = mkstemps( tmp, strlen(suffix) );
 271         if (fd == -1) error( "could not create temp file\n" );
 272     }
 273     close( fd );
 274     strarray_add(tmp_files, tmp);
 275 #ifdef HAVE_SIGPROCMASK
 276     sigprocmask( SIG_SETMASK, &old_set, NULL );
 277 #endif
 278     return tmp;
 279 }
 280
 281 static const strarray* get_translator(struct options *opts)
 282 {
 283     const char *str = NULL;
 284     strarray *ret;
 285
 286     switch(opts->processor)
 287     {
 288     case proc_cpp:
 289         if (opts->target) str = strmake( "%s-cpp", opts->target );
 290         else str = CPP;
 291         break;
 292     case proc_cc:
 293     case proc_as:
 294         if (opts->target) str = strmake( "%s-gcc", opts->target );
 295         else str = CC;
 296         break;
 297     case proc_cxx:
 298         if (opts->target) str = strmake( "%s-g++", opts->target );
 299         else str = CXX;
 300         break;
 301     default:
 302         assert(0);
 303     }
 304     ret = strarray_fromstring( str, " " );
 305     if (opts->force_pointer_size)
 306         strarray_add( ret, strmake("-m%u", 8 * opts->force_pointer_size ));
 307     return ret;
 308 }
 309
 310 static void compile(struct options* opts, const char* lang)
 311 {
 312     strarray* comp_args = strarray_alloc();
 313     unsigned int j;
 314     int gcc_defs = 0;
 315
 316     strarray_addall(comp_args, get_translator(opts));
 317     switch(opts->processor)
 318     {
 319         case proc_cpp: gcc_defs = 1; break;
 320         case proc_as:  gcc_defs = 0; break;
 321         /* Note: if the C compiler is gcc we assume the C++ compiler is too */
 322         /* mixing different C and C++ compilers isn't supported in configure anyway */
 323         case proc_cc:
 324         case proc_cxx:
 325             for ( j = 0; !gcc_defs && j < comp_args->size; j++ )
 326             {
 327                 const char *cc = comp_args->base[j];
 328
 329                 gcc_defs = strendswith(cc, "gcc") || strendswith(cc, "g++");
 330             }
 331             break;
 332     }
 333
 334     if (opts->target_platform == PLATFORM_WINDOWS) goto no_compat_defines;
 335
 336     if (opts->processor != proc_cpp)
 337     {
 338         if (gcc_defs && !opts->wine_objdir && !opts->noshortwchar)
 339         {
 340             strarray_add(comp_args, "-fshort-wchar");
 341             strarray_add(comp_args, "-DWINE_UNICODE_NATIVE");
 342         }
 343         strarray_addall(comp_args, strarray_fromstring(DLLFLAGS, " "));
 344     }
 345
 346     if (opts->target_cpu == CPU_x86_64)
 347     {
 348         strarray_add(comp_args, "-DWIN64");
 349         strarray_add(comp_args, "-D_WIN64");
 350         strarray_add(comp_args, "-D__WIN64");
 351         strarray_add(comp_args, "-D__WIN64__");
 352     }
 353
 354     strarray_add(comp_args, "-DWIN32");
 355     strarray_add(comp_args, "-D_WIN32");
 356     strarray_add(comp_args, "-D__WIN32");
 357     strarray_add(comp_args, "-D__WIN32__");
 358     strarray_add(comp_args, "-D__WINNT");
 359     strarray_add(comp_args, "-D__WINNT__");
 360
 361     if (gcc_defs)
 362     {
 363         int fastcall_done = 0;
 364         if (opts->target_cpu == CPU_x86_64)
 365         {
 366             strarray_add(comp_args, "-D__stdcall=__attribute__((ms_abi))");
 367             strarray_add(comp_args, "-D__cdecl=__attribute__((ms_abi))");
 368             strarray_add(comp_args, "-D_stdcall=__attribute__((ms_abi))");
 369             strarray_add(comp_args, "-D_cdecl=__attribute__((ms_abi))");
 370             strarray_add(comp_args, "-D__fastcall=__attribute__((ms_abi))");
 371             strarray_add(comp_args, "-D_fastcall=__attribute__((ms_abi))");
 372             fastcall_done = 1;
 373         }
 374         else if (opts->target_platform == PLATFORM_APPLE)
 375         {
 376             /* Mac OS X uses a 16-byte aligned stack and not a 4-byte one */
 377             strarray_add(comp_args, "-D__stdcall=__attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))");
 378             strarray_add(comp_args, "-D__cdecl=__attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))");
 379             strarray_add(comp_args, "-D_stdcall=__attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))");
 380             strarray_add(comp_args, "-D_cdecl=__attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))");
 381         }
 382         else
 383         {
 384             strarray_add(comp_args, "-D__stdcall=__attribute__((__stdcall__))");
 385             strarray_add(comp_args, "-D__cdecl=__attribute__((__cdecl__))");
 386             strarray_add(comp_args, "-D_stdcall=__attribute__((__stdcall__))");
 387             strarray_add(comp_args, "-D_cdecl=__attribute__((__cdecl__))");
 388         }
 389
 390         if (!fastcall_done)
 391         {
 392             strarray_add(comp_args, "-D__fastcall=__attribute__((__fastcall__))");
 393             strarray_add(comp_args, "-D_fastcall=__attribute__((__fastcall__))");
 394         }
 395         strarray_add(comp_args, "-D__declspec(x)=__declspec_##x");
 396         strarray_add(comp_args, "-D__declspec_align(x)=__attribute__((aligned(x)))");
 397         strarray_add(comp_args, "-D__declspec_allocate(x)=__attribute__((section(x)))");
 398         strarray_add(comp_args, "-D__declspec_deprecated=__attribute__((deprecated))");
 399         strarray_add(comp_args, "-D__declspec_dllimport=__attribute__((dllimport))");
 400         strarray_add(comp_args, "-D__declspec_dllexport=__attribute__((dllexport))");
 401         strarray_add(comp_args, "-D__declspec_naked=__attribute__((naked))");
 402         strarray_add(comp_args, "-D__declspec_noinline=__attribute__((noinline))");
 403         strarray_add(comp_args, "-D__declspec_noreturn=__attribute__((noreturn))");
 404         strarray_add(comp_args, "-D__declspec_nothrow=__attribute__((nothrow))");
 405         strarray_add(comp_args, "-D__declspec_novtable=__attribute__(())"); /* ignore it */
 406         strarray_add(comp_args, "-D__declspec_selectany=__attribute__((weak))");
 407         strarray_add(comp_args, "-D__declspec_thread=__thread");
 408     }
 409
 410     strarray_add(comp_args, "-D__int8=char");
 411     strarray_add(comp_args, "-D__int16=short");
 412     strarray_add(comp_args, "-D__int32=int");
 413     if (opts->target_cpu == CPU_x86_64)
 414         strarray_add(comp_args, "-D__int64=long");
 415     else
 416         strarray_add(comp_args, "-D__int64=long long");
 417
 418 no_compat_defines:
 419     strarray_add(comp_args, "-D__WINE__");
 420
 421     /* options we handle explicitly */
 422     if (opts->compile_only)
 423         strarray_add(comp_args, "-c");
 424     if (opts->output_name)
 425     {
 426         strarray_add(comp_args, "-o");
 427         strarray_add(comp_args, opts->output_name);
 428     }
 429
 430     /* the rest of the pass-through parameters */
 431     for ( j = 0 ; j < opts->compiler_args->size ; j++ )
 432         strarray_add(comp_args, opts->compiler_args->base[j]);
 433
 434     /* the language option, if any */
 435     if (lang && strcmp(lang, "-xnone"))
 436         strarray_add(comp_args, lang);
 437
 438     /* last, but not least, the files */
 439     for ( j = 0; j < opts->files->size; j++ )
 440     {
 441         if (opts->files->base[j][0] != '-')
 442             strarray_add(comp_args, opts->files->base[j]);
 443     }
 444
 445     /* standard includes come last in the include search path */
 446     if (!opts->wine_objdir && !opts->nostdinc)
 447     {
 448         if (opts->use_msvcrt)
 449         {
 450             strarray_add(comp_args, gcc_defs ? "-isystem" INCLUDEDIR "/msvcrt" : "-I" INCLUDEDIR "/msvcrt" );
 451             strarray_add(comp_args, "-D__MSVCRT__");
 452         }
 453         strarray_add(comp_args, gcc_defs ? "-isystem" INCLUDEDIR "/windows" : "-I" INCLUDEDIR "/windows" );
 454     }
 455     else if (opts->wine_objdir)
 456         strarray_add(comp_args, strmake("-I%s/include", opts->wine_objdir) );
 457
 458     spawn(opts->prefix, comp_args, 0);
 459     strarray_free(comp_args);
 460 }
 461
 462 static const char* compile_to_object(struct options* opts, const char* file, const char* lang)
 463 {
 464     struct options copts;
 465     char* base_name;
 466
 467     /* make a copy so we don't change any of the initial stuff */
 468     /* a shallow copy is exactly what we want in this case */
 469     base_name = get_basename(file);
 470     copts = *opts;
 471     copts.output_name = get_temp_file(base_name, ".o");
 472     copts.compile_only = 1;
 473     copts.files = strarray_alloc();
 474     strarray_add(copts.files, file);
 475     compile(&copts, lang);
 476     strarray_free(copts.files);
 477     free(base_name);
 478
 479     return copts.output_name;
 480 }
 481
 482 /* return the initial set of options needed to run winebuild */
 483 static strarray *get_winebuild_args(struct options *opts)
 484 {
 485     const char* winebuild = getenv("WINEBUILD");
 486     strarray *spec_args = strarray_alloc();
 487
 488     if (!winebuild) winebuild = "winebuild";
 489     strarray_add( spec_args, winebuild );
 490     if (verbose) strarray_add( spec_args, "-v" );
 491     if (keep_generated) strarray_add( spec_args, "--save-temps" );
 492     if (opts->target)
 493     {
 494         strarray_add( spec_args, "--target" );
 495         strarray_add( spec_args, opts->target );
 496     }
 497     if (opts->unwind_tables) strarray_add( spec_args, "-fasynchronous-unwind-tables" );
 498     else strarray_add( spec_args, "-fno-asynchronous-unwind-tables" );
 499     return spec_args;
 500 }
 501
 502 static const char* compile_resources_to_object(struct options* opts, const strarray *resources,
 503                                                const char *res_o_name)
 504 {
 505     strarray *winebuild_args = get_winebuild_args( opts );
 506
 507     strarray_add( winebuild_args, "--resources" );
 508     strarray_add( winebuild_args, "-o" );
 509     strarray_add( winebuild_args, res_o_name );
 510     strarray_addall( winebuild_args, resources );
 511
 512     spawn( opts->prefix, winebuild_args, 0 );
 513     strarray_free( winebuild_args );
 514     return res_o_name;
 515 }
 516
 517 /* check if there is a static lib associated to a given dll */
 518 static char *find_static_lib( const char *dll )
 519 {
 520     char *lib = strmake("%s.a", dll);
 521     if (get_file_type(lib) == file_arh) return lib;
 522     free( lib );
 523     return NULL;
 524 }
 525
 526 /* add specified library to the list of files */
 527 static void add_library( struct options *opts, strarray *lib_dirs, strarray *files, const char *library )
 528 {
 529     char *static_lib, *fullname = 0;
 530
 531     switch(get_lib_type(opts->target_platform, lib_dirs, library, opts->lib_suffix, &fullname))
 532     {
 533     case file_arh:
 534         strarray_add(files, strmake("-a%s", fullname));
 535         break;
 536     case file_dll:
 537         strarray_add(files, strmake("-d%s", fullname));
 538         if ((static_lib = find_static_lib(fullname)))
 539         {
 540             strarray_add(files, strmake("-a%s",static_lib));
 541             free(static_lib);
 542         }
 543         break;
 544     case file_so:
 545     default:
 546         /* keep it anyway, the linker may know what to do with it */
 547         strarray_add(files, strmake("-l%s", library));
 548         break;
 549     }
 550     free(fullname);
 551 }
 552
 553 /* hack a main or WinMain function to work around Mingw's lack of Unicode support */
 554 static const char *mingw_unicode_hack( struct options *opts )
 555 {
 556     char *main_stub = get_temp_file( opts->output_name, ".c" );
 557
 558     create_file( main_stub, 0644,
 559                  "#include <stdlib.h>\n"
 560                  "extern int wmain(int,wchar_t**);\n"
 561                  "int main( int argc, char *argv[] )\n{\n"
 562                  "    return wmain( argc, __wargv );\n}\n" );
 563     return compile_to_object( opts, main_stub, NULL );
 564 }
 565
 566 static void build(struct options* opts)
 567 {
 568     static const char *stdlibpath[] = { DLLDIR, LIBDIR, "/usr/lib", "/usr/local/lib", "/lib" };
 569     strarray *lib_dirs, *files;
 570     strarray *spec_args, *link_args;
 571     char *output_file;
 572     const char *spec_o_name;
 573     const char *output_name, *spec_file, *lang;
 574     int generate_app_loader = 1;
 575     int fake_module = 0;
 576     unsigned int j;
 577
 578     /* NOTE: for the files array we'll use the following convention:
 579      *    -axxx:  xxx is an archive (.a)
 580      *    -dxxx:  xxx is a DLL (.def)
 581      *    -lxxx:  xxx is an unsorted library
 582      *    -oxxx:  xxx is an object (.o)
 583      *    -rxxx:  xxx is a resource (.res)
 584      *    -sxxx:  xxx is a shared lib (.so)
 585      *    -xlll:  lll is the language (c, c++, etc.)
 586      */
 587
 588     output_file = strdup( opts->output_name ? opts->output_name : "a.out" );
 589
 590     /* 'winegcc -o app xxx.exe.so' only creates the load script */
 591     if (opts->files->size == 1 && strendswith(opts->files->base[0], ".exe.so"))
 592     {
 593         create_file(output_file, 0755, app_loader_template, opts->files->base[0]);
 594         return;
 595     }
 596
 597     /* generate app loader only for .exe */
 598     if (opts->shared || strendswith(output_file, ".so"))
 599         generate_app_loader = 0;
 600
 601     if (strendswith(output_file, ".fake")) fake_module = 1;
 602
 603     /* normalize the filename a bit: strip .so, ensure it has proper ext */
 604     if (strendswith(output_file, ".so"))
 605         output_file[strlen(output_file) - 3] = 0;
 606     if ((output_name = strrchr(output_file, '/'))) output_name++;
 607     else output_name = output_file;
 608     if (!strchr(output_name, '.'))
 609         output_file = strmake("%s.%s", output_file, opts->shared ? "dll" : "exe");
 610
 611     /* get the filename from the path */
 612     if ((output_name = strrchr(output_file, '/'))) output_name++;
 613     else output_name = output_file;
 614
 615     /* prepare the linking path */
 616     if (!opts->wine_objdir)
 617     {
 618         lib_dirs = strarray_dup(opts->lib_dirs);
 619         for ( j = 0; j < sizeof(stdlibpath)/sizeof(stdlibpath[0]); j++ )
 620             strarray_add(lib_dirs, stdlibpath[j]);
 621     }
 622     else
 623     {
 624         lib_dirs = strarray_alloc();
 625         strarray_add(lib_dirs, strmake("%s/dlls", opts->wine_objdir));
 626         strarray_add(lib_dirs, strmake("%s/libs/wine", opts->wine_objdir));
 627         strarray_addall(lib_dirs, opts->lib_dirs);
 628     }
 629
 630     /* mark the files with their appropriate type */
 631     spec_file = lang = 0;
 632     files = strarray_alloc();
 633     link_args = strarray_alloc();
 634     for ( j = 0; j < opts->files->size; j++ )
 635     {
 636         const char* file = opts->files->base[j];
 637         if (file[0] != '-')
 638         {
 639             switch(get_file_type(file))
 640             {
 641                 case file_def:
 642                 case file_spec:
 643                     if (spec_file)
 644                         error("Only one spec file can be specified\n");
 645                     spec_file = file;
 646                     break;
 647                 case file_rc:
 648                     /* FIXME: invoke wrc to build it */
 649                     error("Can't compile .rc file at the moment: %s\n", file);
 650                     break;
 651                 case file_res:
 652                     strarray_add(files, strmake("-r%s", file));
 653                     break;
 654                 case file_obj:
 655                     strarray_add(files, strmake("-o%s", file));
 656                     break;
 657                 case file_arh:
 658                     strarray_add(files, strmake("-a%s", file));
 659                     break;
 660                 case file_so:
 661                     strarray_add(files, strmake("-s%s", file));
 662                     break;
 663                 case file_na:
 664                     error("File does not exist: %s\n", file);
 665                     break;
 666                 default:
 667                     file = compile_to_object(opts, file, lang);
 668                     strarray_add(files, strmake("-o%s", file));
 669                     break;
 670             }
 671         }
 672         else if (file[1] == 'l')
 673             add_library(opts, lib_dirs, files, file + 2 );
 674         else if (file[1] == 'x')
 675             lang = file;
 676     }
 677
 678     /* building for Windows is completely different */
 679
 680     if (opts->target_platform == PLATFORM_WINDOWS)
 681     {
 682         strarray *resources = strarray_alloc();
 683         char *res_o_name = NULL;
 684
 685         if (opts->shared)
 686         {
 687             /* run winebuild to generate the .def file */
 688             char *spec_def_name = get_temp_file(output_name, ".spec.def");
 689             spec_args = get_winebuild_args( opts );
 690             strarray_add(spec_args, "--def");
 691             strarray_add(spec_args, "-o");
 692             strarray_add(spec_args, spec_def_name);
 693             if (spec_file)
 694             {
 695                 strarray_add(spec_args, "--export");
 696                 strarray_add(spec_args, spec_file);
 697             }
 698             spawn(opts->prefix, spec_args, 0);
 699             strarray_free(spec_args);
 700
 701             if (opts->target) strarray_add(link_args, strmake("%s-dllwrap", opts->target));
 702             else strarray_add(link_args, "dllwrap");
 703             if (verbose) strarray_add(link_args, "-v");
 704             strarray_add(link_args, "-k");
 705             strarray_add(link_args, "--def");
 706             strarray_add(link_args, spec_def_name);
 707         }
 708         else
 709         {
 710             strarray_addall(link_args, get_translator(opts));
 711             strarray_add(link_args, opts->gui_app ? "-mwindows" : "-mconsole");
 712             if (opts->nodefaultlibs) strarray_add(link_args, "-nodefaultlibs");
 713         }
 714
 715         for ( j = 0 ; j < opts->linker_args->size ; j++ )
 716             strarray_add(link_args, opts->linker_args->base[j]);
 717
 718         strarray_add(link_args, "-o");
 719         strarray_add(link_args, output_file);
 720
 721         if (opts->image_base)
 722             strarray_add(link_args, strmake("-Wl,--image-base,%s", opts->image_base));
 723
 724         if (opts->large_address_aware) strarray_add( link_args, "-Wl,--large-address-aware" );
 725
 726         if (opts->unicode_app && !opts->shared)
 727             strarray_add(link_args, mingw_unicode_hack(opts));
 728
 729         for ( j = 0; j < lib_dirs->size; j++ )
 730             strarray_add(link_args, strmake("-L%s", lib_dirs->base[j]));
 731
 732         if (!opts->nostartfiles) add_library(opts, lib_dirs, files, "winecrt0");
 733         if (opts->shared && !opts->nostdlib) add_library(opts, lib_dirs, files, "wine");
 734
 735         for ( j = 0; j < files->size; j++ )
 736         {
 737             const char* name = files->base[j] + 2;
 738
 739             switch(files->base[j][1])
 740             {
 741             case 'l':
 742             case 'd':
 743                 strarray_add(link_args, strmake("-l%s", name));
 744                 break;
 745             case 's':
 746             case 'o':
 747                 strarray_add(link_args, name);
 748                 break;
 749             case 'a':
 750                 if (strchr(name, '/'))
 751                 {
 752                     /* turn the path back into -Ldir -lfoo options
 753                      * this makes sure that we use the specified libs even
 754                      * when mingw adds its own import libs to the link */
 755                     char *lib = xstrdup( name );
 756                     char *p = strrchr( lib, '/' );
 757
 758                     *p++ = 0;
 759                     if (!strncmp( p, "lib", 3 ))
 760                     {
 761                         char *ext = strrchr( p, '.' );
 762
 763                         if (ext) *ext = 0;
 764                         p += 3;
 765                         strarray_add(link_args, strmake("-L%s", lib ));
 766                         strarray_add(link_args, strmake("-l%s", p ));
 767                         free( lib );
 768                         break;
 769                     }
 770                     free( lib );
 771                 }
 772                 strarray_add(link_args, name);
 773                 break;
 774             case 'r':
 775                 if (!res_o_name)
 776                 {
 777                     res_o_name = get_temp_file( output_name, ".res.o" );
 778                     strarray_add( link_args, res_o_name );
 779                 }
 780                 strarray_add( resources, name );
 781                 break;
 782             }
 783         }
 784         if (!opts->shared && (opts->use_msvcrt || opts->unicode_app)) strarray_add(link_args, "-lmsvcrt");
 785
 786         if (res_o_name) compile_resources_to_object( opts, resources, res_o_name );
 787
 788         spawn(opts->prefix, link_args, 0);
 789         strarray_free (resources);
 790         strarray_free (link_args);
 791         strarray_free (lib_dirs);
 792         strarray_free (files);
 793         return;
 794     }
 795
 796     /* add the default libraries, if needed */
 797     if (!opts->nostdlib && opts->use_msvcrt) add_library(opts, lib_dirs, files, "msvcrt");
 798
 799     if (!opts->wine_objdir && !opts->nodefaultlibs)
 800     {
 801         if (opts->gui_app)
 802         {
 803             add_library(opts, lib_dirs, files, "shell32");
 804             add_library(opts, lib_dirs, files, "comdlg32");
 805             add_library(opts, lib_dirs, files, "gdi32");
 806         }
 807         add_library(opts, lib_dirs, files, "advapi32");
 808         add_library(opts, lib_dirs, files, "user32");
 809         add_library(opts, lib_dirs, files, "kernel32");
 810     }
 811
 812     if (!opts->nostartfiles) add_library(opts, lib_dirs, files, "winecrt0");
 813     if (!opts->nostdlib) add_library(opts, lib_dirs, files, "wine");
 814
 815     /* run winebuild to generate the .spec.o file */
 816     spec_args = get_winebuild_args( opts );
 817     spec_o_name = get_temp_file(output_name, ".spec.o");
 818     if (opts->force_pointer_size)
 819         strarray_add(spec_args, strmake("-m%u", 8 * opts->force_pointer_size ));
 820     strarray_addall(spec_args, strarray_fromstring(DLLFLAGS, " "));
 821     strarray_add(spec_args, opts->shared ? "--dll" : "--exe");
 822     if (fake_module)
 823     {
 824         strarray_add(spec_args, "--fake-module");
 825         strarray_add(spec_args, "-o");
 826         strarray_add(spec_args, output_file);
 827     }
 828     else
 829     {
 830         strarray_add(spec_args, "-o");
 831         strarray_add(spec_args, spec_o_name);
 832     }
 833     if (spec_file)
 834     {
 835         strarray_add(spec_args, "-E");
 836         strarray_add(spec_args, spec_file);
 837     }
 838
 839     if (!opts->shared)
 840     {
 841         strarray_add(spec_args, "-F");
 842         strarray_add(spec_args, output_name);
 843         strarray_add(spec_args, "--subsystem");
 844         strarray_add(spec_args, opts->gui_app ? "windows" : "console");
 845         if (opts->unicode_app)
 846         {
 847             strarray_add(spec_args, "--entry");
 848             strarray_add(spec_args, "__wine_spec_exe_wentry");
 849         }
 850         if (opts->large_address_aware) strarray_add( spec_args, "--large-address-aware" );
 851     }
 852
 853     for ( j = 0; j < lib_dirs->size; j++ )
 854         strarray_add(spec_args, strmake("-L%s", lib_dirs->base[j]));
 855
 856     for ( j = 0 ; j < opts->winebuild_args->size ; j++ )
 857         strarray_add(spec_args, opts->winebuild_args->base[j]);
 858
 859     /* add resource files */
 860     for ( j = 0; j < files->size; j++ )
 861         if (files->base[j][1] == 'r') strarray_add(spec_args, files->base[j]);
 862
 863     /* add other files */
 864     strarray_add(spec_args, "--");
 865     for ( j = 0; j < files->size; j++ )
 866     {
 867         switch(files->base[j][1])
 868         {
 869             case 'd':
 870             case 'a':
 871             case 'o':
 872                 strarray_add(spec_args, files->base[j] + 2);
 873                 break;
 874         }
 875     }
 876
 877     spawn(opts->prefix, spec_args, 0);
 878     strarray_free (spec_args);
 879     if (fake_module) return;  /* nothing else to do */
 880
 881     /* link everything together now */
 882     strarray_addall(link_args, get_translator(opts));
 883     strarray_addall(link_args, strarray_fromstring(LDDLLFLAGS, " "));
 884
 885     strarray_add(link_args, "-o");
 886     strarray_add(link_args, strmake("%s.so", output_file));
 887
 888     for ( j = 0 ; j < opts->linker_args->size ; j++ )
 889         strarray_add(link_args, opts->linker_args->base[j]);
 890
 891     switch (opts->target_platform)
 892     {
 893     case PLATFORM_APPLE:
 894         if (opts->image_base)
 895         {
 896             strarray_add(link_args, "-image_base");
 897             strarray_add(link_args, opts->image_base);
 898         }
 899         break;
 900     case PLATFORM_SOLARIS:
 901         {
 902             char *mapfile = get_temp_file( output_name, ".map" );
 903             const char *align = opts->section_align ? opts->section_align : "0x1000";
 904
 905             create_file( mapfile, 0644, "text = A%s;\ndata = A%s;\n", align, align );
 906             strarray_add(link_args, strmake("-Wl,-M,%s", mapfile));
 907             strarray_add(tmp_files, mapfile);
 908         }
 909         break;
 910     default:
 911         break;
 912     }
 913
 914     for ( j = 0; j < lib_dirs->size; j++ )
 915         strarray_add(link_args, strmake("-L%s", lib_dirs->base[j]));
 916
 917     strarray_add(link_args, spec_o_name);
 918
 919     for ( j = 0; j < files->size; j++ )
 920     {
 921         const char* name = files->base[j] + 2;
 922         switch(files->base[j][1])
 923         {
 924             case 'l':
 925                 strarray_add(link_args, strmake("-l%s", name));
 926                 break;
 927             case 's':
 928             case 'a':
 929             case 'o':
 930                 strarray_add(link_args, name);
 931                 break;
 932         }
 933     }
 934
 935     if (!opts->nostdlib)
 936     {
 937         strarray_add(link_args, "-lm");
 938         strarray_add(link_args, "-lc");
 939     }
 940
 941     spawn(opts->prefix, link_args, 0);
 942     strarray_free (link_args);
 943
 944     /* set the base address */
 945     if (opts->image_base)
 946     {
 947         const char *prelink = PRELINK;
 948         if (prelink[0] && strcmp(prelink,"false"))
 949         {
 950             strarray *prelink_args = strarray_alloc();
 951             strarray_add(prelink_args, prelink);
 952             strarray_add(prelink_args, "--reloc-only");
 953             strarray_add(prelink_args, opts->image_base);
 954             strarray_add(prelink_args, strmake("%s.so", output_file));
 955             spawn(opts->prefix, prelink_args, 1);
 956             strarray_free(prelink_args);
 957         }
 958     }
 959
 960     /* create the loader script */
 961     if (generate_app_loader)
 962         create_file(output_file, 0755, app_loader_template, strmake("%s.so", output_name));
 963 }
 964
 965
 966 static void forward(int argc, char **argv, struct options* opts)
 967 {
 968     strarray* args = strarray_alloc();
 969     int j;
 970
 971     strarray_addall(args, get_translator(opts));
 972
 973     for( j = 1; j < argc; j++ )
 974         strarray_add(args, argv[j]);
 975
 976     spawn(opts->prefix, args, 0);
 977     strarray_free (args);
 978 }
 979
 980 /*
 981  *      Linker Options
 982  *          object-file-name  -llibrary -nostartfiles  -nodefaultlibs
 983  *          -nostdlib -s  -static  -static-libgcc  -shared  -shared-libgcc
 984  *          -symbolic -Wl,option  -Xlinker option -u symbol
 985  *          -framework name
 986  */
 987 static int is_linker_arg(const char* arg)
 988 {
 989     static const char* link_switches[] =
 990     {
 991         "-nostartfiles", "-nodefaultlibs", "-nostdlib", "-s",
 992         "-static", "-static-libgcc", "-shared", "-shared-libgcc", "-symbolic",
 993         "-framework"
 994     };
 995     unsigned int j;
 996
 997     switch (arg[1])
 998     {
 999         case 'R':
1000         case 'z':
1001         case 'l':
1002         case 'u':
1003             return 1;
1004         case 'W':
1005             if (strncmp("-Wl,", arg, 4) == 0) return 1;
1006             break;
1007         case 'X':
1008             if (strcmp("-Xlinker", arg) == 0) return 1;
1009             break;
1010         case 'a':
1011             if (strcmp("-arch", arg) == 0) return 1;
1012             break;
1013     }
1014
1015     for (j = 0; j < sizeof(link_switches)/sizeof(link_switches[0]); j++)
1016         if (strcmp(link_switches[j], arg) == 0) return 1;
1017
1018     return 0;
1019 }
1020
1021 /*
1022  *      Target Options
1023  *          -b machine  -V version
1024  */
1025 static int is_target_arg(const char* arg)
1026 {
1027     return arg[1] == 'b' || arg[2] == 'V';
1028 }
1029
1030
1031 /*
1032  *      Directory Options
1033  *          -Bprefix  -Idir  -I-  -Ldir  -specs=file
1034  */
1035 static int is_directory_arg(const char* arg)
1036 {
1037     return arg[1] == 'B' || arg[1] == 'L' || arg[1] == 'I' || strncmp("-specs=", arg, 7) == 0;
1038 }
1039
1040 /*
1041  *      MinGW Options
1042  *          -mno-cygwin -mwindows -mconsole -mthreads -municode
1043  */
1044 static int is_mingw_arg(const char* arg)
1045 {
1046     static const char* mingw_switches[] =
1047     {
1048         "-mno-cygwin", "-mwindows", "-mconsole", "-mthreads", "-municode"
1049     };
1050     unsigned int j;
1051
1052     for (j = 0; j < sizeof(mingw_switches)/sizeof(mingw_switches[0]); j++)
1053         if (strcmp(mingw_switches[j], arg) == 0) return 1;
1054
1055     return 0;
1056 }
1057
1058 static void parse_target_option( struct options *opts, const char *target )
1059 {
1060     char *p, *platform, *spec = xstrdup( target );
1061     unsigned int i;
1062
1063     /* target specification is in the form CPU-MANUFACTURER-OS or CPU-MANUFACTURER-KERNEL-OS */
1064
1065     /* get the CPU part */
1066
1067     if (!(p = strchr( spec, '-' ))) error( "Invalid target specification '%s'\n", target );
1068     *p++ = 0;
1069     for (i = 0; i < sizeof(cpu_names)/sizeof(cpu_names[0]); i++)
1070     {
1071         if (!strcmp( cpu_names[i].name, spec ))
1072         {
1073             opts->target_cpu = cpu_names[i].cpu;
1074             break;
1075         }
1076     }
1077     if (i == sizeof(cpu_names)/sizeof(cpu_names[0]))
1078         error( "Unrecognized CPU '%s'\n", spec );
1079     platform = p;
1080     if ((p = strrchr( p, '-' ))) platform = p + 1;
1081
1082     /* get the OS part */
1083
1084     opts->target_platform = PLATFORM_UNSPECIFIED;  /* default value */
1085     for (i = 0; i < sizeof(platform_names)/sizeof(platform_names[0]); i++)
1086     {
1087         if (!strncmp( platform_names[i].name, platform, strlen(platform_names[i].name) ))
1088         {
1089             opts->target_platform = platform_names[i].platform;
1090             break;
1091         }
1092     }
1093
1094     free( spec );
1095     opts->target = xstrdup( target );
1096 }
1097
1098 int main(int argc, char **argv)
1099 {
1100     int i, c, next_is_arg = 0, linking = 1;
1101     int raw_compiler_arg, raw_linker_arg;
1102     const char* option_arg;
1103     struct options opts;
1104     char* lang = 0;
1105     char* str;
1106
1107 #ifdef SIGHUP
1108     signal( SIGHUP, exit_on_signal );
1109 #endif
1110     signal( SIGTERM, exit_on_signal );
1111     signal( SIGINT, exit_on_signal );
1112 #ifdef HAVE_SIGADDSET
1113     sigemptyset( &signal_mask );
1114     sigaddset( &signal_mask, SIGHUP );
1115     sigaddset( &signal_mask, SIGTERM );
1116     sigaddset( &signal_mask, SIGINT );
1117 #endif
1118
1119     /* setup tmp file removal at exit */
1120     tmp_files = strarray_alloc();
1121     atexit(clean_temp_files);
1122
1123     /* initialize options */
1124     memset(&opts, 0, sizeof(opts));
1125     opts.target_cpu = build_cpu;
1126     opts.target_platform = build_platform;
1127     opts.lib_dirs = strarray_alloc();
1128     opts.files = strarray_alloc();
1129     opts.linker_args = strarray_alloc();
1130     opts.compiler_args = strarray_alloc();
1131     opts.winebuild_args = strarray_alloc();
1132
1133     /* determine the processor type */
1134     if (strendswith(argv[0], "winecpp")) opts.processor = proc_cpp;
1135     else if (strendswith(argv[0], "++")) opts.processor = proc_cxx;
1136
1137     /* parse options */
1138     for ( i = 1 ; i < argc ; i++ )
1139     {
1140         if (argv[i][0] == '-')  /* option */
1141         {
1142             /* determine if tihs switch is followed by a separate argument */
1143             next_is_arg = 0;
1144             option_arg = 0;
1145             switch(argv[i][1])
1146             {
1147                 case 'x': case 'o': case 'D': case 'U':
1148                 case 'I': case 'A': case 'l': case 'u':
1149                 case 'b': case 'V': case 'G': case 'L':
1150                 case 'B': case 'R': case 'z':
1151                     if (argv[i][2]) option_arg = &argv[i][2];
1152                     else next_is_arg = 1;
1153                     break;
1154                 case 'i':
1155                     next_is_arg = 1;
1156                     break;
1157                 case 'a':
1158                     if (strcmp("-aux-info", argv[i]) == 0)
1159                         next_is_arg = 1;
1160                     if (strcmp("-arch", argv[i]) == 0)
1161                         next_is_arg = 1;
1162                     break;
1163                 case 'X':
1164                     if (strcmp("-Xlinker", argv[i]) == 0)
1165                         next_is_arg = 1;
1166                     break;
1167                 case 'M':
1168                     c = argv[i][2];
1169                     if (c == 'F' || c == 'T' || c == 'Q')
1170                     {
1171                         if (argv[i][3]) option_arg = &argv[i][3];
1172                         else next_is_arg = 1;
1173                     }
1174                     break;
1175                 case 'f':
1176                     if (strcmp("-framework", argv[i]) == 0)
1177                         next_is_arg = 1;
1178                     break;
1179             }
1180             if (next_is_arg) option_arg = argv[i+1];
1181
1182             /* determine what options go 'as is' to the linker & the compiler */
1183             raw_compiler_arg = raw_linker_arg = 0;
1184             if (is_linker_arg(argv[i]))
1185             {
1186                 raw_linker_arg = 1;
1187             }
1188             else
1189             {
1190                 if (is_directory_arg(argv[i]) || is_target_arg(argv[i]))
1191                     raw_linker_arg = 1;
1192                 raw_compiler_arg = !is_mingw_arg(argv[i]);
1193             }
1194
1195             /* these things we handle explicitly so we don't pass them 'as is' */
1196             if (argv[i][1] == 'l' || argv[i][1] == 'I' || argv[i][1] == 'L')
1197                 raw_linker_arg = 0;
1198             if (argv[i][1] == 'c' || argv[i][1] == 'L')
1199                 raw_compiler_arg = 0;
1200             if (argv[i][1] == 'o' || argv[i][1] == 'b')
1201                 raw_compiler_arg = raw_linker_arg = 0;
1202
1203             /* do a bit of semantic analysis */
1204             switch (argv[i][1])
1205             {
1206                 case 'B':
1207                     str = strdup(option_arg);
1208                     if (strendswith(str, "/tools/winebuild"))
1209                     {
1210                         char *objdir = strdup(str);
1211                         objdir[strlen(objdir) - sizeof("/tools/winebuild") + 1] = 0;
1212                         opts.wine_objdir = objdir;
1213                         /* don't pass it to the compiler, this generates warnings */
1214                         raw_compiler_arg = raw_linker_arg = 0;
1215                     }
1216                     if (strendswith(str, "/")) str[strlen(str) - 1] = 0;
1217                     if (!opts.prefix) opts.prefix = strarray_alloc();
1218                     strarray_add(opts.prefix, str);
1219                     break;
1220                 case 'b':
1221                     parse_target_option( &opts, option_arg );
1222                     break;
1223                 case 'c':        /* compile or assemble */
1224                     if (argv[i][2] == 0) opts.compile_only = 1;
1225                     /* fall through */
1226                 case 'S':        /* generate assembler code */
1227                 case 'E':        /* preprocess only */
1228                     if (argv[i][2] == 0) linking = 0;
1229                     break;
1230                 case 'f':
1231                     if (strcmp("-fno-short-wchar", argv[i]) == 0)
1232                         opts.noshortwchar = 1;
1233                     else if (!strcmp("-fasynchronous-unwind-tables", argv[i]))
1234                         opts.unwind_tables = 1;
1235                     else if (!strcmp("-fno-asynchronous-unwind-tables", argv[i]))
1236                         opts.unwind_tables = 0;
1237                     break;
1238                 case 'l':
1239                     strarray_add(opts.files, strmake("-l%s", option_arg));
1240                     break;
1241                 case 'L':
1242                     strarray_add(opts.lib_dirs, option_arg);
1243                     break;
1244                 case 'M':        /* map file generation */
1245                     linking = 0;
1246                     break;
1247                 case 'm':
1248                     if (strcmp("-mno-cygwin", argv[i]) == 0)
1249                         opts.use_msvcrt = 1;
1250                     else if (strcmp("-mwindows", argv[i]) == 0)
1251                         opts.gui_app = 1;
1252                     else if (strcmp("-mconsole", argv[i]) == 0)
1253                         opts.gui_app = 0;
1254                     else if (strcmp("-municode", argv[i]) == 0)
1255                         opts.unicode_app = 1;
1256                     else if (strcmp("-m32", argv[i]) == 0)
1257                     {
1258                         if (opts.target_cpu == CPU_x86_64)
1259                             opts.target_cpu = CPU_x86;
1260                         opts.force_pointer_size = 4;
1261                         raw_linker_arg = 1;
1262                     }
1263                     else if (strcmp("-m64", argv[i]) == 0)
1264                     {
1265                         opts.force_pointer_size = 8;
1266                         raw_linker_arg = 1;
1267                     }
1268                     break;
1269                 case 'n':
1270                     if (strcmp("-nostdinc", argv[i]) == 0)
1271                         opts.nostdinc = 1;
1272                     else if (strcmp("-nodefaultlibs", argv[i]) == 0)
1273                         opts.nodefaultlibs = 1;
1274                     else if (strcmp("-nostdlib", argv[i]) == 0)
1275                         opts.nostdlib = 1;
1276                     else if (strcmp("-nostartfiles", argv[i]) == 0)
1277                         opts.nostartfiles = 1;
1278                     break;
1279                 case 'o':
1280                     opts.output_name = option_arg;
1281                     break;
1282                 case 's':
1283                     if (strcmp("-static", argv[i]) == 0)
1284                         linking = -1;
1285                     else if(strcmp("-save-temps", argv[i]) == 0)
1286                         keep_generated = 1;
1287                     else if(strcmp("-shared", argv[i]) == 0)
1288                     {
1289                         opts.shared = 1;
1290                         raw_compiler_arg = raw_linker_arg = 0;
1291                     }
1292                     break;
1293                 case 'v':
1294                     if (argv[i][2] == 0) verbose++;
1295                     break;
1296                 case 'W':
1297                     if (strncmp("-Wl,", argv[i], 4) == 0)
1298                     {
1299                         unsigned int j;
1300                         strarray* Wl = strarray_fromstring(argv[i] + 4, ",");
1301                         for (j = 0; j < Wl->size; j++)
1302                         {
1303                             if (!strcmp(Wl->base[j], "--image-base") && j < Wl->size - 1)
1304                             {
1305                                 opts.image_base = strdup( Wl->base[++j] );
1306                                 continue;
1307                             }
1308                             if (!strcmp(Wl->base[j], "--section-alignment") && j < Wl->size - 1)
1309                             {
1310                                 opts.section_align = strdup( Wl->base[++j] );
1311                                 continue;
1312                             }
1313                             if (!strcmp(Wl->base[j], "--large-address-aware"))
1314                             {
1315                                 opts.large_address_aware = 1;
1316                                 continue;
1317                             }
1318                             if (!strcmp(Wl->base[j], "-static")) linking = -1;
1319                             strarray_add(opts.linker_args, strmake("-Wl,%s",Wl->base[j]));
1320                         }
1321                         strarray_free(Wl);
1322                         raw_compiler_arg = raw_linker_arg = 0;
1323                     }
1324                     else if (strncmp("-Wb,", argv[i], 4) == 0)
1325                     {
1326                         strarray* Wb = strarray_fromstring(argv[i] + 4, ",");
1327                         strarray_addall(opts.winebuild_args, Wb);
1328                         strarray_free(Wb);
1329                         /* don't pass it to the compiler, it generates errors */
1330                         raw_compiler_arg = raw_linker_arg = 0;
1331                     }
1332                     break;
1333                 case 'x':
1334                     lang = strmake("-x%s", option_arg);
1335                     strarray_add(opts.files, lang);
1336                     /* we'll pass these flags ourselves, explicitly */
1337                     raw_compiler_arg = raw_linker_arg = 0;
1338                     break;
1339                 case '-':
1340                     if (strcmp("-static", argv[i]+1) == 0)
1341                         linking = -1;
1342                     else if (!strncmp("--sysroot", argv[i], 9) && opts.wine_objdir)
1343                     {
1344                         if (argv[i][9] == '=') opts.wine_objdir = argv[i] + 10;
1345                         else opts.wine_objdir = argv[++i];
1346                         raw_compiler_arg = raw_linker_arg = 0;
1347                     }
1348                     else if (!strncmp("--lib-suffix", argv[i], 12) && opts.wine_objdir)
1349                     {
1350                         if (argv[i][12] == '=') opts.lib_suffix = argv[i] + 13;
1351                         else opts.lib_suffix = argv[++i];
1352                         raw_compiler_arg = raw_linker_arg = 0;
1353                     }
1354                     break;
1355             }
1356
1357             /* put the arg into the appropriate bucket */
1358             if (raw_linker_arg)
1359             {
1360                 strarray_add(opts.linker_args, argv[i]);
1361                 if (next_is_arg && (i + 1 < argc))
1362                     strarray_add(opts.linker_args, argv[i + 1]);
1363             }
1364             if (raw_compiler_arg)
1365             {
1366                 strarray_add(opts.compiler_args, argv[i]);
1367                 if (next_is_arg && (i + 1 < argc))
1368                     strarray_add(opts.compiler_args, argv[i + 1]);
1369             }
1370
1371             /* skip the next token if it's an argument */
1372             if (next_is_arg) i++;
1373         }
1374         else
1375         {
1376             strarray_add(opts.files, argv[i]);
1377         }
1378     }
1379
1380     if (opts.processor == proc_cpp) linking = 0;
1381     if (linking == -1) error("Static linking is not supported\n");
1382
1383     if (opts.files->size == 0) forward(argc, argv, &opts);
1384     else if (linking) build(&opts);
1385     else compile(&opts, lang);
1386
1387     return 0;
1388 }