IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-Copyright (C) 1984, 1987-1989, 1993-1995, 1998-2011
+Copyright (C) 1984, 1987-1989, 1993-1995, 1998-2012
Free Software Foundation, Inc.
This file is not considered part of GNU Emacs.
# define NDEBUG /* disable assert */
#endif
-#ifdef HAVE_CONFIG_H
-# include <config.h>
- /* This is probably not necessary any more. On some systems, config.h
- used to define static as nothing for the sake of unexec. We don't
- want that here since we don't use unexec. None of these systems
- are supported any more, but the idea is still mentioned in
- etc/PROBLEMS. */
-# undef static
-# ifndef PTR /* for XEmacs */
-# define PTR void *
-# endif
-#else /* no config.h */
-# if defined(__STDC__) && (__STDC__ || defined(__SUNPRO_C))
-# define PTR void * /* for generic pointers */
-# else /* not standard C */
-# define const /* remove const for old compilers' sake */
-# define PTR long * /* don't use void* */
-# endif
-#endif /* !HAVE_CONFIG_H */
+#include <config.h>
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1 /* enables some compiler checks on GNU */
# include <fcntl.h>
# include <sys/param.h>
# include <io.h>
-# ifndef HAVE_CONFIG_H
-# define DOS_NT
-# include <sys/config.h>
-# endif
#else
# define MSDOS FALSE
#endif /* MSDOS */
#ifdef WINDOWSNT
-# include <stdlib.h>
# include <fcntl.h>
-# include <string.h>
# include <direct.h>
# include <io.h>
# define MAXPATHLEN _MAX_PATH
# define HAVE_GETCWD
# endif /* undef HAVE_GETCWD */
#else /* not WINDOWSNT */
-# ifdef STDC_HEADERS
-# include <stdlib.h>
-# include <string.h>
-# else /* no standard C headers */
- extern char *getenv (const char *);
- extern char *strcpy (char *, const char *);
- extern char *strncpy (char *, const char *, unsigned long);
- extern char *strcat (char *, const char *);
- extern char *strncat (char *, const char *, unsigned long);
- extern int strcmp (const char *, const char *);
- extern int strncmp (const char *, const char *, unsigned long);
- extern int system (const char *);
- extern unsigned long strlen (const char *);
- extern void *malloc (unsigned long);
- extern void *realloc (void *, unsigned long);
- extern void exit (int);
- extern void free (void *);
- extern void *memmove (void *, const void *, unsigned long);
-# define EXIT_SUCCESS 0
-# define EXIT_FAILURE 1
-# endif
#endif /* !WINDOWSNT */
#include <unistd.h>
# endif
#endif /* HAVE_UNISTD_H */
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
+#include <c-strcase.h>
#include <assert.h>
#ifdef NDEBUG
# include <getopt.h>
#endif /* NO_LONG_OPTIONS */
-#ifndef HAVE_CONFIG_H /* this is a standalone compilation */
-# ifdef __CYGWIN__ /* compiling on Cygwin */
- !!! NOTICE !!!
- the regex.h distributed with Cygwin is not compatible with etags, alas!
-If you want regular expression support, you should delete this notice and
- arrange to use the GNU regex.h and regex.c.
-# endif
-#endif
#include <regex.h>
/* Define CTAGS to make the program "ctags" compatible with the usual one.
# define CTAGS FALSE
#endif
-#define streq(s,t) (assert((s)!=NULL || (t)!=NULL), !strcmp (s, t))
-#define strcaseeq(s,t) (assert((s)!=NULL && (t)!=NULL), !etags_strcasecmp (s, t))
-#define strneq(s,t,n) (assert((s)!=NULL || (t)!=NULL), !strncmp (s, t, n))
-#define strncaseeq(s,t,n) (assert((s)!=NULL && (t)!=NULL), !etags_strncasecmp (s, t, n))
+#define streq(s,t) (assert ((s)!=NULL || (t)!=NULL), !strcmp (s, t))
+#define strcaseeq(s,t) (assert ((s)!=NULL && (t)!=NULL), !c_strcasecmp (s, t))
+#define strneq(s,t,n) (assert ((s)!=NULL || (t)!=NULL), !strncmp (s, t, n))
+#define strncaseeq(s,t,n) (assert ((s)!=NULL && (t)!=NULL), !c_strncasecmp (s, t, n))
#define CHARS 256 /* 2^sizeof(char) */
#define CHAR(x) ((unsigned int)(x) & (CHARS - 1))
-#define iswhite(c) (_wht[CHAR(c)]) /* c is white (see white) */
-#define notinname(c) (_nin[CHAR(c)]) /* c is not in a name (see nonam) */
-#define begtoken(c) (_btk[CHAR(c)]) /* c can start token (see begtk) */
-#define intoken(c) (_itk[CHAR(c)]) /* c can be in token (see midtk) */
-#define endtoken(c) (_etk[CHAR(c)]) /* c ends tokens (see endtk) */
+#define iswhite(c) (_wht[CHAR (c)]) /* c is white (see white) */
+#define notinname(c) (_nin[CHAR (c)]) /* c is not in a name (see nonam) */
+#define begtoken(c) (_btk[CHAR (c)]) /* c can start token (see begtk) */
+#define intoken(c) (_itk[CHAR (c)]) /* c can be in token (see midtk) */
+#define endtoken(c) (_etk[CHAR (c)]) /* c ends tokens (see endtk) */
-#define ISALNUM(c) isalnum (CHAR(c))
-#define ISALPHA(c) isalpha (CHAR(c))
-#define ISDIGIT(c) isdigit (CHAR(c))
-#define ISLOWER(c) islower (CHAR(c))
+#define ISALNUM(c) isalnum (CHAR (c))
+#define ISALPHA(c) isalpha (CHAR (c))
+#define ISDIGIT(c) isdigit (CHAR (c))
+#define ISLOWER(c) islower (CHAR (c))
-#define lowcase(c) tolower (CHAR(c))
+#define lowcase(c) tolower (CHAR (c))
/*
struct re_pattern_buffer *pat; /* the compiled pattern */
struct re_registers regs; /* re registers */
bool error_signaled; /* already signaled for this regexp */
- bool force_explicit_name; /* do not allow implict tag name */
+ bool force_explicit_name; /* do not allow implicit tag name */
bool ignore_case; /* ignore case when matching */
bool multi_line; /* do a multi-line match on the whole file */
} regexp;
static void analyse_regex (char *);
static void free_regexps (void);
static void regex_tag_multiline (void);
-static void error (const char *, const char *);
-static void suggest_asking_for_help (void) NO_RETURN;
-void fatal (const char *, const char *) NO_RETURN;
-static void pfatal (const char *) NO_RETURN;
+static void error (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
+static _Noreturn void suggest_asking_for_help (void);
+_Noreturn void fatal (const char *, const char *);
+static _Noreturn void pfatal (const char *);
static void add_node (node *, node **);
static void init (void);
static char *savestr (const char *);
static char *etags_strchr (const char *, int);
static char *etags_strrchr (const char *, int);
-static int etags_strcasecmp (const char *, const char *);
-static int etags_strncasecmp (const char *, const char *, int);
static char *etags_getcwd (void);
static char *relative_filename (char *, char *);
static char *absolute_filename (char *, char *);
static void canonicalize_filename (char *);
static void linebuffer_init (linebuffer *);
static void linebuffer_setlen (linebuffer *, int);
-static PTR xmalloc (unsigned int);
-static PTR xrealloc (char *, unsigned int);
+static void *xmalloc (size_t);
+static void *xrealloc (char *, size_t);
\f
static char searchar = '/'; /* use /.../ searches */
static char *cwd; /* current working directory */
static char *tagfiledir; /* directory of tagfile */
static FILE *tagf; /* ioptr for tags file */
+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 const char *Cplusplus_suffixes [] =
{ "C", "c++", "cc", "cpp", "cxx", "H", "h++", "hh", "hpp", "hxx",
"M", /* Objective C++ */
- "pdb", /* Postscript with C syntax */
+ "pdb", /* PostScript with C syntax */
NULL };
static const char Cplusplus_help [] =
"In C++ code, all the tag constructs of C code are tagged. (Use\n\
print_version (void)
{
/* Makes it easier to update automatically. */
- char emacs_copyright[] = "Copyright (C) 2011 Free Software Foundation, Inc.";
+ char emacs_copyright[] = "Copyright (C) 2012 Free Software Foundation, Inc.";
printf ("%s (%s %s)\n", (CTAGS) ? "ctags" : "etags", EMACS_NAME, VERSION);
puts (emacs_copyright);
int current_arg, file_count;
linebuffer filename_lb;
bool help_asked = FALSE;
+ ptrdiff_t len;
char *optstring;
int opt;
/* This means that a file name has been seen. Record it. */
argbuffer[current_arg].arg_type = at_filename;
argbuffer[current_arg].what = optarg;
+ len = strlen (optarg);
+ if (whatlen_max < len)
+ whatlen_max = len;
++current_arg;
++file_count;
break;
/* Parse standard input. Idea by Vivek <vivek@etla.org>. */
argbuffer[current_arg].arg_type = at_stdin;
argbuffer[current_arg].what = optarg;
+ len = strlen (optarg);
+ if (whatlen_max < len)
+ whatlen_max = len;
++current_arg;
++file_count;
if (parsing_stdin)
case 'o':
if (tagfile)
{
- error ("-o option may only be given once.", (char *)NULL);
+ error ("-o option may only be given once.");
suggest_asking_for_help ();
/* NOTREACHED */
}
case 'r':
argbuffer[current_arg].arg_type = at_regexp;
argbuffer[current_arg].what = optarg;
+ len = strlen (optarg);
+ if (whatlen_max < len)
+ whatlen_max = len;
++current_arg;
break;
case 'R':
{
argbuffer[current_arg].arg_type = at_filename;
argbuffer[current_arg].what = argv[optind];
+ len = strlen (argv[optind]);
+ if (whatlen_max < len)
+ whatlen_max = len;
++current_arg;
++file_count;
}
if (nincluded_files == 0 && file_count == 0)
{
- error ("no input files specified.", (char *)NULL);
+ error ("no input files specified.");
suggest_asking_for_help ();
/* NOTREACHED */
}
/* From here on, we are in (CTAGS && !cxref_style) */
if (update)
{
- char cmd[BUFSIZ];
+ char *cmd =
+ xmalloc (strlen (tagfile) + whatlen_max +
+ sizeof "mv..OTAGS;fgrep -v '\t\t' OTAGS >;rm OTAGS");
for (i = 0; i < current_arg; ++i)
{
switch (argbuffer[i].arg_type)
default:
continue; /* the for loop */
}
- sprintf (cmd,
- "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
- tagfile, argbuffer[i].what, tagfile);
+ strcpy (cmd, "mv ");
+ strcat (cmd, tagfile);
+ strcat (cmd, " OTAGS;fgrep -v '\t");
+ strcat (cmd, argbuffer[i].what);
+ strcat (cmd, "\t' OTAGS >");
+ strcat (cmd, tagfile);
+ strcat (cmd, ";rm OTAGS");
if (system (cmd) != EXIT_SUCCESS)
fatal ("failed to execute shell command", (char *)NULL);
}
+ free (cmd);
append_to_tagfile = TRUE;
}
if (CTAGS)
if (append_to_tagfile || update)
{
- char cmd[2*BUFSIZ+20];
+ char *cmd = xmalloc (2 * strlen (tagfile) + sizeof "sort -u -o..");
/* Maybe these should be used:
setenv ("LC_COLLATE", "C", 1);
setenv ("LC_ALL", "C", 1); */
- sprintf (cmd, "sort -u -o %.*s %.*s", BUFSIZ, tagfile, BUFSIZ, tagfile);
+ strcpy (cmd, "sort -u -o ");
+ strcat (cmd, tagfile);
+ strcat (cmd, " ");
+ strcat (cmd, tagfile);
exit (system (cmd));
}
return EXIT_SUCCESS;
language *lang;
if (name == NULL)
- error ("empty language name", (char *)NULL);
+ error ("empty language name");
else
{
for (lang = lang_names; lang->name != NULL; lang++)
register int i;
for (i = 0; i < CHARS; i++)
- iswhite(i) = notinname(i) = begtoken(i) = intoken(i) = endtoken(i) = FALSE;
+ iswhite (i) = notinname (i) = begtoken (i) = intoken (i) = endtoken (i) = FALSE;
for (sp = white; *sp != '\0'; sp++) iswhite (*sp) = TRUE;
for (sp = nonam; *sp != '\0'; sp++) notinname (*sp) = TRUE;
- notinname('\0') = notinname('\n');
+ notinname ('\0') = notinname ('\n');
for (sp = begtk; *sp != '\0'; sp++) begtoken (*sp) = TRUE;
- begtoken('\0') = begtoken('\n');
+ begtoken ('\0') = begtoken ('\n');
for (sp = midtk; *sp != '\0'; sp++) intoken (*sp) = TRUE;
- intoken('\0') = intoken('\n');
+ intoken ('\0') = intoken ('\n');
for (sp = endtk; *sp != '\0'; sp++) endtoken (*sp) = TRUE;
- endtoken('\0') = endtoken('\n');
+ endtoken ('\0') = endtoken ('\n');
}
/*
assert (parser != NULL);
- /* Generic initialisations before reading from file. */
+ /* Generic initializations before reading from file. */
linebuffer_setlen (&filebuf, 0); /* reset the file buffer */
- /* Generic initialisations before parsing file with readline. */
+ /* Generic initializations before parsing file with readline. */
lineno = 0; /* reset global line number */
charno = 0; /* reset global char number */
linecharno = 0; /* reset global char number of line start */
* 4. the character, if any, immediately after NAME in LINESTART must
* also be a character in NONAM.
*
- * The implementation uses the notinname() macro, which recognises the
+ * The implementation uses the notinname() macro, which recognizes the
* characters stored in the string `nonam'.
* etags.el needs to use the same characters that are in NONAM.
*/
\f
static int total_size_of_entries (node *);
-static int number_len (long);
+static int number_len (long) ATTRIBUTE_CONST;
/* Length of a non-negative number's decimal representation. */
static int
{
/* Ctags mode */
if (np->name == NULL)
- error ("internal error: NULL name in ctags mode.", (char *)NULL);
+ error ("internal error: NULL name in ctags mode.");
if (cxref_style)
{
case dignorerest:
return FALSE;
default:
- error ("internal error: definedef value.", (char *)NULL);
+ error ("internal error: definedef value.");
}
/*
make_tag (token_name.buffer, token_name.len, isfun, token.line,
token.offset+token.length+1, token.lineno, token.linepos);
else if (DEBUG)
- { /* this branch is optimised away if !DEBUG */
+ { /* this branch is optimized away if !DEBUG */
make_tag (concat ("INVALID TOKEN:-->", token_name.buffer, ""),
token_name.len + 17, isfun, token.line,
token.offset+token.length+1, token.lineno, token.linepos);
- error ("INVALID TOKEN", NULL);
+ error ("INVALID TOKEN");
}
token.valid = FALSE;
}
continue;
}
- else if (bracketlev > 0)
- {
- switch (c)
- {
- case ']':
- if (--bracketlev > 0)
- continue;
- break;
- case '\0':
- CNL_SAVE_DEFINEDEF ();
- break;
- }
- continue;
- }
else switch (c)
{
case '"':
inquote = TRUE;
+ if (bracketlev > 0)
+ continue;
if (inattribute)
break;
switch (fvdef)
continue;
case '\'':
inchar = TRUE;
+ if (bracketlev > 0)
+ continue;
if (inattribute)
break;
- if (fvdef != finlist && fvdef != fignore && fvdef !=vignore)
+ if (fvdef != finlist && fvdef != fignore && fvdef != vignore)
{
fvextern = FALSE;
fvdef = fvnone;
incomm = TRUE;
lp++;
c = ' ';
+ if (bracketlev > 0)
+ continue;
}
else if (/* cplpl && */ *lp == '/')
{
for (cp = newlb.buffer; cp < lp-1; cp++)
if (!iswhite (*cp))
{
- if (*cp == '*' && *(cp+1) == '/')
+ if (*cp == '*' && cp[1] == '/')
{
cp++;
cpptoken = TRUE;
continue;
case '[':
bracketlev++;
- continue;
+ continue;
+ default:
+ if (bracketlev > 0)
+ {
+ if (c == ']')
+ --bracketlev;
+ else if (c == '\0')
+ CNL_SAVE_DEFINEDEF ();
+ continue;
+ }
+ break;
} /* switch (c) */
if (c == ':' && *lp == ':' && begtoken (lp[1]))
/* This handles :: in the middle,
but not at the beginning of an identifier.
- Also, space-separated :: is not recognised. */
+ Also, space-separated :: is not recognized. */
{
if (c_ext & C_AUTO) /* automatic detection of C++ */
c_ext = (c_ext | C_PLPL) & ~C_AUTO;
)
#define LOOKING_AT(cp, kw) /* kw is the keyword, a literal string */ \
- ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
- && strneq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
- && notinname ((cp)[sizeof(kw)-1]) /* end of kw */ \
- && ((cp) = skip_spaces((cp)+sizeof(kw)-1))) /* skip spaces */
+ ((assert ("" kw), TRUE) /* syntax error if not a literal string */ \
+ && strneq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
+ && notinname ((cp)[sizeof (kw)-1]) /* end of kw */ \
+ && ((cp) = skip_spaces ((cp)+sizeof (kw)-1))) /* skip spaces */
/* Similar to LOOKING_AT but does not use notinname, does not skip */
#define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */ \
- ((assert("" kw), TRUE) /* syntax error if not a literal string */ \
- && strncaseeq ((cp), kw, sizeof(kw)-1) /* cp points at kw */ \
- && ((cp) += sizeof(kw)-1)) /* skip spaces */
+ ((assert ("" kw), TRUE) /* syntax error if not a literal string */ \
+ && strncaseeq ((cp), kw, sizeof (kw)-1) /* cp points at kw */ \
+ && ((cp) += sizeof (kw)-1)) /* skip spaces */
/*
* Read a file, but do no processing. This is used to do regexp
if (LOOKING_AT_NOCASE (dbp, "recursive"))
dbp = skip_spaces (dbp);
+ if (LOOKING_AT_NOCASE (dbp, "pure"))
+ dbp = skip_spaces (dbp);
+
+ if (LOOKING_AT_NOCASE (dbp, "elemental"))
+ dbp = skip_spaces (dbp);
+
switch (lowcase (*dbp))
{
case 'i':
readline (&lb, inf);
dbp = lb.buffer;
}
- switch (lowcase(*dbp))
+ switch (lowcase (*dbp))
{
case 'b':
if (nocase_tail ("body"))
}
/* We are at the beginning of a token. */
- switch (lowcase(*dbp))
+ switch (lowcase (*dbp))
{
case 'f':
if (!packages_only && nocase_tail ("function"))
*cp = '\0';
name = concat (package, "::", sp);
*cp = savechar;
- make_tag (name, strlen(name), TRUE,
+ make_tag (name, strlen (name), TRUE,
lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
free (name);
}
}
else if (LOOKING_AT (cp, "function"))
{
- if(*cp == '&')
+ if (*cp == '&')
cp = skip_spaces (cp+1);
- if(*cp != '\0')
+ if (*cp != '\0')
{
name = cp;
while (!notinname (*cp))
&& *cp == '$')
{
name = cp;
- while (!notinname(*cp))
+ while (!notinname (*cp))
cp++;
make_tag (name, cp - name, FALSE,
lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
\f
/*
- * Postscript tags
+ * PostScript tags
* Just look for lines where the first character is '/'
* Also look at "defineps" for PSWrap
* Ideas by:
LOOP_ON_INPUT_LINES (inf, lb, bp)
while ((bp = skip_spaces (bp))[0] != '\0')
- if (bp[0] == '\\' && iswhite(bp[1]))
+ if (bp[0] == '\\' && iswhite (bp[1]))
break; /* read next line */
- else if (bp[0] == '(' && iswhite(bp[1]))
+ else if (bp[0] == '(' && iswhite (bp[1]))
do /* skip to ) or eol */
bp++;
while (*bp != ')' && *bp != '\0');
- else if ((bp[0] == ':' && iswhite(bp[1]) && bp++)
+ else if ((bp[0] == ':' && iswhite (bp[1]) && bp++)
|| LOOKING_AT_NOCASE (bp, "constant")
|| LOOKING_AT_NOCASE (bp, "code")
|| LOOKING_AT_NOCASE (bp, "create")
/* Predicate or rule. Store the function name so that we
only generate a tag for the first clause. */
if (last == NULL)
- last = xnew(len + 1, char);
+ last = xnew (len + 1, char);
else if (len + 1 > allocated)
xrnew (last, len + 1, char);
allocated = len + 1;
return;
readline (plb, inf);
}
- while (!feof(inf));
+ while (!feof (inf));
}
/*
origpos = pos;
- if (ISLOWER(s[pos]) || (s[pos] == '_'))
+ if (ISLOWER (s[pos]) || (s[pos] == '_'))
{
/* The atom is unquoted. */
pos++;
- while (ISALNUM(s[pos]) || (s[pos] == '_'))
+ while (ISALNUM (s[pos]) || (s[pos] == '_'))
{
pos++;
}
{
static struct re_pattern_buffer zeropattern;
char sep, *pat, *name, *modifiers;
- char empty[] = "";
+ char empty = '\0';
const char *err;
struct re_pattern_buffer *patbuf;
regexp *rp;
single_line = FALSE; /* dot does not match newline */
- if (strlen(regexp_pattern) < 3)
+ if (strlen (regexp_pattern) < 3)
{
- error ("null regexp", (char *)NULL);
+ error ("null regexp");
return;
}
sep = regexp_pattern[0];
if (modifiers == NULL) /* no terminating separator --> no name */
{
modifiers = name;
- name = empty;
+ name = ∅
}
else
modifiers += 1; /* skip separator */
{
case 'N':
if (modifiers == name)
- error ("forcing explicit tag name but no name, ignoring", NULL);
+ error ("forcing explicit tag name but no name, ignoring");
force_explicit_name = TRUE;
break;
case 'i':
need_filebuf = TRUE;
break;
default:
- {
- char wrongmod [2];
- wrongmod[0] = modifiers[0];
- wrongmod[1] = '\0';
- error ("invalid regexp modifier `%s', ignoring", wrongmod);
- }
+ error ("invalid regexp modifier `%c', ignoring", modifiers[0]);
break;
}
if (!rp->multi_line)
continue; /* skip normal regexps */
- /* Generic initialisations before parsing file from memory. */
+ /* Generic initializations before parsing file from memory. */
lineno = 1; /* reset global line number */
charno = 0; /* reset global char number */
linecharno = 0; /* reset global char number of line start */
lineno += 1; /* increment global line number */
charno += result; /* increment global char number */
- /* Honour #line directives. */
+ /* Honor #line directives. */
if (!no_line_directive)
{
static bool discard_until_line_directive;
return NULL;
}
-/*
- * Compare two strings, ignoring case for alphabetic characters.
- *
- * Same as BSD's strcasecmp, included for portability.
- */
-static int
-etags_strcasecmp (register const char *s1, register const char *s2)
-{
- while (*s1 != '\0'
- && (ISALPHA (*s1) && ISALPHA (*s2)
- ? lowcase (*s1) == lowcase (*s2)
- : *s1 == *s2))
- s1++, s2++;
-
- return (ISALPHA (*s1) && ISALPHA (*s2)
- ? lowcase (*s1) - lowcase (*s2)
- : *s1 - *s2);
-}
-
-/*
- * Compare two strings, ignoring case for alphabetic characters.
- * Stop after a given number of characters
- *
- * Same as BSD's strncasecmp, included for portability.
- */
-static int
-etags_strncasecmp (register const char *s1, register const char *s2, register int n)
-{
- while (*s1 != '\0' && n-- > 0
- && (ISALPHA (*s1) && ISALPHA (*s2)
- ? lowcase (*s1) == lowcase (*s2)
- : *s1 == *s2))
- s1++, s2++;
-
- if (n < 0)
- return 0;
- else
- return (ISALPHA (*s1) && ISALPHA (*s2)
- ? lowcase (*s1) - lowcase (*s2)
- : *s1 - *s2);
-}
-
/* Skip spaces (end of string is not space), return new pointer. */
static char *
skip_spaces (char *cp)
exit (EXIT_FAILURE);
}
-/* Print error message. `s1' is printf control string, `s2' is arg for it. */
+/* Output a diagnostic with printf-style FORMAT and args. */
static void
-error (const char *s1, const char *s2)
+error (const char *format, ...)
{
+ va_list ap;
+ va_start (ap, format);
fprintf (stderr, "%s: ", progname);
- fprintf (stderr, s1, s2);
+ vfprintf (stderr, format, ap);
fprintf (stderr, "\n");
+ va_end (ap);
}
/* Return a newly-allocated string whose contents
else if (cp[0] != '/')
cp = slashp;
#endif
-#ifdef HAVE_MEMMOVE
memmove (cp, slashp + 3, strlen (slashp + 2));
-#else
- /* Overlapping copy isn't really okay */
- strcpy (cp, slashp + 3);
-#endif
slashp = cp;
continue;
}
else if (slashp[2] == '/' || slashp[2] == '\0')
{
-#ifdef HAVE_MEMMOVE
memmove (slashp, slashp + 2, strlen (slashp + 1));
-#else
- strcpy (slashp, slashp + 2);
-#endif
continue;
}
}
{
return (fn[0] == '/'
#ifdef DOS_NT
- || (ISALPHA(fn[0]) && fn[1] == ':' && fn[2] == '/')
+ || (ISALPHA (fn[0]) && fn[1] == ':' && fn[2] == '/')
#endif
);
}
#ifdef DOS_NT
/* Canonicalize drive letter case. */
-# define ISUPPER(c) isupper (CHAR(c))
+# define ISUPPER(c) isupper (CHAR (c))
if (fn[0] != '\0' && fn[1] == ':' && ISUPPER (fn[0]))
fn[0] = lowcase (fn[0]);
}
/* Like malloc but get fatal error if memory is exhausted. */
-static PTR
-xmalloc (unsigned int size)
+static void *
+xmalloc (size_t size)
{
- PTR result = (PTR) malloc (size);
+ void *result = malloc (size);
if (result == NULL)
fatal ("virtual memory exhausted", (char *)NULL);
return result;
}
-static PTR
-xrealloc (char *ptr, unsigned int size)
+static void *
+xrealloc (char *ptr, size_t size)
{
- PTR result = (PTR) realloc (ptr, size);
+ void *result = realloc (ptr, size);
if (result == NULL)
fatal ("virtual memory exhausted", (char *)NULL);
return result;
HCoop / bpt / emacs.git / blobdiff