const_string *
kpathsea_fontmap_lookup (kpathsea kpse, const_string key)
{
const_string *ret;
string suffix = find_suffix (key);
if (kpse->map.size == 0) {
read_all_maps (kpse);
}
ret = (const_string *) hash_lookup (kpse->map, key);
if (!ret) {
/* OK, the original KEY didn't work. Let's check for the KEY without
an extension -- perhaps they gave foobar.tfm, but the mapping only
defines `foobar'. */
if (suffix) {
string base_key = remove_suffix (key);
ret = (const_string *) hash_lookup (kpse->map, base_key);
free (base_key);
}
}
/* Append any original suffix. */
if (ret && suffix) {
const_string *elt;
for (elt = ret; *elt; elt++) {
*elt = extend_filename (*elt, suffix);
}
}
return ret;
}
string
remove_suffix (string s)
{
string suffix = find_suffix (s);
return suffix == NULL ? xstrdup (s) : substring (s, 0, suffix - 2 - s);
}
static unsigned find_dpi(const_string s)
{
unsigned dpi_number = 0;
const_string extension = find_suffix(s);
if (extension != NULL)
sscanf(extension, "%u", &dpi_number);
return dpi_number;
}
string
make_output_filename (string name, string default_suffix)
{
string new_s;
string suffix = find_suffix (name);
new_s = suffix == NULL
? concat3 (name, ".", default_suffix)
: xstrdup (name);
return new_s;
}
string
make_stem_suffix (string name, string stem_suffix)
{
string suffix = find_suffix (name);
name = remove_suffix (name);
return suffix == NULL
? concat (name, stem_suffix)
: concat4 (name, stem_suffix, ".", suffix);
}
string
make_suffix (string s, string new_suffix)
{
string new_s;
string old_suffix = find_suffix (s);
if (old_suffix == NULL)
new_s = concat3 (s, ".", new_suffix);
else
{
unsigned length_through_dot = old_suffix - s;
new_s = xmalloc (length_through_dot + strlen (new_suffix) + 1);
strncpy (new_s, s, length_through_dot);
strcpy (new_s + length_through_dot, new_suffix);
}
return new_s;
}
/*
* Compare two version strings
*/
int
vcmp(struct bwstring *s1, struct bwstring *s2)
{
bwstring_iterator si1, si2;
wchar_t c1, c2;
size_t len1, len2, slen1, slen2;
int cmp_bytes, cmp_res;
if (s1 == s2)
return (0);
cmp_bytes = bwscmp(s1, s2, 0);
if (cmp_bytes == 0)
return (0);
len1 = slen1 = BWSLEN(s1);
len2 = slen2 = BWSLEN(s2);
if (slen1 < 1)
return (-1);
if (slen2 < 1)
return (+1);
si1 = bws_begin(s1);
si2 = bws_begin(s2);
c1 = bws_get_iter_value(si1);
c2 = bws_get_iter_value(si2);
if (c1 == L'.' && (slen1 == 1))
return (-1);
if (c2 == L'.' && (slen2 == 1))
return (+1);
if (slen1 == 2 && c1 == L'.' &&
bws_get_iter_value(bws_iterator_inc(si1, 1)) == L'.')
return (-1);
if (slen2 == 2 && c2 == L'.' &&
bws_get_iter_value(bws_iterator_inc(si2, 1)) == L'.')
return (+1);
if (c1 == L'.' && c2 != L'.')
return (-1);
if (c1 != L'.' && c2 == L'.')
return (+1);
if (c1 == L'.' && c2 == L'.') {
si1 = bws_iterator_inc(si1, 1);
si2 = bws_iterator_inc(si2, 1);
}
find_suffix(si1, bws_end(s1), &len1);
find_suffix(si2, bws_end(s2), &len2);
if ((len1 == len2) && (bws_iterator_cmp(si1, si2, len1) == 0))
return (cmp_bytes);
cmp_res = cmpversions(si1, bws_iterator_inc(si1, len1), si2,
bws_iterator_inc(si2, len2));
if (cmp_res == 0)
cmp_res = cmp_bytes;
return (cmp_res);
}
void
kpse_set_program_name P2C(const_string, argv0, const_string, progname)
{
string ext, sdir, sdir_parent, sdir_grandparent;
string s = getenv ("KPATHSEA_DEBUG");
#ifdef WIN32
string debug_output = getenv("KPATHSEA_DEBUG_OUTPUT");
string append_debug_output = getenv("KPATHSEA_DEBUG_APPEND");
int err, olderr;
#endif
/* Set debugging stuff first, in case we end up doing debuggable stuff
during this initialization. */
if (s) {
kpathsea_debug |= atoi (s);
}
#ifndef HAVE_PROGRAM_INVOCATION_NAME
#if defined(WIN32)
/* Set various info about user. Among many things,
ensure that HOME is set. If debug_paths is on,
turn on some message if $HOME is not found. */
if (KPSE_DEBUG_P(KPSE_DEBUG_PATHS)) {
set_home_warning();
}
init_user_info();
/* redirect stderr to debug_output. Easier to send logfiles. */
if (debug_output) {
int flags = _O_CREAT | _O_TRUNC | _O_RDWR;
err = -1;
if (_stricmp(debug_output, "con") == 0
|| _stricmp(debug_output, "con:") == 0) {
err = _fileno(stdout);
} else {
if (append_debug_output) {
flags = _O_CREAT | _O_APPEND | _O_WRONLY;
} else {
flags = _O_CREAT | _O_TRUNC | _O_WRONLY;
xputenv("KPATHSEA_DEBUG_APPEND", "yes");
}
}
if ((err < 0)
&& (err = _open(debug_output, flags, _S_IREAD | _S_IWRITE)) == -1)
{
WARNING1("Can't open %s for stderr redirection!\n", debug_output);
perror(debug_output);
} else if ((olderr = _dup(fileno(stderr))) == -1) {
WARNING("Can't dup() stderr!\n");
close(err);
} else if (_dup2(err, fileno(stderr)) == -1) {
WARNING1("Can't redirect stderr to %s!\n", debug_output);
close(olderr);
close(err);
} else {
close(err);
}
}
/* Win95 always gives the short filename for argv0, not the long one.
There is only this way to catch it. It makes all the selfdir stuff
useless for win32. */
{
char short_path[PATH_MAX], path[PATH_MAX], *fp;
/* SearchPath() always gives back an absolute directory */
if (SearchPath(NULL, argv0, ".exe", PATH_MAX, short_path, &fp) == 0)
FATAL1("Can't determine where the executable %s is.\n", argv0);
if (!win32_get_long_filename(short_path, path, sizeof(path))) {
FATAL1("This path points to an invalid file : %s\n", short_path);
}
/* slashify the dirname */
for (fp = path; fp && *fp; fp++)
if (IS_DIR_SEP(*fp)) *fp = DIR_SEP;
/* sdir will be the directory of the executable, ie: c:/TeX/bin */
sdir = xdirname(path);
program_invocation_name = xstrdup(xbasename(path));
}
#elif defined(__DJGPP__)
/* DJGPP programs support long filenames on Windows 95, but ARGV0 there
is always made with the short 8+3 aliases of all the pathname elements.
If long names are supported, we need to convert that to a long name.
All we really need is to call `_truename', but most of the code
below is required to deal with the special case of networked drives. */
if (pathconf (argv0, _PC_NAME_MAX) > 12) {
char long_progname[PATH_MAX];
if (_truename (argv0, long_progname)) {
char *fp;
if (long_progname[1] != ':') {
/* A complication: `_truename' returns network-specific string at
the beginning of `long_progname' when the program resides on a
networked drive, and DOS calls cannot grok such pathnames. We
need to convert the filesystem name back to a drive letter. */
char rootname[PATH_MAX], rootdir[4];
if (argv0[0] && argv0[1] == ':')
rootdir[0] = argv0[0]; /* explicit drive in `argv0' */
else
rootdir[0] = getdisk () + 'A';
rootdir[1] = ':';
rootdir[2] = '\\';
rootdir[3] = '\0';
if (_truename (rootdir, rootname)) {
/* Find out where `rootname' ends in `long_progname' and replace
it with the drive letter. */
int root_len = strlen (rootname);
if (IS_DIR_SEP (rootname[root_len - 1]))
root_len--; /* keep the trailing slash */
long_progname[0] = rootdir[0];
long_progname[1] = ':';
memmove (long_progname + 2, long_progname + root_len,
strlen (long_progname + root_len) + 1);
}
}
/* Convert everything to canonical form. */
if (long_progname[0] >= 'A' && long_progname[0] <= 'Z')
long_progname[0] += 'a' - 'A'; /* make drive lower case, for beauty */
for (fp = long_progname; *fp; fp++)
if (IS_DIR_SEP (*fp))
*fp = DIR_SEP;
program_invocation_name = xstrdup (long_progname);
}
else
/* If `_truename' failed, God help them, because we won't... */
program_invocation_name = xstrdup (argv0);
}
else
program_invocation_name = xstrdup (argv0);
#else /* !WIN32 && !__DJGPP__ */
program_invocation_name = xstrdup (argv0);
#endif
#endif /* not HAVE_PROGRAM_INVOCATION_NAME */
/* We need to find SELFAUTOLOC *before* removing the ".exe" suffix from
the program_name, otherwise the PATH search inside selfdir will fail,
since `prog' doesn't exists as a file, there's `prog.exe' instead. */
#ifndef WIN32
sdir = selfdir (program_invocation_name);
#endif
/* SELFAUTODIR is actually the parent of the invocation directory,
and SELFAUTOPARENT the grandparent. This is how teTeX did it. */
xputenv ("SELFAUTOLOC", sdir);
sdir_parent = xdirname (sdir);
xputenv ("SELFAUTODIR", sdir_parent);
sdir_grandparent = xdirname (sdir_parent);
xputenv ("SELFAUTOPARENT", sdir_grandparent);
free (sdir);
free (sdir_parent);
free (sdir_grandparent);
#ifndef HAVE_PROGRAM_INVOCATION_NAME
program_invocation_short_name = (string)xbasename (program_invocation_name);
#endif
if (progname) {
kpse_program_name = xstrdup (progname);
} else {
/* If configured --enable-shared and running from the build directory
with the wrapper scripts (e.g., for make check), the binaries will
be named foo.exe instead of foo. Or possibly if we're running on a
DOSISH system. */
ext = find_suffix (program_invocation_short_name);
if (ext && FILESTRCASEEQ (ext, "exe")) {
kpse_program_name = remove_suffix (program_invocation_short_name);
} else {
kpse_program_name = xstrdup (program_invocation_short_name);
}
}
xputenv("progname", kpse_program_name);
}
/**
* If \p str contains a valid description of a location on \p dev, then
* \p *sector is modified to describe the location and a geometry is created
* in \p *range describing a 2 units large area centered on \p *sector. If the
* \p range as described here would be partially outside the device \p dev, the
* geometry returned is the intersection between the former and the whole
* device geometry. If no units are specified, then the default unit is
* assumed.
*
* \throws PED_EXCEPTION_ERROR if \p str contains invalid description of a
* location
* \throws PED_EXCEPTION_ERROR if location described by \p str
* is outside of the device \p dev->path
*
* \return \c 1 if \p str is a valid location description, \c 0 otherwise.
*/
int
ped_unit_parse_custom (const char* str, const PedDevice* dev, PedUnit unit,
PedSector* sector, PedGeometry** range)
{
char* copy;
char* suffix;
double num;
long long unit_size;
PedSector radius;
if (is_chs (str))
return parse_chs (str, dev, sector, range);
copy = ped_strdup (str);
if (!copy)
goto error;
strip_string (copy);
suffix = find_suffix (copy);
unit = parse_unit_suffix (suffix, unit);
suffix[0] = 0;
if (sscanf (copy, "%lf", &num) != 1) {
ped_exception_throw (
PED_EXCEPTION_ERROR,
PED_EXCEPTION_CANCEL,
_("Invalid number."));
goto error_free_copy;
}
if (num > 0 && num < 1) {
ped_exception_throw (
PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("Use a smaller unit instead of a value < 1"));
goto error_free_copy;
}
unit_size = ped_unit_get_size (dev, unit);
radius = (ped_div_round_up (unit_size, dev->sector_size) / 2) - 1;
if (radius < 0)
radius = 0;
/* If the user specifies units in a power of 2, e.g., 4MiB, as in
parted -s -- $dev mklabel gpt mkpart P-NAME 4MiB -34s
do not use 4MiB as the range. Rather, presume that they
are specifying precisely the starting or ending number,
and treat "4MiB" just as we would treat "4194304B". */
if (is_power_of_2 (unit_size))
radius = 0;
*sector = num * unit_size / dev->sector_size;
/* negative numbers count from the end */
if (copy[0] == '-')
*sector += dev->length;
if (range) {
*range = geometry_from_centre_radius (dev, *sector, radius);
if (!*range) {
ped_exception_throw (
PED_EXCEPTION_ERROR, PED_EXCEPTION_CANCEL,
_("The location %s is outside of the "
"device %s."),
str, dev->path);
goto error_free_copy;
}
}
*sector = clip (dev, *sector);
free (copy);
return 1;
error_free_copy:
free (copy);
error:
*sector = 0;
if (range)
*range = NULL;
return 0;
}
void
main (unsigned argc, string argv[])
{
bzr_preamble_type preamble;
bzr_postamble_type postamble;
tfm_char_type *tfm_chars;
tfm_global_info_type tfm_info;
string tfm_name;
unsigned this_char;
unsigned char_count = 0;
string font_name = read_command_line (argc, argv);
string font_basename = basename (font_name);
string bzr_name = concat (font_name, ".bzr");
if (!bzr_open_input_file (bzr_name))
FATAL1 ("%s: Could not find BZR file", font_name);
tfm_name = find_tfm_filename (font_name);
if (tfm_name == NULL || !tfm_open_input_file (tfm_name))
FATAL1 ("%s: Could not find TFM file", font_name);
preamble = bzr_get_preamble ();
postamble = bzr_get_postamble ();
tfm_info = tfm_get_global_info ();
tfm_chars = tfm_get_chars ();
if (output_name == NULL)
output_name = strtok (xstrdup (font_basename), "0123456789");
else
if (find_suffix (output_name) != NULL
&& ((output[metafont] && output[pstype1])
|| (output[metafont] && output[pstype3])
|| (output[pstype1] && output[pstype3])))
FATAL ("You can't specify all the output files' suffices to be the same");
if (output[metafont])
metafont_start_output (output_name, preamble, tfm_info);
if (output[pstype1])
pstype1_start_output (font_basename, output_name, preamble, postamble,
tfm_info);
if (output[pstype3])
pstype3_start_output (font_basename, output_name, preamble, postamble,
tfm_info);
if (output[text])
text_start_output (font_basename, preamble);
for (this_char = 0; this_char <= MAX_CHARCODE; this_char++)
{
bzr_char_type *c = bzr_get_char (this_char);
if (c != NULL)
{
REPORT1 ("[%u", this_char);
BZR_SHAPE (*c) = oblique_splines (BZR_SHAPE (*c));
if (output[metafont])
metafont_output_char (*c);
if (output[pstype1])
pstype1_output_char (*c);
if (output[pstype3])
pstype3_output_char (*c);
if (output[text])
text_output_char (*c);
REPORT1 ("]%c", ++char_count % 8 ? ' ' : '\n');
}
}
if (output[metafont]) metafont_finish_output (tfm_chars);
if (output[pstype1]) pstype1_finish_output ();
if (output[pstype3]) pstype3_finish_output ();
if (output[text]) text_finish_output (postamble);
if (char_count % 8 != 0)
REPORT ("\n");
bzr_close_input_file ();
tfm_close_input_file ();
exit (0);
}
