git.marmaro.de Git - mmh/blob - docs/historical/mh-6.8.5/miscellany/patch-2.0.12u8/backupfile.c

   1 /* backupfile.c -- make Emacs style backup file names
   2    Copyright (C) 1990 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it without restriction.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  */
  10
  11 /* David MacKenzie <djm@ai.mit.edu>.
  12    Some algorithms adapted from GNU Emacs. */
  13
  14 #include <stdio.h>
  15 #include <ctype.h>
  16 #include <sys/types.h>
  17 #include "backupfile.h"
  18 #include "config.h"
  19 char *index ();
  20 char *rindex ();
  21 char *malloc ();
  22
  23 #ifdef DIRENT
  24 #include <dirent.h>
  25 #ifdef direct
  26 #undef direct
  27 #endif
  28 #define direct dirent
  29 #define NLENGTH(direct) (strlen((direct)->d_name))
  30 #else /* !DIRENT */
  31 #define NLENGTH(direct) ((direct)->d_namlen)
  32 #ifdef USG
  33 #ifdef SYSNDIR
  34 #include <sys/ndir.h>
  35 #else /* !SYSNDIR */
  36 #include <ndir.h>
  37 #endif /* !SYSNDIR */
  38 #else /* !USG */
  39 #ifdef SYSDIR
  40 #include <sys/dir.h>
  41 #endif /* SYSDIR */
  42 #endif /* !USG */
  43 #endif /* !DIRENT */
  44
  45 #ifndef isascii
  46 #define ISDIGIT(c) (isdigit ((unsigned char) (c)))
  47 #else
  48 #define ISDIGIT(c) (isascii (c) && isdigit (c))
  49 #endif
  50
  51 #if defined (HAVE_UNISTD_H)
  52 #include <unistd.h>
  53 #endif
  54
  55 #if defined (_POSIX_VERSION)
  56 /* POSIX does not require that the d_ino field be present, and some
  57    systems do not provide it. */
  58 #define REAL_DIR_ENTRY(dp) 1
  59 #else
  60 #define REAL_DIR_ENTRY(dp) ((dp)->d_ino != 0)
  61 #endif
  62
  63 /* Which type of backup file names are generated. */
  64 enum backup_type backup_type = none;
  65
  66 /* The extension added to file names to produce a simple (as opposed
  67    to numbered) backup file name. */
  68 char *simple_backup_suffix = "~";
  69
  70 char *basename ();
  71 char *dirname ();
  72 static char *concat ();
  73 char *find_backup_file_name ();
  74 static char *make_version_name ();
  75 static int max_backup_version ();
  76 static int version_number ();
  77
  78 #ifndef NODIR
  79 /* Return the name of the new backup file for file FILE,
  80    allocated with malloc.  Return 0 if out of memory.
  81    FILE must not end with a '/' unless it is the root directory.
  82    Do not call this function if backup_type == none. */
  83
  84 char *
  85 find_backup_file_name (file)
  86      char *file;
  87 {
  88   char *dir;
  89   char *base_versions;
  90   int highest_backup;
  91
  92   if (backup_type == simple)
  93     return concat (file, simple_backup_suffix);
  94   base_versions = concat (basename (file), ".~");
  95   if (base_versions == 0)
  96     return 0;
  97   dir = dirname (file);
  98   if (dir == 0)
  99     {
 100       free (base_versions);
 101       return 0;
 102     }
 103   highest_backup = max_backup_version (base_versions, dir);
 104   free (base_versions);
 105   free (dir);
 106   if (backup_type == numbered_existing && highest_backup == 0)
 107     return concat (file, simple_backup_suffix);
 108   return make_version_name (file, highest_backup + 1);
 109 }
 110
 111 /* Return the number of the highest-numbered backup file for file
 112    FILE in directory DIR.  If there are no numbered backups
 113    of FILE in DIR, or an error occurs reading DIR, return 0.
 114    FILE should already have ".~" appended to it. */
 115
 116 static int
 117 max_backup_version (file, dir)
 118      char *file, *dir;
 119 {
 120   DIR *dirp;
 121   struct direct *dp;
 122   int highest_version;
 123   int this_version;
 124   int file_name_length;
 125
 126   dirp = opendir (dir);
 127   if (!dirp)
 128     return 0;
 129
 130   highest_version = 0;
 131   file_name_length = strlen (file);
 132
 133   while ((dp = readdir (dirp)) != 0)
 134     {
 135       if (!REAL_DIR_ENTRY (dp) || NLENGTH (dp) <= file_name_length)
 136         continue;
 137
 138       this_version = version_number (file, dp->d_name, file_name_length);
 139       if (this_version > highest_version)
 140         highest_version = this_version;
 141     }
 142   closedir (dirp);
 143   return highest_version;
 144 }
 145
 146 /* Return a string, allocated with malloc, containing
 147    "FILE.~VERSION~".  Return 0 if out of memory. */
 148
 149 static char *
 150 make_version_name (file, version)
 151      char *file;
 152      int version;
 153 {
 154   char *backup_name;
 155
 156   backup_name = malloc (strlen (file) + 16);
 157   if (backup_name == 0)
 158     return 0;
 159   sprintf (backup_name, "%s.~%d~", file, version);
 160   return backup_name;
 161 }
 162
 163 /* If BACKUP is a numbered backup of BASE, return its version number;
 164    otherwise return 0.  BASE_LENGTH is the length of BASE.
 165    BASE should already have ".~" appended to it. */
 166
 167 static int
 168 version_number (base, backup, base_length)
 169      char *base;
 170      char *backup;
 171      int base_length;
 172 {
 173   int version;
 174   char *p;
 175
 176   version = 0;
 177   if (!strncmp (base, backup, base_length) && ISDIGIT (backup[base_length]))
 178     {
 179       for (p = &backup[base_length]; ISDIGIT (*p); ++p)
 180         version = version * 10 + *p - '0';
 181       if (p[0] != '~' || p[1])
 182         version = 0;
 183     }
 184   return version;
 185 }
 186
 187 /* Return the newly-allocated concatenation of STR1 and STR2.
 188    If out of memory, return 0. */
 189
 190 static char *
 191 concat (str1, str2)
 192      char *str1, *str2;
 193 {
 194   char *newstr;
 195   char str1_length = strlen (str1);
 196
 197   newstr = malloc (str1_length + strlen (str2) + 1);
 198   if (newstr == 0)
 199     return 0;
 200   strcpy (newstr, str1);
 201   strcpy (newstr + str1_length, str2);
 202   return newstr;
 203 }
 204
 205 /* Return NAME with any leading path stripped off.  */
 206
 207 char *
 208 basename (name)
 209      char *name;
 210 {
 211   char *base;
 212
 213   base = rindex (name, '/');
 214   return base ? base + 1 : name;
 215 }
 216
 217 /* Return the leading directories part of PATH,
 218    allocated with malloc.  If out of memory, return 0.
 219    Assumes that trailing slashes have already been
 220    removed.  */
 221
 222 char *
 223 dirname (path)
 224      char *path;
 225 {
 226   char *newpath;
 227   char *slash;
 228   int length;    /* Length of result, not including NUL. */
 229
 230   slash = rindex (path, '/');
 231   if (slash == 0)
 232         {
 233           /* File is in the current directory.  */
 234           path = ".";
 235           length = 1;
 236         }
 237   else
 238         {
 239           /* Remove any trailing slashes from result. */
 240           while (slash > path && *slash == '/')
 241                 --slash;
 242
 243           length = slash - path + 1;
 244         }
 245   newpath = malloc (length + 1);
 246   if (newpath == 0)
 247     return 0;
 248   strncpy (newpath, path, length);
 249   newpath[length] = 0;
 250   return newpath;
 251 }
 252
 253 /* If ARG is an unambiguous match for an element of the
 254    null-terminated array OPTLIST, return the index in OPTLIST
 255    of the matched element, else -1 if it does not match any element
 256    or -2 if it is ambiguous (is a prefix of more than one element). */
 257
 258 int
 259 argmatch (arg, optlist)
 260      char *arg;
 261      char **optlist;
 262 {
 263   int i;                        /* Temporary index in OPTLIST. */
 264   int arglen;                   /* Length of ARG. */
 265   int matchind = -1;            /* Index of first nonexact match. */
 266   int ambiguous = 0;            /* If nonzero, multiple nonexact match(es). */
 267
 268   arglen = strlen (arg);
 269
 270   /* Test all elements for either exact match or abbreviated matches.  */
 271   for (i = 0; optlist[i]; i++)
 272     {
 273       if (!strncmp (optlist[i], arg, arglen))
 274         {
 275           if (strlen (optlist[i]) == arglen)
 276             /* Exact match found.  */
 277             return i;
 278           else if (matchind == -1)
 279             /* First nonexact match found.  */
 280             matchind = i;
 281           else
 282             /* Second nonexact match found.  */
 283             ambiguous = 1;
 284         }
 285     }
 286   if (ambiguous)
 287     return -2;
 288   else
 289     return matchind;
 290 }
 291
 292 /* Error reporting for argmatch.
 293    KIND is a description of the type of entity that was being matched.
 294    VALUE is the invalid value that was given.
 295    PROBLEM is the return value from argmatch. */
 296
 297 void
 298 invalid_arg (kind, value, problem)
 299      char *kind;
 300      char *value;
 301      int problem;
 302 {
 303   fprintf (stderr, "patch: ");
 304   if (problem == -1)
 305     fprintf (stderr, "invalid");
 306   else                          /* Assume -2. */
 307     fprintf (stderr, "ambiguous");
 308   fprintf (stderr, " %s `%s'\n", kind, value);
 309 }
 310
 311 static char *backup_args[] =
 312 {
 313   "never", "simple", "nil", "existing", "t", "numbered", 0
 314 };
 315
 316 static enum backup_type backup_types[] =
 317 {
 318   simple, simple, numbered_existing, numbered_existing, numbered, numbered
 319 };
 320
 321 /* Return the type of backup indicated by VERSION.
 322    Unique abbreviations are accepted. */
 323
 324 enum backup_type
 325 get_version (version)
 326      char *version;
 327 {
 328   int i;
 329
 330   if (version == 0 || *version == 0)
 331     return numbered_existing;
 332   i = argmatch (version, backup_args);
 333   if (i >= 0)
 334     return backup_types[i];
 335   invalid_arg ("version control type", version, i);
 336   exit (1);
 337 }
 338 #endif /* NODIR */