void
fn_free P1C(fn_type *, f)
{
assert (FN_STRING (*f) != NULL);
free (FN_STRING (*f));
FN_STRING (*f) = NULL;
FN_ALLOCATED (*f) = 0;
FN_LENGTH (*f) = 0;
}
fn_type
fn_copy0 P2C(const_string, s, unsigned, len)
{
fn_type ret;
FN_ALLOCATED (ret) = CHUNK_SIZE > len ? CHUNK_SIZE : len + 1;
FN_STRING (ret) = (string)xmalloc (FN_ALLOCATED (ret));
strncpy (FN_STRING (ret), s, len);
FN_STRING (ret)[len] = 0;
FN_LENGTH (ret) = len + 1;
return ret;
}
void
fn_grow P3C(fn_type *, f, const_string, source, unsigned, len)
{
grow (f, len);
strncpy (FN_STRING (*f) + FN_LENGTH (*f), source, len);
FN_LENGTH (*f) += len;
}
void
fn_1grow P2C(fn_type *, f, char, c)
{
grow (f, 1);
FN_STRING (*f)[FN_LENGTH (*f)] = c;
FN_LENGTH (*f)++;
}
void
fn_shrink_to P2C(fn_type *, f, unsigned, loc)
{
assert (FN_LENGTH (*f) > loc);
FN_STRING (*f)[loc] = 0;
FN_LENGTH (*f) = loc + 1;
}
void
fn_str_grow P2C(fn_type *, f, const_string, s)
{
unsigned more_len = strlen (s);
grow (f, more_len);
strcat (FN_STRING (*f), s);
FN_LENGTH (*f) += more_len;
}
fn_type
fn_init P1H(void)
{
fn_type ret;
FN_ALLOCATED (ret) = FN_LENGTH (ret) = 0;
FN_STRING (ret) = NULL;
return ret;
}
string
mktex_var_expand P1C(const_string, src)
{
const_string s;
string ret;
fn_type expansion;
expansion = fn_init ();
/* Copy everything but variable constructs. */
for (s = src; *s; s++) {
if (IS_VAR_START (*s)) {
s++;
/* Three cases: `$VAR', `${VAR}', `$<anything-else>'. */
if (IS_VAR_CHAR (*s)) {
/* $V: collect name constituents, then expand. */
const_string var_end = s;
do {
var_end++;
} while (IS_VAR_CHAR (*var_end));
var_end--; /* had to go one past */
expand (&expansion, s, var_end);
s = var_end;
} else if (IS_VAR_BEGIN_DELIMITER (*s)) {
/* ${: scan ahead for matching delimiter, then expand. */
const_string var_end = ++s;
while (*var_end && !IS_VAR_END_DELIMITER (*var_end))
var_end++;
if (! *var_end) {
WARNING1 ("%s: No matching } for ${", src);
s = var_end - 1; /* will incr to null at top of loop */
} else {
expand (&expansion, s, var_end - 1);
s = var_end; /* will incr past } at top of loop*/
}
} else {
/* $<something-else>: error. */
WARNING2 ("%s: Unrecognized variable construct `$%c'", src, *s);
/* Just ignore those chars and keep going. */
}
} else
fn_1grow (&expansion, *s);
}
fn_1grow (&expansion, 0);
ret = FN_STRING (expansion);
return ret;
}
static void
do_subdir (kpathsea kpse, str_llist_type *str_list_ptr, string elt,
unsigned elt_length, string post)
{
#ifdef WIN32
WIN32_FIND_DATAW find_file_data;
HANDLE hnd;
int proceed;
int nlinks = 2;
#else
DIR *dir;
struct dirent *e;
#endif /* not WIN32 */
fn_type name;
/* Some old compilers don't allow aggregate initialization. */
name = fn_copy0 (elt, elt_length);
assert (IS_DIR_SEP_CH (elt[elt_length - 1])
|| IS_DEVICE_SEP (elt[elt_length - 1]));
#if defined (WIN32)
strcpy(dirname, FN_STRING(name));
strcat(dirname, "/*.*"); /* "*.*" or "*" -- seems equivalent. */
get_wstring_from_fsyscp(dirname, dirnamew);
hnd = FindFirstFileW(dirnamew, &find_file_data);
if (hnd == INVALID_HANDLE_VALUE) {
fn_free(&name);
return;
}
/* Include top level before subdirectories, if nothing to match. */
if (*post == 0)
dir_list_add (str_list_ptr, FN_STRING (name));
else {
/* If we do have something to match, see if it exists. For
example, POST might be `pk/ljfour', and they might have a
directory `$TEXMF/fonts/pk/ljfour' that we should find. */
fn_str_grow (&name, post);
expand_elt (kpse, str_list_ptr, FN_STRING (name), elt_length);
fn_shrink_to (&name, elt_length);
}
proceed = 1;
while (proceed) {
if (find_file_data.cFileName[0] != L'.') {
int links;
/* Construct the potential subdirectory name. */
potname = get_fsyscp_from_wstring(find_file_data.cFileName, potname=NULL);
fn_str_grow (&name, potname);
free(potname);
/* Maybe we have cached the leafness of this directory.
The function will return 0 if unknown,
else the actual (Unix-like) value. */
links = kpathsea_dir_links (kpse, FN_STRING (name), 0);
if (find_file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
unsigned potential_len = FN_LENGTH (name);
/* in any case, compute the leafness */
nlinks++;
/* It's a directory, so append the separator. */
fn_str_grow (&name, DIR_SEP_STRING);
if (*post != 0) {
fn_str_grow (&name, post);
/* Unfortunately we can't check if the new element is
a leaf directory, because we don't have a directory
name here, we just have a path spec. This means we
may descend into a leaf directory cm/pk, if the
spec is ...fonts//pk//. */
expand_elt (kpse, str_list_ptr, FN_STRING (name), potential_len);
fn_shrink_to (&name, potential_len);
}
/* Should we recurse? To see if the subdirectory is a
leaf, check if it has two links (one for . and one for
..). This means that symbolic links to directories do
not affect the leaf-ness. This is arguably wrong, but
the only alternative I know of is to stat every entry
in the directory, and that is unacceptably slow. */
if (links == 0 || links > 2)
/* All criteria are met; find subdirectories. */
do_subdir (kpse, str_list_ptr, FN_STRING (name),
potential_len, post);
else if (*post == 0)
/* Nothing to match, no recursive subdirectories to
look for: we're done with this branch. Add it. */
dir_list_add (str_list_ptr, FN_STRING (name));
}
fn_shrink_to (&name, elt_length);
}
proceed = FindNextFileW (hnd, &find_file_data);
}
/* Update the leafness of name. */
kpathsea_dir_links(kpse, FN_STRING(name), nlinks);
fn_free (&name);
FindClose(hnd);
#else /* not WIN32 */
/* If we can't open it, quit. */
dir = opendir (FN_STRING (name));
if (dir == NULL)
{
fn_free (&name);
return;
}
/* Include top level before subdirectories, if nothing to match. */
if (*post == 0)
dir_list_add (str_list_ptr, FN_STRING (name));
else
{ /* If we do have something to match, see if it exists. For
example, POST might be `pk/ljfour', and they might have a
directory `$TEXMF/fonts/pk/ljfour' that we should find. */
fn_str_grow (&name, post);
expand_elt (kpse, str_list_ptr, FN_STRING (name), elt_length);
fn_shrink_to (&name, elt_length);
}
while ((e = readdir (dir)) != NULL)
{ /* If it begins with a `.', never mind. (This allows ``hidden''
directories that the algorithm won't find.) */
if (e->d_name[0] != '.')
{
int links;
/* Construct the potential subdirectory name. */
fn_str_grow (&name, e->d_name);
/* If we can't stat it, or if it isn't a directory, continue. */
links = kpathsea_dir_links (kpse, FN_STRING (name), 0);
if (links >= 0)
{
unsigned potential_len = FN_LENGTH (name);
/* It's a directory, so append the separator. */
fn_str_grow (&name, DIR_SEP_STRING);
if (*post != 0)
{
fn_str_grow (&name, post);
/* Unfortunately we can't check if the new element is
a leaf directory, because we don't have a directory
name here, we just have a path spec. This means we
may descend into a leaf directory cm/pk, if the
spec is ...fonts//pk//. */
expand_elt (kpse, str_list_ptr, FN_STRING (name),
potential_len);
fn_shrink_to (&name, potential_len);
}
/* Should we recurse? To see if the subdirectory is a
leaf, check if it has two links (one for . and one for
..). This means that symbolic links to directories do
not affect the leaf-ness. This is arguably wrong, but
the only alternative I know of is to stat every entry
in the directory, and that is unacceptably slow.
The #ifdef here makes all this configurable at
compile-time, so that if we're using VMS directories or
some such, we can still find subdirectories, even if it
is much slower. */
#ifdef ST_NLINK_TRICK
/* With SAS/C++ 6.55 on the Amiga, stat sets the st_nlink
field to -1 for a file, or to 1 for a directory.
Cygwin 1.7 also leaves st_nlink as 1:
http://cygwin.com/ml/cygwin-developers/2008-04/msg00110.html
*/
if (links != 2)
#endif /* ST_NLINK_TRICK */
/* All criteria are met; find subdirectories. */
do_subdir (kpse, str_list_ptr, FN_STRING (name),
potential_len, post);
#ifdef ST_NLINK_TRICK
else if (*post == 0)
/* Nothing to match, no recursive subdirectories to
look for: we're done with this branch. Add it. */
dir_list_add (str_list_ptr, FN_STRING (name));
#endif
}
/* Remove the directory entry we just checked from `name'. */
fn_shrink_to (&name, elt_length);
}
}
fn_free (&name);
xclosedir (dir);
#endif /* not WIN32 */
}
string
kpathsea_var_expand (kpathsea kpse, const_string src)
{
const_string s;
string ret;
fn_type expansion;
expansion = fn_init ();
/* Copy everything but variable constructs. */
for (s = src; *s; s++) {
if (IS_VAR_START (*s)) {
s++;
/* Three cases: `$VAR', `${VAR}', `$<anything-else>'. */
if (IS_VAR_CHAR (*s)) {
/* $V: collect name constituents, then expand. */
const_string var_end = s;
do {
var_end++;
} while (IS_VAR_CHAR (*var_end));
var_end--; /* had to go one past */
if (!expand (kpse, &expansion, s, var_end)) {
/* If no expansion, include the literal $x construct,
so filenames containing dollar signs can be read.
The first +1 is to get the full variable name,
the other +1 is to get the dollar sign; we've moved past it. */
fn_grow (&expansion, s - 1, var_end - s + 1 + 1);
}
s = var_end;
} else if (IS_VAR_BEGIN_DELIMITER (*s)) {
/* ${: scan ahead for matching delimiter, then expand. */
const_string var_end = ++s;
while (*var_end && !IS_VAR_END_DELIMITER (*var_end)) {
#if defined(WIN32)
if (kpathsea_IS_KANJI(kpse, var_end))
var_end++;
#endif
var_end++;
}
if (! *var_end) {
WARNING1 ("kpathsea: %s: No matching } for ${", src);
s = var_end - 1; /* will incr to null at top of loop */
} else {
expand (kpse, &expansion, s, var_end - 1);
s = var_end; /* will incr past } at top of loop*/
}
} else {
/* $<something-else>: warn, but preserve characters; again, so
filenames containing dollar signs can be read. */
WARNING2 ("kpathsea: %s: Unrecognized variable construct `$%c'",
src, *s);
fn_grow (&expansion, s - 1, 2); /* moved past the $ */
}
} else
fn_1grow (&expansion, *s);
}
fn_1grow (&expansion, 0);
ret = FN_STRING (expansion);
return ret;
}
static void
do_subdir P4C(str_llist_type *, str_list_ptr, const_string, elt,
unsigned, elt_length, const_string, post)
{
#ifdef WIN32
WIN32_FIND_DATA find_file_data;
HANDLE hnd;
int proceed;
#else
DIR *dir;
struct dirent *e;
#endif /* not WIN32 */
fn_type name;
/* Some old compilers don't allow aggregate initialization. */
name = fn_copy0 (elt, elt_length);
assert (IS_DIR_SEP (elt[elt_length - 1])
|| IS_DEVICE_SEP (elt[elt_length - 1]));
#if defined (WIN32)
strcpy(dirname, FN_STRING(name));
strcat(dirname, "/*.*"); /* "*.*" or "*" -- seems equivalent. */
hnd = FindFirstFile(dirname, &find_file_data);
if (hnd == INVALID_HANDLE_VALUE) {
fn_free(&name);
return;
}
/* Include top level before subdirectories, if nothing to match. */
if (*post == 0)
dir_list_add (str_list_ptr, FN_STRING (name));
else {
/* If we do have something to match, see if it exists. For
example, POST might be `pk/ljfour', and they might have a
directory `$TEXMF/fonts/pk/ljfour' that we should find. */
fn_str_grow (&name, post);
expand_elt (str_list_ptr, FN_STRING (name), elt_length);
fn_shrink_to (&name, elt_length);
}
proceed = 1;
while (proceed) {
if (find_file_data.cFileName[0] != '.') {
/* Construct the potential subdirectory name. */
fn_str_grow (&name, find_file_data.cFileName);
if (find_file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
unsigned potential_len = FN_LENGTH (name);
/* It's a directory, so append the separator. */
fn_str_grow (&name, DIR_SEP_STRING);
do_subdir (str_list_ptr, FN_STRING (name),
potential_len, post);
}
fn_shrink_to (&name, elt_length);
}
proceed = FindNextFile (hnd, &find_file_data);
}
fn_free (&name);
FindClose(hnd);
#else /* not WIN32 */
/* If we can't open it, quit. */
dir = opendir (FN_STRING (name));
if (dir == NULL)
{
fn_free (&name);
return;
}
/* Include top level before subdirectories, if nothing to match. */
if (*post == 0)
dir_list_add (str_list_ptr, FN_STRING (name));
else
{ /* If we do have something to match, see if it exists. For
example, POST might be `pk/ljfour', and they might have a
directory `$TEXMF/fonts/pk/ljfour' that we should find. */
fn_str_grow (&name, post);
expand_elt (str_list_ptr, FN_STRING (name), elt_length);
fn_shrink_to (&name, elt_length);
}
while ((e = readdir (dir)) != NULL)
{ /* If it begins with a `.', never mind. (This allows ``hidden''
directories that the algorithm won't find.) */
if (e->d_name[0] != '.')
{
int links;
/* Construct the potential subdirectory name. */
fn_str_grow (&name, e->d_name);
/* If we can't stat it, or if it isn't a directory, continue. */
links = dir_links (FN_STRING (name));
if (links >= 0)
{
unsigned potential_len = FN_LENGTH (name);
/* It's a directory, so append the separator. */
fn_str_grow (&name, DIR_SEP_STRING);
/* Should we recurse? To see if the subdirectory is a
leaf, check if it has two links (one for . and one for
..). This means that symbolic links to directories do
not affect the leaf-ness. This is arguably wrong, but
the only alternative I know of is to stat every entry
in the directory, and that is unacceptably slow.
The #ifdef here makes all this configurable at
compile-time, so that if we're using VMS directories or
some such, we can still find subdirectories, even if it
is much slower. */
#ifdef ST_NLINK_TRICK
#ifdef AMIGA
/* With SAS/C++ 6.55 on the Amiga, `stat' sets the `st_nlink'
field to -1 for a file, or to 1 for a directory. */
if (links == 1)
#else
if (links > 2)
#endif /* not AMIGA */
#endif /* not ST_NLINK_TRICK */
/* All criteria are met; find subdirectories. */
do_subdir (str_list_ptr, FN_STRING (name),
potential_len, post);
#ifdef ST_NLINK_TRICK
else if (*post == 0)
/* Nothing to match, no recursive subdirectories to
look for: we're done with this branch. Add it. */
dir_list_add (str_list_ptr, FN_STRING (name));
#endif
}
/* Remove the directory entry we just checked from `name'. */
fn_shrink_to (&name, elt_length);
}
}
fn_free (&name);
xclosedir (dir);
#endif /* not WIN32 */
}