9cd188e3c7
And additional wrapper that is needed for the ZDS-II build is a wrapper for the compiler and assemble. This is needed because the ZDS-II cannot control the name or location of the output of the output object file: it is always in the same directory as the source file and with the same name as the source file except with the .obj extension. This was handled in the past with the MOVEOBJ definition which was specifically called Makefiles to move the objects to the correct position. However, now there is a new behavior: Output object files may also be named differently with added decoration in the file name. This is done in the current apps/ directory build. There is currently some ugly implementation that includes a long sequence of Bash code to handle the moving and/or renaming. There is nothing in place for the Windows native case. This wrapper, when complete, will clean up the Makefiles, improve build performance, and provide a solution that is portable to both the Cywin/MSYS environment as well as to the Windows native environment.
1023 lines
26 KiB
C
1023 lines
26 KiB
C
/****************************************************************************
|
|
* tools/zds/zdsar.c
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
#include <ctype.h>
|
|
#include <libgen.h>
|
|
#include <errno.h>
|
|
|
|
#ifdef HOST_CYGWIN
|
|
# include <sys/cygwin.h>
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
#define MAX_BUFFER (4096)
|
|
#define MAX_EXPAND (2048)
|
|
|
|
/* MAX_PATH might be defined in stdlib.h */
|
|
|
|
#if !defined(MAX_PATH)
|
|
# define MAX_PATH (512)
|
|
#endif
|
|
|
|
/* NAME_MAX is typically defined in limits.h */
|
|
|
|
#if !defined(NAME_MAX)
|
|
|
|
/* FILENAME_MAX might be defined in stdio.h */
|
|
|
|
# if defined(FILENAME_MAX)
|
|
# define NAME_MAX FILENAME_MAX
|
|
# else
|
|
|
|
/* MAXNAMELEN might be defined in dirent.h */
|
|
|
|
# include <dirent.h>
|
|
# if defined(MAXNAMLEN)
|
|
# define NAME_MAX MAXNAMLEN
|
|
# else
|
|
|
|
/* Lets not let a silly think like this stop us... just make something up */
|
|
|
|
# define NAME_MAX 256
|
|
# endif
|
|
# endif
|
|
#endif
|
|
|
|
/* Maximum objects per librarian call.
|
|
*
|
|
* REVISIT: The librarian is supposed to handle multiple object insertions
|
|
* per call, but my experience is that it is unreliable in that case.
|
|
*/
|
|
|
|
#define MAX_OBJECTS 1 /* 64 */
|
|
|
|
/* Name of the host. The ZDS-II toolchain runs only on Windows. Therefore,
|
|
* the only options are (1) Windows native, or (2) Cygwin or environments
|
|
* that derive for Cygwin (like MSYS2).
|
|
*/
|
|
|
|
#define WINSEPARATOR '\\'
|
|
|
|
#if defined(HOST_NATIVE)
|
|
# define SEPARATOR '\\'
|
|
# define HOSTNAME "Native" /* Windows native */
|
|
#elif defined(HOST_CYGWIN)
|
|
# define SEPARATOR '/'
|
|
# define HOSTNAME "Cygwin" /* Cygwin or MSYS under Windows */
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
static char *g_current_wd = NULL; /* Current working directory */
|
|
static char *g_ar = NULL; /* Full path to the librarian program */
|
|
static char *g_arflags = NULL; /* Flags to use with the librarian program */
|
|
static char *g_libpath = NULL; /* Path to the library */
|
|
static char *g_libname = NULL; /* Library file name*/
|
|
static char *g_objects = NULL; /* List of object files */
|
|
static int g_debug = 0; /* Debug output enabled if >0 */
|
|
|
|
static char g_command[MAX_BUFFER]; /* Full librarian command */
|
|
static char g_initial_wd[MAX_PATH]; /* Initial working directory */
|
|
static char g_path[MAX_PATH]; /* Buffer for expanding paths */
|
|
static char g_objpath[MAX_PATH]; /* Temporary for path generation */
|
|
#ifdef HOST_CYGWIN
|
|
static char g_expand[MAX_EXPAND]; /* Temporary for expanded path */
|
|
static char g_dequoted[MAX_PATH]; /* Temporary for de-quoted path */
|
|
static char g_hostpath[MAX_PATH]; /* Temporary for host path conversions */
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/* MinGW does not seem to provide strtok_r */
|
|
|
|
#ifndef HAVE_STRTOK_R
|
|
static char *my_strtok_r(char *str, const char *delim, char **saveptr)
|
|
{
|
|
char *pbegin;
|
|
char *pend = NULL;
|
|
|
|
/* Decide if we are starting a new string or continuing from
|
|
* the point we left off.
|
|
*/
|
|
|
|
if (str)
|
|
{
|
|
pbegin = str;
|
|
}
|
|
else if (saveptr && *saveptr)
|
|
{
|
|
pbegin = *saveptr;
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* Find the beginning of the next token */
|
|
|
|
for (;
|
|
*pbegin && strchr(delim, *pbegin) != NULL;
|
|
pbegin++);
|
|
|
|
/* If we are at the end of the string with nothing
|
|
* but delimiters found, then return NULL.
|
|
*/
|
|
|
|
if (!*pbegin)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* Find the end of the token */
|
|
|
|
for (pend = pbegin + 1;
|
|
*pend && strchr(delim, *pend) == NULL;
|
|
pend++);
|
|
|
|
/* pend either points to the end of the string or to
|
|
* the first delimiter after the string.
|
|
*/
|
|
|
|
if (*pend)
|
|
{
|
|
/* Turn the delimiter into a null terminator */
|
|
|
|
*pend++ = '\0';
|
|
}
|
|
|
|
/* Save the pointer where we left off and return the
|
|
* beginning of the token.
|
|
*/
|
|
|
|
if (saveptr)
|
|
{
|
|
*saveptr = pend;
|
|
}
|
|
|
|
return pbegin;
|
|
}
|
|
|
|
#undef strtok_r
|
|
# define strtok_r my_strtok_r
|
|
#endif
|
|
|
|
static void append(char **base, char *str)
|
|
{
|
|
char *oldbase;
|
|
char *newbase;
|
|
int alloclen;
|
|
|
|
oldbase = *base;
|
|
if (oldbase == NULL)
|
|
{
|
|
newbase = strdup(str);
|
|
if (!newbase)
|
|
{
|
|
fprintf(stderr, "ERROR: Failed to strdup %s\n", str);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
alloclen = strlen(oldbase) + strlen(str) + sizeof((char) ' ') +
|
|
sizeof((char) '\0');
|
|
newbase = (char *)malloc(alloclen);
|
|
if (!newbase)
|
|
{
|
|
fprintf(stderr, "ERROR: Failed to allocate %d bytes\n", alloclen);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
snprintf(newbase, alloclen, "%s %s", oldbase, str);
|
|
free(oldbase);
|
|
}
|
|
|
|
*base = newbase;
|
|
}
|
|
|
|
static const char *do_expand(const char *argument)
|
|
{
|
|
#ifdef HOST_CYGWIN
|
|
const char *src;
|
|
char *dest;
|
|
int len;
|
|
|
|
src = argument;
|
|
dest = g_expand;
|
|
len = 0;
|
|
|
|
while (*src && len < MAX_EXPAND)
|
|
{
|
|
if (*src == '\\')
|
|
{
|
|
/* Copy backslash */
|
|
|
|
*dest++ = *src++;
|
|
if (++len >= MAX_EXPAND)
|
|
{
|
|
break;
|
|
}
|
|
|
|
/* Already expanded? */
|
|
|
|
if (*src == '\\')
|
|
{
|
|
/* Yes... just copy all consecutive backslashes */
|
|
|
|
do
|
|
{
|
|
*dest++ = *src++;
|
|
if (++len >= MAX_EXPAND)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
while (*src == '\\');
|
|
}
|
|
else
|
|
{
|
|
/* No.. expend */
|
|
|
|
*dest++ = '\\';
|
|
if (++len >= MAX_EXPAND)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*dest++ = *src++;
|
|
len++;
|
|
}
|
|
}
|
|
|
|
if (*src)
|
|
{
|
|
fprintf(stderr, "ERROR: Truncated during expansion string "
|
|
"is too long [%lu/%u]\n",
|
|
(unsigned long)strlen(argument), MAX_EXPAND);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
*dest = '\0';
|
|
return g_expand;
|
|
#else
|
|
return argument;
|
|
#endif
|
|
}
|
|
|
|
/* Remove backslash quoting from a path */
|
|
|
|
#ifdef HOST_CYGWIN
|
|
static bool dequote_path(const char *winpath)
|
|
{
|
|
char *dest = g_dequoted;
|
|
const char *src = winpath;
|
|
int len = 0;
|
|
bool quoted = false;
|
|
|
|
while (*src && len < MAX_PATH)
|
|
{
|
|
if (src[0] != '\\' ||
|
|
(src[1] != ' ' && src[1] != '(' && src[1] != ')'))
|
|
{
|
|
*dest++ = *src;
|
|
len++;
|
|
}
|
|
else
|
|
{
|
|
quoted = true;
|
|
}
|
|
|
|
src++;
|
|
}
|
|
|
|
if (*src || len >= MAX_PATH)
|
|
{
|
|
fprintf(stderr, "# ERROR: Path truncated\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
*dest = '\0';
|
|
return quoted;
|
|
}
|
|
#endif
|
|
|
|
/* If using Cygwin with a Window's Toolchain, then we have to convert the
|
|
* POSIX path to a Windows or POSIX path.
|
|
*/
|
|
|
|
#ifdef HOST_CYGWIN
|
|
static const char *convert_path(const char *path, cygwin_conv_path_t what)
|
|
{
|
|
const char *retptr;
|
|
ssize_t size;
|
|
ssize_t ret;
|
|
bool quoted;
|
|
|
|
quoted = dequote_path(path);
|
|
if (quoted)
|
|
{
|
|
retptr = g_hostpath;
|
|
}
|
|
else
|
|
{
|
|
retptr = &g_hostpath[1];
|
|
}
|
|
|
|
size = cygwin_conv_path(what | CCP_RELATIVE, g_dequoted, NULL, 0);
|
|
if (size > (MAX_PATH - 3))
|
|
{
|
|
fprintf(stderr, "# ERROR: POSIX path too long: %lu\n",
|
|
(unsigned long)size);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
ret = cygwin_conv_path(what | CCP_RELATIVE, g_dequoted,
|
|
&g_hostpath[1], MAX_PATH - 3);
|
|
if (ret < 0)
|
|
{
|
|
fprintf(stderr, "# ERROR: cygwin_conv_path '%s' failed: %s\n",
|
|
g_dequoted, strerror(errno));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (quoted)
|
|
{
|
|
size++;
|
|
g_hostpath[0] = '"';
|
|
g_hostpath[size] = '"';
|
|
}
|
|
|
|
g_hostpath[size + 1] = '\0';
|
|
return retptr;
|
|
}
|
|
#endif
|
|
|
|
static const char *convert_path_windows(const char *path)
|
|
{
|
|
#ifdef HOST_CYGWIN
|
|
return convert_path(path, CCP_POSIX_TO_WIN_A);
|
|
#else
|
|
return path;
|
|
#endif
|
|
}
|
|
|
|
static const char *convert_path_posix(const char *path)
|
|
{
|
|
#ifdef HOST_CYGWIN
|
|
return convert_path(path, CCP_WIN_A_TO_POSIX);
|
|
#else
|
|
return path;
|
|
#endif
|
|
}
|
|
|
|
static void show_usage(const char *progname, const char *msg, int exitcode)
|
|
{
|
|
if (msg)
|
|
{
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "%s:\n", msg);
|
|
}
|
|
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "%s [OPTIONS] --ar \"<AR>\" --library \"<LIBRARY>\" "
|
|
"obj [obj [obj...]]\n",
|
|
progname);
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "Where:\n");
|
|
fprintf(stderr, " --ar <AR>\n");
|
|
fprintf(stderr, " A command line string that defines how to execute the "
|
|
"ZDS-II librarian\n");
|
|
fprintf(stderr, " --library \"<LIBRARY>\"\n");
|
|
fprintf(stderr, " The library into which the object files will be "
|
|
"inserted\n");
|
|
fprintf(stderr, " obj\n");
|
|
fprintf(stderr, " One or more object files that will be inserted into "
|
|
"the archive. Each expected\n");
|
|
fprintf(stderr, " to reside in the current directory unless --obj-path "
|
|
"is provided on the command line\n");
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "And [OPTIONS] include:\n");
|
|
fprintf(stderr, " --ar_flags \"<ARFLAGS>\"\n");
|
|
fprintf(stderr, " Optional librarian flags\n");
|
|
fprintf(stderr, " --obj-path <path>\n");
|
|
fprintf(stderr, " Do not look in the current directory for the object "
|
|
"files. Instead, look in <path> to\n");
|
|
fprintf(stderr, " for the object files. --obj-path may be used once "
|
|
"on the command line\n");
|
|
fprintf(stderr, " --debug\n");
|
|
fprintf(stderr, " Enable %s debug output\n", progname);
|
|
fprintf(stderr, " --help\n");
|
|
fprintf(stderr, " Shows this message and exits\n");
|
|
exit(exitcode);
|
|
}
|
|
|
|
static void parse_args(int argc, char **argv)
|
|
{
|
|
char *library = NULL;
|
|
char *objpath = NULL;
|
|
int argidx;
|
|
|
|
/* Parse arguments */
|
|
|
|
for (argidx = 1; argidx < argc; argidx++)
|
|
{
|
|
if (strcmp(argv[argidx], "--ar") == 0)
|
|
{
|
|
argidx++;
|
|
if (argidx >= argc)
|
|
{
|
|
show_usage(argv[0], "ERROR: Missing argument to --ar",
|
|
EXIT_FAILURE);
|
|
}
|
|
else if (g_ar != NULL)
|
|
{
|
|
show_usage(argv[0], "ERROR: Multiple --ar arguments",
|
|
EXIT_FAILURE);
|
|
}
|
|
|
|
g_ar = argv[argidx];
|
|
}
|
|
else if (strcmp(argv[argidx], "--ar_flags") == 0)
|
|
{
|
|
argidx++;
|
|
if (argidx >= argc)
|
|
{
|
|
show_usage(argv[0], "ERROR: Missing argument to --ar_flags",
|
|
EXIT_FAILURE);
|
|
}
|
|
else if (g_arflags != NULL)
|
|
{
|
|
show_usage(argv[0], "ERROR: Multiple --ar_flags arguments",
|
|
EXIT_FAILURE);
|
|
}
|
|
|
|
g_arflags = argv[argidx];
|
|
}
|
|
else if (strcmp(argv[argidx], "--library") == 0)
|
|
{
|
|
const char *tmp_path;
|
|
|
|
argidx++;
|
|
if (argidx >= argc)
|
|
{
|
|
show_usage(argv[0], "ERROR: Missing argument to --library",
|
|
EXIT_FAILURE);
|
|
}
|
|
else if (library != NULL)
|
|
{
|
|
show_usage(argv[0], "ERROR: Multiple --library arguments",
|
|
EXIT_FAILURE);
|
|
}
|
|
|
|
/* Convert the library path a POSIX. NOTE this is a no-op in Windows
|
|
* native mode.
|
|
*/
|
|
|
|
tmp_path = convert_path_posix(argv[argidx]);
|
|
library = strdup(tmp_path);
|
|
if (library == NULL)
|
|
{
|
|
fprintf(stderr, "ERROR: strdup() failed\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
else if (strcmp(argv[argidx], "--obj-path") == 0)
|
|
{
|
|
argidx++;
|
|
if (argidx >= argc)
|
|
{
|
|
show_usage(argv[0], "ERROR: Missing argument to --obj-path",
|
|
EXIT_FAILURE);
|
|
}
|
|
else if (objpath != NULL)
|
|
{
|
|
show_usage(argv[0], "ERROR: Multiple --obj-path arguments",
|
|
EXIT_FAILURE);
|
|
}
|
|
|
|
objpath = argv[argidx];
|
|
}
|
|
else if (strcmp(argv[argidx], "--debug") == 0)
|
|
{
|
|
g_debug++;
|
|
}
|
|
else if (strcmp(argv[argidx], "--help") == 0)
|
|
{
|
|
show_usage(argv[0], NULL, EXIT_SUCCESS);
|
|
}
|
|
else if (strncmp(argv[argidx], "--", 2) == 0)
|
|
{
|
|
show_usage(argv[0], "ERROR: Unrecognized option", EXIT_FAILURE);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Accumulate object files */
|
|
|
|
for (; argidx < argc; argidx++)
|
|
{
|
|
append(&g_objects, argv[argidx]);
|
|
}
|
|
|
|
if (g_debug)
|
|
{
|
|
fprintf(stderr, "Selections:\n");
|
|
fprintf(stderr, " CWD : [%s]\n",
|
|
g_initial_wd);
|
|
fprintf(stderr, " Host Environ : [%s]\n",
|
|
HOSTNAME);
|
|
fprintf(stderr, " AR : [%s]\n",
|
|
g_ar ? g_ar : "(None)");
|
|
fprintf(stderr, " AR Flags : [%s]\n",
|
|
g_arflags ? g_arflags : "(None)");
|
|
fprintf(stderr, " Library : [%s]\n",
|
|
library ? library : "(None)");
|
|
fprintf(stderr, " Object Path : [%s]\n",
|
|
objpath ? objpath : "(None");
|
|
fprintf(stderr, " Object Files : [%s]\n\n",
|
|
g_objects ? g_objects : "(None)");
|
|
}
|
|
|
|
/* Check for required parameters */
|
|
|
|
if (g_ar == NULL)
|
|
{
|
|
show_usage(argv[0], "ERROR: No librarian specified",
|
|
EXIT_FAILURE);
|
|
}
|
|
|
|
if (library == NULL)
|
|
{
|
|
show_usage(argv[0], "ERROR: No library specified",
|
|
EXIT_FAILURE);
|
|
}
|
|
else
|
|
{
|
|
/* Separate the library file name from the path. The ZDS-II librarian
|
|
* expects the library to be in the current working directory.
|
|
*/
|
|
|
|
g_libname = basename(library); /* Must come first */
|
|
g_libpath = dirname(library);
|
|
}
|
|
|
|
if (g_objects == NULL)
|
|
{
|
|
/* Don't report an error -- this happens normally in some configurations */
|
|
|
|
printf("No object files specified\n");
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
g_objpath[0] = '\0';
|
|
if (objpath != NULL)
|
|
{
|
|
const char *hostpath;
|
|
int pathlen;
|
|
|
|
/* If the object path relative to the current working directory? */
|
|
|
|
/* It is a relative path if the path does not begin with the path
|
|
* segment separator or if in the Windows native case, it begins
|
|
* with a volume specified like C:.
|
|
*/
|
|
|
|
pathlen = 0;
|
|
|
|
#ifdef HOST_NATIVE
|
|
if (objpath[0] != SEPARATOR ||
|
|
(isalpha(objpath[0]) && objpath[1] != ':'))
|
|
#else
|
|
if (objpath[0] != SEPARATOR)
|
|
#endif
|
|
{
|
|
/* Add the default working directory to the path */
|
|
|
|
/* Copy the initial working directory */
|
|
|
|
pathlen = strlen(g_initial_wd);
|
|
if (pathlen >= MAX_PATH)
|
|
{
|
|
fprintf(stderr, "ERROR: Working directory path is "
|
|
"too long [%d/%d]: %s\n",
|
|
pathlen, MAX_PATH, g_initial_wd);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
strcpy(g_path, g_initial_wd);
|
|
|
|
/* Append a separator is one is not already present */
|
|
|
|
if (g_path[pathlen - 1] != WINSEPARATOR)
|
|
{
|
|
int newlen = pathlen + 1;
|
|
if (newlen >= MAX_PATH)
|
|
{
|
|
fprintf(stderr, "ERROR: Object path is too long "
|
|
"with separator[%d/%d]: %s\n",
|
|
newlen, MAX_PATH, g_initial_wd);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
g_path[pathlen] = WINSEPARATOR;
|
|
g_path[pathlen + 1] = '\0';
|
|
pathlen = newlen;
|
|
}
|
|
}
|
|
|
|
/* Add the object file path after the current working directory */
|
|
|
|
pathlen += strlen(objpath);
|
|
if (pathlen >= MAX_PATH)
|
|
{
|
|
fprintf(stderr, "ERROR: Path+objpath is too long [%d/%d]\n",
|
|
pathlen, MAX_PATH);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
strcat(g_path, objpath);
|
|
|
|
/* Convert the POSIX working directory to a Windows native path. NOTE
|
|
* that convert_path_windows() is a no-op in Windows native mode.
|
|
*/
|
|
|
|
hostpath = convert_path_windows(g_path);
|
|
strcpy(g_objpath, hostpath);
|
|
}
|
|
|
|
/* The object was in the current working directory. If a library path
|
|
* is NOT the current working directory, then the library path will now
|
|
* be the current working directory and the path to the objects will be
|
|
* the working directory when the program was started.
|
|
*/
|
|
|
|
else if (g_libpath != NULL && strcmp(g_libpath, ".") != 0)
|
|
{
|
|
const char *converted = convert_path_windows(g_initial_wd);
|
|
strcpy(g_objpath, converted);
|
|
}
|
|
|
|
if (g_debug)
|
|
{
|
|
fprintf(stderr, "Derived:\n");
|
|
fprintf(stderr, " Object Path : [%s]\n",
|
|
g_objpath[0] != '\0' ? g_objpath : "(None");
|
|
fprintf(stderr, " Library Path : [%s]\n",
|
|
g_libpath ? g_libpath : "(None)");
|
|
fprintf(stderr, " Library Name : [%s]\n\n",
|
|
g_libname ? g_libname : "(None)");
|
|
}
|
|
}
|
|
|
|
static void do_archive(void)
|
|
{
|
|
struct stat buf;
|
|
char *alloc;
|
|
char *objects;
|
|
char *object;
|
|
char *lasts;
|
|
int cmdlen;
|
|
int pathlen;
|
|
int objlen;
|
|
int totallen;
|
|
int nobjects;
|
|
int ret;
|
|
|
|
/* Make a copy of g_objects. We need to do this because at least the version
|
|
* of strtok_r above does modify it.
|
|
*/
|
|
|
|
alloc = strdup(g_objects);
|
|
if (alloc == NULL)
|
|
{
|
|
fprintf(stderr, "ERROR: Failed to strdup object list\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
objects = alloc;
|
|
|
|
/* We may have to loop since we limit the number of objects in each call
|
|
* to the librarian.
|
|
*/
|
|
|
|
lasts = NULL;
|
|
for (; ; )
|
|
{
|
|
/* Copy the librarian into the command buffer */
|
|
|
|
cmdlen = strlen(g_ar);
|
|
if (cmdlen >= MAX_BUFFER)
|
|
{
|
|
fprintf(stderr, "ERROR: Librarian string is too long [%d/%d]: %s\n",
|
|
cmdlen, MAX_BUFFER, g_ar);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
strcpy(g_command, g_ar);
|
|
|
|
/* Add a space */
|
|
|
|
g_command[cmdlen] = ' ';
|
|
cmdlen++;
|
|
g_command[cmdlen] = '\0';
|
|
|
|
/* Copy the librarian flags into the command buffer */
|
|
|
|
if (g_arflags != NULL)
|
|
{
|
|
const char *expanded;
|
|
|
|
expanded = do_expand(g_arflags);
|
|
cmdlen += strlen(expanded);
|
|
|
|
if (cmdlen >= MAX_BUFFER)
|
|
{
|
|
fprintf(stderr, "ERROR: CFLAG string is too long [%d/%d]: %s\n",
|
|
cmdlen, MAX_BUFFER, g_arflags);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
strcat(g_command, expanded);
|
|
}
|
|
|
|
/* Add each object file. This loop will continue until each path has been
|
|
* tried (failure) or until stat() finds the object file
|
|
*/
|
|
|
|
nobjects = 0;
|
|
while ((object = strtok_r(objects, " ", &lasts)) != NULL)
|
|
{
|
|
const char *expanded;
|
|
const char *converted;
|
|
|
|
/* Set objects to NULL. This will force strtok_r to move from the
|
|
* the first object in the list.
|
|
*/
|
|
|
|
objects = NULL;
|
|
|
|
/* Add a space */
|
|
|
|
g_command[cmdlen] = ' ';
|
|
cmdlen++;
|
|
g_command[cmdlen] = '\0';
|
|
|
|
/* Create a full path to the object file */
|
|
|
|
g_path[0] = '\0';
|
|
pathlen = 0;
|
|
|
|
/* Add the path to buffer path buffer first */
|
|
|
|
if (g_objpath[0] != '\0')
|
|
{
|
|
/* Copy the obj_path */
|
|
|
|
pathlen = strlen(g_objpath);
|
|
if (pathlen >= MAX_PATH)
|
|
{
|
|
fprintf(stderr, "ERROR: Path is too long [%d/%d]: %s\n",
|
|
pathlen, MAX_PATH, g_objpath);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
strcpy(g_path, g_objpath);
|
|
|
|
/* Append a separator is one is not already present */
|
|
|
|
if (g_path[pathlen - 1] != WINSEPARATOR)
|
|
{
|
|
int newlen = pathlen + 1;
|
|
if (newlen >= MAX_PATH)
|
|
{
|
|
fprintf(stderr, "ERROR: Path is too long with "
|
|
"separator[%d/%d]: %s\n",
|
|
newlen, MAX_PATH, g_path);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
g_path[pathlen] = WINSEPARATOR;
|
|
g_path[pathlen + 1] = '\0';
|
|
pathlen = newlen;
|
|
}
|
|
}
|
|
|
|
/* Add the object file name after the path */
|
|
|
|
objlen = strlen(object);
|
|
pathlen += objlen;
|
|
if (pathlen >= MAX_PATH)
|
|
{
|
|
fprintf(stderr, "ERROR: Path+objfile is too long [%d/%d]\n",
|
|
pathlen, MAX_PATH);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
strcat(g_path, object);
|
|
|
|
/* Check that a object file actually exists at this path. NOTE
|
|
* that convert_path_posix() is a no-op in Windows native mode.
|
|
*/
|
|
|
|
converted = convert_path_posix(g_path);
|
|
ret = stat(converted, &buf);
|
|
if (ret < 0)
|
|
{
|
|
fprintf(stderr, "WARNING: Stat of object %s failed: %s\n",
|
|
g_path, strerror(errno));
|
|
continue;
|
|
}
|
|
|
|
if (!S_ISREG(buf.st_mode))
|
|
{
|
|
fprintf(stderr, "ERROR: Object %s exists but is not a regular "
|
|
"file\n",
|
|
g_path);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/* Expand the path */
|
|
|
|
/* Copy the librarian argument of form like:
|
|
*
|
|
* <libname>=-+<objpath>
|
|
*/
|
|
|
|
pathlen = 4; /* For =-+ and terminator */
|
|
|
|
expanded = do_expand(g_path);
|
|
pathlen += strlen(expanded);
|
|
|
|
/* Get the full length */
|
|
|
|
pathlen += strlen(g_libname);
|
|
totallen = cmdlen + pathlen;
|
|
|
|
if (totallen >= MAX_BUFFER)
|
|
{
|
|
fprintf(stderr, "ERROR: object argument is too long [%d/%d]: "
|
|
"%s=-+%s\n",
|
|
totallen, MAX_BUFFER, g_libname, expanded);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/* Append the next librarian command */
|
|
|
|
pathlen = snprintf(&g_command[cmdlen], MAX_BUFFER - cmdlen, "%s=-+%s",
|
|
g_libname, expanded);
|
|
cmdlen += pathlen;
|
|
|
|
/* Terminate early if we have a LOT files in the command line */
|
|
|
|
if (++nobjects >= MAX_OBJECTS)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Handling the final command which may have not objects to insert */
|
|
|
|
if (nobjects > 0)
|
|
{
|
|
/* Okay.. we have everything. Add the object files to the library.
|
|
* On a failure to start the compiler, system() will return -1;
|
|
* Otherwise, the returned value from the compiler is in
|
|
* WEXITSTATUS(ret).
|
|
*/
|
|
|
|
if (g_debug)
|
|
{
|
|
fprintf(stderr, "Executing: %s\n", g_command);
|
|
}
|
|
|
|
ret = system(g_command);
|
|
#ifdef WEXITSTATUS
|
|
if (ret < 0 || WEXITSTATUS(ret) != 0)
|
|
{
|
|
if (ret < 0)
|
|
{
|
|
fprintf(stderr, "ERROR: system failed: %s\n",
|
|
strerror(errno));
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "ERROR: %s failed: %d\n", g_ar,
|
|
WEXITSTATUS(ret));
|
|
}
|
|
|
|
fprintf(stderr, " command: %s\n", g_command);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
#else
|
|
if (ret < 0)
|
|
{
|
|
fprintf(stderr, "ERROR: system failed: %s\n", strerror(errno));
|
|
fprintf(stderr, " command: %s\n", g_command);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
#endif
|
|
|
|
/* We don't really know that the command succeeded... Let's
|
|
* assume that it did
|
|
*/
|
|
}
|
|
|
|
/* Check if we have more objects to process */
|
|
|
|
if (object == NULL)
|
|
{
|
|
/* No, we are finished */
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
free(alloc);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
int main(int argc, char **argv, char **envp)
|
|
{
|
|
char *wd;
|
|
int ret;
|
|
|
|
/* Get the current working directory */
|
|
|
|
wd = getcwd(g_initial_wd, MAX_PATH);
|
|
if (wd == NULL)
|
|
{
|
|
fprintf(stderr, "ERROR: getcwd failed: %s\n", strerror(errno));
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
g_current_wd = g_initial_wd;
|
|
|
|
/* Parse command line parameters */
|
|
|
|
parse_args(argc, argv);
|
|
|
|
/* Change to the directory containing the library */
|
|
|
|
if (g_libpath != NULL && strcmp(g_libpath, ".") != 0)
|
|
{
|
|
ret = chdir(g_libpath);
|
|
if (ret < 0)
|
|
{
|
|
fprintf(stderr, "ERROR: getcwd failed: %s\n", strerror(errno));
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
g_current_wd = g_libpath;
|
|
}
|
|
|
|
/* Then generate dependencies for each path on the command line. */
|
|
|
|
do_archive();
|
|
return EXIT_SUCCESS;
|
|
}
|