etags: remove some arbitrary limits

etags had undefined behavior if input files, lines, tags, etc.,
had more than INT_MAX bytes.  Clean up the usage of integer types
to fix the overflow errors I found.
* admin/merge-gnulib (GNULIB_MODULES): Add mempcpy.
* lib-src/etags.c: Include inttypes.h, intprops.h.
(memcpyz): New function.  Use it to simplify several occurrences
of memcpy followed by storing a trailing '\0'.
(xnew): Use xnmalloc, to catch overflow on integer multiplication.
(xrnew): Change last arg to multiplier.  The type is not needed.
All callers changed.
(node, lineno, charno, linecharno, invalidcharno, make_tag):
(pfnote, add_node, number_len, C_symtype, lbz, Makefile_targets)
(readline):
Use intmax_t for line numbers and character positions, instead of
int or long.
(linebuffer, make_tag, pfnote, total_size_of_entries, put_entry)
(in_word_set, C_symtype, token, cstack, pushclass_above):
(popclass_above, write_classname, consider_token, C_entries)
(Ruby_functions, Makefile_targets, Lua_functions, TeX_commands)
(TeX_decode_env, erlang_func, erlang_attribute, erlang_atom)
(substitute, regex_tag_multiline, nocase_tail, readline_interval)
(readline, savenstr, concat, etags_getcwd, relative_filename)
(linebuffer_setlen):
Use ptrdiff_t for object sizes, instead of int or long or unsigned
or size_t.
(write_classname, C_entries):
Avoid sprintf, as the result could exceed INT_MAX bytes
and then behavior goes haywire.
(main): Use int, instead of unsigned, for argv counts.
(get_language_from_filename): Use bool for boolean.
(Ruby_functions): Prefer strcpy to memcpy when copying "=".
(linebuffer_setlen): Use ‘if’ instead of ‘while’.
(memory_full, xnmalloc, xnrealloc): New functions.
(xmalloc): Use memory_full, and take a ptrdiff_t instead of a size_t.
(xrealloc): Remove; no longer needed.
* lib/gnulib.mk.in, m4/gnulib-comp.m4: Regenerate.
* lib/mempcpy.c, m4/mempcpy.m4: New files, copied from Gnulib.

1 files changed, 211 insertions, 193 deletions

diff --git a/lib-src/etags.c b/lib-src/etags.c
index 6409407e466..0665cb00b9b 100644
--- a/lib-src/etags.c
+++ b/lib-src/etags.c
@@ -114,6 +114,7 @@ char pot_etags_version[] = "@(#) pot revision number is 17.38.1.4";
 # define O_CLOEXEC O_NOINHERIT
 #endif /* WINDOWSNT */
 
+#include <inttypes.h>
 #include <limits.h>
 #include <unistd.h>
 #include <stdarg.h>
@@ -123,6 +124,7 @@ char pot_etags_version[] = "@(#) pot revision number is 17.38.1.4";
 #include <errno.h>
 #include <fcntl.h>
 #include <binary-io.h>
+#include <intprops.h>
 #include <unlocked-io.h>
 #include <c-ctype.h>
 #include <c-strcase.h>
@@ -141,6 +143,14 @@ char pot_etags_version[] = "@(#) pot revision number is 17.38.1.4";
 # define CTAGS false
 #endif
 
+/* Copy to DEST from SRC (containing LEN bytes), and append a NUL byte.  */
+static void
+memcpyz (void *dest, void const *src, ptrdiff_t len)
+{
+  char *e = mempcpy (dest, src, len);
+  *e = '\0';
+}
+
 static bool
 streq (char const *s, char const *t)
 {
@@ -235,11 +245,11 @@ endtoken (unsigned char c)
 /*
  *      xnew, xrnew -- allocate, reallocate storage
  *
- * SYNOPSIS:    Type *xnew (int n, Type);
- *              void xrnew (OldPointer, int n, Type);
+ * SYNOPSIS:    Type *xnew (ptrdiff_t n, Type);
+ *              void xrnew (OldPointer, ptrdiff_t n, int multiplier);
  */
-#define xnew(n, Type)      ((Type *) xmalloc ((n) * sizeof (Type)))
-#define xrnew(op, n, Type) ((op) = (Type *) xrealloc (op, (n) * sizeof (Type)))
+#define xnew(n, Type) ((Type *) xnmalloc (n, sizeof (Type)))
+#define xrnew(op, n, m) ((op) = xnrealloc (op, n, (m) * sizeof *(op)))
 
 typedef void Lang_function (FILE *);
 
@@ -282,8 +292,8 @@ typedef struct node_st
   bool valid;                   /* write this tag on the tag file */
   bool is_func;                 /* function tag: use regexp in CTAGS mode */
   bool been_warned;             /* warning already given for duplicated tag */
-  int lno;                      /* line number tag is on */
-  long cno;                     /* character number line starts on */
+  intmax_t lno;                 /* line number tag is on */
+  intmax_t cno;                 /* character number line starts on */
 } node;
 
 /*
@@ -295,8 +305,8 @@ typedef struct node_st
  */
 typedef struct
 {
-  long size;
-  int len;
+  ptrdiff_t size;
+  ptrdiff_t len;
   char *buffer;
 } linebuffer;
 
@@ -365,7 +375,7 @@ static void just_read_file (FILE *);
 
 static language *get_language_from_langname (const char *);
 static void readline (linebuffer *, FILE *);
-static long readline_internal (linebuffer *, FILE *, char const *);
+static ptrdiff_t readline_internal (linebuffer *, FILE *, char const *);
 static bool nocase_tail (const char *);
 static void get_tag (char *, char **);
 static void get_lispy_tag (char *);
@@ -385,7 +395,7 @@ static void process_file (FILE *, char *, language *);
 static void find_entries (FILE *);
 static void free_tree (node *);
 static void free_fdesc (fdesc *);
-static void pfnote (char *, bool, char *, int, int, long);
+static void pfnote (char *, bool, char *, ptrdiff_t, intmax_t, intmax_t);
 static void invalidate_nodes (fdesc *, node **);
 static void put_entries (node *);
 
@@ -393,7 +403,7 @@ static char *concat (const char *, const char *, const char *);
 static char *skip_spaces (char *);
 static char *skip_non_spaces (char *);
 static char *skip_name (char *);
-static char *savenstr (const char *, int);
+static char *savenstr (const char *, ptrdiff_t);
 static char *savestr (const char *);
 static char *etags_getcwd (void);
 static char *relative_filename (char *, char *);
@@ -403,9 +413,11 @@ static bool filename_is_absolute (char *f);
 static void canonicalize_filename (char *);
 static char *etags_mktmp (void);
 static void linebuffer_init (linebuffer *);
-static void linebuffer_setlen (linebuffer *, int);
-static void *xmalloc (size_t);
-static void *xrealloc (void *, size_t);
+static void linebuffer_setlen (linebuffer *, ptrdiff_t);
+static void *xmalloc (ptrdiff_t) ATTRIBUTE_MALLOC_SIZE ((1));
+static void *xnmalloc (ptrdiff_t, ptrdiff_t) ATTRIBUTE_MALLOC_SIZE ((1,2));
+static void *xnrealloc (void *, ptrdiff_t, ptrdiff_t)
+  ATTRIBUTE_ALLOC_SIZE ((2,3));
 
 
 static char searchar = '/';     /* use /.../ searches */
@@ -420,12 +432,12 @@ static ptrdiff_t whatlen_max;	/* maximum length of any 'what' member */
 static fdesc *fdhead;           /* head of file description list */
 static fdesc *curfdp;           /* current file description */
 static char *infilename;        /* current input file name */
-static int lineno;              /* line number of current line */
-static long charno;             /* current character number */
-static long linecharno;         /* charno of start of current line */
+static intmax_t lineno;         /* line number of current line */
+static intmax_t charno;         /* current character number */
+static intmax_t linecharno;     /* charno of start of current line */
 static char *dbp;               /* pointer to start of current tag */
 
-static const int invalidcharno = -1;
+static intmax_t const invalidcharno = -1;
 
 static node *nodehead;          /* the head of the binary tree of tags */
 static node *last_node;         /* the last node created */
@@ -1070,7 +1082,7 @@ int
 main (int argc, char **argv)
 {
   int i;
-  unsigned int nincluded_files;
+  int nincluded_files;
   char **included_files;
   argument *argbuffer;
   int current_arg, file_count;
@@ -1484,7 +1496,7 @@ get_language_from_interpreter (char *interpreter)
  * Return a language given the file name.
  */
 static language *
-get_language_from_filename (char *file, int case_sensitive)
+get_language_from_filename (char *file, bool case_sensitive)
 {
   language *lang;
   const char **name, **ext, *suffix;
@@ -1918,26 +1930,26 @@ find_entries (FILE *inf)
  */
 static void
 make_tag (const char *name,     /* tag name, or NULL if unnamed */
-          int namelen,          /* tag length */
+          ptrdiff_t namelen,    /* tag length */
           bool is_func,         /* tag is a function */
           char *linestart,      /* start of the line where tag is */
-          int linelen,          /* length of the line where tag is */
-          int lno,              /* line number */
-          long int cno)         /* character number */
+          ptrdiff_t linelen,    /* length of the line where tag is */
+          intmax_t lno,         /* line number */
+          intmax_t cno)         /* character number */
 {
   bool named = (name != NULL && namelen > 0);
   char *nname = NULL;
 
   if (debug)
-    fprintf (stderr, "%s on %s:%d: %s\n",
+    fprintf (stderr, "%s on %s:%"PRIdMAX": %s\n",
              named ? name : "(unnamed)", curfdp->taggedfname, lno, linestart);
 
   if (!CTAGS && named)          /* maybe set named to false */
     /* Let's try to make an implicit tag name, that is, create an unnamed tag
        such that etags.el can guess a name from it. */
     {
-      int i;
-      register const char *cp = name;
+      ptrdiff_t i;
+      const char *cp = name;
 
       for (i = 0; i < namelen; i++)
         if (notinname (*cp++))
@@ -1963,8 +1975,8 @@ make_tag (const char *name, 	/* tag name, or NULL if unnamed */
 
 /* Record a tag. */
 static void
-pfnote (char *name, bool is_func, char *linestart, int linelen, int lno,
-        long int cno)
+pfnote (char *name, bool is_func, char *linestart, ptrdiff_t linelen,
+        intmax_t lno, intmax_t cno)
                                 /* tag name, or NULL if unnamed */
                                 /* tag is a function */
                                 /* start of the line where tag is */
@@ -2197,7 +2209,8 @@ add_node (node *np, node **cur_node_p)
                   if (!no_warnings)
                     {
                       fprintf (stderr,
-                               "Duplicate entry in file %s, line %d: %s\n",
+                               ("Duplicate entry in file %s, "
+                                "line %"PRIdMAX": %s\n"),
                                np->fdp->infname, lineno, np->name);
                       fprintf (stderr, "Second entry ignored\n");
                     }
@@ -2293,12 +2306,12 @@ invalidate_nodes (fdesc *badfdp, node **npp)
 }
 
 
-static int total_size_of_entries (node *);
-static int number_len (long) ATTRIBUTE_CONST;
+static ptrdiff_t total_size_of_entries (node *);
+static int number_len (intmax_t) ATTRIBUTE_CONST;
 
 /* Length of a non-negative number's decimal representation. */
 static int
-number_len (long int num)
+number_len (intmax_t num)
 {
   int len = 1;
   while ((num /= 10) > 0)
@@ -2312,10 +2325,10 @@ number_len (long int num)
  * This count is irrelevant with etags.el since emacs 19.34 at least,
  * but is still supplied for backward compatibility.
  */
-static int
-total_size_of_entries (register node *np)
+static ptrdiff_t
+total_size_of_entries (node *np)
 {
-  register int total = 0;
+  ptrdiff_t total = 0;
 
   for (; np != NULL; np = np->right)
     if (np->valid)
@@ -2323,7 +2336,7 @@ total_size_of_entries (register node *np)
         total += strlen (np->regex) + 1;                /* pat\177 */
         if (np->name != NULL)
           total += strlen (np->name) + 1;               /* name\001 */
-        total += number_len ((long) np->lno) + 1;       /* lno, */
+        total += number_len (np->lno) + 1;              /* lno, */
         if (np->cno != invalidcharno)                   /* cno */
           total += number_len (np->cno);
         total += 1;                                     /* newline */
@@ -2347,7 +2360,7 @@ put_entry (node *np)
           if (fdp != np->fdp)
             {
               fdp = np->fdp;
-              fprintf (tagf, "\f\n%s,%d\n",
+              fprintf (tagf, "\f\n%s,%"PRIdPTR"\n",
                        fdp->taggedfname, total_size_of_entries (np));
               fdp->written = true;
             }
@@ -2358,9 +2371,9 @@ put_entry (node *np)
               fputs (np->name, tagf);
               fputc ('\001', tagf);
             }
-          fprintf (tagf, "%d,", np->lno);
+          fprintf (tagf, "%"PRIdMAX",", np->lno);
           if (np->cno != invalidcharno)
-            fprintf (tagf, "%ld", np->cno);
+            fprintf (tagf, "%"PRIdMAX, np->cno);
           fputs ("\n", tagf);
         }
       else
@@ -2372,10 +2385,10 @@ put_entry (node *np)
           if (cxref_style)
             {
               if (vgrind_style)
-                fprintf (stdout, "%s %s %d\n",
+                fprintf (stdout, "%s %s %"PRIdMAX"\n",
                          np->name, np->fdp->taggedfname, (np->lno + 63) / 64);
               else
-                fprintf (stdout, "%-16s %3d %-16s %s\n",
+                fprintf (stdout, "%-16s %3"PRIdMAX" %-16s %s\n",
                          np->name, np->lno, np->fdp->taggedfname, np->regex);
             }
           else
@@ -2397,7 +2410,7 @@ put_entry (node *np)
                 }
               else
                 {               /* anything else; text pattern inadequate */
-                  fprintf (tagf, "%d", np->lno);
+                  fprintf (tagf, "%"PRIdMAX, np->lno);
                 }
               putc ('\n', tagf);
             }
@@ -2591,7 +2604,7 @@ hash (const char *str, int len)
 }
 
 static struct C_stab_entry *
-in_word_set (register const char *str, register unsigned int len)
+in_word_set (const char *str, ptrdiff_t len)
 {
   enum
     {
@@ -2658,9 +2671,9 @@ in_word_set (register const char *str, register unsigned int len)
 /*%>*/
 
 static enum sym_type
-C_symtype (char *str, int len, int c_ext)
+C_symtype (char *str, ptrdiff_t len, int c_ext)
 {
-  register struct C_stab_entry *se = in_word_set (str, len);
+  struct C_stab_entry *se = in_word_set (str, len);
 
   if (se == NULL || (se->c_ext && !(c_ext & se->c_ext)))
     return st_none;
@@ -2770,8 +2783,8 @@ static enum
 static struct tok
 {
   char *line;                   /* string containing the token */
-  int offset;                   /* where the token starts in LINE */
-  int length;                   /* token length */
+  ptrdiff_t offset;             /* where the token starts in LINE */
+  ptrdiff_t length;             /* token length */
   /*
     The previous members can be used to pass strings around for generic
     purposes.  The following ones specifically refer to creating tags.  In this
@@ -2782,23 +2795,23 @@ static struct tok
                                    invalidated whenever a state machine is
                                    reset prematurely */
   bool named;                   /* create a named tag */
-  int lineno;                   /* source line number of tag */
-  long linepos;                 /* source char number of tag */
+  intmax_t lineno;              /* source line number of tag */
+  intmax_t linepos;             /* source char number of tag */
 } token;                        /* latest token read */
 
 /*
  * Variables and functions for dealing with nested structures.
  * Idea by Mykola Dzyuba <mdzyuba@yahoo.com> (2001)
  */
-static void pushclass_above (int, char *, int);
-static void popclass_above (int);
+static void pushclass_above (ptrdiff_t, char *, ptrdiff_t);
+static void popclass_above (ptrdiff_t);
 static void write_classname (linebuffer *, const char *qualifier);
 
 static struct {
   char **cname;                 /* nested class names */
-  int *bracelev;                /* nested class brace level */
-  int nl;                       /* class nesting level (elements used) */
-  int size;                     /* length of the array */
+  ptrdiff_t *bracelev;          /* nested class brace level */
+  ptrdiff_t nl;                 /* class nesting level (elements used) */
+  ptrdiff_t size;               /* length of the array */
 } cstack;                       /* stack for nested declaration tags */
 /* Current struct nesting depth (namespace, class, struct, union, enum). */
 #define nestlev         (cstack.nl)
@@ -2807,17 +2820,17 @@ static struct {
                          && bracelev == cstack.bracelev[nestlev-1] + 1)
 
 static void
-pushclass_above (int bracelev, char *str, int len)
+pushclass_above (ptrdiff_t bracelev, char *str, ptrdiff_t len)
 {
-  int nl;
+  ptrdiff_t nl;
 
   popclass_above (bracelev);
   nl = cstack.nl;
   if (nl >= cstack.size)
     {
-      int size = cstack.size *= 2;
-      xrnew (cstack.cname, size, char *);
-      xrnew (cstack.bracelev, size, int);
+      xrnew (cstack.cname, cstack.size, 2);
+      xrnew (cstack.bracelev, cstack.size, 2);
+      cstack.size *= 2;
     }
   assert (nl == 0 || cstack.bracelev[nl-1] < bracelev);
   cstack.cname[nl] = (str == NULL) ? NULL : savenstr (str, len);
@@ -2826,11 +2839,9 @@ pushclass_above (int bracelev, char *str, int len)
 }
 
 static void
-popclass_above (int bracelev)
+popclass_above (ptrdiff_t bracelev)
 {
-  int nl;
-
-  for (nl = cstack.nl - 1;
+  for (ptrdiff_t nl = cstack.nl - 1;
        nl >= 0 && cstack.bracelev[nl] >= bracelev;
        nl--)
     {
@@ -2842,8 +2853,7 @@ popclass_above (int bracelev)
 static void
 write_classname (linebuffer *cn, const char *qualifier)
 {
-  int i, len;
-  int qlen = strlen (qualifier);
+  ptrdiff_t len;
 
   if (cstack.nl == 0 || cstack.cname[0] == NULL)
     {
@@ -2857,18 +2867,22 @@ write_classname (linebuffer *cn, const char *qualifier)
       linebuffer_setlen (cn, len);
       strcpy (cn->buffer, cstack.cname[0]);
     }
-  for (i = 1; i < cstack.nl; i++)
+  for (ptrdiff_t i = 1; i < cstack.nl; i++)
     {
       char *s = cstack.cname[i];
       if (s == NULL)
         continue;
-      linebuffer_setlen (cn, len + qlen + strlen (s));
-      len += sprintf (cn->buffer + len, "%s%s", qualifier, s);
+      int qlen = strlen (qualifier);
+      ptrdiff_t slen = strlen (s);
+      linebuffer_setlen (cn, len + qlen + slen);
+      memcpyz (stpcpy (cn->buffer + len, qualifier), s, slen);
+      len += qlen + slen;
     }
 }
 
 
-static bool consider_token (char *, int, int, int *, int, int, bool *);
+static bool consider_token (char *, ptrdiff_t, int, int *,
+                            ptrdiff_t, ptrdiff_t, bool *);
 static void make_C_tag (bool);
 
 /*
@@ -2889,8 +2903,8 @@ static void make_C_tag (bool);
  */
 
 static bool
-consider_token (char *str, int len, int c, int *c_extp,
-                int bracelev, int parlev, bool *is_func_or_var)
+consider_token (char *str, ptrdiff_t len, int c, int *c_extp,
+                ptrdiff_t bracelev, ptrdiff_t parlev, bool *is_func_or_var)
                                 /* IN: token pointer */
                                 /* IN: token length */
                                 /* IN: first char after the token */
@@ -2903,7 +2917,7 @@ consider_token (char *str, int len, int c, int *c_extp,
      structtype is the type of the preceding struct-like keyword, and
      structbracelev is the brace level where it has been seen. */
   static enum sym_type structtype;
-  static int structbracelev;
+  static ptrdiff_t structbracelev;
   static enum sym_type toktype;
 
 
@@ -3098,8 +3112,7 @@ consider_token (char *str, int len, int c, int *c_extp,
            fvdef = fvnone;
            objdef = omethodtag;
            linebuffer_setlen (&token_name, len);
-           memcpy (token_name.buffer, str, len);
-           token_name.buffer[len] = '\0';
+           memcpyz (token_name.buffer, str, len);
            return true;
          }
        return false;
@@ -3113,11 +3126,10 @@ consider_token (char *str, int len, int c, int *c_extp,
            objdef = omethodtag;
            if (class_qualify)
              {
-               int oldlen = token_name.len;
+               ptrdiff_t oldlen = token_name.len;
                fvdef = fvnone;
                linebuffer_setlen (&token_name, oldlen + len);
-               memcpy (token_name.buffer + oldlen, str, len);
-               token_name.buffer[oldlen + len] = '\0';
+               memcpyz (token_name.buffer + oldlen, str, len);
              }
            return true;
          }
@@ -3228,7 +3240,7 @@ consider_token (char *str, int len, int c, int *c_extp,
  */
 static struct
 {
-  long linepos;
+  intmax_t linepos;
   linebuffer lb;
 } lbs[2];
 
@@ -3302,19 +3314,19 @@ C_entries (int c_ext, FILE *inf)
                                 /* extension of C */
                                 /* input file */
 {
-  register char c;              /* latest char read; '\0' for end of line */
-  register char *lp;            /* pointer one beyond the character `c' */
-  int curndx, newndx;           /* indices for current and new lb */
-  register int tokoff;          /* offset in line of start of current token */
-  register int toklen;          /* length of current token */
+  char c;                       /* latest char read; '\0' for end of line */
+  char *lp;                     /* pointer one beyond the character `c' */
+  bool curndx, newndx;          /* indices for current and new lb */
+  ptrdiff_t tokoff;             /* offset in line of start of current token */
+  ptrdiff_t toklen;             /* length of current token */
   const char *qualifier;        /* string used to qualify names */
   int qlen;                     /* length of qualifier */
-  int bracelev;                 /* current brace level */
-  int bracketlev;               /* current bracket level */
-  int parlev;                   /* current parenthesis level */
-  int attrparlev;               /* __attribute__ parenthesis level */
-  int templatelev;              /* current template level */
-  int typdefbracelev;           /* bracelev where a typedef struct body begun */
+  ptrdiff_t bracelev;           /* current brace level */
+  ptrdiff_t bracketlev;         /* current bracket level */
+  ptrdiff_t parlev;             /* current parenthesis level */
+  ptrdiff_t attrparlev;         /* __attribute__ parenthesis level */
+  ptrdiff_t templatelev;        /* current template level */
+  ptrdiff_t typdefbracelev;     /* bracelev where a typedef struct body begun */
   bool incomm, inquote, inchar, quotednl, midtoken;
   bool yacc_rules;              /* in the rules part of a yacc file */
   struct tok savetoken = {0};   /* token saved during preprocessor handling */
@@ -3327,7 +3339,7 @@ C_entries (int c_ext, FILE *inf)
       cstack.size = (DEBUG) ? 1 : 4;
       cstack.nl = 0;
       cstack.cname = xnew (cstack.size, char *);
-      cstack.bracelev = xnew (cstack.size, int);
+      cstack.bracelev = xnew (cstack.size, ptrdiff_t);
     }
 
   tokoff = toklen = typdefbracelev = 0; /* keep compiler quiet */
@@ -3579,20 +3591,19 @@ C_entries (int c_ext, FILE *inf)
                             {
                               if (class_qualify)
                                 {
-                                  int len;
                                   write_classname (&token_name, qualifier);
-                                  len = token_name.len;
+                                  ptrdiff_t len = token_name.len;
                                   linebuffer_setlen (&token_name,
                                                      len + qlen + toklen);
-                                  sprintf (token_name.buffer + len, "%s%.*s",
-                                           qualifier, toklen,
-                                           newlb.buffer + tokoff);
+                                  memcpyz (stpcpy (token_name.buffer + len,
+                                                   qualifier),
+                                           newlb.buffer + tokoff, toklen);
                                 }
                               else
                                 {
                                   linebuffer_setlen (&token_name, toklen);
-                                  sprintf (token_name.buffer, "%.*s",
-                                           toklen, newlb.buffer + tokoff);
+                                  memcpyz (token_name.buffer,
+                                           newlb.buffer + tokoff, toklen);
                                 }
                               token.named = true;
                             }
@@ -3601,17 +3612,19 @@ C_entries (int c_ext, FILE *inf)
                             {
                               if (class_qualify)
                                 {
-                                  int len = strlen (objtag) + 2 + toklen;
+                                  ptrdiff_t len = strlen (objtag) + 2 + toklen;
                                   linebuffer_setlen (&token_name, len);
-                                  sprintf (token_name.buffer, "%s(%.*s)",
-                                           objtag, toklen,
-                                           newlb.buffer + tokoff);
+                                  char *p1 = stpcpy (token_name.buffer, objtag);
+                                  char *p2 = stpcpy (p1, "(");
+                                  char *p3 = mempcpy (p2, newlb.buffer + tokoff,
+                                                      toklen);
+                                  strcpy (p3, ")");
                                 }
                               else
                                 {
                                   linebuffer_setlen (&token_name, toklen);
-                                  sprintf (token_name.buffer, "%.*s",
-                                           toklen, newlb.buffer + tokoff);
+                                  memcpyz (token_name.buffer,
+                                           newlb.buffer + tokoff, toklen);
                                 }
                               token.named = true;
                             }
@@ -3625,8 +3638,8 @@ C_entries (int c_ext, FILE *inf)
                             /* GNU DEFUN and similar macros */
                             {
                               bool defun = (newlb.buffer[tokoff] == 'F');
-                              int off = tokoff;
-                              int len = toklen;
+                              ptrdiff_t off = tokoff;
+                              ptrdiff_t len = toklen;
 
                               if (defun)
                                 {
@@ -3635,9 +3648,8 @@ C_entries (int c_ext, FILE *inf)
 
                                   /* First, tag it as its C name */
                                   linebuffer_setlen (&token_name, toklen);
-                                  memcpy (token_name.buffer,
-                                          newlb.buffer + tokoff, toklen);
-                                  token_name.buffer[toklen] = '\0';
+                                  memcpyz (token_name.buffer,
+                                           newlb.buffer + tokoff, toklen);
                                   token.named = true;
                                   token.lineno = lineno;
                                   token.offset = tokoff;
@@ -3650,9 +3662,8 @@ C_entries (int c_ext, FILE *inf)
                               /* Rewrite the tag so that emacs lisp DEFUNs
                                  can be found also by their elisp name */
                               linebuffer_setlen (&token_name, len);
-                              memcpy (token_name.buffer,
-                                      newlb.buffer + off, len);
-                              token_name.buffer[len] = '\0';
+                              memcpyz (token_name.buffer,
+                                       newlb.buffer + off, len);
                               if (defun)
                                 while (--len >= 0)
                                   if (token_name.buffer[len] == '_')
@@ -3662,9 +3673,8 @@ C_entries (int c_ext, FILE *inf)
                           else
                             {
                               linebuffer_setlen (&token_name, toklen);
-                              memcpy (token_name.buffer,
-                                      newlb.buffer + tokoff, toklen);
-                              token_name.buffer[toklen] = '\0';
+                              memcpyz (token_name.buffer,
+                                       newlb.buffer + tokoff, toklen);
                               /* Name macros and members. */
                               token.named = (structdef == stagseen
                                              || typdef == ttypeseen
@@ -3790,7 +3800,7 @@ C_entries (int c_ext, FILE *inf)
               objdef = omethodcolon;
               if (class_qualify)
                 {
-                  int toklen = token_name.len;
+                  ptrdiff_t toklen = token_name.len;
                   linebuffer_setlen (&token_name, toklen + 1);
                   strcpy (token_name.buffer + toklen, ":");
                 }
@@ -4061,7 +4071,7 @@ C_entries (int c_ext, FILE *inf)
                     }
                   if (uqname > token_name.buffer)
                     {
-                      int uqlen = strlen (uqname);
+                      ptrdiff_t uqlen = strlen (uqname);
                       linebuffer_setlen (&token_name, uqlen);
                       memmove (token_name.buffer, uqname, uqlen + 1);
                     }
@@ -4979,12 +4989,11 @@ Ruby_functions (FILE *inf)
                         size_t name_len = cp - np + 1;
                         char *wr_name = xnew (name_len + 1, char);
 
-                        memcpy (wr_name, np, name_len - 1);
-                        memcpy (wr_name + name_len - 1, "=", 2);
+                        strcpy (mempcpy (wr_name, np, name_len - 1), "=");
                         pfnote (wr_name, true, lb.buffer, cp - lb.buffer + 1,
                                 lineno, linecharno);
                         if (debug)
-                          fprintf (stderr, "%s on %s:%d: %s\n", wr_name,
+                          fprintf (stderr, "%s on %s:%"PRIdMAX": %s\n", wr_name,
                                    curfdp->taggedfname, lineno, lb.buffer);
                         continuation = false;
                       }
@@ -5178,8 +5187,8 @@ static void
 Pascal_functions (FILE *inf)
 {
   linebuffer tline;             /* mostly copied from C_entries */
-  long save_lcno;
-  int save_lineno, namelen, taglen;
+  intmax_t save_lcno, save_lineno;
+  ptrdiff_t namelen, taglen;
   char c, *name;
 
   bool                          /* each of these flags is true if: */
@@ -5455,7 +5464,7 @@ Lua_functions (FILE *inf)
           if (tp_dot || tp_colon)
             {
               char *p = tp_dot > tp_colon ? tp_dot : tp_colon;
-              int len_add = p - tag_name + 1;
+              ptrdiff_t len_add = p - tag_name + 1;
 
               get_tag (bp + len_add, NULL);
             }
@@ -5656,7 +5665,7 @@ TeX_commands (FILE *inf)
             if (strneq (cp, key->buffer, key->len))
               {
                 char *p;
-                int namelen, linelen;
+                ptrdiff_t namelen, linelen;
                 bool opgrp = false;
 
                 cp = skip_spaces (cp + key->len);
@@ -5693,8 +5702,8 @@ TeX_commands (FILE *inf)
 static void
 TEX_decode_env (const char *evarname, const char *defenv)
 {
-  register const char *env, *p;
-  int i, len;
+  const char *env, *p;
+  ptrdiff_t len;
 
   /* Append default string to environment. */
   env = getenv (evarname);
@@ -5711,7 +5720,7 @@ TEX_decode_env (const char *evarname, const char *defenv)
 
   /* Unpack environment string into token table. Be careful about */
   /* zero-length strings (leading ':', "::" and trailing ':') */
-  for (i = 0; *env != '\0';)
+  for (ptrdiff_t i = 0; *env != '\0'; )
     {
       p = strchr (env, ':');
       if (!p)                   /* End of environment string. */
@@ -5811,8 +5820,7 @@ HTML_labels (FILE *inf)
                   for (end = dbp; *end != '\0' && intoken (*end); end++)
                     continue;
                 linebuffer_setlen (&token_name, end - dbp);
-                memcpy (token_name.buffer, dbp, end - dbp);
-                token_name.buffer[end - dbp] = '\0';
+                memcpyz (token_name.buffer, dbp, end - dbp);
 
                 dbp = end;
                 intag = false;  /* we found what we looked for */
@@ -5906,11 +5914,10 @@ Prolog_functions (FILE *inf)
                  tags later.  */
               if (allocated <= len)
                 {
-                  xrnew (last, len + 1, char);
+                  xrnew (last, len + 1, 1);
                   allocated = len + 1;
                 }
-              memcpy (last, cp, len);
-              last[len] = '\0';
+              memcpyz (last, cp, len);
               lastlen = len;
             }
         }
@@ -6031,9 +6038,9 @@ prolog_atom (char *s, size_t pos)
  * Assumes that Erlang functions start at column 0.
  * Original code by Anders Lindgren (1996)
  */
-static int erlang_func (char *, char *, ptrdiff_t, ptrdiff_t *);
+static ptrdiff_t erlang_func (char *, char *, ptrdiff_t, ptrdiff_t *);
 static void erlang_attribute (char *);
-static int erlang_atom (char *);
+static ptrdiff_t erlang_atom (char *);
 
 static void
 Erlang_functions (FILE *inf)
@@ -6070,11 +6077,10 @@ Erlang_functions (FILE *inf)
                  tags later.  */
               if (allocated <= len)
                 {
-                  xrnew (last, len + 1, char);
+                  xrnew (last, len + 1, 1);
                   allocated = len + 1;
                 }
-              memcpy (last, cp + name_offset, len);
-              last[len] = '\0';
+              memcpyz (last, cp + name_offset, len);
               lastlen = len;
             }
         }
@@ -6093,7 +6099,7 @@ Erlang_functions (FILE *inf)
  * Return the size of the name of the function, or 0 if no function
  * was found.
  */
-static int
+static ptrdiff_t
 erlang_func (char *s, char *last, ptrdiff_t lastlen, ptrdiff_t *name_offset)
 {
   char *name = s;
@@ -6133,15 +6139,13 @@ static void
 erlang_attribute (char *s)
 {
   char *cp = s;
-  int pos;
-  int len;
 
   if ((LOOKING_AT (cp, "-define") || LOOKING_AT (cp, "-record"))
       && *cp++ == '(')
     {
       cp = skip_spaces (cp);
-      len = erlang_atom (cp);
-      pos = cp + len - s;
+      ptrdiff_t len = erlang_atom (cp);
+      ptrdiff_t pos = cp + len - s;
       if (len > 0)
         {
           /* If the name is quoted, the quotes are not part of the name. */
@@ -6161,10 +6165,10 @@ erlang_attribute (char *s)
  * Consume an Erlang atom (or variable).
  * Return the number of bytes consumed, or -1 if there was an error.
  */
-static int
+static ptrdiff_t
 erlang_atom (char *s)
 {
-  int pos = 0;
+  ptrdiff_t pos = 0;
 
   if (c_isalpha (s[pos]) || s[pos] == '_')
     {
@@ -6437,10 +6441,9 @@ static char *
 substitute (char *in, char *out, struct re_registers *regs)
 {
   char *result, *t;
-  int size, dig, diglen;
 
   result = NULL;
-  size = strlen (out);
+  ptrdiff_t size = strlen (out);
 
   /* Pass 1: figure out how much to allocate by finding all \N strings. */
   if (out[size - 1] == '\\')
@@ -6450,8 +6453,8 @@ substitute (char *in, char *out, struct re_registers *regs)
        t = strchr (t + 2, '\\'))
     if (c_isdigit (t[1]))
       {
-        dig = t[1] - '0';
-        diglen = regs->end[dig] - regs->start[dig];
+        int dig = t[1] - '0';
+        ptrdiff_t diglen = regs->end[dig] - regs->start[dig];
         size += diglen - 2;
       }
     else
@@ -6464,8 +6467,8 @@ substitute (char *in, char *out, struct re_registers *regs)
   for (t = result; *out != '\0'; out++)
     if (*out == '\\' && c_isdigit (*++out))
       {
-        dig = *out - '0';
-        diglen = regs->end[dig] - regs->start[dig];
+        int dig = *out - '0';
+        ptrdiff_t diglen = regs->end[dig] - regs->start[dig];
         memcpy (t, in + regs->start[dig], diglen);
         t += diglen;
       }
@@ -6474,7 +6477,7 @@ substitute (char *in, char *out, struct re_registers *regs)
   *t = '\0';
 
   assert (t <= result + size);
-  assert (t - result == (int)strlen (result));
+  assert (t == result + strlen (result));
 
   return result;
 }
@@ -6511,7 +6514,7 @@ regex_tag_multiline (void)
 
   for (rp = p_head; rp != NULL; rp = rp->p_next)
     {
-      int match = 0;
+      ptrdiff_t match = 0;
 
       if (!rp->multi_line)
         continue;               /* skip normal regexps */
@@ -6572,7 +6575,7 @@ regex_tag_multiline (void)
                           charno - linecharno + 1, lineno, linecharno);
 
                   if (debug)
-                    fprintf (stderr, "%s on %s:%d: %s\n",
+                    fprintf (stderr, "%s on %s:%"PRIdMAX": %s\n",
                              name ? name : "(unnamed)", curfdp->taggedfname,
                              lineno, buffer + linecharno);
                 }
@@ -6589,7 +6592,7 @@ regex_tag_multiline (void)
 static bool
 nocase_tail (const char *cp)
 {
-  int len = 0;
+  ptrdiff_t len = 0;
 
   while (*cp != '\0' && c_tolower (*cp) == c_tolower (dbp[len]))
     cp++, len++;
@@ -6648,7 +6651,7 @@ get_lispy_tag (register char *bp)
  * If multi-line regular expressions are requested, each line read is
  * appended to `filebuf'.
  */
-static long
+static ptrdiff_t
 readline_internal (linebuffer *lbp, FILE *stream, char const *filename)
 {
   char *buffer = lbp->buffer;
@@ -6664,8 +6667,8 @@ readline_internal (linebuffer *lbp, FILE *stream, char const *filename)
       if (p == pend)
         {
           /* We're at the end of linebuffer: expand it. */
+          xrnew (buffer, lbp->size, 2);
           lbp->size *= 2;
-          xrnew (buffer, lbp->size, char);
           p += buffer - lbp->buffer;
           pend = buffer + lbp->size;
           lbp->buffer = buffer;
@@ -6702,13 +6705,12 @@ readline_internal (linebuffer *lbp, FILE *stream, char const *filename)
       while (filebuf.size <= filebuf.len + lbp->len + 1) /* +1 for \n */
         {
           /* Expand filebuf. */
+          xrnew (filebuf.buffer, filebuf.size, 2);
           filebuf.size *= 2;
-          xrnew (filebuf.buffer, filebuf.size, char);
         }
-      memcpy (filebuf.buffer + filebuf.len, lbp->buffer, lbp->len);
-      filebuf.len += lbp->len;
-      filebuf.buffer[filebuf.len++] = '\n';
-      filebuf.buffer[filebuf.len] = '\0';
+      strcpy (mempcpy (filebuf.buffer + filebuf.len, lbp->buffer, lbp->len),
+              "\n");
+      filebuf.len += lbp->len + 1;
     }
 
   return lbp->len + chars_deleted;
@@ -6722,10 +6724,8 @@ readline_internal (linebuffer *lbp, FILE *stream, char const *filename)
 static void
 readline (linebuffer *lbp, FILE *stream)
 {
-  long result;
-
   linecharno = charno;          /* update global char number of line start */
-  result = readline_internal (lbp, stream, infilename); /* read line */
+  ptrdiff_t result = readline_internal (lbp, stream, infilename);
   lineno += 1;                  /* increment global line number */
   charno += result;             /* increment global char number */
 
@@ -6737,10 +6737,10 @@ readline (linebuffer *lbp, FILE *stream)
       /* Check whether this is a #line directive. */
       if (result > 12 && strneq (lbp->buffer, "#line ", 6))
         {
-          unsigned int lno;
+          intmax_t lno;
           int start = 0;
 
-          if (sscanf (lbp->buffer, "#line %u \"%n", &lno, &start) >= 1
+          if (sscanf (lbp->buffer, "#line %"SCNdMAX" \"%n", &lno, &start) >= 1
               && start > 0)     /* double quote character found */
             {
               char *endp = lbp->buffer + start;
@@ -6850,7 +6850,7 @@ readline (linebuffer *lbp, FILE *stream)
     } /* if #line directives should be considered */
 
   {
-    int match;
+    ptrdiff_t match;
     regexp *rp;
     char *name;
 
@@ -6900,7 +6900,7 @@ readline (linebuffer *lbp, FILE *stream)
                   /* Force explicit tag name, if a name is there. */
                   pfnote (name, true, lbp->buffer, match, lineno, linecharno);
                   if (debug)
-                    fprintf (stderr, "%s on %s:%d: %s\n",
+                    fprintf (stderr, "%s on %s:%"PRIdMAX": %s\n",
                              name ? name : "(unnamed)", curfdp->taggedfname,
                              lineno, lbp->buffer);
                 }
@@ -6925,11 +6925,11 @@ savestr (const char *cp)
 }
 
 /*
- * Return a pointer to a space of size LEN+1 allocated with xnew where
- * the string CP has been copied for at most the first LEN characters.
+ * Return a pointer to a space of size LEN+1 allocated with xnew
+ * with a copy of CP (containing LEN bytes) followed by a NUL byte.
  */
 static char *
-savenstr (const char *cp, int len)
+savenstr (const char *cp, ptrdiff_t len)
 {
   char *dp = xnew (len + 1, char);
   dp[len] = '\0';
@@ -7013,13 +7013,9 @@ verror (char const *format, va_list ap)
 static char *
 concat (const char *s1, const char *s2, const char *s3)
 {
-  int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
+  ptrdiff_t len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
   char *result = xnew (len1 + len2 + len3 + 1, char);
-
-  strcpy (result, s1);
-  strcpy (result + len1, s2);
-  strcpy (result + len1 + len2, s3);
-
+  strcpy (stpcpy (stpcpy (result, s1), s2), s3);
   return result;
 }
 
@@ -7029,16 +7025,16 @@ concat (const char *s1, const char *s2, const char *s3)
 static char *
 etags_getcwd (void)
 {
-  int bufsize = 200;
+  ptrdiff_t bufsize = 200;
   char *path = xnew (bufsize, char);
 
   while (getcwd (path, bufsize) == NULL)
     {
       if (errno != ERANGE)
         pfatal ("getcwd");
-      bufsize *= 2;
       free (path);
-      path = xnew (bufsize, char);
+      path = xnmalloc (bufsize, 2 * sizeof *path);
+      bufsize *= 2;
     }
 
   canonicalize_filename (path);
@@ -7099,7 +7095,7 @@ static char *
 relative_filename (char *file, char *dir)
 {
   char *fp, *dp, *afn, *res;
-  int i;
+  ptrdiff_t i;
 
   /* Find the common root of file and dir (with a trailing slash). */
   afn = absolute_filename (file, cwd);
@@ -7282,32 +7278,54 @@ linebuffer_init (linebuffer *lbp)
 
 /* Set the minimum size of a string contained in a linebuffer. */
 static void
-linebuffer_setlen (linebuffer *lbp, int toksize)
+linebuffer_setlen (linebuffer *lbp, ptrdiff_t toksize)
 {
-  while (lbp->size <= toksize)
+  if (lbp->size <= toksize)
     {
-      lbp->size *= 2;
-      xrnew (lbp->buffer, lbp->size, char);
+      ptrdiff_t multiplier = toksize / lbp->size + 1;
+      xrnew (lbp->buffer, lbp->size, multiplier);
+      lbp->size *= multiplier;
     }
   lbp->len = toksize;
 }
 
-/* Like malloc but get fatal error if memory is exhausted. */
-static void * ATTRIBUTE_MALLOC
-xmalloc (size_t size)
+/* Memory allocators with a fatal error if memory is exhausted.  */
+
+static void
+memory_full (void)
+{
+  fatal ("virtual memory exhausted");
+}
+
+static void *
+xmalloc (ptrdiff_t size)
 {
+  if (SIZE_MAX < size)
+    memory_full ();
   void *result = malloc (size);
   if (result == NULL)
-    fatal ("virtual memory exhausted");
+    memory_full ();
   return result;
 }
 
 static void *
-xrealloc (void *ptr, size_t size)
+xnmalloc (ptrdiff_t nitems, ptrdiff_t item_size)
 {
-  void *result = realloc (ptr, size);
-  if (result == NULL)
-    fatal ("virtual memory exhausted");
+  ptrdiff_t nbytes;
+  if (INT_MULTIPLY_WRAPV (nitems, item_size, &nbytes))
+    memory_full ();
+  return xmalloc (nbytes);
+}
+
+static void *
+xnrealloc (void *pa, ptrdiff_t nitems, ptrdiff_t item_size)
+{
+  ptrdiff_t nbytes;
+  if (INT_MULTIPLY_WRAPV (nitems, item_size, &nbytes) || SIZE_MAX < nbytes)
+    memory_full ();
+  void *result = realloc (pa, nbytes);
+  if (!result)
+    memory_full ();
   return result;
 }