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