void f_utf8_to(){ struct translation *newt = get_translator((char *)sp->u.string); pop_stack(); if(!newt) error("unknown encoding"); char *text = (char *)sp->u.string; char *translated = translate_easy(newt->outgoing, text); pop_stack(); copy_and_push_string(translated); }
void f_set_encoding(){ if(current_object->interactive){ struct translation *newt = get_translator((char *)sp->u.string); if(newt){ current_object->interactive->trans = newt; return; } } pop_stack(); push_number(0); }
static void forward(int argc, char **argv, struct options* opts) { strarray* args = strarray_alloc(); int j; strarray_addall(args, get_translator(opts->processor)); for( j = 1; j < argc; j++ ) strarray_add(args, argv[j]); spawn(opts->prefix, args, 0); }
void f_str_to_arr(){ static struct translation *newt = 0; if(!newt){ newt = get_translator("UTF-32"); translate_easy(newt->outgoing, " "); } int len; int *trans = (int *)translate(newt->outgoing, sp->u.string, SVALUE_STRLEN(sp)+1, &len); len/=4; array_t *arr = allocate_array(len); while(len--) arr->item[len].u.number = trans[len]; free_svalue(sp, "str_to_arr"); put_array(arr); }
void f_arr_to_str(){ static struct translation *newt = 0; if(!newt){ newt = get_translator("UTF-32"); } int len = sp->u.arr->size; int *in = (int *)DMALLOC(sizeof(int)*(len+1), TAG_TEMPORARY, "f_arr_to_str"); char *trans; in[len] = 0; while(len--) in[len] = sp->u.arr->item[len].u.number; trans = translate(newt->incoming, (char *)in, (sp->u.arr->size+1)*4, &len); FREE(in); pop_stack(); copy_and_push_string(trans); }
static void build(struct options* opts) { static const char *stdlibpath[] = { DLLDIR, LIBDIR, "/usr/lib", "/usr/local/lib", "/lib" }; strarray *lib_dirs, *files; strarray *spec_args, *link_args; char *output_file; const char *spec_o_name; const char *output_name, *spec_file, *lang; const char* winebuild = getenv("WINEBUILD"); int generate_app_loader = 1; unsigned int j; /* NOTE: for the files array we'll use the following convention: * -axxx: xxx is an archive (.a) * -dxxx: xxx is a DLL (.def) * -lxxx: xxx is an unsorted library * -oxxx: xxx is an object (.o) * -rxxx: xxx is a resource (.res) * -sxxx: xxx is a shared lib (.so) * -xlll: lll is the language (c, c++, etc.) */ if (!winebuild) winebuild = "winebuild"; output_file = strdup( opts->output_name ? opts->output_name : "a.out" ); /* 'winegcc -o app xxx.exe.so' only creates the load script */ if (opts->files->size == 1 && strendswith(opts->files->base[0], ".exe.so")) { create_file(output_file, 0755, app_loader_template, opts->files->base[0]); return; } /* generate app loader only for .exe */ if (opts->shared || strendswith(output_file, ".exe.so")) generate_app_loader = 0; /* normalize the filename a bit: strip .so, ensure it has proper ext */ if (strendswith(output_file, ".so")) output_file[strlen(output_file) - 3] = 0; if (opts->shared) { if ((output_name = strrchr(output_file, '/'))) output_name++; else output_name = output_file; if (!strchr(output_name, '.')) output_file = strmake("%s.dll", output_file); } else if (!strendswith(output_file, ".exe")) output_file = strmake("%s.exe", output_file); /* get the filename from the path */ if ((output_name = strrchr(output_file, '/'))) output_name++; else output_name = output_file; /* prepare the linking path */ if (!opts->wine_objdir) { lib_dirs = strarray_dup(opts->lib_dirs); for ( j = 0; j < sizeof(stdlibpath)/sizeof(stdlibpath[0]); j++ ) strarray_add(lib_dirs, stdlibpath[j]); } else { lib_dirs = strarray_alloc(); strarray_add(lib_dirs, strmake("%s/dlls", opts->wine_objdir)); strarray_add(lib_dirs, strmake("%s/libs/wine", opts->wine_objdir)); strarray_addall(lib_dirs, opts->lib_dirs); } /* mark the files with their appropriate type */ spec_file = lang = 0; files = strarray_alloc(); for ( j = 0; j < opts->files->size; j++ ) { const char* file = opts->files->base[j]; if (file[0] != '-') { switch(get_file_type(file)) { case file_def: case file_spec: if (spec_file) error("Only one spec file can be specified\n"); spec_file = file; break; case file_rc: /* FIXME: invoke wrc to build it */ error("Can't compile .rc file at the moment: %s\n", file); break; case file_res: strarray_add(files, strmake("-r%s", file)); break; case file_obj: strarray_add(files, strmake("-o%s", file)); break; case file_arh: strarray_add(files, strmake("-a%s", file)); break; case file_so: strarray_add(files, strmake("-s%s", file)); break; case file_na: error("File does not exist: %s\n", file); break; default: file = compile_to_object(opts, file, lang); strarray_add(files, strmake("-o%s", file)); break; } } else if (file[1] == 'l') add_library( lib_dirs, files, file + 2 ); else if (file[1] == 'x') lang = file; } if (opts->shared && !spec_file) error("A spec file is currently needed in shared mode\n"); /* add the default libraries, if needed */ if (!opts->nostdlib && opts->use_msvcrt) add_library(lib_dirs, files, "msvcrt"); if (!opts->wine_objdir && !opts->nodefaultlibs) { if (opts->gui_app) { add_library(lib_dirs, files, "shell32"); add_library(lib_dirs, files, "comdlg32"); add_library(lib_dirs, files, "gdi32"); } add_library(lib_dirs, files, "advapi32"); add_library(lib_dirs, files, "user32"); add_library(lib_dirs, files, "kernel32"); } if (!opts->nostartfiles) add_library(lib_dirs, files, "winecrt0"); if (!opts->nostdlib) add_library(lib_dirs, files, "wine"); /* run winebuild to generate the .spec.o file */ spec_args = strarray_alloc(); spec_o_name = get_temp_file(output_name, ".spec.o"); strarray_add(spec_args, winebuild); if (verbose) strarray_add(spec_args, "-v"); if (keep_generated) strarray_add(spec_args, "--save-temps"); strarray_add(spec_args, "--as-cmd"); strarray_add(spec_args, AS); strarray_add(spec_args, "--ld-cmd"); strarray_add(spec_args, LD); strarray_addall(spec_args, strarray_fromstring(DLLFLAGS, " ")); strarray_add(spec_args, opts->shared ? "--dll" : "--exe"); strarray_add(spec_args, "-o"); strarray_add(spec_args, spec_o_name); if (spec_file) { strarray_add(spec_args, "-E"); strarray_add(spec_args, spec_file); } if (!opts->shared) { strarray_add(spec_args, "-F"); strarray_add(spec_args, output_name); strarray_add(spec_args, "--subsystem"); strarray_add(spec_args, opts->gui_app ? "windows" : "console"); if (opts->unicode_app) { strarray_add(spec_args, "--entry"); strarray_add(spec_args, "__wine_spec_exe_wentry"); } } for ( j = 0; j < lib_dirs->size; j++ ) strarray_add(spec_args, strmake("-L%s", lib_dirs->base[j])); for ( j = 0 ; j < opts->winebuild_args->size ; j++ ) strarray_add(spec_args, opts->winebuild_args->base[j]); for ( j = 0; j < files->size; j++ ) { const char* name = files->base[j] + 2; switch(files->base[j][1]) { case 'r': strarray_add(spec_args, files->base[j]); break; case 'd': case 'a': case 'o': strarray_add(spec_args, name); break; } } spawn(opts->prefix, spec_args, 0); /* link everything together now */ link_args = strarray_alloc(); strarray_addall(link_args, get_translator(opts->processor)); strarray_addall(link_args, strarray_fromstring(LDDLLFLAGS, " ")); strarray_add(link_args, "-o"); strarray_add(link_args, strmake("%s.so", output_file)); for ( j = 0 ; j < opts->linker_args->size ; j++ ) strarray_add(link_args, opts->linker_args->base[j]); #ifdef __APPLE__ if (opts->image_base) { strarray_add(link_args, "-image_base"); strarray_add(link_args, opts->image_base); } #endif for ( j = 0; j < lib_dirs->size; j++ ) strarray_add(link_args, strmake("-L%s", lib_dirs->base[j])); strarray_add(link_args, spec_o_name); for ( j = 0; j < files->size; j++ ) { const char* name = files->base[j] + 2; switch(files->base[j][1]) { case 'l': case 's': strarray_add(link_args, strmake("-l%s", name)); break; case 'a': case 'o': strarray_add(link_args, name); break; } } if (!opts->nostdlib) { strarray_add(link_args, "-lm"); strarray_add(link_args, "-lc"); } spawn(opts->prefix, link_args, 0); /* set the base address */ if (opts->image_base) { const char *prelink = PRELINK; if (prelink[0] && strcmp(prelink,"false")) { strarray *prelink_args = strarray_alloc(); strarray_add(prelink_args, prelink); strarray_add(prelink_args, "--reloc-only"); strarray_add(prelink_args, opts->image_base); strarray_add(prelink_args, strmake("%s.so", output_file)); spawn(opts->prefix, prelink_args, 1); strarray_free(prelink_args); } } /* create the loader script */ if (generate_app_loader) { if (strendswith(output_file, ".exe")) output_file[strlen(output_file) - 4] = 0; create_file(output_file, 0755, app_loader_template, strmake("%s.exe.so", output_name)); } }
static void compile(struct options* opts, const char* lang) { strarray* comp_args = strarray_alloc(); unsigned int j; int gcc_defs = 0; switch(opts->processor) { case proc_cpp: gcc_defs = 1; break; #ifdef __GNUC__ /* Note: if the C compiler is gcc we assume the C++ compiler is too */ /* mixing different C and C++ compilers isn't supported in configure anyway */ case proc_cc: gcc_defs = 1; break; case proc_cxx: gcc_defs = 1; break; #else case proc_cc: gcc_defs = 0; break; case proc_cxx: gcc_defs = 0; break; #endif case proc_as: gcc_defs = 0; break; } strarray_addall(comp_args, get_translator(opts->processor)); if (opts->processor != proc_cpp) { #ifdef CC_FLAG_SHORT_WCHAR if (!opts->wine_objdir && !opts->noshortwchar) { strarray_add(comp_args, CC_FLAG_SHORT_WCHAR); strarray_add(comp_args, "-DWINE_UNICODE_NATIVE"); } #endif strarray_addall(comp_args, strarray_fromstring(DLLFLAGS, " ")); } #ifdef _WIN64 strarray_add(comp_args, "-DWIN64"); strarray_add(comp_args, "-D_WIN64"); strarray_add(comp_args, "-D__WIN64"); strarray_add(comp_args, "-D__WIN64__"); #else strarray_add(comp_args, "-DWIN32"); strarray_add(comp_args, "-D_WIN32"); strarray_add(comp_args, "-D__WIN32"); strarray_add(comp_args, "-D__WIN32__"); #endif strarray_add(comp_args, "-D__WINNT"); strarray_add(comp_args, "-D__WINNT__"); if (gcc_defs) { #ifdef __APPLE__ /* Mac OS X uses a 16-byte aligned stack and not a 4-byte one */ strarray_add(comp_args, "-D__stdcall=__attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))"); strarray_add(comp_args, "-D__cdecl=__attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))"); strarray_add(comp_args, "-D_stdcall=__attribute__((__stdcall__)) __attribute__((__force_align_arg_pointer__))"); strarray_add(comp_args, "-D_cdecl=__attribute__((__cdecl__)) __attribute__((__force_align_arg_pointer__))"); #else strarray_add(comp_args, "-D__stdcall=__attribute__((__stdcall__))"); strarray_add(comp_args, "-D__cdecl=__attribute__((__cdecl__))"); strarray_add(comp_args, "-D_stdcall=__attribute__((__stdcall__))"); strarray_add(comp_args, "-D_cdecl=__attribute__((__cdecl__))"); #endif strarray_add(comp_args, "-D__fastcall=__attribute__((__fastcall__))"); 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(comp_args, "-D__WINE__"); strarray_add(comp_args, "-D__int8=char"); strarray_add(comp_args, "-D__int16=short"); /* FIXME: what about 64-bit platforms? */ strarray_add(comp_args, "-D__int32=int"); #ifdef HAVE_LONG_LONG strarray_add(comp_args, "-D__int64=long long"); #endif /* options we handle explicitly */ if (opts->compile_only) strarray_add(comp_args, "-c"); if (opts->output_name) { strarray_add(comp_args, "-o"); strarray_add(comp_args, opts->output_name); } /* the rest of the pass-through parameters */ for ( j = 0 ; j < opts->compiler_args->size ; j++ ) strarray_add(comp_args, opts->compiler_args->base[j]); /* the language option, if any */ if (lang && strcmp(lang, "-xnone")) strarray_add(comp_args, lang); /* last, but not least, the files */ for ( j = 0; j < opts->files->size; j++ ) { if (opts->files->base[j][0] != '-') strarray_add(comp_args, opts->files->base[j]); } /* standard includes come last in the include search path */ #ifdef __GNUC__ #define SYS_INCLUDE "-isystem" #else #define SYS_INCLUDE "-I" #endif if (!opts->wine_objdir && !opts->nostdinc) { if (opts->use_msvcrt) { strarray_add(comp_args, SYS_INCLUDE INCLUDEDIR "/msvcrt"); strarray_add(comp_args, "-D__MSVCRT__"); } strarray_add(comp_args, SYS_INCLUDE INCLUDEDIR "/windows"); } #undef SYS_INCLUDE spawn(opts->prefix, comp_args, 0); }