?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shell32/shlview: Try to use IShellDetails to respond on notifications if IShellFolder...
[wine/multimedia.git] / tools / winegcc / winegcc.c
blob10a4d7a20790e4796c5e2342a87b422b7675a92a
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 }
Maarten's multimedia branch