Merge winewrap into winegcc. Many cleanups.
diff --git a/tools/winegcc/.cvsignore b/tools/winegcc/.cvsignore
index 52b9a43..011635b 100644
--- a/tools/winegcc/.cvsignore
+++ b/tools/winegcc/.cvsignore
@@ -1,3 +1,2 @@
Makefile
winegcc
-winewrap
diff --git a/tools/winegcc/Makefile.in b/tools/winegcc/Makefile.in
index 62f7c51..74bee1a 100644
--- a/tools/winegcc/Makefile.in
+++ b/tools/winegcc/Makefile.in
@@ -5,14 +5,11 @@
VPATH = @srcdir@
MODULE = none
-PROGRAMS = \
- winegcc \
- winewrap
+PROGRAMS = winegcc
C_SRCS = \
utils.c \
- winegcc.c \
- winewrap.c
+ winegcc.c
all: $(PROGRAMS)
@@ -21,18 +18,13 @@
winegcc: winegcc.o utils.o
$(CC) $(CFLAGS) -o $@ winegcc.o utils.o $(LIBPORT)
-winewrap: winewrap.o utils.o
- $(CC) $(CFLAGS) -o $@ winewrap.o utils.o $(LIBPORT)
-
install:: $(PROGRAMS)
$(MKINSTALLDIRS) $(bindir)
$(INSTALL_PROGRAM) winegcc $(bindir)/winegcc
- $(INSTALL_PROGRAM) winewrap $(bindir)/winewrap
cd $(bindir) && $(RM) wineg++ && $(LN_S) winegcc wineg++
cd $(bindir) && $(RM) winecpp && $(LN_S) winegcc winecpp
uninstall::
- $(RM) $(bindir)/winegcc $(bindir)/wineg++ \
- $(bindir)/winecpp $(bindir)/winewrap
+ $(RM) $(bindir)/winegcc $(bindir)/wineg++ $(bindir)/winecpp
### Dependencies:
diff --git a/tools/winegcc/utils.c b/tools/winegcc/utils.c
index 61d4857..d1541e0 100644
--- a/tools/winegcc/utils.c
+++ b/tools/winegcc/utils.c
@@ -36,7 +36,7 @@
int verbose = 0;
-void error(const char *s, ...)
+void error(const char* s, ...)
{
va_list ap;
@@ -48,9 +48,10 @@
exit(2);
}
-void *xmalloc(size_t size)
+void* xmalloc(size_t size)
{
- void *p;
+ void* p;
+
if ((p = malloc (size)) == NULL)
error("Can not malloc %d bytes.", size);
@@ -66,14 +67,22 @@
return p2;
}
-char *strmake(const char *fmt, ...)
+int strendswith(const char* str, const char* end)
+{
+ int l = strlen(str);
+ int m = strlen(end);
+
+ return l >= m && strcmp(str + l - m, end) == 0;
+}
+
+char* strmake(const char* fmt, ...)
{
int n;
size_t size = 100;
- char *p;
+ char* p;
va_list ap;
- p = xmalloc (size);
+ p = xmalloc (size);
while (1)
{
va_start(ap, fmt);
@@ -85,9 +94,9 @@
}
}
-strarray *strarray_alloc(void)
+strarray* strarray_alloc(void)
{
- strarray *arr = xmalloc(sizeof(*arr));
+ strarray* arr = xmalloc(sizeof(*arr));
arr->maximum = arr->size = 0;
arr->base = NULL;
return arr;
@@ -109,19 +118,137 @@
arr->base[arr->size++] = str;
}
-void spawn(const strarray* arr)
+strarray* strarray_dup(const strarray* arr)
+{
+ strarray* dup = strarray_alloc();
+ int i;
+
+ for (i = 0; i < arr->size; i++)
+ strarray_add(dup, arr->base[i]);
+
+ return dup;
+}
+
+char* get_basename(const char* file)
+{
+ const char* name;
+ char *base_name, *p;
+
+ if ((name = strrchr(file, '/'))) name++;
+ else name = file;
+
+ base_name = strdup(name);
+ if ((p = strrchr(base_name, '.'))) *p = 0;
+
+ return base_name;
+}
+
+void create_file(const char* name, const char* fmt, ...)
+{
+ va_list ap;
+ FILE *file;
+
+ if (verbose) printf("Creating file %s\n", name);
+ va_start(ap, fmt);
+ if ( !(file = fopen(name, "w")) )
+ error ("Can not create %s.", name);
+ vfprintf(file, fmt, ap);
+ va_end(ap);
+ fclose(file);
+}
+
+file_type get_file_type(const char* dir, const char* filename)
+{
+ /* see tools/winebuild/res32.c: check_header for details */
+ static const char res_sig[] = { 0,0,0,0, 32,0,0,0, 0xff,0xff, 0,0, 0xff,0xff, 0,0, 0,0,0,0, 0,0, 0,0, 0,0,0,0, 0,0,0,0 };
+ char buf[sizeof(res_sig)];
+ char *fullname;
+ int fd, cnt;
+
+ fullname = strmake("%s/%s", dir, filename);
+ fd = open( fullname, O_RDONLY );
+ cnt = read(fd, buf, sizeof(buf));
+ if (cnt == -1) error("Can't read file: %s/%s", dir, filename);
+ free( fullname );
+ close( fd );
+
+ if (fd == -1) return file_na;
+
+ if (cnt == sizeof(res_sig) && !memcmp(buf, res_sig, sizeof(res_sig))) return file_res;
+ if (strendswith(filename, ".o")) return file_obj;
+ if (strendswith(filename, ".a")) return file_arh;
+ if (strendswith(filename, ".res")) return file_res;
+ if (strendswith(filename, ".so")) return file_so;
+ if (strendswith(filename, ".def")) return file_dll;
+ if (strendswith(filename, ".rc")) return file_rc;
+
+ return file_other;
+}
+
+static file_type try_lib_path(const char* dir, const char* pre,
+ const char* library, const char* ext)
+{
+ char *fullname;
+ file_type type;
+
+ fullname = strmake("%s%s%s", pre, library, ext);
+ if (verbose > 1) fprintf(stderr, "Try %s/%s...", dir, fullname);
+ type = get_file_type(dir, fullname);
+ free( fullname );
+ if (verbose > 1) fprintf(stderr, type == file_na ? "no\n" : "FOUND!\n");
+ return type;
+}
+
+static file_type guess_lib_type(const char* dir, const char* library)
+{
+ /* Unix shared object */
+ if (try_lib_path(dir, "lib", library, ".so") == file_so)
+ return file_so;
+
+ /* Windows DLL */
+ if (try_lib_path(dir, "lib", library, ".def") == file_dll)
+ return file_dll;
+ if (try_lib_path(dir, "", library, ".def") == file_dll)
+ return file_dll;
+
+ /* Unix static archives */
+ if (try_lib_path(dir, "lib", library, ".a") == file_arh)
+ return file_arh;
+
+ return file_na;
+}
+
+file_type get_lib_type(strarray* path, const char* library)
+{
+ int i;
+
+ for (i = 0; i < path->size; i++)
+ {
+ file_type type = guess_lib_type(path->base[i], library);
+ if (type != file_na) return type;
+ }
+ return file_na;
+}
+
+void spawn(const strarray* args)
{
int i, status;
+ strarray* arr = strarray_dup(args);
const char **argv = arr->base;
+ strarray_add(arr, NULL);
if (verbose)
{
for(i = 0; argv[i]; i++) printf("%s ", argv[i]);
printf("\n");
}
- if (!(status = spawnvp( _P_WAIT, argv[0], argv))) return;
- if (status > 0) error("%s failed.", argv[0]);
- else perror("Error:");
- exit(3);
+ if ((status = spawnvp( _P_WAIT, argv[0], argv)))
+ {
+ if (status > 0) error("%s failed.", argv[0]);
+ else perror("Error:");
+ exit(3);
+ }
+
+ strarray_free(arr);
}
diff --git a/tools/winegcc/utils.h b/tools/winegcc/utils.h
index 053798f..c0c0b4f 100644
--- a/tools/winegcc/utils.h
+++ b/tools/winegcc/utils.h
@@ -21,11 +21,12 @@
*/
-void error(const char *s, ...);
+void error(const char* s, ...);
-void *xmalloc(size_t size);
-void *xrealloc(void* p, size_t size);
-char *strmake(const char *fmt, ...);
+void* xmalloc(size_t size);
+void* xrealloc(void* p, size_t size);
+char* strmake(const char* fmt, ...);
+int strendswith(const char* str, const char* end);
typedef struct {
size_t maximum;
@@ -33,10 +34,20 @@
const char** base;
} strarray;
-strarray *strarray_alloc(void);
+strarray* strarray_alloc(void);
+strarray* strarray_dup(const strarray* arr);
void strarray_free(strarray* arr);
void strarray_add(strarray* arr, const char* str);
+typedef enum {
+ file_na, file_other, file_obj, file_res,
+ file_rc, file_arh, file_dll, file_so
+} file_type;
+
+char* get_basename(const char* file);
+void create_file(const char* name, const char* fmt, ...);
+file_type get_file_type(const char* dir, const char* filename);
+file_type get_lib_type(strarray* path, const char* library);
void spawn(const strarray* arr);
extern int verbose;
diff --git a/tools/winegcc/winegcc.c b/tools/winegcc/winegcc.c
index 04c2667..5786a23 100644
--- a/tools/winegcc/winegcc.c
+++ b/tools/winegcc/winegcc.c
@@ -2,6 +2,7 @@
* MinGW wrapper: makes gcc behave like MinGW.
*
* Copyright 2000 Manuel Novoa III
+ * Copyright 2000 Francois Gouget
* Copyright 2002 Dimitrie O. Paun
*
* This library is free software; you can redistribute it and/or
@@ -95,6 +96,61 @@
#include "utils.h"
+static const char *app_loader_template =
+ "#!/bin/sh\n"
+ "\n"
+ "appname=\"%s\"\n"
+ "# determine the application directory\n"
+ "appdir=''\n"
+ "case \"$0\" in\n"
+ " */*)\n"
+ " # $0 contains a path, use it\n"
+ " appdir=`dirname \"$0\"`\n"
+ " ;;\n"
+ " *)\n"
+ " # no directory in $0, search in PATH\n"
+ " saved_ifs=$IFS\n"
+ " IFS=:\n"
+ " for d in $PATH\n"
+ " do\n"
+ " IFS=$saved_ifs\n"
+ " if [ -x \"$d/$appname\" ]; then appdir=\"$d\"; break; fi\n"
+ " done\n"
+ " ;;\n"
+ "esac\n"
+ "\n"
+ "while true; do\n"
+ " case \"$1\" in\n"
+ " --debugmsg)\n"
+ " debugmsg=\"$1 $2\"\n"
+ " shift; shift;\n"
+ " ;;\n"
+ " --dll)\n"
+ " dll=\"$1 $2\"\n"
+ " shift; shift;\n"
+ " ;;\n"
+ " *)\n"
+ " break\n"
+ " ;;\n"
+ " esac\n"
+ "done\n"
+ "\n"
+ "# figure out the full app path\n"
+ "if [ -n \"$appdir\" ]; then\n"
+ " apppath=\"$appdir/$appname.exe.so\"\n"
+ " WINEDLLPATH=\"$appdir:$WINEDLLPATH\"\n"
+ " export WINEDLLPATH\n"
+ "else\n"
+ " apppath=\"$appname.exe.so\"\n"
+ "fi\n"
+ "\n"
+ "# determine the WINELOADER\n"
+ "if [ ! -x \"$WINELOADER\" ]; then WINELOADER=\"wine\"; fi\n"
+ "\n"
+ "# and try to start the app\n"
+ "exec \"$WINELOADER\" $debugmsg $dll -- \"$apppath\" \"$@\"\n"
+;
+
static int keep_generated = 0;
static strarray *tmp_files;
@@ -115,36 +171,25 @@
strarray* files;
};
-static strarray* build_compile_cmd(struct options* opts);
-
-static int strendswith(const char *str, const char *end)
-{
- int l = strlen(str);
- int m = strlen(end);
-
- return l >= m && strcmp(str + l - m, end) == 0;
-}
-
static void clean_temp_files()
{
- if (!keep_generated)
- {
- int i;
- for (i = 0; i < tmp_files->size; i++)
- unlink(tmp_files->base[i]);
- }
- strarray_free(tmp_files);
+ int i;
+
+ if (keep_generated) return;
+
+ for (i = 0; i < tmp_files->size; i++)
+ unlink(tmp_files->base[i]);
}
-static char *get_temp_file(const char *suffix)
+char* get_temp_file(const char* prefix, const char* suffix)
{
- char *tmp = strmake("wgcc.XXXXXX%s", suffix);
+ char *tmp = strmake("%s-XXXXXX%s", prefix, suffix);
int fd = mkstemps( tmp, strlen(suffix) );
if (fd == -1)
{
/* could not create it in current directory, try in /tmp */
free(tmp);
- tmp = strmake("/tmp/wgcc.XXXXXX%s", suffix);
+ tmp = strmake("/tmp/%s-XXXXXX%s", prefix, suffix);
fd = mkstemps( tmp, strlen(suffix) );
if (fd == -1) error( "could not create temp file" );
}
@@ -154,36 +199,6 @@
return tmp;
}
-static int is_object_file(const char* arg)
-{
- return strendswith(arg, ".o")
- || strendswith(arg, ".a")
- || strendswith(arg, ".res");
-}
-
-static const char *get_obj_file(const char* file, struct options* opts)
-{
- strarray* compargv;
- struct options copts;
-
- if (is_object_file(file)) return file;
-
- /* make a copy we so don't change any of the initial stuff */
- /* a shallow copy is exactly what we want in this case */
- copts = *opts;
- copts.processor = proc_cc;
- copts.output_name = get_temp_file(".o");
- copts.compile_only = 1;
- copts.files = strarray_alloc();
- strarray_add(copts.files, file);
- compargv = build_compile_cmd(&copts);
- spawn(compargv);
- strarray_free(copts.files);
- strarray_free(compargv);
-
- return copts.output_name;
-}
-
static const char* get_translator(struct options* args)
{
const char* cc = proc_cc; /* keep compiler happy */
@@ -199,134 +214,285 @@
return cc;
}
-static strarray* build_compile_cmd(struct options* opts)
+static void compile(struct options* opts)
{
- strarray *gcc_argv = strarray_alloc();
+ strarray *comp_args = strarray_alloc();
int j;
- strarray_add(gcc_argv, get_translator(opts));
+ strarray_add(comp_args, get_translator(opts));
if (opts->processor != proc_pp)
{
- strarray_add(gcc_argv, "-fshort-wchar");
- strarray_add(gcc_argv, "-fPIC");
+ strarray_add(comp_args, "-fshort-wchar");
+ strarray_add(comp_args, "-fPIC");
}
if (!opts->nostdinc)
{
if (opts->use_msvcrt)
{
- strarray_add(gcc_argv, "-I" INCLUDEDIR "/msvcrt");
- strarray_add(gcc_argv, "-D__MSVCRT__");
+ strarray_add(comp_args, "-I" INCLUDEDIR "/msvcrt");
+ strarray_add(comp_args, "-D__MSVCRT__");
}
- strarray_add(gcc_argv, "-I" INCLUDEDIR "/windows");
+ strarray_add(comp_args, "-I" INCLUDEDIR "/windows");
}
- strarray_add(gcc_argv, "-DWIN32");
- strarray_add(gcc_argv, "-D_WIN32");
- strarray_add(gcc_argv, "-D__WIN32");
- strarray_add(gcc_argv, "-D__WIN32__");
- strarray_add(gcc_argv, "-D__WINNT");
- strarray_add(gcc_argv, "-D__WINNT__");
+ strarray_add(comp_args, "-DWIN32");
+ strarray_add(comp_args, "-D_WIN32");
+ strarray_add(comp_args, "-D__WIN32");
+ strarray_add(comp_args, "-D__WIN32__");
+ strarray_add(comp_args, "-D__WINNT");
+ strarray_add(comp_args, "-D__WINNT__");
- strarray_add(gcc_argv, "-D__stdcall=__attribute__((__stdcall__))");
- strarray_add(gcc_argv, "-D__cdecl=__attribute__((__cdecl__))");
- strarray_add(gcc_argv, "-D__fastcall=__attribute__((__fastcall__))");
- strarray_add(gcc_argv, "-D_stdcall=__attribute__((__stdcall__))");
- strarray_add(gcc_argv, "-D_cdecl=__attribute__((__cdecl__))");
- strarray_add(gcc_argv, "-D_fastcall=__attribute__((__fastcall__))");
- strarray_add(gcc_argv, "-D__declspec(x)=__declspec_##x");
- strarray_add(gcc_argv, "-D__declspec_align(x)=__attribute__((aligned(x)))");
- strarray_add(gcc_argv, "-D__declspec_allocate(x)=__attribute__((section(x)))");
- strarray_add(gcc_argv, "-D__declspec_deprecated=__attribute__((deprecated))");
- strarray_add(gcc_argv, "-D__declspec_dllimport=__attribute__((dllimport))");
- strarray_add(gcc_argv, "-D__declspec_dllexport=__attribute__((dllexport))");
- strarray_add(gcc_argv, "-D__declspec_naked=__attribute__((naked))");
- strarray_add(gcc_argv, "-D__declspec_noinline=__attribute__((noinline))");
- strarray_add(gcc_argv, "-D__declspec_noreturn=__attribute__((noreturn))");
- strarray_add(gcc_argv, "-D__declspec_nothrow=__attribute__((nothrow))");
- strarray_add(gcc_argv, "-D__declspec_novtable=__attribute__(())"); /* ignore it */
- strarray_add(gcc_argv, "-D__declspec_selectany=__attribute__((weak))");
- strarray_add(gcc_argv, "-D__declspec_thread=__thread");
+ strarray_add(comp_args, "-D__stdcall=__attribute__((__stdcall__))");
+ strarray_add(comp_args, "-D__cdecl=__attribute__((__cdecl__))");
+ strarray_add(comp_args, "-D__fastcall=__attribute__((__fastcall__))");
+ strarray_add(comp_args, "-D_stdcall=__attribute__((__stdcall__))");
+ strarray_add(comp_args, "-D_cdecl=__attribute__((__cdecl__))");
+ strarray_add(comp_args, "-D_fastcall=__attribute__((__fastcall__))");
+ strarray_add(comp_args, "-D__declspec(x)=__declspec_##x");
+ strarray_add(comp_args, "-D__declspec_align(x)=__attribute__((aligned(x)))");
+ strarray_add(comp_args, "-D__declspec_allocate(x)=__attribute__((section(x)))");
+ strarray_add(comp_args, "-D__declspec_deprecated=__attribute__((deprecated))");
+ strarray_add(comp_args, "-D__declspec_dllimport=__attribute__((dllimport))");
+ strarray_add(comp_args, "-D__declspec_dllexport=__attribute__((dllexport))");
+ strarray_add(comp_args, "-D__declspec_naked=__attribute__((naked))");
+ strarray_add(comp_args, "-D__declspec_noinline=__attribute__((noinline))");
+ strarray_add(comp_args, "-D__declspec_noreturn=__attribute__((noreturn))");
+ strarray_add(comp_args, "-D__declspec_nothrow=__attribute__((nothrow))");
+ strarray_add(comp_args, "-D__declspec_novtable=__attribute__(())"); /* ignore it */
+ strarray_add(comp_args, "-D__declspec_selectany=__attribute__((weak))");
+ strarray_add(comp_args, "-D__declspec_thread=__thread");
/* Wine specific defines */
- strarray_add(gcc_argv, "-D__WINE__");
- strarray_add(gcc_argv, "-DWINE_UNICODE_NATIVE");
- strarray_add(gcc_argv, "-D__int8=char");
- strarray_add(gcc_argv, "-D__int16=short");
- strarray_add(gcc_argv, "-D__int32=int");
- strarray_add(gcc_argv, "-D__int64=long long");
+ strarray_add(comp_args, "-D__WINE__");
+ strarray_add(comp_args, "-DWINE_UNICODE_NATIVE");
+ strarray_add(comp_args, "-D__int8=char");
+ strarray_add(comp_args, "-D__int16=short");
+ strarray_add(comp_args, "-D__int32=int");
+ strarray_add(comp_args, "-D__int64=long long");
/* options we handle explicitly */
if (opts->compile_only)
- strarray_add(gcc_argv, "-c");
+ strarray_add(comp_args, "-c");
if (opts->output_name)
- strarray_add(gcc_argv, strmake("-o%s", opts->output_name));
+ strarray_add(comp_args, strmake("-o%s", opts->output_name));
/* the rest of the pass-through parameters */
for ( j = 0 ; j < opts->compiler_args->size ; j++ )
- strarray_add(gcc_argv, opts->compiler_args->base[j]);
+ strarray_add(comp_args, opts->compiler_args->base[j]);
/* last, but not least, the files */
for ( j = 0; j < opts->files->size; j++ )
- strarray_add(gcc_argv, opts->files->base[j]);
+ strarray_add(comp_args, opts->files->base[j]);
- return gcc_argv;
+ spawn(comp_args);
}
-
-static strarray* build_link_cmd(struct options* opts)
+static const char* compile_to_object(struct options* opts, const char* file)
{
- strarray *gcc_argv = strarray_alloc();
+ struct options copts;
+ char* base_name;
+
+ /* make a copy we so don't change any of the initial stuff */
+ /* a shallow copy is exactly what we want in this case */
+ base_name = get_basename(file);
+ copts = *opts;
+ copts.processor = proc_cc;
+ copts.output_name = get_temp_file(base_name, ".o");
+ copts.compile_only = 1;
+ copts.files = strarray_alloc();
+ strarray_add(copts.files, file);
+ compile(&copts);
+ strarray_free(copts.files);
+ free(base_name);
+
+ return copts.output_name;
+}
+
+static void build(struct options* opts)
+{
+ static const char *stdlibpath[] = { DLLDIR, LIBDIR, "/usr/lib", "/usr/local/lib" };
+ strarray *so_libs, *arh_libs, *dll_libs, *lib_paths, *lib_dirs;
+ strarray *res_files, *obj_files, *spec_args, *comp_args, *link_args;
+ char *spec_c_name, *spec_o_name, *base_file, *base_name;
+ const char* output_name;
int j;
- strarray_add(gcc_argv, "winewrap");
- if (opts->gui_app) strarray_add(gcc_argv, "-mgui");
+ so_libs = strarray_alloc();
+ arh_libs = strarray_alloc();
+ dll_libs = strarray_alloc();
+ obj_files = strarray_alloc();
+ res_files = strarray_alloc();
+ lib_paths = strarray_alloc();
- if (opts->processor == proc_cpp) strarray_add(gcc_argv, "-C");
+ output_name = opts->output_name ? opts->output_name : "a.out.exe";
- if (opts->output_name)
- strarray_add(gcc_argv, strmake("-o%s", opts->output_name));
- else
- strarray_add(gcc_argv, "-oa.out");
+ /* get base filename by removing the .exe extension, if present */
+ base_file = strdup(output_name);
+ if (strendswith(base_file, ".exe")) base_file[strlen(base_file) - 4] = 0;
+ base_name = get_basename(output_name);
- for ( j = 0 ; j < opts->linker_args->size ; j++ )
- strarray_add(gcc_argv, opts->linker_args->base[j]);
+ /* prepare the linking path */
+ lib_dirs = strarray_dup(opts->lib_dirs);
+ for ( j = 0; j < sizeof(stdlibpath)/sizeof(stdlibpath[0]);j++ )
+ strarray_add(lib_dirs, stdlibpath[j]);
- for ( j = 0; j < opts->lib_dirs->size; j++ )
- strarray_add(gcc_argv, strmake("-L%s", opts->lib_dirs->base[j]));
+ for ( j = 0; j < lib_dirs->size; j++ )
+ strarray_add(lib_paths, strmake("-L%s", lib_dirs->base[j]));
+ /* prepare the libraries */
for ( j = 0; j < opts->lib_names->size; j++ )
- strarray_add(gcc_argv, strmake("-l%s", opts->lib_names->base[j]));
+ {
+ const char* name = opts->lib_names->base[j];
+ const char* lib = strmake("-l%s", name);
+ switch(get_lib_type(lib_dirs, name))
+ {
+ case file_arh:
+ strarray_add(arh_libs, lib);
+ break;
+ case file_dll:
+ strarray_add(dll_libs, lib);
+ break;
+ case file_so:
+ strarray_add(so_libs, lib);
+ break;
+ default:
+ fprintf(stderr, "Can't find library %s, ignoring\n", name);
+ }
+ }
if (!opts->nostdlib)
{
- if (opts->use_msvcrt) strarray_add(gcc_argv, "-lmsvcrt");
+ if (opts->use_msvcrt) strarray_add(dll_libs, "-lmsvcrt");
}
if (!opts->nodefaultlibs)
{
- if (opts->gui_app) strarray_add(gcc_argv, "-lcomdlg32");
- strarray_add(gcc_argv, "-ladvapi32");
- strarray_add(gcc_argv, "-lshell32");
+ if (opts->gui_app)
+ {
+ strarray_add(dll_libs, "-lcomdlg32");
+ strarray_add(dll_libs, "-lgdi32");
+ }
+ strarray_add(dll_libs, "-lshell32");
+ strarray_add(dll_libs, "-ladvapi32");
+ strarray_add(dll_libs, "-luser32");
+ strarray_add(dll_libs, "-lkernel32");
}
+ /* sort object file */
for ( j = 0; j < opts->files->size; j++ )
- strarray_add(gcc_argv, get_obj_file(opts->files->base[j], opts));
+ {
+ const char* file = opts->files->base[j];
+ switch(get_file_type(".", file))
+ {
+ case file_rc:
+ /* FIXME: invoke wrc to build it */
+ break;
+ case file_res:
+ strarray_add(res_files, file);
+ break;
+ case file_obj:
+ strarray_add(obj_files, file);
+ break;
+ case file_na:
+ error("File does not exist: %s", file);
+ break;
+ default:
+ file = compile_to_object(opts, file);
+ strarray_add(obj_files, file);
+ break;
+ }
+ }
- return gcc_argv;
+ /* run winebuild to generate the .spec.c file */
+ spec_args = strarray_alloc();
+ spec_c_name = get_temp_file(base_name, ".spec.c");
+ strarray_add(spec_args, "winebuild");
+ strarray_add(spec_args, "-o");
+ strarray_add(spec_args, spec_c_name);
+ strarray_add(spec_args, "--exe");
+ strarray_add(spec_args, strmake("%s.exe", base_name));
+ strarray_add(spec_args, opts->gui_app ? "-mgui" : "-mcui");
+
+ for ( j = 0; j < lib_paths->size; j++ )
+ strarray_add(spec_args, lib_paths->base[j]);
+
+ for ( j = 0; j < dll_libs->size; j++ )
+ strarray_add(spec_args, dll_libs->base[j]);
+
+ for ( j = 0; j < arh_libs->size; j++)
+ strarray_add(spec_args, arh_libs->base[j]);
+
+ for ( j = 0; j < res_files->size; j++ )
+ strarray_add(spec_args, res_files->base[j]);
+
+ for ( j = 0; j < obj_files->size; j++ )
+ strarray_add(spec_args, obj_files->base[j]);
+
+ spawn(spec_args);
+
+ /* compile the .spec.c file into a .spec.o file */
+ comp_args = strarray_alloc();
+ spec_o_name = get_temp_file(base_name, ".spec.o");
+ strarray_add(comp_args, "gcc");
+ strarray_add(comp_args, "-fPIC");
+ strarray_add(comp_args, "-o");
+ strarray_add(comp_args, spec_o_name);
+ strarray_add(comp_args, "-c");
+ strarray_add(comp_args, spec_c_name);
+
+ spawn(comp_args);
+
+ /* link everything together now */
+ link_args = strarray_alloc();
+ strarray_add(link_args, get_translator(opts));
+ strarray_add(link_args, "-shared");
+#ifdef HAVE_LINKER_INIT_FINI
+ strarray_add(link_args, "-Wl,-Bsymbolic,-z,defs,-init,__wine_spec_init,-fini,__wine_spec_fini");
+#else
+ strarray_add(link_args, "-Wl,-Bsymbolic,-z,defs");
+#endif
+
+ strarray_add(link_args, strmake("-o%s.exe.so", base_file));
+
+ for ( j = 0 ; j < opts->linker_args->size ; j++ )
+ strarray_add(link_args, opts->linker_args->base[j]);
+
+ for ( j = 0; j < lib_paths->size; j++ )
+ strarray_add(link_args, lib_paths->base[j]);
+
+ strarray_add(link_args, "-lwine");
+ strarray_add(link_args, "-lm");
+
+ for ( j = 0; j < so_libs->size; j++ )
+ strarray_add(link_args, so_libs->base[j]);
+
+ for ( j = 0; j < arh_libs->size; j++ )
+ strarray_add(link_args, arh_libs->base[j]);
+
+ for ( j = 0; j < obj_files->size; j++ )
+ strarray_add(link_args, obj_files->base[j]);
+
+ strarray_add(link_args, spec_o_name);
+
+ spawn(link_args);
+
+ /* create the loader script */
+ create_file(base_file, app_loader_template, base_name);
+ chmod(base_file, 0755);
}
-static strarray* build_forward_cmd(int argc, char **argv, struct options* opts)
+static void forward(int argc, char **argv, struct options* opts)
{
- strarray *gcc_argv = strarray_alloc();
+ strarray *args = strarray_alloc();
int j;
- strarray_add(gcc_argv, get_translator(opts));
+ strarray_add(args, get_translator(opts));
for( j = 1; j < argc; j++ )
- strarray_add(gcc_argv, argv[j]);
+ strarray_add(args, argv[j]);
- return gcc_argv;
+ spawn(args);
}
/*
@@ -406,7 +572,6 @@
int raw_compiler_arg, raw_linker_arg;
const char* option_arg;
struct options opts;
- strarray *gcc_argv;
/* setup tmp file removal at exit */
tmp_files = strarray_alloc();
@@ -537,6 +702,8 @@
case 's':
if (strcmp("-static", argv[i]) == 0)
linking = -1;
+ else if(strcmp("-save-temps", argv[i]) == 0)
+ keep_generated = 1;
break;
case 'v':
if (argv[i][2] == 0) verbose = 1;
@@ -566,13 +733,9 @@
if (opts.processor == proc_pp) linking = 0;
if (linking == -1) error("Static linking is not supported.");
- if (opts.files->size == 0)
- gcc_argv = build_forward_cmd(argc, argv, &opts);
- else if (linking)
- gcc_argv = build_link_cmd(&opts);
- else
- gcc_argv = build_compile_cmd(&opts);
- spawn(gcc_argv);
+ if (opts.files->size == 0) forward(argc, argv, &opts);
+ else if (linking) build(&opts);
+ else compile(&opts);
return 0;
}
