# define EXE_EXT ".exe"
#endif
+#ifndef CC
+#define CC "gcc"
+#endif
+
+#ifndef CXX
+#define CXX "g++"
+#endif
+
+#ifndef LINK_c
+#define LINK_c "gcc"
+#endif
+
+#ifndef LINK_cxx
+#define LINK_cxx "g++"
+#endif
+
+#ifndef LIBDIR
+#define LIBDIR "/usr/local/lib"
+#endif
+
#define OBJDIR ".libs"
#ifndef SHELL_CMD
enum lib_type {
type_UNKNOWN,
- type_DYNAMIC_LIB,
type_STATIC_LIB,
+ type_DYNAMIC_LIB,
type_MODULE_LIB,
type_OBJECT,
};
typedef struct {
const char **vals;
- int num;
+ int num;
} count_chars;
typedef struct {
printf(" -prefer-non-pic prefer non position-independent-code when compiling\n");
printf(" -static create a static library when linking\n");
printf(" -no-install link libraries locally\n");
+ printf(" -rpath arg Set install path for shared libraries\n");
printf(" -l arg pass '-l arg' to the link stage\n");
printf(" -L arg pass '-L arg' to the link stage\n");
printf(" -R dir add 'dir' to runtime library search path.\n");
{
va_list ap;
int res;
-
+
va_start( ap, fmt );
res = vsnprintf( str, n, fmt, ap );
va_end( ap );
static int external_spawn(command_t *cmd, const char *file, const char **argv)
{
+ file = file; /* -Wunused */
+
if (!cmd->options.silent) {
const char **argument = argv;
- // printf("Executing: ");
+ printf("Executing: ");
while (*argument) {
printf("%s ", *argument);
argument++;
spawn_args[1] = "-c";
spawn_args[2] = command;
spawn_args[3] = NULL;
-
- return external_spawn(cmd_data, spawn_args[0], (const char**)spawn_args);
+ return external_spawn(cmd_data, spawn_args[0], spawn_args);
}
/*
#ifdef RANLIB
printc("ranlib", RANLIB);
#endif
+
}
/*
* Add a directory to the runtime library search path.
#ifdef RPATH
add_rpath(cmd_data->shared_opts.dependencies, arg);
#else
+ arg = arg; /* -Wunused */
+ cmd_data = cmd_data;
#endif
}
} else if (strcmp(var, "debug") == 0) {
cmd_data->options.debug = 1;
} else if (strcmp(var, "mode") == 0) {
+ if (cmd_data->mode != mUnknown) {
+ fprintf(stderr, "Cannot set --mode twice\n");
+ exit(1);
+ }
+
if (strcmp(value, "compile") == 0) {
cmd_data->mode = mCompile;
cmd_data->output = otObject;
}
if (strcmp(arg, "static") == 0) {
+ if ((cmd_data->mode == mLink) &&
+ (cmd_data->output == otLibrary)) {
+ cmd_data->output = otStaticLibraryOnly;
+ }
cmd_data->options.shared = share_STATIC;
return 1;
}
return 0;
}
+#ifdef TRUNCATE_DLL_NAME
static char *truncate_dll_name(char *path)
{
/* Cut DLL name down to 8 characters after removing any mod_ prefix */
return tmppath;
}
+#endif
static long safe_strtol(const char *nptr, const char **endptr, int base)
{
return 0;
}
- return rv;
+ return rv;
}
static void safe_mkdir(const char *path)
return name;
}
+#ifdef GEN_EXPORTS
/* returns just a file's name without path or extension */
static const char *nameof(const char *fullpath)
{
return name;
}
+#endif
/* version_info is in the form of MAJOR:MINOR:PATCH */
static const char *darwin_dynamic_link_function(const char *version_info)
memcpy(name, ".libs/", 6);
}
-/* genlib values
- * 0 - static
- * 1 - dynamic
- * 2 - module
- */
-static char *gen_library_name(const char *name, int genlib)
+static char *gen_library_name(const char *name, enum lib_type genlib)
{
char *newarg, *newext;
newarg = (char *)malloc(strlen(name) + 11);
- if (genlib == 2 && strncmp(name, "lib", 3) == 0) {
+ if (genlib == type_MODULE_LIB && strncmp(name, "lib", 3) == 0) {
name += 3;
}
- if (genlib == 2) {
+ if (genlib == type_MODULE_LIB) {
strcat(newarg, jlibtool_basename(name));
}
else {
newext = strrchr(newarg, '.') + 1;
switch (genlib) {
- case 0:
+ case type_STATIC_LIB:
strcpy(newext, STATIC_LIB_EXT);
break;
- case 1:
+ case type_DYNAMIC_LIB:
strcpy(newext, DYNAMIC_LIB_EXT);
break;
- case 2:
+ case type_MODULE_LIB:
strcpy(newext, MODULE_LIB_EXT);
break;
+
+ default:
+ break;
}
add_dotlibs(newarg);
return newarg;
}
-/* genlib values
- * 0 - static
- * 1 - dynamic
- * 2 - module
- */
-static char *gen_install_name(const char *name, int genlib)
+static char *gen_install_name(const char *name, enum lib_type genlib)
{
struct stat sb;
char *newname;
return newname;
}
-static char *check_object_exists(command_t *cmd, const char *arg, int arglen)
+static const char *check_object_exists(command_t *cmd, const char *arg, int arglen)
{
char *newarg, *ext;
int pass, rv;
*/
default:
break;
- }
+ }
if (cmd->options.debug) {
printf("Checking (obj): %s\n", newarg);
default:
*libtype = type_UNKNOWN;
break;
- }
+ }
if (cmd->options.debug) {
printf("Checking (lib): %s\n", newarg);
}
#endif
+#ifdef ADD_MINUS_L
/* use -L -llibname to allow to use installed libraries */
static void add_minus_l(count_chars *cc, const char *arg)
{
push_count_chars(cc, arg);
}
}
+#endif
+#if 0
static void add_linker_flag_prefix(count_chars *cc, const char *arg)
{
#ifndef LINKER_FLAG_PREFIX
push_count_chars(cc, newarg);
#endif
}
+#endif
static int explode_static_lib(command_t *cmd_data, const char *lib)
{
static int parse_input_file_name(char *arg, command_t *cmd_data)
{
- char *ext = strrchr(arg, '.');
+ const char *ext = strrchr(arg, '.');
const char *name;
int pathlen;
enum lib_type libtype;
- char *newarg;
+ const char *newarg;
if (!ext) {
return 0;
/* Try the normal dir next. */
newarg = check_library_exists(cmd_data, arg, pathlen, 0, &libtype);
if (!newarg) {
- fprintf(stderr, "Can not find suitable library for %s\n", arg);
+ fprintf(stderr, "Can not find suitable library for %s\n", arg);
exit(1);
}
}
static int parse_output_file_name(char *arg, command_t *cmd_data)
{
const char *name;
- char *ext;
+ const char *ext;
char *newarg = NULL;
int pathlen;
name = jlibtool_basename(arg);
ext = strrchr(name, '.');
-
+
#ifdef EXE_EXT
if (!ext || strcmp(ext, EXE_EXT) == 0) {
#else
assert(cmd_data->mode == mLink);
cmd_data->basename = arg;
- cmd_data->static_name.normal = gen_library_name(arg, 0);
- cmd_data->shared_name.normal = gen_library_name(arg, 1);
- cmd_data->module_name.normal = gen_library_name(arg, 2);
- cmd_data->static_name.install = gen_install_name(arg, 0);
- cmd_data->shared_name.install = gen_install_name(arg, 1);
- cmd_data->module_name.install = gen_install_name(arg, 2);
+ cmd_data->static_name.normal = gen_library_name(arg, type_STATIC_LIB);
+ cmd_data->shared_name.normal = gen_library_name(arg, type_DYNAMIC_LIB);
+ cmd_data->module_name.normal = gen_library_name(arg, type_MODULE_LIB);
+ cmd_data->static_name.install = gen_install_name(arg, type_STATIC_LIB);
+ cmd_data->shared_name.install = gen_install_name(arg, type_DYNAMIC_LIB);
+ cmd_data->module_name.install = gen_install_name(arg, type_MODULE_LIB);
if (!cmd_data->options.dry_run) {
- char *cname;
+ char *newname;
+ char *newext;
+ newname = malloc(strlen(cmd_data->static_name.normal) + 1);
- cname = malloc(strlen(cmd_data->static_name.normal) + 1);
-
- strcpy(cname, cmd_data->static_name.normal);
- ext = strrchr(cname, '/');
- if (!ext) {
+ strcpy(newname, cmd_data->static_name.normal);
+ newext = strrchr(newname, '/');
+ if (!newext) {
/* Check first to see if the dir already exists! */
safe_mkdir(".libs");
} else {
- *ext = '\0';
- safe_mkdir(cname);
+ *newext = '\0';
+ safe_mkdir(newname);
}
- free(cname);
+ free(newname);
}
#ifdef TRUNCATE_DLL_NAME
return 1;
}
+ if (strcmp(ext, STATIC_LIB_EXT) == 0) {
+ assert(cmd_data->mode == mLink);
+
+ cmd_data->basename = arg;
+ cmd_data->options.shared = share_STATIC;
+ cmd_data->output = otStaticLibraryOnly;
+ cmd_data->static_name.normal = gen_library_name(arg, type_STATIC_LIB);
+ cmd_data->static_name.install = gen_install_name(arg, type_STATIC_LIB);
+
+ if (!cmd_data->options.dry_run) {
+ char *newname;
+ char *newext;
+ newname = malloc(strlen(cmd_data->static_name.normal) + 1);
+
+ strcpy(newname, cmd_data->static_name.normal);
+ newext = strrchr(newname, '/');
+ if (!newext) {
+ /* Check first to see if the dir already exists! */
+ safe_mkdir(".libs");
+ } else {
+ *newext = '\0';
+ safe_mkdir(newname);
+ }
+ free(newname);
+ }
+
+ cmd_data->output_name = arg;
+ return 1;
+ }
+
+ if (strcmp(ext, DYNAMIC_LIB_EXT) == 0) {
+ assert(cmd_data->mode == mLink);
+
+ cmd_data->basename = arg;
+ cmd_data->options.shared = share_SHARED;
+ cmd_data->output = otDynamicLibraryOnly;
+ cmd_data->shared_name.normal = gen_library_name(arg, type_DYNAMIC_LIB);
+ cmd_data->module_name.normal = gen_library_name(arg, type_MODULE_LIB);
+ cmd_data->shared_name.install = gen_install_name(arg, type_DYNAMIC_LIB);
+ cmd_data->module_name.install = gen_install_name(arg, type_MODULE_LIB);
+
+ if (!cmd_data->options.dry_run) {
+ char *newname;
+ char *newext;
+ newname = malloc(strlen(cmd_data->shared_name.normal) + 1);
+
+ strcpy(newname, cmd_data->shared_name.normal);
+ newext = strrchr(newname, '/');
+ if (!newext) {
+ /* Check first to see if the dir already exists! */
+ safe_mkdir(".libs");
+ } else {
+ *newext = '\0';
+ safe_mkdir(newname);
+ }
+ free(newname);
+ }
+
+ cmd_data->output_name = arg;
+ return 1;
+ }
+
if (strcmp(ext, "lo") == 0) {
+ char *newext;
cmd_data->basename = arg;
cmd_data->output = otObject;
newarg = (char *)malloc(strlen(arg) + 2);
strcpy(newarg, arg);
- ext = strrchr(newarg, '.') + 1;
- strcpy(ext, OBJECT_EXT);
+ newext = strrchr(newarg, '.') + 1;
+ strcpy(newext, OBJECT_EXT);
cmd_data->output_name = newarg;
return 1;
}
+ if (strcmp(ext, DYNAMIC_LIB_EXT) == 0) {
+ fprintf(stderr, "Please build libraries with .la target, not ."
+ DYNAMIC_LIB_EXT "\n");
+ exit(1);
+ }
+
+ if (strcmp(ext, STATIC_LIB_EXT) == 0) {
+ fprintf(stderr, "Please build libraries with .la target, not ."
+ STATIC_LIB_EXT "\n");
+ exit(1);
+ }
+
return 0;
}
+static char *automode(char *arg, command_t *cmd_data)
+{
+ if (cmd_data->mode != mUnknown) return arg;
+
+ if (strcmp(arg, "CC") == 0) {
+ arg = CC;
+ cmd_data->mode = mCompile;
+
+ } else if (strcmp(arg, "CXX") == 0) {
+ arg = CXX;
+ cmd_data->mode = mCompile;
+
+ } else if (strcmp(arg, "LINK") == 0) {
+ arg = LINK_c;
+ cmd_data->mode = mLink;
+
+ } else if (strcmp(arg, "LINK.c") == 0) {
+ arg = LINK_c;
+ cmd_data->mode = mLink;
+
+ } else if (strcmp(arg, "LINK.cxx") == 0) {
+ arg = LINK_cxx;
+ cmd_data->mode = mLink;
+ }
+
+ return arg;
+}
+
static void parse_args(int argc, char *argv[], command_t *cmd_data)
{
int a;
- char *arg;
+ char *arg, *base;
int argused;
+ /*
+ * We now take a major step past libtool.
+ *
+ * IF there's no "--mode=...", AND we recognise
+ * the binary as a "special" name, THEN replace it
+ * with the correct one, and set the correct mode.
+ */
+ base = jlibtool_basename(argv[0]);
+ arg = automode(base, cmd_data);
+
+ if (arg != base) {
+ if (cmd_data->options.debug) {
+ printf("Adding: %s\n", arg);
+ }
+ push_count_chars(cmd_data->arglist, arg);
+ assert(cmd_data->mode != mUnknown);
+ }
+
+ /*
+ * We first pass over the command-line arguments looking for
+ * "--mode", etc. If so, then use the libtool compatibility
+ * method for building the software. Otherwise, auto-detect it
+ * via "-o" and the extensions.
+ */
+ base = NULL;
+ if (cmd_data->mode == mUnknown) for (a = 1; a < argc; a++) {
+ arg = argv[a];
+
+ if (strncmp(arg, "--mode=", 7) == 0) {
+ base = NULL;
+ break;
+ }
+
+ if (strncmp(arg, "-o", 2) == 0) {
+ base = argv[++a];
+ }
+ }
+
+ if (base) {
+ arg = strrchr(base, '.');
+ if (!arg) {
+ cmd_data->mode = mLink;
+ push_count_chars(cmd_data->arglist, LINK_c);
+ }
+#ifdef EXE_EXT
+ else if (strcmp(arg, EXE_EXT) == 0) {
+ cmd_data->mode = mLink;
+ push_count_chars(cmd_data->arglist, LINK_c);
+ }
+#endif
+ else if (strcmp(arg + 1, DYNAMIC_LIB_EXT) == 0) {
+ cmd_data->mode = mLink;
+ push_count_chars(cmd_data->arglist, LINK_c);
+ }
+ else if (strcmp(arg + 1, STATIC_LIB_EXT) == 0) {
+ cmd_data->mode = mLink;
+ push_count_chars(cmd_data->arglist, LINK_c);
+ }
+ else if (strcmp(arg + 1, "la") == 0) {
+ cmd_data->mode = mLink;
+ push_count_chars(cmd_data->arglist, LINK_c);
+ }
+ else if ((strcmp(arg + 1, "lo") == 0) ||
+ (strcmp(arg + 1, "o") == 0)) {
+ cmd_data->mode = mCompile;
+ push_count_chars(cmd_data->arglist, CC);
+ }
+ }
+
for (a = 1; a < argc; a++) {
arg = argv[a];
argused = 1;
}
if (!argused) {
+ /*
+ * If we still don't have a run mode, look for a magic
+ * program name CC, LINK, or whatever. Then replace that
+ * with the name of the real program we want to run.
+ */
+ if ((cmd_data->arglist->num == 0) &&
+ (cmd_data->mode == mUnknown)) {
+ arg = automode(arg, cmd_data);
+ }
+
if (cmd_data->options.debug) {
printf("Adding: %s\n", arg);
}
}
#endif
+#if 0
static const char* expand_path(const char *relpath)
{
char foo[PATH_MAX], *newpath;
getcwd(foo, PATH_MAX-1);
newpath = (char*)malloc(strlen(foo)+strlen(relpath)+2);
- strcat(newpath, foo);
+ strcpy(newpath, foo);
strcat(newpath, "/");
strcat(newpath, relpath);
return newpath;
}
+#endif
static void link_fixup(command_t *c)
{
*/
if (!c->install_path && (c->output == otDynamicLibraryOnly ||
c->output == otModule || c->output == otLibrary)) {
- c->output = otStaticLibraryOnly;
-
if (c->options.shared == share_SHARED) {
- fprintf(stderr, "Can not build a shared library without -rpath");
- exit(1);
+ c->install_path = LIBDIR;
}
}
else {
char *tmp;
push_count_chars(c->shared_opts.normal, c->shared_name.normal);
-#ifdef DYNAMIC_INSTALL_NAME
+#if 0
+ /* really #ifdef DYNAMIC_INSTALL_NAME */
push_count_chars(c->shared_opts.normal, DYNAMIC_INSTALL_NAME);
tmp = (char*)malloc(PATH_MAX);
- strcat(tmp, c->install_path);
+ strcpy(tmp, c->install_path);
strcat(tmp, strrchr(c->shared_name.normal, '/'));
push_count_chars(c->shared_opts.normal, tmp);
#endif
break;
}
-#if USE_OMF
+#ifdef USE_OMF
if (cmd_data->output == otObject ||
cmd_data->output == otProgram ||
cmd_data->output == otLibrary ||
case mExecute:
{
char *l, libpath[PATH_MAX];
-
+
strcpy(libpath, cmd_data->arglist->vals[0]);
add_dotlibs(libpath);
l = strrchr(libpath, '/');
} else {
l = ".libs/";
}
-
- setenv(LD_LIBRARY_PATH_LOCAL, "./build/lib/.libs/", 1);
+
+ setenv(LD_LIBRARY_PATH_LOCAL, l, 1);
rv = run_command(cmd_data, cmd_data->arglist);
if (rv) {
return rv;
default:
break;
- }
+ }
return 0;
}
rc = run_mode(&cmd_data);
if (!rc) {
- add_for_runtime(&cmd_data);
+ add_for_runtime(&cmd_data);
}
cleanup_tmp_dirs(&cmd_data);
projects / thirdparty / freeradius-server.git / commitdiff
