binutils/bucomm.c

   1 /* bucomm.c -- Bin Utils COMmon code.
   2    Copyright 1991, 1992, 1993, 1994, 1995, 1997, 1998, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21 \f
  22 /* We might put this in a library someday so it could be dynamically
  23    loaded, but for now it's not necessary.  */
  24
  25 #include "bfd.h"
  26 #include "libiberty.h"
  27 #include "bucomm.h"
  28 #include "filenames.h"
  29
  30 #include <sys/stat.h>
  31 #include <time.h>               /* ctime, maybe time_t */
  32
  33 #ifndef HAVE_TIME_T_IN_TIME_H
  34 #ifndef HAVE_TIME_T_IN_TYPES_H
  35 typedef long time_t;
  36 #endif
  37 #endif
  38 \f
  39 /* Error reporting */
  40
  41 char *program_name;
  42
  43 void
  44 bfd_nonfatal (string)
  45      CONST char *string;
  46 {
  47   CONST char *errmsg = bfd_errmsg (bfd_get_error ());
  48
  49   if (string)
  50     fprintf (stderr, "%s: %s: %s\n", program_name, string, errmsg);
  51   else
  52     fprintf (stderr, "%s: %s\n", program_name, errmsg);
  53 }
  54
  55 void
  56 bfd_fatal (string)
  57      CONST char *string;
  58 {
  59   bfd_nonfatal (string);
  60   xexit (1);
  61 }
  62
  63 void
  64 report (format, args)
  65      const char * format;
  66      va_list args;
  67 {
  68   fprintf (stderr, "%s: ", program_name);
  69   vfprintf (stderr, format, args);
  70   putc ('\n', stderr);
  71 }
  72
  73 #ifdef ANSI_PROTOTYPES
  74 void
  75 fatal (const char *format, ...)
  76 {
  77   va_list args;
  78
  79   va_start (args, format);
  80   report (format, args);
  81   va_end (args);
  82   xexit (1);
  83 }
  84
  85 void
  86 non_fatal (const char *format, ...)
  87 {
  88   va_list args;
  89
  90   va_start (args, format);
  91   report (format, args);
  92   va_end (args);
  93 }
  94 #else
  95 void
  96 fatal (va_alist)
  97      va_dcl
  98 {
  99   char *Format;
 100   va_list args;
 101
 102   va_start (args);
 103   Format = va_arg (args, char *);
 104   report (Format, args);
 105   va_end (args);
 106   xexit (1);
 107 }
 108
 109 void
 110 non_fatal (va_alist)
 111      va_dcl
 112 {
 113   char *Format;
 114   va_list args;
 115
 116   va_start (args);
 117   Format = va_arg (args, char *);
 118   report (Format, args);
 119   va_end (args);
 120 }
 121 #endif
 122
 123 /* Set the default BFD target based on the configured target.  Doing
 124    this permits the binutils to be configured for a particular target,
 125    and linked against a shared BFD library which was configured for a
 126    different target.  */
 127
 128 void
 129 set_default_bfd_target ()
 130 {
 131   /* The macro TARGET is defined by Makefile.  */
 132   const char *target = TARGET;
 133
 134   if (! bfd_set_default_target (target))
 135     fatal (_("can't set BFD default target to `%s': %s"),
 136            target, bfd_errmsg (bfd_get_error ()));
 137 }
 138
 139 /* After a false return from bfd_check_format_matches with
 140    bfd_get_error () == bfd_error_file_ambiguously_recognized, print
 141    the possible matching targets.  */
 142
 143 void
 144 list_matching_formats (p)
 145      char **p;
 146 {
 147   fprintf (stderr, _("%s: Matching formats:"), program_name);
 148   while (*p)
 149     fprintf (stderr, " %s", *p++);
 150   fputc ('\n', stderr);
 151 }
 152
 153 /* List the supported targets.  */
 154
 155 void
 156 list_supported_targets (name, f)
 157      const char *name;
 158      FILE *f;
 159 {
 160   extern const bfd_target *const *bfd_target_vector;
 161   int t;
 162
 163   if (name == NULL)
 164     fprintf (f, _("Supported targets:"));
 165   else
 166     fprintf (f, _("%s: supported targets:"), name);
 167   for (t = 0; bfd_target_vector[t] != NULL; t++)
 168     fprintf (f, " %s", bfd_target_vector[t]->name);
 169   fprintf (f, "\n");
 170 }
 171
 172 /* List the supported architectures.  */
 173
 174 void
 175 list_supported_architectures (name, f)
 176      const char *name;
 177      FILE *f;
 178 {
 179   const char** arch;
 180
 181   if (name == NULL)
 182     fprintf (f, _("Supported architectures:"));
 183   else
 184     fprintf (f, _("%s: supported architectures:"), name);
 185
 186   for (arch = bfd_arch_list (); *arch; arch++)
 187     fprintf (f, " %s", *arch);
 188   fprintf (f, "\n");
 189 }
 190 \f
 191 /* Display the archive header for an element as if it were an ls -l listing:
 192
 193    Mode       User\tGroup\tSize\tDate               Name */
 194
 195 void
 196 print_arelt_descr (file, abfd, verbose)
 197      FILE *file;
 198      bfd *abfd;
 199      boolean verbose;
 200 {
 201   struct stat buf;
 202
 203   if (verbose)
 204     {
 205       if (bfd_stat_arch_elt (abfd, &buf) == 0)
 206         {
 207           char modebuf[11];
 208           char timebuf[40];
 209           time_t when = buf.st_mtime;
 210           CONST char *ctime_result = (CONST char *) ctime (&when);
 211
 212           /* POSIX format:  skip weekday and seconds from ctime output.  */
 213           sprintf (timebuf, "%.12s %.4s", ctime_result + 4, ctime_result + 20);
 214
 215           mode_string (buf.st_mode, modebuf);
 216           modebuf[10] = '\0';
 217           /* POSIX 1003.2/D11 says to skip first character (entry type).  */
 218           fprintf (file, "%s %ld/%ld %6ld %s ", modebuf + 1,
 219                    (long) buf.st_uid, (long) buf.st_gid,
 220                    (long) buf.st_size, timebuf);
 221         }
 222     }
 223
 224   fprintf (file, "%s\n", bfd_get_filename (abfd));
 225 }
 226
 227 /* Return the name of a temporary file in the same directory as FILENAME.  */
 228
 229 char *
 230 make_tempname (filename)
 231      char *filename;
 232 {
 233   static char template[] = "stXXXXXX";
 234   char *tmpname;
 235   char *slash = strrchr (filename, '/');
 236
 237 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 238   {
 239     /* We could have foo/bar\\baz, or foo\\bar, or d:bar.  */
 240     char *bslash = strrchr (filename, '\\');
 241     if (slash == NULL || (bslash != NULL && bslash > slash))
 242       slash = bslash;
 243     if (slash == NULL && filename[0] != '\0' && filename[1] == ':')
 244       slash = filename + 1;
 245   }
 246 #endif
 247
 248   if (slash != (char *) NULL)
 249     {
 250       char c;
 251
 252       c = *slash;
 253       *slash = 0;
 254       tmpname = xmalloc (strlen (filename) + sizeof (template) + 2);
 255       strcpy (tmpname, filename);
 256 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 257       /* If tmpname is "X:", appending a slash will make it a root
 258          directory on drive X, which is NOT the same as the current
 259          directory on drive X.  */
 260       if (tmpname[1] == ':' && tmpname[2] == '\0')
 261         strcat (tmpname, ".");
 262 #endif
 263       strcat (tmpname, "/");
 264       strcat (tmpname, template);
 265       mktemp (tmpname);
 266       *slash = c;
 267     }
 268   else
 269     {
 270       tmpname = xmalloc (sizeof (template));
 271       strcpy (tmpname, template);
 272       mktemp (tmpname);
 273     }
 274   return tmpname;
 275 }
 276
 277 /* Parse a string into a VMA, with a fatal error if it can't be
 278    parsed.  */
 279
 280 bfd_vma
 281 parse_vma (s, arg)
 282      const char *s;
 283      const char *arg;
 284 {
 285   bfd_vma ret;
 286   const char *end;
 287
 288   ret = bfd_scan_vma (s, &end, 0);
 289
 290   if (*end != '\0')
 291     fatal (_("%s: bad number: %s"), arg, s);
 292
 293   return ret;
 294 }