/* Lookup the location of the style file. */
static const char *
style_file_lookup (const char *file_name)
{
if (!IS_PATH_WITH_DIR (file_name))
{
/* It's a file name without a directory specification.
If it does not exist in the current directory... */
struct stat statbuf;
if (stat (file_name, &statbuf) < 0)
{
/* ... but it exists in the styles installation location... */
const char *gettextstylesdir = relocate (GETTEXTDATADIR "/styles");
char *possible_file_name =
xconcatenated_filename (gettextstylesdir, file_name, NULL);
if (stat (possible_file_name, &statbuf) >= 0)
{
/* ... then use the file in the styles installation directory. */
return possible_file_name;
}
free (possible_file_name);
}
/* Let the CSS library show a warning. */
}
return file_name;
}
BOOL WINAPI
DllMain (HINSTANCE module_handle, DWORD event, LPVOID reserved)
{
(void) reserved;
if (event == DLL_PROCESS_ATTACH)
{
/* The DLL is being loaded into an application's address range. */
static char location[MAX_PATH];
if (!GetModuleFileName (module_handle, location, sizeof (location)))
/* Shouldn't happen. */
return FALSE;
if (!IS_PATH_WITH_DIR (location))
/* Shouldn't happen. */
return FALSE;
{
#if defined __CYGWIN__
/* On Cygwin, we need to convert paths coming from Win32 system calls
to the Unix-like slashified notation. */
static char location_as_posix_path[2 * MAX_PATH];
/* There's no error return defined for cygwin_conv_to_posix_path.
See cygwin-api/func-cygwin-conv-to-posix-path.html.
Does it overflow the buffer of expected size MAX_PATH or does it
truncate the path? I don't know. Let's catch both. */
cygwin_conv_to_posix_path (location, location_as_posix_path);
location_as_posix_path[MAX_PATH - 1] = '\0';
if (strlen (location_as_posix_path) >= MAX_PATH - 1)
/* A sign of buffer overflow or path truncation. */
return FALSE;
shared_library_fullname = strdup (location_as_posix_path);
#else
shared_library_fullname = strdup (location);
#endif
}
}
return TRUE;
}
BOOL WINAPI
DllMain (HINSTANCE module_handle, DWORD event, LPVOID reserved)
{
(void) reserved;
if (event == DLL_PROCESS_ATTACH)
{
/* The DLL is being loaded into an application's address range. */
static char location[MAX_PATH];
if (!GetModuleFileName (module_handle, location, sizeof (location)))
/* Shouldn't happen. */
return FALSE;
if (!IS_PATH_WITH_DIR (location))
/* Shouldn't happen. */
return FALSE;
shared_library_fullname = strdup (location);
}
return TRUE;
}
BOOL WINAPI
DllMain (HINSTANCE module_handle, DWORD event, LPVOID reserved)
{
(void) reserved;
if (event == DLL_PROCESS_ATTACH)
{
static char location[MAX_PATH];
if (!GetModuleFileName (module_handle, location, sizeof (location)))
return FALSE;
if (!IS_PATH_WITH_DIR (location))
return FALSE;
shared_library_fullname = strdup (location);
}
return TRUE;
}
static void
output_skeleton (void)
{
int filter_fd[2];
pid_t pid;
/* Compute the names of the package data dir and skeleton files. */
char const *m4 = (m4 = getenv ("M4")) ? m4 : M4;
char const *datadir = pkgdatadir ();
char *m4sugar = xconcatenated_filename (datadir, "m4sugar/m4sugar.m4", NULL);
char *m4bison = xconcatenated_filename (datadir, "bison.m4", NULL);
char *skel = (IS_PATH_WITH_DIR (skeleton)
? xstrdup (skeleton)
: xconcatenated_filename (datadir, skeleton, NULL));
/* Test whether m4sugar.m4 is readable, to check for proper
installation. A faulty installation can cause deadlock, so a
cheap sanity check is worthwhile. */
xfclose (xfopen (m4sugar, "r"));
/* Create an m4 subprocess connected to us via two pipes. */
if (trace_flag & trace_tools)
fprintf (stderr, "running: %s %s - %s %s\n",
m4, m4sugar, m4bison, skel);
/* Some future version of GNU M4 (most likely 1.6) may treat the -dV in a
position-dependent manner. Keep it as the first argument so that all
files are traced.
See the thread starting at
<http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
for details. */
{
char const *argv[10];
int i = 0;
argv[i++] = m4;
/* When POSIXLY_CORRECT is set, GNU M4 1.6 and later disable GNU
extensions, which Bison's skeletons depend on. With older M4,
it has no effect. M4 1.4.12 added a -g/--gnu command-line
option to make it explicit that a program wants GNU M4
extensions even when POSIXLY_CORRECT is set.
See the thread starting at
<http://lists.gnu.org/archive/html/bug-bison/2008-07/msg00000.html>
for details. */
if (*M4_GNU_OPTION)
argv[i++] = M4_GNU_OPTION;
argv[i++] = "-I";
argv[i++] = datadir;
if (trace_flag & trace_m4)
argv[i++] = "-dV";
argv[i++] = m4sugar;
argv[i++] = "-";
argv[i++] = m4bison;
argv[i++] = skel;
argv[i++] = NULL;
aver (i <= ARRAY_CARDINALITY (argv));
/* The ugly cast is because gnulib gets the const-ness wrong. */
pid = create_pipe_bidi ("m4", m4, (char **)(void*)argv, false, true,
true, filter_fd);
}
free (m4sugar);
free (m4bison);
free (skel);
if (trace_flag & trace_muscles)
muscles_output (stderr);
{
FILE *out = xfdopen (filter_fd[1], "w");
muscles_output (out);
xfclose (out);
}
/* Read and process m4's output. */
timevar_push (TV_M4);
{
FILE *in = xfdopen (filter_fd[0], "r");
scan_skel (in);
/* scan_skel should have read all of M4's output. Otherwise, when we
close the pipe, we risk letting M4 report a broken-pipe to the
Bison user. */
aver (feof (in));
xfclose (in);
}
wait_subprocess (pid, "m4", false, false, true, true, NULL);
timevar_pop (TV_M4);
}
/* Determine the full pathname of the current executable, freshly allocated.
Return NULL if unknown.
Guaranteed to work on Linux and Woe32. Likely to work on the other
Unixes (maybe except BeOS), under most conditions. */
static char *
find_executable (const char *argv0)
{
#if defined WIN32_NATIVE
/* Native Win32 only.
On Cygwin, it is better to use the Cygwin provided /proc interface, than
to use native Win32 API and cygwin_conv_to_posix_path, because it supports
longer file names
(see <http://cygwin.com/ml/cygwin/2011-01/msg00410.html>). */
char location[MAX_PATH];
int length = GetModuleFileName (NULL, location, sizeof (location));
if (length < 0)
return NULL;
if (!IS_PATH_WITH_DIR (location))
/* Shouldn't happen. */
return NULL;
return xstrdup (location);
#else /* Unix */
# ifdef __linux__
/* The executable is accessible as /proc/<pid>/exe. In newer Linux
versions, also as /proc/self/exe. Linux >= 2.1 provides a symlink
to the true pathname; older Linux versions give only device and ino,
enclosed in brackets, which we cannot use here. */
{
char *link;
link = xreadlink ("/proc/self/exe");
if (link != NULL && link[0] != '[')
return link;
if (executable_fd < 0)
executable_fd = open ("/proc/self/exe", O_EXEC, 0);
{
char buf[6+10+5];
sprintf (buf, "/proc/%d/exe", getpid ());
link = xreadlink (buf);
if (link != NULL && link[0] != '[')
return link;
if (executable_fd < 0)
executable_fd = open (buf, O_EXEC, 0);
}
}
# endif
# ifdef __CYGWIN__
/* The executable is accessible as /proc/<pid>/exe, at least in
Cygwin >= 1.5. */
{
char *link;
link = xreadlink ("/proc/self/exe");
if (link != NULL)
return link;
if (executable_fd < 0)
executable_fd = open ("/proc/self/exe", O_EXEC, 0);
}
# endif
# if HAVE_MACH_O_DYLD_H && HAVE__NSGETEXECUTABLEPATH
/* On MacOS X 10.2 or newer, the function
int _NSGetExecutablePath (char *buf, uint32_t *bufsize);
can be used to retrieve the executable's full path. */
char location[4096];
unsigned int length = sizeof (location);
if (_NSGetExecutablePath (location, &length) == 0
&& location[0] == '/')
return canonicalize_file_name (location);
# endif
/* Guess the executable's full path. We assume the executable has been
called via execlp() or execvp() with properly set up argv[0]. The
login(1) convention to add a '-' prefix to argv[0] is not supported. */
{
bool has_slash = false;
{
const char *p;
for (p = argv0; *p; p++)
if (*p == '/')
{
has_slash = true;
break;
}
}
if (!has_slash)
{
/* exec searches paths without slashes in the directory list given
by $PATH. */
const char *path = getenv ("PATH");
if (path != NULL)
{
const char *p;
const char *p_next;
for (p = path; *p; p = p_next)
{
const char *q;
size_t p_len;
char *concat_name;
for (q = p; *q; q++)
if (*q == ':')
break;
p_len = q - p;
p_next = (*q == '\0' ? q : q + 1);
/* We have a path item at p, of length p_len.
Now concatenate the path item and argv0. */
concat_name = (char *) xmalloc (p_len + strlen (argv0) + 2);
# ifdef NO_XMALLOC
if (concat_name == NULL)
return NULL;
# endif
if (p_len == 0)
/* An empty PATH element designates the current directory. */
strcpy (concat_name, argv0);
else
{
memcpy (concat_name, p, p_len);
concat_name[p_len] = '/';
strcpy (concat_name + p_len + 1, argv0);
}
if (maybe_executable (concat_name))
return canonicalize_file_name (concat_name);
free (concat_name);
}
}
/* Not found in the PATH, assume the current directory. */
}
/* exec treats paths containing slashes as relative to the current
directory. */
if (maybe_executable (argv0))
return canonicalize_file_name (argv0);
}
/* No way to find the executable. */
return NULL;
#endif
}
/* Determine the full pathname of the current executable, freshly allocated.
Return NULL if unknown.
Guaranteed to work on Linux and Woe32. Likely to work on the other
Unixes (maybe except BeOS), under most conditions. */
static char *
find_executable (const char *argv0)
{
#if defined WIN32_NATIVE || defined __CYGWIN__
char location[MAX_PATH];
int length = GetModuleFileName (NULL, location, sizeof (location));
if (length < 0)
return NULL;
if (!IS_PATH_WITH_DIR (location))
/* Shouldn't happen. */
return NULL;
{
#if defined __CYGWIN__
/* cygwin-1.5.13 (2005-03-01) or newer would also allow a Linux-like
implementation: readlink of "/proc/self/exe". But using the
result of the Win32 system call is simpler and is consistent with the
code in relocatable.c. */
/* On Cygwin, we need to convert paths coming from Win32 system calls
to the Unix-like slashified notation. */
static char location_as_posix_path[2 * MAX_PATH];
/* There's no error return defined for cygwin_conv_to_posix_path.
See cygwin-api/func-cygwin-conv-to-posix-path.html.
Does it overflow the buffer of expected size MAX_PATH or does it
truncate the path? I don't know. Let's catch both. */
cygwin_conv_to_posix_path (location, location_as_posix_path);
location_as_posix_path[MAX_PATH - 1] = '\0';
if (strlen (location_as_posix_path) >= MAX_PATH - 1)
/* A sign of buffer overflow or path truncation. */
return NULL;
/* Call canonicalize_file_name, because Cygwin supports symbolic links. */
return canonicalize_file_name (location_as_posix_path);
#else
return xstrdup (location);
#endif
}
#else /* Unix && !Cygwin */
#ifdef __linux__
/* The executable is accessible as /proc/<pid>/exe. In newer Linux
versions, also as /proc/self/exe. Linux >= 2.1 provides a symlink
to the true pathname; older Linux versions give only device and ino,
enclosed in brackets, which we cannot use here. */
{
char *link;
link = xreadlink ("/proc/self/exe");
if (link != NULL && link[0] != '[')
return link;
if (executable_fd < 0)
executable_fd = open ("/proc/self/exe", O_RDONLY, 0);
{
char buf[6+10+5];
sprintf (buf, "/proc/%d/exe", getpid ());
link = xreadlink (buf);
if (link != NULL && link[0] != '[')
return link;
if (executable_fd < 0)
executable_fd = open (buf, O_RDONLY, 0);
}
}
#endif
#if HAVE_MACH_O_DYLD_H && HAVE__NSGETEXECUTABLEPATH
/* On MacOS X 10.2 or newer, the function
int _NSGetExecutablePath (char *buf, unsigned long *bufsize);
can be used to retrieve the executable's full path. */
char location[4096];
unsigned long length = sizeof (location);
if (_NSGetExecutablePath (location, &length) == 0
&& location[0] == '/')
return canonicalize_file_name (location);
#endif
/* Guess the executable's full path. We assume the executable has been
called via execlp() or execvp() with properly set up argv[0]. The
login(1) convention to add a '-' prefix to argv[0] is not supported. */
{
bool has_slash = false;
{
const char *p;
for (p = argv0; *p; p++)
if (*p == '/')
{
has_slash = true;
break;
}
}
if (!has_slash)
{
/* exec searches paths without slashes in the directory list given
by $PATH. */
const char *path = getenv ("PATH");
if (path != NULL)
{
const char *p;
const char *p_next;
for (p = path; *p; p = p_next)
{
const char *q;
size_t p_len;
char *concat_name;
for (q = p; *q; q++)
if (*q == ':')
break;
p_len = q - p;
p_next = (*q == '\0' ? q : q + 1);
/* We have a path item at p, of length p_len.
Now concatenate the path item and argv0. */
concat_name = (char *) xmalloc (p_len + strlen (argv0) + 2);
#ifdef NO_XMALLOC
if (concat_name == NULL)
return NULL;
#endif
if (p_len == 0)
/* An empty PATH element designates the current directory. */
strcpy (concat_name, argv0);
else
{
memcpy (concat_name, p, p_len);
concat_name[p_len] = '/';
strcpy (concat_name + p_len + 1, argv0);
}
if (maybe_executable (concat_name))
return canonicalize_file_name (concat_name);
free (concat_name);
}
}
/* Not found in the PATH, assume the current directory. */
}
/* exec treats paths containing slashes as relative to the current
directory. */
if (maybe_executable (argv0))
return canonicalize_file_name (argv0);
}
/* No way to find the executable. */
return NULL;
#endif
}
/* Determine the full pathname of the current executable, freshly allocated.
Return NULL if unknown.
Guaranteed to work on Linux and Woe32. Likely to work on the other
Unixes (maybe except BeOS), under most conditions. */
static char *
find_executable (const char *argv0)
{
#ifdef WIN32
char buf[1024];
int length = GetModuleFileName (NULL, buf, sizeof (buf));
if (length < 0)
return NULL;
if (!IS_PATH_WITH_DIR (buf))
/* Shouldn't happen. */
return NULL;
return xstrdup (buf);
#else /* Unix */
#ifdef __linux__
/* The executable is accessible as /proc/<pid>/exe. In newer Linux
versions, also as /proc/self/exe. Linux >= 2.1 provides a symlink
to the true pathname; older Linux versions give only device and ino,
enclosed in brackets, which we cannot use here. */
{
char *link;
link = xreadlink ("/proc/self/exe");
if (link != NULL && link[0] != '[')
return link;
if (executable_fd < 0)
executable_fd = open ("/proc/self/exe", O_RDONLY, 0);
{
char buf[6+10+5];
sprintf (buf, "/proc/%d/exe", getpid ());
link = xreadlink (buf);
if (link != NULL && link[0] != '[')
return link;
if (executable_fd < 0)
executable_fd = open (buf, O_RDONLY, 0);
}
}
#endif
/* Guess the executable's full path. We assume the executable has been
called via execlp() or execvp() with properly set up argv[0]. The
login(1) convention to add a '-' prefix to argv[0] is not supported. */
{
bool has_slash = false;
{
const char *p;
for (p = argv0; *p; p++)
if (*p == '/')
{
has_slash = true;
break;
}
}
if (!has_slash)
{
/* exec searches paths without slashes in the directory list given
by $PATH. */
const char *path = getenv ("PATH");
if (path != NULL)
{
const char *p;
const char *p_next;
for (p = path; *p; p = p_next)
{
const char *q;
size_t p_len;
char *concat_name;
for (q = p; *q; q++)
if (*q == ':')
break;
p_len = q - p;
p_next = (*q == '\0' ? q : q + 1);
/* We have a path item at p, of length p_len.
Now concatenate the path item and argv0. */
concat_name = (char *) xmalloc (p_len + strlen (argv0) + 2);
#ifdef NO_XMALLOC
if (concat_name == NULL)
return NULL;
#endif
if (p_len == 0)
/* An empty PATH element designates the current directory. */
strcpy (concat_name, argv0);
else
{
memcpy (concat_name, p, p_len);
concat_name[p_len] = '/';
strcpy (concat_name + p_len + 1, argv0);
}
if (maybe_executable (concat_name))
return canonicalize_file_name (concat_name);
free (concat_name);
}
}
/* Not found in the PATH, assume the current directory. */
}
/* exec treats paths containing slashes as relative to the current
directory. */
if (maybe_executable (argv0))
return canonicalize_file_name (argv0);
}
/* No way to find the executable. */
return NULL;
#endif
}
