binutils/bucomm.c

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