/* General utility routines for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free
- Software Foundation, Inc.
+ Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdb_assert.h"
#include "annotate.h"
#include "filenames.h"
#include "symfile.h"
+#include "gdb_obstack.h"
+#include "top.h"
#include "inferior.h" /* for signed_pointer_to_address */
/* Prototypes for local functions */
static void vfprintf_maybe_filtered (struct ui_file *, const char *,
- va_list, int);
+ va_list, int) ATTR_FORMAT (printf, 2, 0);
static void fputs_maybe_filtered (const char *, struct ui_file *, int);
static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
-static struct cleanup *run_cleanup_chain; /* cleaned up on each 'run' */
static struct cleanup *exec_cleanup_chain; /* cleaned up on each execution command */
/* cleaned up on each error from within an execution command */
static struct cleanup *exec_error_cleanup_chain;
return make_my_cleanup (&final_cleanup_chain, function, arg);
}
-struct cleanup *
-make_run_cleanup (make_cleanup_ftype *function, void *arg)
-{
- return make_my_cleanup (&run_cleanup_chain, function, arg);
-}
-
struct cleanup *
make_exec_cleanup (make_cleanup_ftype *function, void *arg)
{
do_my_cleanups (&final_cleanup_chain, old_chain);
}
-void
-do_run_cleanups (struct cleanup *old_chain)
-{
- do_my_cleanups (&run_cleanup_chain, old_chain);
-}
-
void
do_exec_cleanups (struct cleanup *old_chain)
{
has been reported, and assuming GDB didn't quit, the caller can
either allow execution to resume or throw an error. */
-static void
+static void ATTR_FORMAT (printf, 4, 0)
internal_vproblem (struct internal_problem *problem,
const char *file, int line, const char *fmt, va_list ap)
{
va_end (ap);
}
-/* The strerror() function can return NULL for errno values that are
- out of range. Provide a "safe" version that always returns a
- printable string. */
-
-char *
-safe_strerror (int errnum)
-{
- char *msg;
- static char buf[32];
-
- msg = strerror (errnum);
- if (msg == NULL)
- {
- sprintf (buf, "(undocumented errno %d)", errnum);
- msg = buf;
- }
- return (msg);
-}
-
/* Print the system error message for errno, and also mention STRING
as the file name for which the error was encountered.
Then return to command level. */
#endif
}
-/* Control C comes here */
-void
-request_quit (int signo)
-{
- quit_flag = 1;
- /* Restore the signal handler. Harmless with BSD-style signals,
- needed for System V-style signals. */
- signal (signo, request_quit);
-
- if (immediate_quit)
- quit ();
-}
\f
/* Called when a memory allocation fails, with the number of bytes of
memory requested in SIZE. */
{
char *ret = NULL;
int status = vasprintf (&ret, format, ap);
- /* NULL is returned when there was a memory allocation problem. */
- if (ret == NULL)
- nomem (0);
- /* A negative status (the printed length) with a non-NULL buffer
- should never happen, but just to be sure. */
- if (status < 0)
- internal_error (__FILE__, __LINE__,
- _("vasprintf call failed (errno %d)"), errno);
+ /* NULL is returned when there was a memory allocation problem, or
+ any other error (for instance, a bad format string). A negative
+ status (the printed length) with a non-NULL buffer should never
+ happen, but just to be sure. */
+ if (ret == NULL || status < 0)
+ internal_error (__FILE__, __LINE__, _("vasprintf call failed"));
+ return ret;
+}
+
+int
+xsnprintf (char *str, size_t size, const char *format, ...)
+{
+ va_list args;
+ int ret;
+
+ va_start (args, format);
+ ret = vsnprintf (str, size, format, args);
+ gdb_assert (ret < size);
+ va_end (args);
+
return ret;
}
fprintf_filtered (stream, "0x%lx", (unsigned long) addr);
}
-
-/* Ask user a y-or-n question and return 1 iff answer is yes.
- Takes three args which are given to printf to print the question.
- The first, a control string, should end in "? ".
- It should not say how to answer, because we do that. */
-
-/* VARARGS */
-int
-query (const char *ctlstr, ...)
-{
- va_list args;
- int answer;
- int ans2;
- int retval;
-
- if (deprecated_query_hook)
- {
- va_start (args, ctlstr);
- return deprecated_query_hook (ctlstr, args);
- }
-
- /* Automatically answer "yes" if input is not from a terminal. */
- if (!input_from_terminal_p ())
- return 1;
-
- while (1)
- {
- wrap_here (""); /* Flush any buffered output */
- gdb_flush (gdb_stdout);
-
- if (annotation_level > 1)
- printf_filtered (("\n\032\032pre-query\n"));
-
- va_start (args, ctlstr);
- vfprintf_filtered (gdb_stdout, ctlstr, args);
- va_end (args);
- printf_filtered (_("(y or n) "));
-
- if (annotation_level > 1)
- printf_filtered (("\n\032\032query\n"));
-
- wrap_here ("");
- gdb_flush (gdb_stdout);
-
- answer = fgetc (stdin);
- clearerr (stdin); /* in case of C-d */
- if (answer == EOF) /* C-d */
- {
- retval = 1;
- break;
- }
- /* Eat rest of input line, to EOF or newline */
- if (answer != '\n')
- do
- {
- ans2 = fgetc (stdin);
- clearerr (stdin);
- }
- while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
-
- if (answer >= 'a')
- answer -= 040;
- if (answer == 'Y')
- {
- retval = 1;
- break;
- }
- if (answer == 'N')
- {
- retval = 0;
- break;
- }
- printf_filtered (_("Please answer y or n.\n"));
- }
-
- if (annotation_level > 1)
- printf_filtered (("\n\032\032post-query\n"));
- return retval;
-}
\f
-/* This function supports the nquery() and yquery() functions.
+/* This function supports the query, nquery, and yquery functions.
Ask user a y-or-n question and return 0 if answer is no, 1 if
- answer is yes, or default the answer to the specified default.
- DEFCHAR is either 'y' or 'n' and refers to the default answer.
+ answer is yes, or default the answer to the specified default
+ (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
+ default answer, or '\0' for no default.
CTLSTR is the control string and should end in "? ". It should
not say how to answer, because we do that.
ARGS are the arguments passed along with the CTLSTR argument to
printf. */
-static int
+static int ATTR_FORMAT (printf, 1, 0)
defaulted_query (const char *ctlstr, const char defchar, va_list args)
{
int answer;
int retval;
int def_value;
char def_answer, not_def_answer;
- char *y_string, *n_string;
+ char *y_string, *n_string, *question;
/* Set up according to which answer is the default. */
- if (defchar == 'y')
+ if (defchar == '\0')
+ {
+ def_value = 1;
+ def_answer = 'Y';
+ not_def_answer = 'N';
+ y_string = "y";
+ n_string = "n";
+ }
+ else if (defchar == 'y')
{
def_value = 1;
def_answer = 'Y';
n_string = "[n]";
}
+ /* Automatically answer the default value if the user did not want
+ prompts. */
+ if (! caution)
+ return def_value;
+
+ /* If input isn't coming from the user directly, just say what
+ question we're asking, and then answer "yes" automatically. This
+ way, important error messages don't get lost when talking to GDB
+ over a pipe. */
+ if (! input_from_terminal_p ())
+ {
+ wrap_here ("");
+ vfprintf_filtered (gdb_stdout, ctlstr, args);
+
+ printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"),
+ y_string, n_string, def_answer);
+ gdb_flush (gdb_stdout);
+
+ return def_value;
+ }
+
+ /* Automatically answer the default value if input is not from the user
+ directly, or if the user did not want prompts. */
+ if (!input_from_terminal_p () || !caution)
+ return def_value;
+
if (deprecated_query_hook)
{
return deprecated_query_hook (ctlstr, args);
}
- /* Automatically answer default value if input is not from a terminal. */
- if (!input_from_terminal_p ())
- return def_value;
+ /* Format the question outside of the loop, to avoid reusing args. */
+ question = xstrvprintf (ctlstr, args);
while (1)
{
if (annotation_level > 1)
printf_filtered (("\n\032\032pre-query\n"));
- vfprintf_filtered (gdb_stdout, ctlstr, args);
+ fputs_filtered (question, gdb_stdout);
printf_filtered (_("(%s or %s) "), y_string, n_string);
if (annotation_level > 1)
clearerr (stdin); /* in case of C-d */
if (answer == EOF) /* C-d */
{
+ printf_filtered ("EOF [assumed %c]\n", def_answer);
retval = def_value;
break;
}
retval = !def_value;
break;
}
- /* Otherwise, for the default, the user may either specify
- the required input or have it default by entering nothing. */
- if (answer == def_answer || answer == '\n' ||
- answer == '\r' || answer == EOF)
+ /* Otherwise, if a default was specified, the user may either
+ specify the required input or have it default by entering
+ nothing. */
+ if (answer == def_answer
+ || (defchar != '\0' &&
+ (answer == '\n' || answer == '\r' || answer == EOF)))
{
retval = def_value;
break;
y_string, n_string);
}
+ xfree (question);
if (annotation_level > 1)
printf_filtered (("\n\032\032post-query\n"));
return retval;
va_end (args);
}
+/* Ask user a y-or-n question and return 1 iff answer is yes.
+ Takes three args which are given to printf to print the question.
+ The first, a control string, should end in "? ".
+ It should not say how to answer, because we do that. */
+
+int
+query (const char *ctlstr, ...)
+{
+ va_list args;
+
+ va_start (args, ctlstr);
+ return defaulted_query (ctlstr, '\0', args);
+ va_end (args);
+}
+
/* Print an error message saying that we couldn't make sense of a
\^mumble sequence in a string or character constant. START and END
indicate a substring of some larger string that contains the
static void
printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
- void (*do_fprintf) (struct ui_file *, const char *, ...),
- struct ui_file *stream, int quoter)
+ void (*do_fprintf) (struct ui_file *, const char *, ...)
+ ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
{
c &= 0xFF; /* Avoid sign bit follies */
printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
}
+void
+fputstrn_filtered (const char *str, int n, int quoter,
+ struct ui_file *stream)
+{
+ int i;
+ for (i = 0; i < n; i++)
+ printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
+}
+
void
fputstrn_unfiltered (const char *str, int n, int quoter,
struct ui_file *stream)
rows = INT_MAX;
if (cols <= 0)
- rl_get_screen_size (NULL, &cols);
+ cols = INT_MAX;
/* Update Readline's idea of the terminal size. */
rl_set_screen_size (rows, cols);
return match;
}
-
-static void pagination_on_command (char *arg, int from_tty);
static void
pagination_on_command (char *arg, int from_tty)
{
pagination_enabled = 1;
}
-static void pagination_on_command (char *arg, int from_tty);
static void
pagination_off_command (char *arg, int from_tty)
{
int
strlen_paddr (void)
{
- return (TARGET_ADDR_BIT / 8 * 2);
+ return (gdbarch_addr_bit (current_gdbarch) / 8 * 2);
}
char *
paddr (CORE_ADDR addr)
{
- return phex (addr, TARGET_ADDR_BIT / 8);
+ return phex (addr, gdbarch_addr_bit (current_gdbarch) / 8);
}
char *
paddr_nz (CORE_ADDR addr)
{
- return phex_nz (addr, TARGET_ADDR_BIT / 8);
+ return phex_nz (addr, gdbarch_addr_bit (current_gdbarch) / 8);
}
const char *
when it won't occur. */
/* NOTE: This assumes that the significant address information is
kept in the least significant bits of ADDR - the upper bits were
- either zero or sign extended. Should ADDRESS_TO_POINTER() or
+ either zero or sign extended. Should gdbarch_address_to_pointer or
some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
- int addr_bit = TARGET_ADDR_BIT;
+ int addr_bit = gdbarch_addr_bit (current_gdbarch);
if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
return hex_string (addr);
}
-static void
-decimal2str (char *paddr_str, char *sign, ULONGEST addr, int width)
+static char *
+decimal2str (char *sign, ULONGEST addr, int width)
{
- /* steal code from valprint.c:print_decimal(). Should this worry
+ /* Steal code from valprint.c:print_decimal(). Should this worry
about the real size of addr as the above does? */
unsigned long temp[3];
+ char *str = get_cell ();
+
int i = 0;
do
{
width -= 9;
}
while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
+
width += 9;
if (width < 0)
width = 0;
+
switch (i)
{
case 1:
- sprintf (paddr_str, "%s%0*lu", sign, width, temp[0]);
+ xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]);
break;
case 2:
- sprintf (paddr_str, "%s%0*lu%09lu", sign, width, temp[1], temp[0]);
+ xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width,
+ temp[1], temp[0]);
break;
case 3:
- sprintf (paddr_str, "%s%0*lu%09lu%09lu", sign, width,
- temp[2], temp[1], temp[0]);
+ xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width,
+ temp[2], temp[1], temp[0]);
break;
default:
internal_error (__FILE__, __LINE__,
_("failed internal consistency check"));
}
+
+ return str;
}
-static void
-octal2str (char *paddr_str, ULONGEST addr, int width)
+static char *
+octal2str (ULONGEST addr, int width)
{
unsigned long temp[3];
+ char *str = get_cell ();
+
int i = 0;
do
{
width -= 10;
}
while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
+
width += 10;
if (width < 0)
width = 0;
+
switch (i)
{
case 1:
if (temp[0] == 0)
- sprintf (paddr_str, "%*o", width, 0);
+ xsnprintf (str, CELLSIZE, "%*o", width, 0);
else
- sprintf (paddr_str, "0%0*lo", width, temp[0]);
+ xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]);
break;
case 2:
- sprintf (paddr_str, "0%0*lo%010lo", width, temp[1], temp[0]);
+ xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
break;
case 3:
- sprintf (paddr_str, "0%0*lo%010lo%010lo", width,
- temp[2], temp[1], temp[0]);
+ xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width,
+ temp[2], temp[1], temp[0]);
break;
default:
internal_error (__FILE__, __LINE__,
_("failed internal consistency check"));
}
+
+ return str;
}
char *
paddr_u (CORE_ADDR addr)
{
- char *paddr_str = get_cell ();
- decimal2str (paddr_str, "", addr, 0);
- return paddr_str;
+ return decimal2str ("", addr, 0);
}
char *
paddr_d (LONGEST addr)
{
- char *paddr_str = get_cell ();
if (addr < 0)
- decimal2str (paddr_str, "-", -addr, 0);
+ return decimal2str ("-", -addr, 0);
else
- decimal2str (paddr_str, "", addr, 0);
- return paddr_str;
+ return decimal2str ("", addr, 0);
}
-/* eliminate warning from compiler on 32-bit systems */
+/* Eliminate warning from compiler on 32-bit systems. */
static int thirty_two = 32;
char *
phex (ULONGEST l, int sizeof_l)
{
char *str;
+
switch (sizeof_l)
{
case 8:
str = get_cell ();
- sprintf (str, "%08lx%08lx",
- (unsigned long) (l >> thirty_two),
- (unsigned long) (l & 0xffffffff));
+ xsnprintf (str, CELLSIZE, "%08lx%08lx",
+ (unsigned long) (l >> thirty_two),
+ (unsigned long) (l & 0xffffffff));
break;
case 4:
str = get_cell ();
- sprintf (str, "%08lx", (unsigned long) l);
+ xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l);
break;
case 2:
str = get_cell ();
- sprintf (str, "%04x", (unsigned short) (l & 0xffff));
+ xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff));
break;
default:
str = phex (l, sizeof (l));
break;
}
+
return str;
}
phex_nz (ULONGEST l, int sizeof_l)
{
char *str;
+
switch (sizeof_l)
{
case 8:
unsigned long high = (unsigned long) (l >> thirty_two);
str = get_cell ();
if (high == 0)
- sprintf (str, "%lx", (unsigned long) (l & 0xffffffff));
+ xsnprintf (str, CELLSIZE, "%lx",
+ (unsigned long) (l & 0xffffffff));
else
- sprintf (str, "%lx%08lx", high, (unsigned long) (l & 0xffffffff));
+ xsnprintf (str, CELLSIZE, "%lx%08lx", high,
+ (unsigned long) (l & 0xffffffff));
break;
}
case 4:
str = get_cell ();
- sprintf (str, "%lx", (unsigned long) l);
+ xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l);
break;
case 2:
str = get_cell ();
- sprintf (str, "%x", (unsigned short) (l & 0xffff));
+ xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff));
break;
default:
str = phex_nz (l, sizeof (l));
break;
}
+
return str;
}
hex_string (LONGEST num)
{
char *result = get_cell ();
- snprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
+ xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
return result;
}
}
case 10:
{
- char *result = get_cell ();
if (is_signed && val < 0)
- decimal2str (result, "-", -val, width);
+ return decimal2str ("-", -val, width);
else
- decimal2str (result, "", val, width);
- return result;
+ return decimal2str ("", val, width);
}
case 8:
{
- char *result = get_cell ();
- octal2str (result, val, width);
+ char *result = octal2str (val, width);
if (use_c_format || val == 0)
return result;
else
CORE_ADDR addr = 0;
if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
{
- /* Assume that it is in decimal. */
+ /* Assume that it is in hex. */
int i;
for (i = 2; my_string[i] != '\0'; i++)
{
else if (isxdigit (my_string[i]))
addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
else
- internal_error (__FILE__, __LINE__, _("invalid hex"));
+ error (_("invalid hex \"%s\""), my_string);
}
}
else
if (isdigit (my_string[i]))
addr = (my_string[i] - '0') + (addr * 10);
else
- internal_error (__FILE__, __LINE__, _("invalid decimal"));
+ error (_("invalid decimal \"%s\""), my_string);
}
}
return addr;
directory separator, avoid doubling it. */
real_path = gdb_realpath (dir_name);
if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
- result = concat (real_path, base_name, NULL);
+ result = concat (real_path, base_name, (char *)NULL);
else
- result = concat (real_path, SLASH_STRING, base_name, NULL);
+ result = concat (real_path, SLASH_STRING, base_name, (char *)NULL);
xfree (real_path);
return result;
gdb_assert (n && (n & (n-1)) == 0);
return (v & -n);
}
+
+/* Allocation function for the libiberty hash table which uses an
+ obstack. The obstack is passed as DATA. */
+
+void *
+hashtab_obstack_allocate (void *data, size_t size, size_t count)
+{
+ unsigned int total = size * count;
+ void *ptr = obstack_alloc ((struct obstack *) data, total);
+ memset (ptr, 0, total);
+ return ptr;
+}
+
+/* Trivial deallocation function for the libiberty splay tree and hash
+ table - don't deallocate anything. Rely on later deletion of the
+ obstack. DATA will be the obstack, although it is not needed
+ here. */
+
+void
+dummy_obstack_deallocate (void *object, void *data)
+{
+ return;
+}
+
+/* The bit offset of the highest byte in a ULONGEST, for overflow
+ checking. */
+
+#define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
+
+/* True (non-zero) iff DIGIT is a valid digit in radix BASE,
+ where 2 <= BASE <= 36. */
+
+static int
+is_digit_in_base (unsigned char digit, int base)
+{
+ if (!isalnum (digit))
+ return 0;
+ if (base <= 10)
+ return (isdigit (digit) && digit < base + '0');
+ else
+ return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
+}
+
+static int
+digit_to_int (unsigned char c)
+{
+ if (isdigit (c))
+ return c - '0';
+ else
+ return tolower (c) - 'a' + 10;
+}
+
+/* As for strtoul, but for ULONGEST results. */
+
+ULONGEST
+strtoulst (const char *num, const char **trailer, int base)
+{
+ unsigned int high_part;
+ ULONGEST result;
+ int minus = 0;
+ int i = 0;
+
+ /* Skip leading whitespace. */
+ while (isspace (num[i]))
+ i++;
+
+ /* Handle prefixes. */
+ if (num[i] == '+')
+ i++;
+ else if (num[i] == '-')
+ {
+ minus = 1;
+ i++;
+ }
+
+ if (base == 0 || base == 16)
+ {
+ if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X'))
+ {
+ i += 2;
+ if (base == 0)
+ base = 16;
+ }
+ }
+
+ if (base == 0 && num[i] == '0')
+ base = 8;
+
+ if (base == 0)
+ base = 10;
+
+ if (base < 2 || base > 36)
+ {
+ errno = EINVAL;
+ return 0;
+ }
+
+ result = high_part = 0;
+ for (; is_digit_in_base (num[i], base); i += 1)
+ {
+ result = result * base + digit_to_int (num[i]);
+ high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN);
+ result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
+ if (high_part > 0xff)
+ {
+ errno = ERANGE;
+ result = ~ (ULONGEST) 0;
+ high_part = 0;
+ minus = 0;
+ break;
+ }
+ }
+
+ if (trailer != NULL)
+ *trailer = &num[i];
+
+ result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
+ if (minus)
+ return -result;
+ else
+ return result;
+}
+
+/* Simple, portable version of dirname that does not modify its
+ argument. */
+
+char *
+ldirname (const char *filename)
+{
+ const char *base = lbasename (filename);
+ char *dirname;
+
+ while (base > filename && IS_DIR_SEPARATOR (base[-1]))
+ --base;
+
+ if (base == filename)
+ return NULL;
+
+ dirname = xmalloc (base - filename + 2);
+ memcpy (dirname, filename, base - filename);
+
+ /* On DOS based file systems, convert "d:foo" to "d:.", so that we
+ create "d:./bar" later instead of the (different) "d:/bar". */
+ if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
+ && !IS_DIR_SEPARATOR (filename[0]))
+ dirname[base++ - filename] = '.';
+
+ dirname[base - filename] = '\0';
+ return dirname;
+}
projects / deliverable / binutils-gdb.git / blobdiff