/* inputting files to be patched */ /* $Id: inp.c,v 1.18 1997/07/21 17:59:46 eggert Exp $ */ /* Copyright 1986, 1988 Larry Wall Copyright 1991, 1992, 1993, 1997 Free Software Foundation, Inc. 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, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #define XTERN extern #include #include #include #include #undef XTERN #define XTERN #include /* Input-file-with-indexable-lines abstract type */ static char *i_buffer; /* plan A buffer */ static char const **i_ptr; /* pointers to lines in plan A buffer */ static size_t tibufsize; /* size of plan b buffers */ #ifndef TIBUFSIZE_MINIMUM #define TIBUFSIZE_MINIMUM (8 * 1024) /* minimum value for tibufsize */ #endif static int tifd = -1; /* plan b virtual string array */ static char *tibuf[2]; /* plan b buffers */ static LINENUM tiline[2] = {-1, -1}; /* 1st line in each buffer */ static LINENUM lines_per_buf; /* how many lines per buffer */ static size_t tireclen; /* length of records in tmp file */ static size_t last_line_size; /* size of last input line */ static bool plan_a PARAMS ((char const *));/* yield FALSE if memory runs out */ static void plan_b PARAMS ((char const *)); static void report_revision PARAMS ((int)); static void too_many_lines PARAMS ((char const *)) __attribute__((noreturn)); /* New patch--prepare to edit another file. */ void re_input() { if (using_plan_a) { free (i_buffer); free (i_ptr); } else { close (tifd); tifd = -1; free(tibuf[0]); tibuf[0] = 0; tiline[0] = tiline[1] = -1; tireclen = 0; } } /* Construct the line index, somehow or other. */ void scan_input(filename) char *filename; { using_plan_a = ! (debug & 16) && plan_a (filename); if (!using_plan_a) plan_b(filename); switch (verbosity) { case SILENT: break; case VERBOSE: say ("Patching file `%s' using Plan %s...\n", filename, using_plan_a ? "A" : "B"); break; case DEFAULT_VERBOSITY: say ("patching file `%s'\n", filename); break; } } /* Report whether a desired revision was found. */ static void report_revision (found_revision) int found_revision; { if (found_revision) { if (verbosity == VERBOSE) say ("Good. This file appears to be the %s version.\n", revision); } else if (force) { if (verbosity != SILENT) say ("Warning: this file doesn't appear to be the %s version -- patching anyway.\n", revision); } else if (batch) { fatal ("This file doesn't appear to be the %s version -- aborting.", revision); } else { ask ("This file doesn't appear to be the %s version -- patch anyway? [n] ", revision); if (*buf != 'y') fatal ("aborted"); } } static void too_many_lines (filename) char const *filename; { fatal ("File `%s' has too many lines.", filename); } void get_input_file (filename, outname) char const *filename; char const *outname; { int elsewhere = strcmp (filename, outname); char const *cs; char *diffbuf; char *getbuf; if (inerrno == -1) inerrno = stat (inname, &instat) == 0 ? 0 : errno; /* Perhaps look for RCS or SCCS versions. */ if (patch_get && invc != 0 && (inerrno || (! elsewhere && (/* No one can write to it. */ (instat.st_mode & (S_IWUSR|S_IWGRP|S_IWOTH)) == 0 /* Only the owner (who's not me) can write to it. */ || ((instat.st_mode & (S_IWGRP|S_IWOTH)) == 0 && instat.st_uid != geteuid ())))) && (invc = !! (cs = (version_controller (filename, elsewhere, inerrno ? (struct stat *) 0 : &instat, &getbuf, &diffbuf))))) { if (!inerrno) { if (!elsewhere && (instat.st_mode & (S_IWUSR|S_IWGRP|S_IWOTH)) != 0) /* Somebody can write to it. */ fatal ("file `%s' seems to be locked by somebody else under %s", filename, cs); /* It might be checked out unlocked. See if it's safe to check out the default version locked. */ if (verbosity == VERBOSE) say ("Comparing file `%s' to default %s version...\n", filename, cs); if (systemic (diffbuf) != 0) { say ("warning: patching file `%s', which does not match default %s version\n", filename, cs); cs = 0; } } if (cs && version_get (filename, cs, ! inerrno, elsewhere, getbuf, &instat)) inerrno = 0; free (getbuf); free (diffbuf); } else if (inerrno && !pch_says_nonexistent (reverse)) { errno = inerrno; pfatal ("can't find file `%s'", filename); } if (inerrno) { instat.st_mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH; instat.st_size = 0; } else if (! S_ISREG (instat.st_mode)) fatal ("`%s' is not a regular file -- can't patch", filename); } /* Try keeping everything in memory. */ static bool plan_a(filename) char const *filename; { register char const *s; register char const *lim; register char const **ptr; register char *buffer; register LINENUM iline; size_t size = instat.st_size; /* Fail if the file size doesn't fit in a size_t, or if storage isn't available. */ if (! (size == instat.st_size && (buffer = malloc (size ? size : (size_t) 1)))) return FALSE; /* Read the input file, but don't bother reading it if it's empty. When creating files, the files do not actually exist. */ if (size) { int ifd = open (filename, O_RDONLY|binary_transput); size_t buffered = 0, n; if (ifd < 0) pfatal ("can't open file `%s'", filename); while (size - buffered != 0) { n = read (ifd, buffer + buffered, size - buffered); if (n == 0) { /* Some non-POSIX hosts exaggerate st_size in text mode; or the file may have shrunk! */ size = buffered; break; } if (n == (size_t) -1) { /* Perhaps size is too large for this host. */ close (ifd); free (buffer); return FALSE; } buffered += n; } if (close (ifd) != 0) read_fatal (); } /* Scan the buffer and build array of pointers to lines. */ lim = buffer + size; iline = 3; /* 1 unused, 1 for SOF, 1 for EOF if last line is incomplete */ for (s = buffer; (s = (char *) memchr (s, '\n', lim - s)); s++) if (++iline < 0) too_many_lines (filename); if (! (iline == (size_t) iline && (size_t) iline * sizeof *ptr / sizeof *ptr == (size_t) iline && (ptr = (char const **) malloc ((size_t) iline * sizeof *ptr)))) { free (buffer); return FALSE; } iline = 0; for (s = buffer; ; s++) { ptr[++iline] = s; if (! (s = (char *) memchr (s, '\n', lim - s))) break; } if (size && lim[-1] != '\n') ptr[++iline] = lim; input_lines = iline - 1; if (revision) { char const *rev = revision; int rev0 = rev[0]; int found_revision = 0; size_t revlen = strlen (rev); if (revlen <= size) { char const *limrev = lim - revlen; for (s = buffer; (s = (char *) memchr (s, rev0, limrev - s)); s++) if (memcmp (s, rev, revlen) == 0 && (s == buffer || ISSPACE ((unsigned char) s[-1])) && (s + 1 == limrev || ISSPACE ((unsigned char) s[revlen]))) { found_revision = 1; break; } } report_revision (found_revision); } /* Plan A will work. */ i_buffer = buffer; i_ptr = ptr; return TRUE; } /* Keep (virtually) nothing in memory. */ static void plan_b(filename) char const *filename; { register FILE *ifp; register int c; register size_t len; register size_t maxlen; register int found_revision; register size_t i; register char const *rev; register size_t revlen; register LINENUM line = 1; if (instat.st_size == 0) filename = NULL_DEVICE; if (! (ifp = fopen (filename, binary_transput ? "rb" : "r"))) pfatal ("can't open file `%s'", filename); tifd = create_file (TMPINNAME, O_RDWR | O_BINARY, (mode_t) 0); i = 0; len = 0; maxlen = 1; rev = revision; found_revision = !rev; revlen = rev ? strlen (rev) : 0; while ((c = getc (ifp)) != EOF) { len++; if (c == '\n') { if (++line < 0) too_many_lines (filename); if (maxlen < len) maxlen = len; len = 0; } if (!found_revision) { if (i == revlen) { found_revision = ISSPACE ((unsigned char) c); i = (size_t) -1; } else if (i != (size_t) -1) i = rev[i]==c ? i + 1 : (size_t) -1; if (i == (size_t) -1 && ISSPACE ((unsigned char) c)) i = 0; } } if (revision) report_revision (found_revision); Fseek (ifp, (off_t) 0, SEEK_SET); /* rewind file */ for (tibufsize = TIBUFSIZE_MINIMUM; tibufsize < maxlen; tibufsize <<= 1) continue; lines_per_buf = tibufsize / maxlen; tireclen = maxlen; tibuf[0] = xmalloc (2 * tibufsize); tibuf[1] = tibuf[0] + tibufsize; for (line = 1; ; line++) { char *p = tibuf[0] + maxlen * (line % lines_per_buf); char const *p0 = p; if (! (line % lines_per_buf)) /* new block */ if (write (tifd, tibuf[0], tibufsize) != tibufsize) write_fatal (); if ((c = getc (ifp)) == EOF) break; for (;;) { *p++ = c; if (c == '\n') { last_line_size = p - p0; break; } if ((c = getc (ifp)) == EOF) { last_line_size = p - p0; line++; goto EOF_reached; } } } EOF_reached: if (ferror (ifp) || fclose (ifp) != 0) read_fatal (); if (line % lines_per_buf != 0) if (write (tifd, tibuf[0], tibufsize) != tibufsize) write_fatal (); input_lines = line - 1; } /* Fetch a line from the input file. */ char const * ifetch (line, whichbuf, psize) register LINENUM line; int whichbuf; /* ignored when file in memory */ size_t *psize; { register char const *q; register char const *p; if (line < 1 || line > input_lines) { *psize = 0; return ""; } if (using_plan_a) { p = i_ptr[line]; *psize = i_ptr[line + 1] - p; return p; } else { LINENUM offline = line % lines_per_buf; LINENUM baseline = line - offline; if (tiline[0] == baseline) whichbuf = 0; else if (tiline[1] == baseline) whichbuf = 1; else { tiline[whichbuf] = baseline; if (lseek (tifd, (off_t) (baseline/lines_per_buf * tibufsize), SEEK_SET) == -1 || read (tifd, tibuf[whichbuf], tibufsize) < 0) read_fatal (); } p = tibuf[whichbuf] + (tireclen*offline); if (line == input_lines) *psize = last_line_size; else { for (q = p; *q++ != '\n'; ) continue; *psize = q - p; } return p; } }