xemacs-beta: lib-src/etags.c comparison

comparison lib-src/etags.c @ 4:b82b59fe008d r19-15b3

Import from CVS: tag r19-15b3

author	cvs
date	Mon, 13 Aug 2007 08:46:56 +0200
parents	ac2d302a0011
children	34a5b81f86ba

comparison

equal deleted inserted replaced

-:30df88044ec6
+:b82b59fe008d
 /* Tags file maker to go with GNU Emacs
 Copyright (C) 1984, 87, 88, 89, 93, 94, 95
 Free Software Foundation, Inc. and Ken Arnold
 This file is not considered part of GNU Emacs.
 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 of the License, or
 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
+along with this program; if not, write to the Free Software Foundation,
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
-Boston, MA 02111-1307, USA.  */
-/* Synched up with: FSF 19.30. */
 /*
 * Authors:
 *	Ctags originally by Ken Arnold.
 *	Fortran added by Jim Kleckner.
 *	Ed Pelegri-Llopart added C typedefs.
 *	Gnu Emacs TAGS format and modifications by RMS?
 *	Sam Kendall added C++.
 *	Francesco Potorti` reorganised C and C++ based on work by Joe Wells.
-#ifdef ETAGS_REGEXPS
 *	Regexp tags by Tom Tromey.
-#endif
 *
-*	Francesco Potorti` (pot@cnuce.cnr.it) is the current maintainer.
+*	Francesco Potorti` (F.Potorti@cnuce.cnr.it) is the current maintainer.
 */
-char pot_etags_version[] = "@(#) pot revision number is 11.45";
+char pot_etags_version[] = "@(#) pot revision number is 11.78";
 #define	TRUE	1
 #define	FALSE	0
 #ifndef DEBUG
 # define DEBUG FALSE
 #endif
 #ifdef MSDOS
-#include <fcntl.h>
+# include <string.h>
-#include <sys/param.h>
+# include <fcntl.h>
+# include <sys/param.h>
 #endif /* MSDOS */
 #ifdef WINDOWSNT
+# include <stdlib.h>
+# include <fcntl.h>
+# include <string.h>
+# include <io.h>
+# define MAXPATHLEN _MAX_PATH
+#endif
+#if !defined (MSDOS) && !defined (WINDOWSNT) && defined (STDC_HEADERS)
 #include <stdlib.h>
-#include <fcntl.h>
 #include <string.h>
-#define MAXPATHLEN _MAX_PATH
 #endif
 #ifdef HAVE_CONFIG_H
-#include <../src/config.h>
+# include <config.h>
 /* On some systems, Emacs defines static as nothing for the sake
 of unexec.  We don't want that here since we don't use unexec. */
-#undef static
+# undef static
-#endif
-#if __STDC__ || defined(STDC_HEADERS)
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#else
-extern char *getenv ();
 #endif
 #include <stdio.h>
 #include <ctype.h>
 #include <errno.h>
 #endif
 #include <getopt.h>
 #ifdef ETAGS_REGEXPS
-#include <regex.h>
+# include <regex.h>
 #endif /* ETAGS_REGEXPS */
 /* Define CTAGS to make the program "ctags" compatible with the usual one.
 Let it undefined to make the program "etags", which makes emacs-style
 tag tables and tags typedefs, #defines and struct/union/enum by default. */
 # define CTAGS FALSE
 #endif
 /* Exit codes for success and failure.  */
 #ifdef VMS
-#define	GOOD	1
+# define	GOOD	1
-#define BAD	0
+# define	BAD	0
 #else
-#define	GOOD	0
+# define	GOOD	0
-#define	BAD	1
+# define	BAD	1
 #endif
 /* C extensions. */
 #define C_PLPL	0x00001		/* C++ */
 #define C_STAR	0x00003		/* C* */
 #define YACC	0x10000		/* yacc file */
-#define streq(s,t)	(strcmp (s, t) == 0)
+#define streq(s,t)	((DEBUG &&!(s)&&!(t)&&(abort(),1)) || !strcmp(s,t))
-#define strneq(s,t,n)	(strncmp (s, t, n) == 0)
+#define strneq(s,t,n)	((DEBUG &&!(s)&&!(t)&&(abort(),1)) || !strncmp(s,t,n))
-#define lowcase(c)	tolower ((unsigned char)c)
+#define lowcase(c)	tolower ((char)c)
-#define	iswhite(arg)	(_wht[(unsigned int) arg]) /* T if char is white */
+#define	iswhite(arg)	(_wht[arg])	/* T if char is white		*/
-#define	begtoken(arg)	(_btk[(unsigned int) arg]) /* T if char can start token */
+#define	begtoken(arg)	(_btk[arg])	/* T if char can start token	*/
-#define	intoken(arg)	(_itk[(unsigned int) arg]) /* T if char can be in token */
+#define	intoken(arg)	(_itk[arg])	/* T if char can be in token	*/
-#define	endtoken(arg)	(_etk[(unsigned int) arg]) /* T if char ends tokens */
+#define	endtoken(arg)	(_etk[arg])	/* T if char ends tokens	*/
-/* typedefs from down below, moved up for prototypes */
-/*
-* A `struct linebuffer' is a structure which holds a line of text.
-* `readline' reads a line from a stream into a linebuffer and works
-* regardless of the length of the line.
-*/
-struct linebuffer
-{
-long size;
-char *buffer;
-};
 #ifdef DOS_NT
-# define absolutefn(fn) (fn[0] == '/' || (isalpha (fn[0]) && fn[1] == ':'))
+# define absolutefn(fn) (fn[0] == '/' \
+			 || (fn[1] == ':' && fn[2] == '/'))
 #else
 # define absolutefn(fn) (fn[0] == '/')
 #endif
 #define xnew(n,Type)	((Type *) xmalloc ((n) * sizeof (Type)))
 typedef int logical;
 typedef struct nd_st
-{				/* sorting structure			*/
+{				/* sorting structure		*/
 char *name;			/* function or type name	*/
 char *file;			/* file name			*/
 logical is_func;		/* use pattern or line no	*/
 logical been_warned;		/* set if noticed dup		*/
-long lno;			/* line number tag is on	*/
+int lno;			/* line number tag is on	*/
 long cno;			/* character number line starts on */
 char *pat;			/* search pattern		*/
 struct nd_st *left, *right;	/* left and right sons		*/
 } NODE;
 extern char *getenv ();
-char *concat (CONST char *s1, CONST char *s2, CONST char *s3);
+char *concat ();
-char *savenstr (CONST char *cp, int len);
+char *savenstr (), *savestr ();
-char *savestr (CONST char *cp);
+char *etags_strchr (), *etags_strrchr ();
-char *etags_strchr (CONST char *sp, char c);
+char *etags_getcwd ();
-char *etags_strrchr (CONST char *sp, char c);
+char *relative_filename (), *absolute_filename (), *absolute_dirname ();
-char *etags_getcwd (void);
+void grow_linebuffer ();
-char *relative_filename (CONST char *file, CONST char *dir);
+long *xmalloc (), *xrealloc ();
-char *absolute_filename (CONST char *file, CONST char *cwd);
-char *absolute_dirname (char *file, CONST char *cwd);
-void *xmalloc (unsigned int size);
-void *xrealloc (void *ptr, unsigned int size);
 typedef void Lang_function ();
 #if FALSE				/* many compilers barf on this */
 Lang_function Asm_labels;
 Lang_function default_C_entries;
 Lang_function C_entries;
 Lang_function Cplusplus_entries;
 Lang_function Cstar_entries;
+Lang_function Erlang_functions;
 Lang_function Fortran_functions;
 Lang_function Yacc_entries;
 Lang_function Lisp_functions;
 Lang_function Pascal_functions;
 Lang_function Perl_functions;
-Lang_function Postscript_functions;
 Lang_function Prolog_functions;
 Lang_function Scheme_functions;
 Lang_function TeX_functions;
 Lang_function just_read_file;
 #else				/* so let's write it this way */
-void Asm_labels (FILE *inf);
+void Asm_labels ();
-void C_entries (int c_ext, FILE *inf);
+void C_entries ();
-void default_C_entries (FILE *inf);
+void default_C_entries ();
-void plain_C_entries (FILE *inf);
+void plain_C_entries ();
-void Cplusplus_entries (FILE *inf);
+void Cplusplus_entries ();
-void Cstar_entries (FILE *inf);
+void Cstar_entries ();
-void Fortran_functions (FILE *inf);
+void Erlang_functions ();
-void Yacc_entries (FILE *inf);
+void Fortran_functions ();
-void Lisp_functions (FILE *inf);
+void Yacc_entries ();
-void Pascal_functions (FILE *inf);
+void Lisp_functions ();
-void Perl_functions (FILE *inf);
+void Pascal_functions ();
-void Postscript_functions (FILE *inf);
+void Perl_functions ();
-void Prolog_functions (FILE *inf);
+void Prolog_functions ();
-void Scheme_functions (FILE *inf);
+void Scheme_functions ();
-void TeX_functions (FILE *inf);
+void TeX_functions ();
-void just_read_file (FILE *inf);
+void just_read_file ();
 #endif
-Lang_function *get_language_from_name (char *name);
+Lang_function *get_language_from_name ();
-Lang_function *get_language_from_interpreter (char *interpreter);
+Lang_function *get_language_from_interpreter ();
-Lang_function *get_language_from_suffix (CONST char *suffix);
+Lang_function *get_language_from_suffix ();
-int total_size_of_entries (NODE *node);
+int total_size_of_entries ();
-long readline (struct linebuffer *linebuffer, FILE *stream);
+long readline ();
-long readline_internal (struct linebuffer *linebuffer, FILE *stream);
+long readline_internal ();
 #ifdef ETAGS_REGEXPS
-void add_regex (char *regexp_pattern);
+void add_regex ();
 #endif
-void add_node (NODE *node, NODE **cur_node_p);
+void add_node ();
-void error (CONST char *s1, CONST void *s2);
+void error ();
-void fatal (CONST char *s1, CONST char *s2);
+void suggest_asking_for_help ();
-void pfatal (CONST char *s1);
+void fatal (), pfatal ();
-void find_entries (CONST char *file, FILE *inf);
+void find_entries ();
-void free_tree (NODE *);
+void free_tree ();
-void getit (FILE *inf);
+void getit ();
-void init (void);
+void init ();
-void initbuffer (struct linebuffer *linebuffer);
+void initbuffer ();
-void pfnote (char *name, logical is_func, char *linestart,
+void pfnote ();
-	     int linelen, int lno, long cno);
+void process_file ();
-void process_file (CONST char *file);
+void put_entries ();
-void put_entries (NODE *node);
+void takeprec ();
-void takeprec (void);
 char searchar = '/';		/* use /.../ searches */
 int lineno;			/* line number of current line */
 long charno;			/* current character number */
+long linecharno;		/* charno of start of line */
-long linecharno;		/* charno of start of line; not used by C,
-				   but by every other language. */
 char *curfile;			/* current input file name */
 char *tagfile;			/* output file */
-CONST char *progname;		/* name this program was invoked with */
+char *progname;			/* name this program was invoked with */
 char *cwd;			/* current working directory */
 char *tagfiledir;		/* directory of tagfile */
 FILE *tagf;			/* ioptr for tags file */
 NODE *head;			/* the head of the binary tree of tags */
+/*
+* A `struct linebuffer' is a structure which holds a line of text.
+* `readline' reads a line from a stream into a linebuffer and works
+* regardless of the length of the line.
+*/
+struct linebuffer
+{
+long size;
+char *buffer;
+};
 struct linebuffer lb;		/* the current line */
-struct linebuffer token_name;	/* used by C_entries as temporary area */
+struct linebuffer token_name;	/* used by C_entries as a temporary area */
 struct
 {
 long linepos;
 struct linebuffer lb;		/* used by C_entries instead of lb */
 } lbs[2];
 /* boolean "functions" (see init)	*/
 logical _wht[0177], _etk[0177], _itk[0177], _btk[0177];
-CONST char
+char
-*white = " \f\t\n\013",	/* white chars				*/
+/* white chars */
-*endtk = " \t\n\013\"'#()[]{}=-+%*/&|^~!<>;,.:?", /* token ending chars */
+*white = " \f\t\n\013",
-				/* token starting chars			*/
+/* token ending chars */
-*begtk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$~",
+*endtk = " \t\n\013\"'#()[]{}=-+%*/&|^~!<>;,.:?",
-				/* valid in-token chars			*/
+/* token starting chars */
-*intk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
+*begtk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$~@",
+/* valid in-token chars */
+*intk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
 logical append_to_tagfile;	/* -a: append to tags */
 /* The following three default to TRUE for etags, but to FALSE for ctags.  */
 logical typedefs;		/* -t: create tags for typedefs */
 logical typedefs_and_cplusplus;	/* -T: create tags for typedefs, level */
 				/* 0 struct/enum/union decls, and C++ */
 				/* member functions. */
 logical constantypedefs;	/* -d: create tags for C #define and enum */
-				/* constants.  Enum consts not implemented. */
+				/* constants. */
 				/* -D: opposite of -d.  Default under ctags. */
 logical update;			/* -u: update tags */
 logical vgrind_style;		/* -v: create vgrind style index output */
 logical no_warnings;		/* -w: suppress warnings */
 logical cxref_style;		/* -x: create cxref style output */
 /* Non-NULL if language fixed. */
 Lang_function *lang_func = NULL;
 /* Assembly code */
-CONST char *Asm_suffixes [] = { "a",	/* Unix assembler */
+char *Asm_suffixes [] = { "a",	/* Unix assembler */
 			  "asm", /* Microcontroller assembly */
 			  "def", /* BSO/Tasking definition includes  */
 			  "inc", /* Microcontroller include files */
 			  "ins", /* Microcontroller include files */
 			  "s", "sa", /* Unix assembler */
 			  NULL
 			};
 /* Note that .c and .h can be considered C++, if the --c++ flag was
 given.  That is why default_C_entries is called here. */
-CONST char *default_C_suffixes [] =
+char *default_C_suffixes [] =
 { "c", "h", NULL };
-/* C++ file */
+/* .M is for Objective C++ files. */
-CONST char *Cplusplus_suffixes [] =
+char *Cplusplus_suffixes [] =
-{ "C", "H", "c++", "cc", "cpp", "cxx", "h++", "hh", "hpp", "hxx",
+{ "C", "H", "c++", "cc", "cpp", "cxx", "h++", "hh", "hpp", "hxx", "M", NULL};
-/* XEmacs addition: Postscript with C syntax */
-"pdb", NULL };
+char *Cstar_suffixes [] =
-/* C* file */
-CONST char *Cstar_suffixes [] =
 { "cs", "hs", NULL };
-/* Fortran */
+char *Erlang_suffixes [] =
-CONST char *Fortran_suffixes [] =
+{ "erl", "hrl", NULL };
+char *Fortran_suffixes [] =
 { "F", "f", "f90", "for", NULL };
-/* Lisp source code */
+char *Lisp_suffixes [] =
-CONST char *Lisp_suffixes [] =
 { "cl", "clisp", "el", "l", "lisp", "lsp", "ml", NULL };
-/* Pascal file */
+char *Pascal_suffixes [] =
-CONST char *Pascal_suffixes [] =
 { "p", "pas", NULL };
-/* Perl file */
+char *Perl_suffixes [] =
-CONST char *Perl_suffixes [] =
 { "pl", "pm", NULL };
-CONST char *Perl_interpreters [] =
+char *Perl_interpreters [] =
-{ "perl", NULL };
+{ "perl", "@PERL@", NULL };
-/* Pro*C file. */
+char *plain_C_suffixes [] =
-CONST char *plain_C_suffixes [] =
+{ "pc",			/* Pro*C file */
-{ "pc", NULL };
+"m",			/* Objective C file */
+"lm",			/* Objective lex file */
-/* XEmacs addition */
+NULL };
-/* Postscript source code */
-CONST char *Postscript_suffixes [] =
+char *Prolog_suffixes [] =
-{ "ps", NULL };
-/* Prolog source code */
-CONST char *Prolog_suffixes [] =
 { "prolog", NULL };
-/* Scheme source code */
+/* Can't do the `SCM' or `scm' prefix with a version number. */
-/* FIXME Can't do the `SCM' or `scm' prefix with a version number */
+char *Scheme_suffixes [] =
-CONST char *Scheme_suffixes [] =
 { "SCM", "SM", "oak", "sch", "scheme", "scm", "sm", "t", NULL };
-/* TeX/LaTeX source code */
+char *TeX_suffixes [] =
-CONST char *TeX_suffixes [] =
+{ "TeX", "bib", "clo", "cls", "ltx", "sty", "tex", NULL };
-{ "bib", "clo", "cls", "ltx", "sty", "TeX", "tex", NULL };
+char *Yacc_suffixes [] =
-/* Yacc file */
+{ "y", "ym", NULL };		/* .ym is Objective yacc file */
-CONST char *Yacc_suffixes [] =
-{ "y", NULL };
 /* Table of language names and corresponding functions, file suffixes
 and interpreter names.
 It is ok for a given function to be listed under more than one
 name.  I just didn't. */
 struct lang_entry
 {
-CONST char *name;
+char *name;
 Lang_function *function;
-CONST char **suffixes;
+char **suffixes;
-CONST char **interpreters;
+char **interpreters;
 };
-CONST struct lang_entry lang_names [] =
+struct lang_entry lang_names [] =
 {
-{ "asm", Asm_labels, Asm_suffixes },
+{ "asm",     Asm_labels,	    Asm_suffixes,	  NULL              },
-{ "c", default_C_entries, default_C_suffixes },
+{ "c",       default_C_entries,   default_C_suffixes,	  NULL              },
-{ "c++", Cplusplus_entries, Cplusplus_suffixes },
+{ "c++",     Cplusplus_entries,   Cplusplus_suffixes,	  NULL              },
-{ "c*", Cstar_entries, Cstar_suffixes },
+{ "c*",      Cstar_entries,	    Cstar_suffixes,	  NULL              },
-{ "fortran", Fortran_functions, Fortran_suffixes },
+{ "erlang",  Erlang_functions,    Erlang_suffixes,	  NULL              },
-{ "lisp", Lisp_functions, Lisp_suffixes },
+{ "fortran", Fortran_functions,   Fortran_suffixes,	  NULL              },
-{ "pascal", Pascal_functions, Pascal_suffixes },
+{ "lisp",    Lisp_functions,	    Lisp_suffixes,	  NULL              },
-{ "perl", Perl_functions, Perl_suffixes, Perl_interpreters },
+{ "pascal",  Pascal_functions,    Pascal_suffixes,	  NULL              },
-{ "proc", plain_C_entries, plain_C_suffixes },
+{ "perl",    Perl_functions,	    Perl_suffixes,	  Perl_interpreters },
-{ "prolog", Prolog_functions, Prolog_suffixes },
+{ "proc",    plain_C_entries,	    plain_C_suffixes,	  NULL              },
-{ "postscript", Postscript_functions, Postscript_suffixes },
+{ "prolog",  Prolog_functions,    Prolog_suffixes,	  NULL              },
-{ "scheme" , Scheme_functions, Scheme_suffixes },
+{ "scheme",  Scheme_functions,    Scheme_suffixes,	  NULL              },
-{ "tex", TeX_functions, TeX_suffixes },
+{ "tex",     TeX_functions,	    TeX_suffixes,	  NULL              },
-{ "yacc", Yacc_entries, Yacc_suffixes },
+{ "yacc",    Yacc_entries,	    Yacc_suffixes,	  NULL              },
-{ "auto", NULL },		/* default guessing scheme */
+{ "auto", NULL },             /* default guessing scheme */
-{ "none", just_read_file },	/* regexp matching only */
+{ "none", just_read_file },   /* regexp matching only */
-{ NULL, NULL }		/* end of list */
+{ NULL, NULL }                /* end of list */
 };
-static void
+void
-print_language_names (void)
+print_language_names ()
 {
-CONST struct lang_entry *lang;
+struct lang_entry *lang;
-CONST char **ext;
+char **ext;
 puts ("\nThese are the currently supported languages, along with the\n\
 default file name suffixes:");
 for (lang = lang_names; lang->name != NULL; lang++)
 {
 }
 #ifndef VERSION
 # define VERSION "19"
 #endif
-static void
+void
-print_version (void)
+print_version ()
 {
-printf ("%s for Emacs version %s\n", (CTAGS) ? "ctags" : "etags", VERSION);
+printf ("%s (GNU Emacs %s)\n", (CTAGS) ? "ctags" : "etags", VERSION);
+puts ("Copyright (C) 1996 Free Software Foundation, Inc. and Ken Arnold");
+puts ("This program is distributed under the same terms as Emacs");
 exit (GOOD);
 }
-static void
+void
-print_help (void)
+print_help ()
 {
 printf ("These are the options accepted by %s.  You may use unambiguous\n\
 abbreviations for the long option names.  A - as file name means read\n\
-names from stdin.\n\n", progname);
+names from stdin.", progname);
+if (!CTAGS)
+printf ("  Absolute names are stored in the output file as they\n\
+are.  Relative ones are stored relative to the output file's directory.");
+puts ("\n");
 puts ("-a, --append\n\
 Append tag entries to existing tags file.");
 if (CTAGS)
 puts ("-C, --c++\n\
 Treat files whose name suffix defaults to C language as C++ files.");
 if (CTAGS)
 puts ("-d, --defines\n\
-Create tag entries for constant C #defines, too.");
+Create tag entries for C #define constants and enum constants, too.");
 else
 puts ("-D, --no-defines\n\
-Don't create tag entries for constant C #defines.  This makes\n\
+Don't create tag entries for C #define constants and enum constants.\n\
-	the tags file smaller.");
+	This makes the tags file smaller.");
 if (!CTAGS)
 {
 puts ("-i FILE, --include=FILE\n\
 Include a note in tag file indicating that, when searching for\n\
 -h, --help\n\
 Print this help message.");
 print_language_names ();
+puts ("");
+puts ("Report bugs to bug-gnu-emacs@prep.ai.mit.edu");
 exit (GOOD);
 }
-#ifdef ETAGS_REGEXPS
 enum argument_type
 {
 at_language,
 at_regexp,
 at_filename
 };
-#else /* !ETAGS_REGEXPS */
-enum argument_type
-{
-at_language,
-at_filename
-};
-#endif /* !ETAGS_REGEXPS */
 /* This structure helps us allow mixing of --lang and filenames. */
 typedef struct
 {
 enum argument_type arg_type;
 #include	<rmsdef.h>
 #include	<descrip.h>
 #define		OUTSIZE	MAX_FILE_SPEC_LEN
 short
-fn_exp (vspec *out, char *in)
+fn_exp (out, in)
+vspec *out;
+char *in;
 {
 static long context = 0;
 static struct dsc$descriptor_s o;
 static struct dsc$descriptor_s i;
 static logical pass1 = TRUE;
 /*
 v1.01 nmm 19-Aug-85 gfnames - return in successive calls the
 name of each file specified by the provided arg expanding wildcards.
 */
 char *
-gfnames (char *arg, logical *p_error)
+gfnames (arg, p_error)
+char *arg;
+logical *p_error;
 {
 static vspec filename = {MAX_FILE_SPEC_LEN, "\0"};
 switch (fn_exp (&filename, arg))
 {
 return filename.body;
 }
 }
 #ifndef OLD  /* Newer versions of VMS do provide `system'.  */
-void
+system (cmd)
-system (char *cmd)
+char *cmd;
 {
 fprintf (stderr, "system() function not implemented under VMS\n");
 }
 #endif
 #define	VERSION_DELIM	';'
-char *
+char *massage_name (s)
-massage_name (char *s)
+char *s;
 {
 char *start = s;
 for ( ; *s; s++)
 if (*s == VERSION_DELIM)
 return start;
 }
 #endif /* VMS */
-void
+int
-main (int argc, char *argv[])
+main (argc, argv)
+int argc;
+char *argv[];
 {
 int i;
 unsigned int nincluded_files = 0;
 char **included_files = xnew (argc, char *);
 char *this_file;
 re_set_syntax (RE_SYNTAX_EMACS);
 #endif /* ETAGS_REGEXPS */
 /*
 * If etags, always find typedefs and structure tags.  Why not?
-* Also default is to find macro constants.
+* Also default is to find macro constants and enum constants.
 */
 if (!CTAGS)
 typedefs = typedefs_and_cplusplus = constantypedefs = TRUE;
 while (1)
 	case 'o':
 	  if (tagfile)
 	    {
 	      fprintf (stderr, "%s: -%c option may only be given once.\n",
 		       progname, opt);
-	      goto usage;
+	      suggest_asking_for_help ();
 	    }
 	  tagfile = optarg;
 	  break;
 	case 'I':
 	case 'S':		/* for backward compatibility */
 	  noindentypedefs = TRUE;
 	  break;
 	case 'l':
 	  argbuffer[current_arg].function = get_language_from_name (optarg);
-	  if (argbuffer[current_arg].function == NULL)
-	    {
-	      fprintf (stderr, "%s: language \"%s\" not recognized.\n",
-		       progname, optarg);
-	      goto usage;
-	    }
 	  argbuffer[current_arg].arg_type = at_language;
 	  ++current_arg;
 	  break;
 #ifdef ETAGS_REGEXPS
 	case 'r':
 	case 'w':
 	  no_warnings = TRUE;
 	  break;
 #endif /* CTAGS */
 	default:
-	  goto usage;
+	  suggest_asking_for_help ();
 	}
 }
 for (; optind < argc; ++optind)
 {
 }
 if (nincluded_files == 0 && file_count == 0)
 {
 fprintf (stderr, "%s: No input files specified.\n", progname);
+suggest_asking_for_help ();
-usage:
-fprintf (stderr, "\tTry `%s --help' for a complete list of options.\n",
-	       progname);
-exit (BAD);
 }
 if (tagfile == NULL)
-{
+tagfile = CTAGS ? "tags" : "TAGS";
-tagfile = CTAGS ? (char *) "tags" : (char *) "TAGS";
-}
 cwd = etags_getcwd ();	/* the current working directory */
-strcat (cwd, "/");
+if (cwd[strlen (cwd) - 1] != '/')
+cwd = concat (cwd, "/", "");
 if (streq (tagfile, "-"))
-{
+tagfiledir = cwd;
-tagfiledir = cwd;
-}
 else
-{
+tagfiledir = absolute_dirname (tagfile, cwd);
-tagfiledir = absolute_dirname (tagfile, cwd);
-}
 init ();			/* set up boolean "functions" */
 initbuffer (&lb);
 initbuffer (&token_name);
 initbuffer (&filename_lb);
 if (!CTAGS)
 {
 if (streq (tagfile, "-"))
-	tagf = stdout;
+	{
+	  tagf = stdout;
+#ifdef DOS_NT
+	  /* Switch redirected `stdout' to binary mode (setting `_fmode'
+	     doesn't take effect until after `stdout' is already open). */
+	  if (!isatty (fileno (stdout)))
+	    setmode (fileno (stdout), O_BINARY);
+#endif /* DOS_NT */
+	}
 else
 	tagf = fopen (tagfile, append_to_tagfile ? "a" : "w");
 if (tagf == NULL)
 	pfatal (tagfile);
 }
 /* If CTAGS, we are here.  process_file did not write the tags yet,
 because we want them ordered.  Let's do it now. */
 if (cxref_style)
 {
-tagf = fopen (tagfile, append_to_tagfile ? "a" : "w");
-if (tagf == NULL)
-	pfatal (tagfile);
 put_entries (head);
 exit (GOOD);
 }
 if (update)
 	    continue;
 	  sprintf (cmd,
 		   "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
 		   tagfile, argbuffer[i].what, tagfile);
 	  if (system (cmd) != GOOD)
-	    fatal ("failed to execute shell command", 0);
+	    fatal ("failed to execute shell command", (char *)NULL);
 	}
 append_to_tagfile = TRUE;
 }
 tagf = fopen (tagfile, append_to_tagfile ? "a" : "w");
 {
 char cmd[BUFSIZ];
 sprintf (cmd, "sort %s -o %s", tagfile, tagfile);
 exit (system (cmd));
 }
-exit (GOOD);
+return GOOD;
 }
 /*
 * Return a Lang_function given the name.
 */
 Lang_function *
-get_language_from_name (char *name)
+get_language_from_name (name)
-{
+char *name;
-CONST struct lang_entry *lang;
+{
+struct lang_entry *lang;
-if (name == NULL)
-return NULL;
+if (name != NULL)
 for (lang = lang_names; lang->name != NULL; lang++)
 {
-if (streq (name, lang->name))
+	if (streq (name, lang->name))
-	return lang->function;
+	  return lang->function;
 }
-return NULL;
+fprintf (stderr, "%s: language \"%s\" not recognized.\n",
+	   progname, optarg);
+suggest_asking_for_help ();
+/* This point should never be reached.  The function should either
+return a function pointer  or never return.  Note that a NULL
+pointer cannot be considered as an error, as it means that the
+language has not been explicitely imposed by the user ("auto"). */
+return NULL;			/* avoid warnings from compiler */
 }
 /*
 * Return a Lang_function given the interpreter name.
 */
 Lang_function *
-get_language_from_interpreter (char *interpreter)
+get_language_from_interpreter (interpreter)
-{
+char *interpreter;
-CONST struct lang_entry *lang;
+{
-CONST char **iname;
+struct lang_entry *lang;
+char **iname;
 if (interpreter == NULL)
 return NULL;
 for (lang = lang_names; lang->name != NULL; lang++)
 if (lang->interpreters != NULL)
 /*
 * Return a Lang_function given the file suffix.
 */
 Lang_function *
-get_language_from_suffix (CONST char *suffix)
+get_language_from_suffix (suffix)
-{
+char *suffix;
-CONST struct lang_entry *lang;
+{
-CONST char **ext;
+struct lang_entry *lang;
+char **ext;
 if (suffix == NULL)
 return NULL;
 for (lang = lang_names; lang->name != NULL; lang++)
 if (lang->suffixes != NULL)
 /*
 * This routine is called on each file argument.
 */
 void
-process_file (CONST char *file)
+process_file (file)
+char *file;
 {
 struct stat stat_buf;
 FILE *inf;
+#ifdef DOS_NT
+char *p;
+for (p = file; *p != '\0'; p++)
+if (*p == '\\')
+*p = '/';
+#endif
 if (stat (file, &stat_buf) == 0 && !S_ISREG (stat_buf.st_mode))
 {
 fprintf (stderr, "Skipping %s: it is not a regular file.\n", file);
 return;
 * all of the array "_wht" is set to FALSE, and then the elements
 * subscripted by the chars in "white" are set to TRUE.  Thus "_wht"
 * of a char is TRUE if it is the string "white", else FALSE.
 */
 void
-init (void)
+init ()
 {
-register CONST char *sp;
+register char *sp;
 register int i;
 for (i = 0; i < 0177; i++)
 _wht[i] = _etk[i] = _itk[i] = _btk[i] = FALSE;
 for (sp = white; *sp; sp++)
-_wht[(unsigned int) *sp] = TRUE;
+_wht[*sp] = TRUE;
 for (sp = endtk; *sp; sp++)
-_etk[(unsigned int) *sp] = TRUE;
+_etk[*sp] = TRUE;
 for (sp = intk; *sp; sp++)
-_itk[(unsigned int) *sp] = TRUE;
+_itk[*sp] = TRUE;
 for (sp = begtk; *sp; sp++)
-_btk[(unsigned int) *sp] = TRUE;
+_btk[*sp] = TRUE;
 _wht[0] = _wht['\n'];
 _etk[0] = _etk['\n'];
 _btk[0] = _btk['\n'];
 _itk[0] = _itk['\n'];
 }
 /*
 * This routine opens the specified file and calls the function
 * which finds the function and type definitions.
 */
 void
-find_entries (CONST char *file, FILE *inf)
+find_entries (file, inf)
+char *file;
+FILE *inf;
 {
 char *cp;
 Lang_function *function;
 NODE *old_last_node;
 extern NODE *last_node;
 /* Memory leakage here: the memory block pointed by curfile is never
 released.  The amount of memory leaked here is the sum of the
 lengths of the input file names. */
 curfile = savestr (file);
 	  continue;
 for (cp = lp; *cp != '\0' && !isspace (*cp); cp++)
 	continue;
 *cp = '\0';
-if (strlen (lp) > (size_t) 0)
+if (strlen (lp) > 0)
 	{
 	  function = get_language_from_interpreter (lp);
 	  if (function != NULL)
 	    {
 	      function (inf);
 fclose (inf);
 return;
 }
 /* Record a tag. */
-#if 0
+void
-char *name;		/* tag name, if different from definition */
+pfnote (name, is_func, linestart, linelen, lno, cno)
+char *name;		/* tag name, or NULL if unnamed */
 logical 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 cno;			/* character number */
-#endif
+{
-void
+register NODE *np;
-pfnote (char *name, logical is_func, char *linestart,
-	int linelen, int lno, long cno)
+if (CTAGS && name == NULL)
-{
+return;
-register NODE *np = xnew (1, NODE);
+np = xnew (1, NODE);
 /* If ctags mode, change name "main" to M<thisfilename>. */
 if (CTAGS && !cxref_style && streq (name, "main"))
 {
 register char *fp = etags_strrchr (curfile, '/');
 np->file = curfile;
 np->is_func = is_func;
 np->lno = lno;
 /* Our char numbers are 0-base, because of C language tradition?
 ctags compatibility?  old versions compatibility?   I don't know.
-Anyway, since emacs's are 1-base we espect etags.el to take care
+Anyway, since emacs's are 1-base we expect etags.el to take care
 of the difference.  If we wanted to have 1-based numbers, we would
 uncomment the +1 below. */
 np->cno = cno /* + 1 */ ;
 np->left = np->right = NULL;
-np->pat = savenstr (linestart, ((CTAGS && !cxref_style) ? 50 : linelen));
+if (CTAGS && !cxref_style)
+{
+if (strlen (linestart) < 50)
+	np->pat = concat (linestart, "$", "");
+else
+	np->pat = savenstr (linestart, 50);
+}
+else
+np->pat = savenstr (linestart, linelen);
 add_node (np, &head);
 }
 /*
 * free_tree ()
 *	recurse on left children, iterate on right children.
 */
 void
-free_tree (NODE *node)
+free_tree (node)
+register NODE *node;
 {
 while (node)
 {
 register NODE *node_right = node->right;
 free_tree (node->left);
 *	add_node is the only function allowed to add nodes, so it can
 *	maintain state.
 */
 NODE *last_node = NULL;
 void
-add_node (NODE *node, NODE **cur_node_p)
+add_node (node, cur_node_p)
+NODE *node, **cur_node_p;
 {
 register int dif;
 register NODE *cur_node = *cur_node_p;
 if (cur_node == NULL)
 if (!CTAGS)
 {
 /* Etags Mode */
 if (last_node == NULL)
-	fatal ("internal error in add_node", 0);
+	fatal ("internal error in add_node", (char *)NULL);
 last_node->right = node;
 last_node = node;
 }
 else
 {
 add_node (node, dif < 0 ? &cur_node->left : &cur_node->right);
 }
 }
 void
-put_entries (NODE *node)
+put_entries (node)
+register NODE *node;
 {
 register char *sp;
 if (node == NULL)
 return;
 /* Output this entry */
 if (!CTAGS)
 {
 if (node->name != NULL)
-	fprintf (tagf, "%s\177%s\001%ld,%ld\n",
+	fprintf (tagf, "%s\177%s\001%d,%d\n",
 		 node->pat, node->name, node->lno, node->cno);
 else
-	fprintf (tagf, "%s\177%ld,%ld\n",
+	fprintf (tagf, "%s\177%d,%d\n",
 		 node->pat, node->lno, node->cno);
 }
-else if (!cxref_style)
+else
 {
-fprintf (tagf, "%s\t%s\t",
+if (node->name == NULL)
-	       node->name, node->file);
+	error ("internal error: NULL name in ctags mode.", (char *)NULL);
-if (node->is_func)
+if (cxref_style)
-	{			/* a function */
+	{
-	  putc (searchar, tagf);
+	  if (vgrind_style)
-	  putc ('^', tagf);
+	    fprintf (stdout, "%s %s %d\n",
+		     node->name, node->file, (node->lno + 63) / 64);
-	  for (sp = node->pat; *sp; sp++)
+	  else
-	    {
+	    fprintf (stdout, "%-16s %3d %-16s %s\n",
-	      if (*sp == '\\' || *sp == searchar)
+		     node->name, node->lno, node->file, node->pat);
-		putc ('\\', tagf);
-	      putc (*sp, tagf);
-	    }
-	  putc (searchar, tagf);
 	}
 else
-	{			/* a typedef; text pattern inadequate */
+	{
-	  fprintf (tagf, "%ld", node->lno);
+	  fprintf (tagf, "%s\t%s\t", node->name, node->file);
-	}
-putc ('\n', tagf);
+	  if (node->is_func)
-}
+	    {			/* a function */
-else if (vgrind_style)
+	      putc (searchar, tagf);
-fprintf (stdout, "%s %s %ld\n",
+	      putc ('^', tagf);
-	     node->name, node->file, (node->lno + 63) / 64);
-else
+	      for (sp = node->pat; *sp; sp++)
-fprintf (stdout, "%-16s %3ld %-16s %s\n",
+		{
-	     node->name, node->lno, node->file, node->pat);
+		  if (*sp == '\\' || *sp == searchar)
+		    putc ('\\', tagf);
+		  putc (*sp, tagf);
+		}
+	      putc (searchar, tagf);
+	    }
+	  else
+	    {			/* a typedef; text pattern inadequate */
+	      fprintf (tagf, "%d", node->lno);
+	    }
+	  putc ('\n', tagf);
+	}
+}
 /* Output subentries that follow this one */
 put_entries (node->right);
 }
 /* Length of a number's decimal representation. */
-static int
+int
-number_len (long num)
+number_len (num)
+long num;
 {
 int len = 0;
 if (!num)
 return 1;
 for (; num; num /= 10)
 * we are not ctags, but called only in that case.  This count
 * is irrelevant with the new tags.el, but is still supplied for
 * backward compatibility.
 */
 int
-total_size_of_entries (NODE *node)
+total_size_of_entries (node)
+register NODE *node;
 {
 register int total;
 if (node == NULL)
 return 0;
 /*
 * The C symbol tables.
 */
 enum sym_type
 {
-st_none, st_C_struct, st_C_enum, st_C_define, st_C_typedef, st_C_typespec
+st_none, st_C_objprot, st_C_objimpl, st_C_objend, st_C_gnumacro,
+st_C_struct, st_C_enum, st_C_define, st_C_typedef, st_C_typespec
 };
 /* Feed stuff between (but not including) %[ and %] lines to:
-gperf -c -k1,3 -o -p -r -t
+gperf -c -k 1,3 -o -p -r -t
 %[
-struct C_stab_entry { CONST char *name; int c_ext; enum sym_type type; }
+struct C_stab_entry { char *name; int c_ext; enum sym_type type; }
 %%
+@interface,	0,	st_C_objprot
+@protocol,	0,	st_C_objprot
+@implementation,0,	st_C_objimpl
+@end,		0,	st_C_objend
 class,  	C_PLPL,	st_C_struct
+namespace,	C_PLPL,	st_C_struct
 domain, 	C_STAR,	st_C_struct
 union,  	0,	st_C_struct
 struct, 	0,	st_C_struct
 enum,    	0,	st_C_enum
 typedef, 	0,	st_C_typedef
 define,  	0,	st_C_define
+bool,		C_PLPL,	st_C_typespec
 long,    	0,	st_C_typespec
 short,   	0,	st_C_typespec
 int,     	0,	st_C_typespec
 char,    	0,	st_C_typespec
 float,   	0,	st_C_typespec
 void,    	0,	st_C_typespec
 extern,  	0,	st_C_typespec
 static,  	0,	st_C_typespec
 const,   	0,	st_C_typespec
 volatile,	0,	st_C_typespec
+explicit,	C_PLPL,	st_C_typespec
+mutable,	C_PLPL,	st_C_typespec
+typename,	C_PLPL,	st_C_typespec
+# DEFUN used in emacs, the next three used in glibc (SYSCALL only for mach).
+DEFUN,		0,	st_C_gnumacro
+SYSCALL,	0,	st_C_gnumacro
+ENTRY,		0,	st_C_gnumacro
+PSEUDO,		0,	st_C_gnumacro
+# These are defined inside C functions, so currently they are not met.
+# EXFUN used in glibc, DEFVAR_* in emacs.
+#EXFUN,		0,	st_C_gnumacro
+#DEFVAR_,	0,	st_C_gnumacro
 %]
 and replace lines between %< and %> with its output. */
 /*%<*/
-/* C code produced by gperf version 1.8.1 (K&R C version) */
+/* C code produced by gperf version 2.1 (K&R C version) */
-/* Command-line: gperf -c -k1,3 -o -p -r -t  */
+/* Command-line: gperf -c -k 1,3 -o -p -r -t  */
-struct C_stab_entry { CONST char *name; int c_ext; enum sym_type type; };
+struct C_stab_entry { char *name; int c_ext; enum sym_type type; };
 #define MIN_WORD_LENGTH 3
-#define MAX_WORD_LENGTH 8
+#define MAX_WORD_LENGTH 15
-#define MIN_HASH_VALUE 10
+#define MIN_HASH_VALUE 34
-#define MAX_HASH_VALUE 62
+#define MAX_HASH_VALUE 121
 /*
-21 keywords
+34 keywords
-53 is the maximum key range
+88 is the maximum key range
 */
 static int
-hash (CONST char *str, int len)
+hash (str, len)
+register char *str;
+register unsigned int  len;
 {
 static unsigned char hash_table[] =
 {
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+121, 121, 121, 121, 121, 121, 121, 121, 121, 121,
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+121, 121, 121, 121,  45, 121, 121, 121,  16,  19,
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+61, 121, 121, 121, 121, 121, 121, 121, 121, 121,
-62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
+10, 121, 121,  20,  53, 121, 121, 121, 121, 121,
-62, 62, 62, 62, 62, 62, 62,  2, 62,  7,
+121, 121, 121, 121, 121, 121, 121,  41,  45,  22,
-6,  9, 15, 30, 62, 24, 62, 62,  1, 24,
+60,  47,  37,  28, 121,  55, 121, 121,  20,  14,
-7, 27, 13, 62, 19, 26, 18, 27,  1, 62,
+29,  30,   5, 121,  50,  59,  30,  54,   6, 121,
-62, 62, 62, 62, 62, 62, 62, 62,
+121, 121, 121, 121, 121, 121, 121, 121,
 };
-return len + hash_table[(int) str[2]] + hash_table[(int) str[0]];
+return len + hash_table[str[2]] + hash_table[str[0]];
 }
-static struct C_stab_entry *
+struct C_stab_entry *
-in_word_set  (CONST char *str, int len)
+in_word_set (str, len)
+register char *str;
+register unsigned int len;
 {
 static struct C_stab_entry  wordlist[] =
 {
 {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
-{"",},
+{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
 {"volatile", 	0,	st_C_typespec},
-{"",},
+{"PSEUDO", 		0,	st_C_gnumacro},
+{"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+{"typedef",  	0,	st_C_typedef},
+{"typename", 	C_PLPL,	st_C_typespec},
+{"",}, {"",}, {"",},
+{"SYSCALL", 	0,	st_C_gnumacro},
+{"",}, {"",}, {"",},
+{"mutable", 	C_PLPL,	st_C_typespec},
+{"namespace", 	C_PLPL,	st_C_struct},
 {"long",     	0,	st_C_typespec},
+{"",}, {"",},
+{"const",    	0,	st_C_typespec},
+{"",}, {"",}, {"",},
+{"explicit", 	C_PLPL,	st_C_typespec},
+{"",}, {"",}, {"",}, {"",},
+{"void",     	0,	st_C_typespec},
+{"",},
 {"char",     	0,	st_C_typespec},
 {"class",   	C_PLPL,	st_C_struct},
-{"",}, {"",}, {"",}, {"",},
+{"",}, {"",}, {"",},
-{"const",    	0,	st_C_typespec},
+{"float",    	0,	st_C_typespec},
-{"",}, {"",}, {"",}, {"",},
+{"",},
+{"@implementation", 0,	st_C_objimpl},
 {"auto",     	0,	st_C_typespec},
-{"",}, {"",},
+{"",},
+{"ENTRY", 		0,	st_C_gnumacro},
+{"@end", 		0,	st_C_objend},
+{"bool", 		C_PLPL,	st_C_typespec},
+{"domain",  	C_STAR,	st_C_struct},
+{"",},
+{"DEFUN", 		0,	st_C_gnumacro},
+{"extern",   	0,	st_C_typespec},
+{"@interface", 	0,	st_C_objprot},
+{"",}, {"",}, {"",},
+{"int",      	0,	st_C_typespec},
+{"",}, {"",}, {"",}, {"",},
+{"signed",   	0,	st_C_typespec},
+{"short",    	0,	st_C_typespec},
+{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
 {"define",   	0,	st_C_define},
-{"",},
+{"@protocol", 	0,	st_C_objprot},
-{"void",     	0,	st_C_typespec},
+{"enum",     	0,	st_C_enum},
-{"",}, {"",}, {"",},
-{"extern",   	0,	st_C_typespec},
 {"static",   	0,	st_C_typespec},
-{"",},
+{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
-{"domain",  	C_STAR,	st_C_struct},
+{"union",   	0,	st_C_struct},
-{"",},
+{"struct",  	0,	st_C_struct},
-{"typedef",  	0,	st_C_typedef},
+{"",}, {"",}, {"",}, {"",},
 {"double",   	0,	st_C_typespec},
-{"enum",     	0,	st_C_enum},
-{"",}, {"",}, {"",}, {"",},
-{"int",      	0,	st_C_typespec},
-{"",},
-{"float",    	0,	st_C_typespec},
-{"",}, {"",}, {"",},
-{"struct",  	0,	st_C_struct},
-{"",}, {"",}, {"",}, {"",},
-{"union",   	0,	st_C_struct},
-{"",},
-{"short",    	0,	st_C_typespec},
-{"",}, {"",},
 {"unsigned", 	0,	st_C_typespec},
-{"signed",   	0,	st_C_typespec},
 };
 if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
 {
 register int key = hash (str, len);
 if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
 {
-register CONST char *s = wordlist[key].name;
+register char *s = wordlist[key].name;
-if (*s == *str && strneq (str + 1, s + 1, len - 1))
+if (*s == *str && !strncmp (str + 1, s + 1, len - 1))
 return &wordlist[key];
 }
 }
 return 0;
 }
 /*%>*/
-static enum sym_type
+enum sym_type
-C_symtype (char *str, int len, int c_ext)
+C_symtype (str, len, c_ext)
-{
+char *str;
-register struct C_stab_entry *se = in_word_set(str, len);
+int len;
+int c_ext;
+{
+register struct C_stab_entry *se = in_word_set (str, len);
 if (se == NULL || (se->c_ext && !(c_ext & se->c_ext)))
 return st_none;
 return se->type;
 }
 /*
 * C functions are recognized using a simple finite automaton.
 * funcdef is its state variable.
 */
-typedef enum
+enum
 {
 fnone,			/* nothing seen */
 ftagseen,			/* function-like tag seen */
 fstartlist,			/* just after open parenthesis */
 finlist,			/* in parameter list */
 flistseen,			/* after parameter list */
 fignore			/* before open brace */
-} FUNCST;
+} funcdef;
-FUNCST funcdef;
 /*
 * typedefs are recognized using a simple finite automaton.
-* typeddef is its state variable.
+* typdef is its state variable.
 */
-typedef enum
+enum
 {
 tnone,			/* nothing seen */
 ttypedseen,			/* typedef keyword seen */
 tinbody,			/* inside typedef body */
 tend,				/* just before typedef tag */
 tignore			/* junk after typedef tag */
-} TYPEDST;
+} typdef;
-TYPEDST typdef;
 /*
 * struct-like structures (enum, struct and union) are recognized
 * using another simple finite automaton.  `structdef' is its state
 * variable.
 */
-typedef enum
+enum
 {
 snone,			/* nothing seen yet */
 skeyseen,			/* struct-like keyword seen */
 stagseen,			/* struct-like tag seen */
 scolonseen,			/* colon seen after struct-like tag */
 sinbody			/* in struct body: recognize member func defs*/
-} STRUCTST;
+} structdef;
-STRUCTST structdef;
 /*
 * When structdef is stagseen, scolonseen, or sinbody, structtag is the
 * struct tag, and structtype is the type of the preceding struct-like
 * keyword.
 */
-CONST char *structtag = "<uninited>";
+char *structtag = "<uninited>";
 enum sym_type structtype;
+/*
+* When objdef is different from onone, objtag is the name of the class.
+*/
+char *objtag = "<uninited>";
 /*
 * Yet another little state machine to deal with preprocessor lines.
 */
-typedef enum
+enum
 {
 dnone,			/* nothing seen */
 dsharpseen,			/* '#' seen as first char on line */
 ddefineseen,			/* '#' and 'define' seen */
 dignorerest			/* ignore rest of line */
-} DEFINEST;
+} definedef;
-DEFINEST definedef;
+/*
+* State machine for Objective C protocols and implementations.
+*/
+enum
+{
+onone,			/* nothing seen */
+oprotocol,			/* @interface or @protocol seen */
+oimplementation,		/* @implementations seen */
+otagseen,			/* class name seen */
+oparenseen,			/* parenthesis before category seen */
+ocatseen,			/* category name seen */
+oinbody,			/* in @implementation body */
+omethodsign,			/* in @implementation body, after +/- */
+omethodtag,			/* after method name */
+omethodcolon,			/* after method colon */
+omethodparm,			/* after method parameter */
+oignore			/* wait for @end */
+} objdef;
 /*
 * Set this to TRUE, and the next token considered is called a function.
 * Used only for GNU emacs's function-defining macros.
 */
 * TRUE in the rules part of a yacc file, FALSE outside (parse as C).
 */
 logical yacc_rules;
 /*
+* methodlen is the length of the method name stored in token_name.
+*/
+int methodlen;
+/*
 * consider_token ()
 *	checks to see if the current token is at the start of a
 *	function, or corresponds to a typedef, or is a struct/union/enum
-*	tag.
+*	tag, or #define, or an enum constant.
 *
-*	*IS_FUNC gets TRUE iff the token is a function or macro with args.
+*	*IS_FUNC gets TRUE iff the token is a function or #define macro
-*	C_EXT is which language we are looking at.
+*	with args.  C_EXT is which language we are looking at.
 *
 *	In the future we will need some way to adjust where the end of
 *	the token is; for instance, implementing the C++ keyword
 *	`operator' properly will adjust the end of the token to be after
 *	whatever follows `operator'.
 * Globals
 *	funcdef			IN OUT
 *	structdef		IN OUT
 *	definedef		IN OUT
 *	typdef			IN OUT
+*	objdef			IN OUT
 *	next_token_is_func	IN OUT
 */
-#if 0
+logical
+consider_token (str, len, c, c_ext, cblev, parlev, is_func)
 register char *str;	/* IN: token pointer */
 register int len;		/* IN: token length */
 register char c;		/* IN: first char after the token */
 int c_ext;			/* IN: C extensions mask */
 int cblev;			/* IN: curly brace level */
+int parlev;		/* IN: parenthesis level */
 logical *is_func;		/* OUT: function found */
-#endif
-static logical
-consider_token (char *str, int len, char c, int c_ext, int cblev,
-		logical *is_func)
 {
 enum sym_type toktype = C_symtype (str, len, c_ext);
 /*
 * Advance the definedef state machine.
 else
 	return TRUE;
 case dignorerest:
 return FALSE;
 default:
-error ("internal error: definedef value.", 0);
+error ("internal error: definedef value.", (char *)NULL);
 }
 /*
 * Now typedefs
 */
 	  typdef = tend;
 	  break;
 	case st_C_struct:
 	case st_C_enum:
 	  break;
-	default:
-	  break;
 	}
 /* Do not return here, so the structdef stuff has a chance. */
 break;
 case tend:
 switch (toktype)
 	{
 	case st_C_typespec:
 	case st_C_struct:
 	case st_C_enum:
 	  return FALSE;
-	default:
-	  break;
 	}
 return TRUE;
-default:
-break;
 }
 /*
 * This structdef business is currently only invoked when cblev==0.
 * It should be recursively invoked whatever the curly brace level,
 * within structs.
 *
 * This structdef business is NOT invoked when we are ctags and the
 * file is plain C.  This is because a struct tag may have the same
 * name as another tag, and this loses with ctags.
-*
-* This if statement deals with the typdef state machine as
-* follows: if typdef==ttypedseen and token is struct/union/class/enum,
-* return FALSE.  All the other code here is for the structdef
-* state machine.
 */
 switch (toktype)
 {
 case st_C_struct:
 case st_C_enum:
 	{
 	  structdef = skeyseen;
 	  structtype = toktype;
 	}
 return FALSE;
-default:
+}
-break;
-}
 if (structdef == skeyseen)
 {
 /* Save the tag for struct/union/class, for functions that may be
 defined inside. */
 if (structtype == st_C_struct)
 {
 definedef = dnone;
 return FALSE;
 }
-/* Detect GNU macros. */
+/* Detect GNU macros.
-if (definedef == dnone)
-if (strneq (str, "DEFUN", len)	/* Used in emacs */
+DEFUN note for writers of emacs C code:
-#if FALSE
+The DEFUN macro, used in emacs C source code, has a first arg
-	   These are defined inside C functions, so currently they
+that is a string (the lisp function name), and a second arg that
-	   are not met anyway.
+is a C function name.  Since etags skips strings, the second arg
-	|| strneq (str, "EXFUN", len) /* Used in glibc */
+is tagged.  This is unfortunate, as it would be better to tag the
-	|| strneq (str, "DEFVAR_", 7) /* Used in emacs */
+first arg.  The simplest way to deal with this problem would be
-#endif
+to name the tag with a name built from the function name, by
-	|| strneq (str, "SYSCALL", len) /* Used in glibc (mach) */
+removing the initial 'F' character and substituting '-' for '_'.
-	|| strneq (str, "ENTRY", len) /* Used in glibc */
+Anyway, this assumes that the conventions of naming lisp
-	|| strneq (str, "PSEUDO", len)) /* Used in glibc */
+functions will never change.  Currently, this method is not
+implemented, so writers of emacs code are recommended to put the
-{
+first two args of a DEFUN on the same line. */
-	next_token_is_func = TRUE;
+if (definedef == dnone && toktype == st_C_gnumacro)
-	return FALSE;
+{
-}
+next_token_is_func = TRUE;
+return FALSE;
+}
 if (next_token_is_func)
 {
 next_token_is_func = FALSE;
 funcdef = fignore;
 *is_func = TRUE;
 return TRUE;
 }
-/* A function? */
+/* Detect Objective C constructs. */
+switch (objdef)
+{
+case onone:
+switch (toktype)
+	{
+	case st_C_objprot:
+	  objdef = oprotocol;
+	  return FALSE;
+	case st_C_objimpl:
+	  objdef = oimplementation;
+	  return FALSE;
+	}
+break;
+case oimplementation:
+/* Save the class tag for functions that may be defined inside. */
+objtag = savenstr (str, len);
+objdef = oinbody;
+return FALSE;
+case oprotocol:
+/* Save the class tag for categories. */
+objtag = savenstr (str, len);
+objdef = otagseen;
+*is_func = TRUE;
+return TRUE;
+case oparenseen:
+objdef = ocatseen;
+*is_func = TRUE;
+return TRUE;
+case oinbody:
+break;
+case omethodsign:
+if (parlev == 0)
+	{
+	  objdef = omethodtag;
+	  methodlen = len;
+	  grow_linebuffer (&token_name, methodlen+1);
+	  strncpy (token_name.buffer, str, len);
+	  token_name.buffer[methodlen] = '\0';
+	  return TRUE;
+	}
+return FALSE;
+case omethodcolon:
+if (parlev == 0)
+	objdef = omethodparm;
+return FALSE;
+case omethodparm:
+if (parlev == 0)
+	{
+	  objdef = omethodtag;
+	  methodlen += len;
+	  grow_linebuffer (&token_name, methodlen+1);
+	  strncat (token_name.buffer, str, len);
+	  return TRUE;
+	}
+return FALSE;
+case oignore:
+if (toktype == st_C_objend)
+	{
+	  /* Memory leakage here: the string pointed by objtag is
+	     never released, because many tests would be needed to
+	     avoid breaking on incorrect input code.  The amount of
+	     memory leaked here is the sum of the lengths of the
+	     class tags.
+	  free (objtag); */
+	  objdef = onone;
+	}
+return FALSE;
+}
+/* A function or enum constant? */
 switch (toktype)
 {
 case st_C_typespec:
 if (funcdef != finlist && funcdef != fignore)
 funcdef = fnone;		/* should be useless */
 return FALSE;
-default:
+case st_none:
+if (constantypedefs && structdef == sinbody && structtype == st_C_enum)
+	return TRUE;
 if (funcdef == fnone)
 	{
 	  funcdef = ftagseen;
 	  *is_func = TRUE;
 	  return TRUE;
 return FALSE;
 }
 /*
 * C_entries ()
-*	This routine finds functions, typedefs, #define's and
+*	This routine finds functions, typedefs, #define's, enum
-* 	struct/union/enum definitions in C syntax and adds them
+* 	constants and struct/union/enum definitions in C syntax
-*	to the list.
+*	and adds them to the list.
 */
 typedef struct
 {
 logical valid;
 char *str;
 #define CNL_SAVE_DEFINEDEF						\
 do {									\
 curlinepos = charno;							\
 lineno++;								\
+linecharno = charno;							\
 charno += readline (&curlb, inf);					\
 lp = curlb.buffer;							\
 quotednl = FALSE;							\
 newndx = curndx;							\
 } while (0)
 savetok.valid = FALSE;						\
 }									\
 definedef = dnone;							\
 } while (0)
-#define make_tag(isfun)  do \
+/* This macro should never be called when tok.valid is FALSE, but
-{									\
+we must protect about both invalid input and internal errors. */
-if (tok.valid)							\
+#define make_C_tag(isfun)  do \
-{									\
+if (tok.valid) {							\
-char *name = NULL;						\
+char *name = NULL;							\
-if (tok.named)							\
+if (CTAGS || tok.named)						\
-	name = savestr (token_name.buffer);				\
+name = savestr (token_name.buffer);					\
 pfnote (name, isfun, tok.buffer, tok.linelen, tok.lineno, tok.linepos); \
-}									\
-else if (DEBUG) abort ();						\
 tok.valid = FALSE;							\
-} while (0)
+} /* else if (DEBUG) abort (); */ while (0)
-#if 0
+void
+C_entries (c_ext, inf)
 int c_ext;			/* extension of C */
 FILE *inf;			/* input file */
-#endif
-void
-C_entries (int c_ext, FILE *inf)
 {
 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 */
 TOKEN tok;			/* latest token read */
-register int tokoff = 0;	/* offset in line of start of current token */
+register int tokoff;		/* offset in line of start of current token */
-register int toklen = 0;	/* length of current token */
+register int toklen;		/* length of current token */
 int cblev;			/* current curly brace level */
 int parlev;			/* current parenthesis level */
 logical incomm, inquote, inchar, quotednl, midtoken;
 logical cplpl;
 TOKEN savetok;		/* token saved during preprocessor handling */
 lineno = 0;
 charno = 0;
 lp = curlb.buffer;
 *lp = 0;
-definedef = dnone; funcdef = fnone; typdef = tnone; structdef = snone;
+funcdef = fnone; typdef = tnone; structdef = snone;
+definedef = dnone; objdef = onone;
 next_token_is_func = yacc_rules = FALSE;
 midtoken = inquote = inchar = incomm = quotednl = FALSE;
 tok.valid = savetok.valid = FALSE;
 cblev = 0;
 parlev = 0;
 	      {
 		lp++;
 		incomm = TRUE;
 		continue;
 	      }
-	    else if (cplpl && *lp == '/')
+	    else if (/* cplpl && */ *lp == '/')
 	      {
-		c = 0;
+		c = '\0';
 		break;
 	      }
 	    else
 	      break;
 	  case '%':
 /* Consider token only if some complicated conditions are satisfied. */
 if ((definedef != dnone
 	   || (cblev == 0 && structdef != scolonseen)
-	   || (cblev == 1 && cplpl && structdef == sinbody))
+	   || (cblev == 1 && cplpl && structdef == sinbody)
+	   || (structdef == sinbody && structtype == st_C_enum))
 	  && typdef != tignore
 	  && definedef != dignorerest
 	  && funcdef != finlist)
 	{
 	  if (midtoken)
 	    {
 	      if (endtoken (c))
 		{
-		  if (cplpl && c == ':' && *lp == ':' && begtoken(*(lp + 1)))
+		  if (c == ':' && cplpl && *lp == ':' && begtoken(*(lp + 1)))
 		    {
 		      /*
 		       * This handles :: in the middle, but not at the
 		       * beginning of an identifier.
 		       */
 		  else
 		    {
 		      logical is_func = FALSE;
 		      if (yacc_rules
-			  || consider_token (newlb.buffer + tokoff, toklen,
+			  || consider_token (newlb.buffer + tokoff, toklen, c,
-					     c, c_ext, cblev, &is_func))
+					     c_ext, cblev, parlev, &is_func))
 			{
 			  if (structdef == sinbody
 			      && definedef == dnone
 			      && is_func)
 			    /* function defined in C++ class body */
 			    {
-			      int strsize = strlen(structtag) + 2 + toklen + 1;
+			      grow_linebuffer (&token_name,
-			      while (token_name.size < strsize)
+					       strlen(structtag)+2+toklen+1);
-				{
-				  token_name.size *= 2;
-				  token_name.buffer
-				    = (char *) xrealloc (token_name.buffer,
-							 token_name.size);
-				}
 			      strcpy (token_name.buffer, structtag);
 			      strcat (token_name.buffer, "::");
 			      strncat (token_name.buffer,
 				       newlb.buffer+tokoff, toklen);
 			      tok.named = TRUE;
 			    }
+			  else if (objdef == ocatseen)
+			    /* Objective C category */
+			    {
+			      grow_linebuffer (&token_name,
+					       strlen(objtag)+2+toklen+1);
+			      strcpy (token_name.buffer, objtag);
+			      strcat (token_name.buffer, "(");
+			      strncat (token_name.buffer,
+				       newlb.buffer+tokoff, toklen);
+			      strcat (token_name.buffer, ")");
+			      tok.named = TRUE;
+			    }
+			  else if (objdef == omethodtag
+				   || objdef == omethodparm)
+			    /* Objective C method */
+			    {
+			      tok.named = TRUE;
+			    }
 			  else
 			    {
-			      while (token_name.size < toklen + 1)
+			      grow_linebuffer (&token_name, toklen+1);
-				{
-				  token_name.size *= 2;
-				  token_name.buffer
-				    = (char *) xrealloc (token_name.buffer,
-							 token_name.size);
-				}
 			      strncpy (token_name.buffer,
 				       newlb.buffer+tokoff, toklen);
 			      token_name.buffer[toklen] = '\0';
 			      if (structdef == stagseen
 				  || typdef == tend
 			  tok.valid = TRUE;
 			  if (definedef == dnone
 			      && (funcdef == ftagseen
 				  || structdef == stagseen
-				  || typdef == tend))
+				  || typdef == tend
+				  || objdef != onone))
 			    {
 			      if (current_lb_is_new)
 				switch_line_buffers ();
 			    }
 			  else
-			    make_tag (is_func);
+			    make_C_tag (is_func);
 			}
 		      midtoken = FALSE;
 		    }
 		} /* if (endtoken (c)) */
 	      else if (intoken (c))
 		    {
 		    case fstartlist:
 		      funcdef = finlist;
 		      continue;
 		    case flistseen:
-		      make_tag (TRUE);
+		      make_C_tag (TRUE);
 		      funcdef = fignore;
 		      break;
 		    case ftagseen:
 		      funcdef = fnone;
-		      break;
-		    default:
 		      break;
 		    }
 		  if (structdef == stagseen)
 		    structdef = snone;
 		  break;
 		case dsharpseen:
 		  savetok = tok;
-		default:
-		  break;
 		}
 	      if (!yacc_rules || lp == newlb.buffer + 1)
 		{
 		  tokoff = lp - 1 - newlb.buffer;
 		  toklen = 1;
 switch (c)
 	{
 	case ':':
 	  if (definedef != dnone)
 	    break;
+	  switch (objdef)
+	    {
+	    case  otagseen:
+	      objdef = oignore;
+	      make_C_tag (TRUE);
+	      break;
+	    case omethodtag:
+	    case omethodparm:
+	      objdef = omethodcolon;
+	      methodlen += 1;
+	      grow_linebuffer (&token_name, methodlen+1);
+	      strcat (token_name.buffer, ":");
+	      break;
+	    }
 	  if (structdef == stagseen)
 	    structdef = scolonseen;
 	  else
 	    switch (funcdef)
 	      {
 	      case ftagseen:
 		if (yacc_rules)
 		  {
-		    make_tag (FALSE);
+		    make_C_tag (FALSE);
 		    funcdef = fignore;
 		  }
 		break;
 	      case fstartlist:
 		funcdef = fnone;
-		break;
-	      default:
 		break;
 	      }
 	  break;
 	case ';':
 	  if (definedef != dnone)
 	    break;
 	  if (cblev == 0)
 	    switch (typdef)
 	      {
 	      case tend:
-		make_tag (FALSE);
+		make_C_tag (FALSE);
 		/* FALLTHRU */
 	      default:
 		typdef = tnone;
 	      }
 	  if (funcdef != fignore)
 	    structdef = snone;
 	  break;
 	case ',':
 	  if (definedef != dnone)
 	    break;
+	  switch (objdef)
+	    {
+	    case omethodtag:
+	    case omethodparm:
+	      make_C_tag (TRUE);
+	      objdef = oinbody;
+	      break;
+	    }
 	  if (funcdef != finlist && funcdef != fignore)
 	    funcdef = fnone;
 	  if (structdef == stagseen)
 	    structdef = snone;
 	  break;
 	  if (definedef != dnone)
 	    break;
 	  if (cblev == 0 && typdef == tend)
 	    {
 	      typdef = tignore;
-	      make_tag (FALSE);
+	      make_C_tag (FALSE);
 	      break;
 	    }
 	  if (funcdef != finlist && funcdef != fignore)
 	    funcdef = fnone;
 	  if (structdef == stagseen)
 	    structdef = snone;
 	  break;
 	case '(':
 	  if (definedef != dnone)
 	    break;
+	  if (objdef == otagseen && parlev == 0)
+	    objdef = oparenseen;
 	  switch (funcdef)
 	    {
 	    case fnone:
 	      switch (typdef)
 		{
 		     This handles constructs like:
 		     typedef void OperatorFun (int fun); */
 		  if (*lp != '*')
 		    {
 		      typdef = tignore;
-		      make_tag (FALSE);
+		      make_C_tag (FALSE);
 		    }
-		  break;
-		default:
 		  break;
 		} /* switch (typdef) */
 	      break;
 	    case ftagseen:
 	      funcdef = fstartlist;
 	      break;
 	    case flistseen:
 	      funcdef = finlist;
 	      break;
-	    default:
-	      break;
 	    }
 	  parlev++;
 	  break;
 	case ')':
 	  if (definedef != dnone)
 	    break;
+	  if (objdef == ocatseen && parlev == 1)
+	    {
+	      make_C_tag (TRUE);
+	      objdef = oignore;
+	    }
 	  if (--parlev == 0)
 	    {
 	      switch (funcdef)
 		{
 		case fstartlist:
 		case finlist:
 		  funcdef = flistseen;
 		  break;
-		default:
-		  break;
 		}
 	      if (cblev == 0 && typdef == tend)
 		{
 		  typdef = tignore;
-		  make_tag (FALSE);
+		  make_C_tag (FALSE);
 		}
 	    }
 	  else if (parlev < 0)	/* can happen due to ill-conceived #if's. */
 	    parlev = 0;
 	  break;
 	  if (typdef == ttypedseen)
 	    typdef = tinbody;
 	  switch (structdef)
 	    {
 	    case skeyseen:	/* unnamed struct */
+	      structdef = sinbody;
 	      structtag = "_anonymous_";
-	      structdef = sinbody;
 	      break;
 	    case stagseen:
 	    case scolonseen:	/* named struct */
 	      structdef = sinbody;
-	      make_tag (FALSE);
+	      make_C_tag (FALSE);
 	      break;
-	    default:
-	      break;
 	    }
 	  switch (funcdef)
 	    {
 	    case flistseen:
-	      make_tag (TRUE);
+	      make_C_tag (TRUE);
 	      /* FALLTHRU */
 	    case fignore:
 	      funcdef = fnone;
 	      break;
 	    case fnone:
-	      /* Neutralize `extern "C" {' grot and look inside structs. */
+	      switch (objdef)
-	      if (cblev == 0 && structdef == snone && typdef == tnone)
+		{
-		cblev = -1;
+		case otagseen:
-	    default:
+		  make_C_tag (TRUE);
-	      break;
+		  objdef = oignore;
+		  break;
+		case omethodtag:
+		case omethodparm:
+		  make_C_tag (TRUE);
+		  objdef = oinbody;
+		  break;
+		default:
+		  /* Neutralize `extern "C" {' grot. */
+		  if (cblev == 0 && structdef == snone && typdef == tnone)
+		    cblev = -1;
+		}
 	    }
 	  cblev++;
 	  break;
 	case '*':
 	  if (definedef != dnone)
 	      if (typdef == tinbody)
 		typdef = tend;
 	      /* Memory leakage here: the string pointed by structtag is
 	         never released, because I fear to miss something and
 	         break things while freeing the area.  The amount of
-	         memory leaked here is the sum of the lenghts of the
+	         memory leaked here is the sum of the lengths of the
 	         struct tags.
 	      if (structdef == sinbody)
 		free (structtag); */
 	      structdef = snone;
 	      structtag = "<error>";
 	    }
 	  break;
-	case '=':
+	case '+':
-	case '#': case '+': case '-': case '~': case '&': case '%': case '/':
+	case '-':
+	  if (objdef == oinbody && cblev == 0)
+	    {
+	      objdef = omethodsign;
+	      break;
+	    }
+	  /* FALLTHRU */
+	case '=': case '#': case '~': case '&': case '%': case '/':
 	case '|': case '^': case '!': case '<': case '>': case '.': case '?':
 	  if (definedef != dnone)
 	    break;
 	  /* These surely cannot follow a function tag. */
 	  if (funcdef != finlist && funcdef != fignore)
 	    funcdef = fnone;
 	  break;
 	case '\0':
+	  if (objdef == otagseen)
+	    {
+	      make_C_tag (TRUE);
+	      objdef = oignore;
+	    }
 	  /* If a macro spans multiple lines don't reset its state. */
 	  if (quotednl)
 	    CNL_SAVE_DEFINEDEF;
 	  else
 	    CNL;
 /*
 * Process either a C++ file or a C file depending on the setting
 * of a global flag.
 */
 void
-default_C_entries (FILE *inf)
+default_C_entries (inf)
+FILE *inf;
 {
 C_entries (cplusplus ? C_PLPL : 0, inf);
 }
 /* Always do plain ANSI C. */
 C_entries (0, inf);
 }
 /* Always do C++. */
 void
-Cplusplus_entries (FILE *inf)
+Cplusplus_entries (inf)
+FILE *inf;
 {
 C_entries (C_PLPL, inf);
 }
 /* Always do C*. */
 void
-Cstar_entries (FILE *inf)
+Cstar_entries (inf)
+FILE *inf;
 {
 C_entries (C_STAR, inf);
 }
 /* Always do Yacc. */
 void
-Yacc_entries (FILE *inf)
+Yacc_entries (inf)
+FILE *inf;
 {
 C_entries (YACC, inf);
 }
 /* Fortran parsing */
 char *dbp;
-static logical
+logical
-tail (CONST char *cp)
+tail (cp)
+char *cp;
 {
 register int len = 0;
 while (*cp && lowcase(*cp) == lowcase(dbp[len]))
 cp++, len++;
 }
 return FALSE;
 }
 void
-takeprec (void)
+takeprec ()
 {
 while (isspace (*dbp))
 dbp++;
 if (*dbp != '*')
 return;
 dbp++;
 while (isdigit (*dbp));
 }
 void
-getit (FILE *inf)
+getit (inf)
+FILE *inf;
 {
 register char *cp;
 while (isspace (*dbp))
 dbp++;
 for (cp = dbp + 1;
 (*cp
 	&& (isalpha (*cp) || isdigit (*cp) || (*cp == '_') || (*cp == '$')));
 cp++)
 continue;
-pfnote (NULL, TRUE, lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
+pfnote ((CTAGS) ? savenstr (dbp, cp-dbp) : NULL, TRUE,
+	  lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
 }
 void
-Fortran_functions (FILE *inf)
+Fortran_functions (inf)
+FILE *inf;
 {
 lineno = 0;
 charno = 0;
 while (!feof (inf))
 * Bob Weiner, Motorola Inc., 4/3/94
 * Unix and microcontroller assembly tag handling
 * look for '^[a-zA-Z_.$][a-zA_Z0-9_.$]*[: ^I^J]'
 */
 void
-Asm_labels (FILE *inf)
+Asm_labels (inf)
+FILE *inf;
 {
 register char *cp;
 lineno = 0;
 charno = 0;
 	  while (isalnum (*cp) || *cp == '_' || *cp == '.' || *cp == '$')
 	    cp++;
 	  if (*cp == ':' || isspace (*cp))
 	    {
 	      /* Found end of label, so copy it and add it to the table. */
-	      pfnote (NULL, TRUE,
+	      pfnote ((CTAGS) ? savenstr(lb.buffer, cp-lb.buffer) : NULL, TRUE,
 		      lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
 	    }
 	}
 }
 }
 	{
 	  while (*cp && isspace(*cp))
 	    cp++;
 	  while (*cp && ! isspace(*cp) && *cp != '{')
 	    cp++;
-	  pfnote (NULL, TRUE,
+	  pfnote ((CTAGS) ? savenstr (lb.buffer, cp-lb.buffer) : NULL, TRUE,
 		  lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
 	}
 }
 }
 /* Added by Mosur Mohan, 4/22/88 */
 /* Pascal parsing                */
-#define GET_NEW_LINE \
-{ \
-linecharno = charno; lineno++; \
-charno += 1 + readline (&lb, inf); \
-dbp = lb.buffer; \
-}
 /*
 *  Locates tags for procedures & functions.  Doesn't do any type- or
 *  var-definitions.  It does look for the keyword "extern" or
 *  "forward" immediately following the procedure statement; if found,
 *  the tag is skipped.
 */
 void
-Pascal_functions (FILE *inf)
+Pascal_functions (inf)
+FILE *inf;
 {
 struct linebuffer tline;	/* mostly copied from C_entries */
-long save_lcno = 0;
+long save_lcno;
-int save_lineno = 0, save_len = 0;
+int save_lineno, save_len;
-char c;
+char c, *cp, *namebuf;
 logical			/* each of these flags is TRUE iff: */
 incomment,			/* point is inside a comment */
 inquote,			/* point is inside '..' string */
 get_tagname,		/* point is after PROCEDURE/FUNCTION
 while (!feof (inf))
 {
 c = *dbp++;
 if (c == '\0')		/* if end of line */
 	{
-	  GET_NEW_LINE;
+	  lineno++;
+	  linecharno = charno;
+	  charno += readline (&lb, inf);
+	  dbp = lb.buffer;
 	  if (*dbp == '\0')
 	    continue;
 	  if (!((found_tag && verify_tag) ||
 		get_tagname))
 	    c = *dbp++;		/* only if don't need *dbp pointing
 	    }
 	  if (found_tag && verify_tag) /* not external proc, so make tag */
 	    {
 	      found_tag = FALSE;
 	      verify_tag = FALSE;
-	      pfnote (NULL, TRUE,
+	      pfnote (namebuf, TRUE,
 		      tline.buffer, save_len, save_lineno, save_lcno);
 	      continue;
 	    }
 	}
 if (get_tagname)		/* grab name of proc or fn */
 	{
-	  int size;
 	  if (*dbp == '\0')
 	    continue;
 	  /* save all values for later tagging */
-	  size  = strlen (lb.buffer) + 1;
+	  grow_linebuffer (&tline, strlen (lb.buffer) + 1);
-	  while (size > tline.size)
-	    {
-	      tline.size *= 2;
-	      tline.buffer = (char *) xrealloc (tline.buffer, tline.size);
-	    }
 	  strcpy (tline.buffer, lb.buffer);
 	  save_lineno = lineno;
 	  save_lcno = linecharno;
 	  /* grab block name */
-	  for (dbp++; *dbp && (!endtoken (*dbp)); dbp++)
+	  for (cp = dbp + 1; *cp && (!endtoken (*cp)); cp++)
 	    continue;
+	  namebuf = (CTAGS) ? savenstr (dbp, cp-dbp) : NULL;
+	  dbp = cp;		/* set dbp to e-o-token */
 	  save_len = dbp - lb.buffer + 1;
 	  get_tagname = FALSE;
 	  found_tag = TRUE;
 	  continue;
 /*
 * lisp tag functions
 *  look for (def or (DEF, quote or QUOTE
 */
-static int
+int
-L_isdef (char *strp)
+L_isdef (strp)
+register char *strp;
 {
 return ((strp[1] == 'd' || strp[1] == 'D')
 	  && (strp[2] == 'e' || strp[2] == 'E')
 	  && (strp[3] == 'f' || strp[3] == 'F'));
 }
-static int
+int
-L_isquote (char *strp)
+L_isquote (strp)
+register char *strp;
 {
 return ((*(++strp) == 'q' || *strp == 'Q')
 	  && (*(++strp) == 'u' || *strp == 'U')
 	  && (*(++strp) == 'o' || *strp == 'O')
 	  && (*(++strp) == 't' || *strp == 'T')
 	  && (*(++strp) == 'e' || *strp == 'E')
 	  && isspace(*(++strp)));
 }
-static void
+void
-L_getit (void)
+L_getit ()
 {
 register char *cp;
 if (*dbp == '\'')		/* Skip prefix quote */
 dbp++;
 cp++)
 continue;
 if (cp == dbp)
 return;
-pfnote (NULL, TRUE, lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
+pfnote ((CTAGS) ? savenstr (dbp, cp-dbp) : NULL, TRUE,
+	  lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
 }
 void
-Lisp_functions (FILE *inf)
+Lisp_functions (inf)
+FILE *inf;
 {
 lineno = 0;
 charno = 0;
 while (!feof (inf))
 	    }
 	}
 }
 }
-/* XEmacs addition: */
-/*
-* Postscript tag functions
-* Just look for lines where the first character is '/'
-*/
-static void
-PS_getit (void)
-{
-register char *cp;
-char c;
-char nambuf[BUFSIZ];
-if (*dbp == 0) return;
-for (cp = dbp+1; *cp && *cp != ' ' && *cp != '{'; cp++)
-continue;
-c = cp[0];
-cp[0] = 0;
-strcpy(nambuf, dbp);
-cp[0] = c;
-pfnote (nambuf, TRUE, lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
-}
-void
-Postscript_functions (FILE *fi)
-{
-lineno = 0;
-charno = 0;
-while (!feof (fi))
-{
-lineno++;
-linecharno = charno;
-charno += readline (&lb, fi) + 1;
-dbp = lb.buffer;
-if (dbp[0] == '/')
-{
-PS_getit();
-}
-}
-}
 /*
 * Scheme tag functions
 * look for (def... xyzzy
 * look for (def... (xyzzy
 * look for (def ... ((...(xyzzy ....
 * look for (set! xyzzy
 */
-void get_scheme (void);
+void get_scheme ();
 void
-Scheme_functions (FILE *inf)
+Scheme_functions (inf)
+FILE *inf;
 {
 lineno = 0;
 charno = 0;
 while (!feof (inf))
 	}
 }
 }
 void
-get_scheme (void)
+get_scheme ()
 {
 register char *cp;
 if (*dbp == '\0')
 return;
 /* Go till you get to white space or a syntactic break */
 for (cp = dbp + 1;
 *cp && *cp != '(' && *cp != ')' && !isspace (*cp);
 cp++)
 continue;
-pfnote (NULL, TRUE, lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
+pfnote ((CTAGS) ? savenstr (dbp, cp-dbp) : NULL, TRUE,
+	  lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
 }
 /* Find tags in TeX and LaTeX input files.  */
 /* TEX_toktab is a table of TeX control sequences that define tags.
 Each TEX_tabent records one such control sequence.
 CONVERT THIS TO USE THE Stab TYPE!! */
 struct TEX_tabent
 {
-CONST char *name;
+char *name;
 int len;
 };
 struct TEX_tabent *TEX_toktab = NULL;	/* Table with tag tokens */
 /* Default set of control sequences to put into TEX_toktab.
 The value of environment var TEXTAGS is prepended to this.  */
-CONST char *TEX_defenv = "\
+char *TEX_defenv = "\
 :chapter:section:subsection:subsubsection:eqno:label:ref:cite:bibitem\
 :part:appendix:entry:index";
-void TEX_mode (FILE *inf);
+void TEX_mode ();
-struct TEX_tabent *TEX_decode_env (CONST char *evarname, CONST char *defenv);
+struct TEX_tabent *TEX_decode_env ();
-int TEX_Token (char *cp);
+int TEX_Token ();
 #if TeX_named_tokens
-void TEX_getit (char *name, int len);
+void TEX_getit ();
 #endif
 char TEX_esc = '\\';
 char TEX_opgrp = '{';
 char TEX_clgrp = '}';
 /*
 * TeX/LaTeX scanning loop.
 */
 void
-TeX_functions (FILE *inf)
+TeX_functions (inf)
+FILE *inf;
 {
 char *lasthit;
 lineno = 0;
 charno = 0;
 lineno++;
 linecharno = charno;
 charno += readline (&lb, inf);
 dbp = lb.buffer;
 lasthit = dbp;
-while ((dbp = etags_strchr (dbp, TEX_esc)))/* Look at each esc in line */
+while (dbp = etags_strchr (dbp, TEX_esc)) /* Look at each esc in line */
 	{
 	  register int i;
 	  if (!*(++dbp))
 	    break;
 	  linecharno += dbp - lasthit;
 	  lasthit = dbp;
 	  i = TEX_Token (lasthit);
 	  if (0 <= i)
 	    {
-	      pfnote (NULL, TRUE,
+	      pfnote ((char *)NULL, TRUE,
 		      lb.buffer, strlen (lb.buffer), lineno, linecharno);
 #if TeX_named_tokens
 	      TEX_getit (lasthit, TEX_toktab[i].len);
 #endif
 	      break;		/* We only save a line once */
 #define TEX_cmt  '%'
 /* Figure out whether TeX's escapechar is '\\' or '!' and set grouping
 chars accordingly. */
 void
-TEX_mode (FILE *inf)
+TEX_mode (inf)
+FILE *inf;
 {
 int c;
 while ((c = getc (inf)) != EOF)
 {
 }
 /* Read environment and prepend it to the default string.
 Build token table. */
 struct TEX_tabent *
-TEX_decode_env (CONST char *evarname, CONST char *defenv)
+TEX_decode_env (evarname, defenv)
-{
+char *evarname;
-register CONST char *env, *p;
+char *defenv;
+{
+register char *env, *p;
 struct TEX_tabent *tab;
 int size, i;
 /* Append default string to environment. */
 env = getenv (evarname);
 if (!env)
 env = defenv;
 else
-env = concat (env, defenv, ""); /* never freed! */
+env = concat (env, defenv, "");
 /* Allocate a token table */
 for (size = 1, p = env; p;)
 if ((p = etags_strchr (p, ':')) && *(++p))
 size++;
 #if TeX_named_tokens
 /* Record a tag defined by a TeX command of length LEN and starting at NAME.
 The name being defined actually starts at (NAME + LEN + 1).
 But we seem to include the TeX command in the tag name.  */
 void
-TEX_getit (char *name, int len)
+TEX_getit (name, len)
+char *name;
+int len;
 {
 char *p = name + len;
 if (*name == '\0')
 return;
 return the pointer to the first occurrence of that command in TEX_toktab.
 Otherwise return -1.
 Keep the capital `T' in `Token' for dumb truncating compilers
 (this distinguishes it from `TEX_toktab' */
 int
-TEX_Token (char *cp)
+TEX_Token (cp)
+char *cp;
 {
 int i;
 for (i = 0; TEX_toktab[i].len > 0; i++)
 if (strneq (TEX_toktab[i].name, cp, TEX_toktab[i].len))
 return i;
 return -1;
 }
-/* Support for Prolog.  */
+/*
+* Prolog support (rewritten) by Anders Lindgren, Mar. 96
-/* Whole head (not only functor, but also arguments)
+*
-is gotten in compound term. */
+* Assumes that the predicate starts at column 0.
-static void
+* Only the first clause of a predicate is added.
-prolog_getit (char *s)
+*/
-{
-char *save_s;
-int insquote, npar;
-save_s = s;
-insquote = FALSE;
-npar = 0;
-while (1)
-{
-if (s[0] == '\0')		/* syntax error. */
-	return;
-else if (insquote && s[0] == '\'' && s[1] == '\'')
-	s += 2;
-else if (s[0] == '\'')
-	{
-	  insquote = !insquote;
-	  s++;
-	}
-else if (!insquote && s[0] == '(')
-	{
-	  npar++;
-	  s++;
-	}
-else if (!insquote && s[0] == ')')
-	{
-	  npar--;
-	  s++;
-	  if (npar == 0)
-	    break;
-	  else if (npar < 0)	/* syntax error. */
-	    return;
-	}
-else if (!insquote && s[0] == '.'
-	       && (isspace (s[1]) || s[1] == '\0'))
-	{			/* fullstop. */
-	  if (npar != 0)	/* syntax error. */
-	    return;
-	  s++;
-	  break;
-	}
-else
-	s++;
-}
-pfnote (NULL, TRUE, save_s, s-save_s, lineno, linecharno);
-}
-void skip_comment (struct linebuffer *plb, FILE *inf, int *plineno,
-		   long *plinecharno);
-/* It is assumed that prolog predicate starts from column 0. */
 void
-Prolog_functions (FILE *inf)
+Prolog_functions (inf)
-{
+FILE *inf;
-lineno = linecharno = charno = 0;
+{
+int prolog_pred ();
+void prolog_skip_comment ();
+char * last;
+int len;
+int allocated;
+allocated = 0;
+len = 0;
+last = NULL;
+lineno = 0;
+linecharno = 0;
+charno = 0;
 while (!feof (inf))
 {
 lineno++;
 linecharno += charno;
-charno = readline (&lb, inf) + 1;	/* 1 for newline. */
+charno = readline (&lb, inf);
 dbp = lb.buffer;
-if (isspace (dbp[0]))	/* not predicate header. */
+if (dbp[0] == '\0')	/* Empty line */
 	continue;
-else if (dbp[0] == '%')	/* comment. */
+else if (isspace (dbp[0])) /* Not a predicate */
 	continue;
 else if (dbp[0] == '/' && dbp[1] == '*')	/* comment. */
-	skip_comment (&lb, inf, &lineno, &linecharno);
+	prolog_skip_comment (&lb, inf);
-else			/* found. */
+else if (len = prolog_pred (dbp, last))
-	prolog_getit (dbp);
+	{
-}
+	  /* Predicate.  Store the function name so that we only
-}
+	   * generates a tag for the first clause.  */
+	  if (last == NULL)
+	    last = xnew(len + 1, char);
+	  else if (len + 1 > allocated)
+	    last = (char *) xrealloc(last, len + 1);
+	  allocated = len + 1;
+	  strncpy (last, dbp, len);
+	  last[len] = '\0';
+	}
+}
+}
 void
-skip_comment (struct linebuffer *plb, FILE *inf, int *plineno,
+prolog_skip_comment (plb, inf)
-	      long *plinecharno)
+struct linebuffer *plb;
+FILE *inf;
 {
 char *cp;
 do
 {
 for (cp = plb->buffer; *cp != '\0'; cp++)
 	if (cp[0] == '*' && cp[1] == '/')
 	  return;
-(*plineno)++;
+lineno++;
-*plinecharno += readline (plb, inf) + 1; /* 1 for newline. */
+linecharno += readline (plb, inf);
 }
 while (!feof(inf));
+}
+/*
+* A predicate definition is added if it matches:
+*     <beginning of line><Prolog Atom><whitespace>(
+*
+* It is added to the tags database if it doesn't match the
+* name of the previous clause header.
+*
+* Return the size of the name of the predicate, or 0 if no header
+* was found.
+*/
+int
+prolog_pred (s, last)
+char *s;
+char *last;		/* Name of last clause. */
+{
+int prolog_atom();
+int prolog_white();
+int pos;
+int len;
+pos = prolog_atom(s, 0);
+if (pos < 1)
+return 0;
+len = pos;
+pos += prolog_white(s, pos);
+if ((s[pos] == '(') || (s[pos] == '.'))
+{
+if (s[pos] == '(')
+	pos++;
+/* Save only the first clause. */
+if ((last == NULL) ||
+	  (len != strlen(last)) ||
+	  (strncmp(s, last, len) != 0))
+	{
+	  pfnote ((CTAGS) ? savenstr (s, len) : NULL, TRUE,
+		  s, pos, lineno, linecharno);
+	  return len;
+	}
+}
+return 0;
+}
+/*
+* Consume a Prolog atom.
+* Return the number of bytes consumed, or -1 if there was an error.
+*
+* A prolog atom, in this context, could be one of:
+* - An alphanumeric sequence, starting with a lower case letter.
+* - A quoted arbitrary string. Single quotes can escape themselves.
+*   Backslash quotes everything.
+*/
+int
+prolog_atom (s, pos)
+char *s;
+int pos;
+{
+int origpos;
+origpos = pos;
+if (islower(s[pos]) || (s[pos] == '_'))
+{
+/* The atom is unquoted. */
+pos++;
+while (isalnum(s[pos]) || (s[pos] == '_'))
+	{
+	  pos++;
+	}
+return pos - origpos;
+}
+else if (s[pos] == '\'')
+{
+pos++;
+while (1)
+	{
+	  if (s[pos] == '\'')
+	    {
+	      pos++;
+	      if (s[pos] != '\'')
+		break;
+	      pos++;		/* A double quote */
+	    }
+	  else if (s[pos] == '\0')
+	    /* Multiline quoted atoms are ignored. */
+	    return -1;
+	  else if (s[pos] == '\\')
+	    {
+	      if (s[pos+1] == '\0')
+		return -1;
+	      pos += 2;
+	    }
+	  else
+	    pos++;
+	}
+return pos - origpos;
+}
+else
+return -1;
+}
+/* Consume whitespace.  Return the number of bytes eaten. */
+int
+prolog_white (s, pos)
+char *s;
+int pos;
+{
+int origpos;
+origpos = pos;
+while (isspace(s[pos]))
+pos++;
+return pos - origpos;
+}
+/*
+* Support for Erlang  --  Anders Lindgren, Feb 1996.
+*
+* Generates tags for functions, defines, and records.
+*
+* Assumes that Erlang functions start at column 0.
+*/
+void
+Erlang_functions (inf)
+FILE *inf;
+{
+int erlang_func ();
+void erlang_attribute ();
+char * last;
+int len;
+int allocated;
+allocated = 0;
+len = 0;
+last = NULL;
+lineno = 0;
+linecharno = 0;
+charno = 0;
+while (!feof (inf))
+{
+lineno++;
+linecharno += charno;
+charno = readline (&lb, inf);
+dbp = lb.buffer;
+if (dbp[0] == '\0')	/* Empty line */
+	continue;
+else if (isspace (dbp[0])) /* Not function nor attribute */
+	continue;
+else if (dbp[0] == '%')	/* comment */
+	continue;
+else if (dbp[0] == '"')	/* Sometimes, strings start in column one */
+	continue;
+else if (dbp[0] == '-') 	/* attribute, e.g. "-define" */
+	{
+	  erlang_attribute(dbp);
+	  last = NULL;
+	}
+else if (len = erlang_func (dbp, last))
+	{
+	  /*
+	   * Function.  Store the function name so that we only
+	   * generates a tag for the first clause.
+	   */
+	  if (last == NULL)
+	    last = xnew(len + 1, char);
+	  else if (len + 1 > allocated)
+	    last = (char *) xrealloc(last, len + 1);
+	  allocated = len + 1;
+	  strncpy (last, dbp, len);
+	  last[len] = '\0';
+	}
+}
+}
+/*
+* A function definition is added if it matches:
+*     <beginning of line><Erlang Atom><whitespace>(
+*
+* It is added to the tags database if it doesn't match the
+* name of the previous clause header.
+*
+* Return the size of the name of the function, or 0 if no function
+* was found.
+*/
+int
+erlang_func (s, last)
+char *s;
+char *last;		/* Name of last clause. */
+{
+int erlang_atom ();
+int erlang_white ();
+int pos;
+int len;
+pos = erlang_atom(s, 0);
+if (pos < 1)
+return 0;
+len = pos;
+pos += erlang_white(s, pos);
+if (s[pos++] == '(')
+{
+/* Save only the first clause. */
+if ((last == NULL) ||
+	  (len != strlen(last)) ||
+	  (strncmp(s, last, len) != 0))
+	{
+	  pfnote ((CTAGS) ? savenstr (s, len) : NULL, TRUE,
+		  s, pos, lineno, linecharno);
+	  return len;
+	}
+}
+return 0;
+}
+/*
+* Handle attributes.  Currently, tags are generated for defines
+* and records.
+*
+* They are on the form:
+* -define(foo, bar).
+* -define(Foo(M, N), M+N).
+* -record(graph, {vtab = notable, cyclic = true}).
+*/
+void
+erlang_attribute (s)
+char *s;
+{
+int erlang_atom ();
+int erlang_white ();
+int pos;
+int len;
+if ((strncmp(s, "-define", 7) == 0) ||
+(strncmp(s, "-record", 7) == 0))
+{
+pos = 7;
+pos += erlang_white(s, pos);
+if (s[pos++] == '(')
+	{
+	  pos += erlang_white(s, pos);
+	  if (len = erlang_atom(s, pos))
+	    {
+	      pfnote ((CTAGS) ? savenstr (& s[pos], len) : NULL, TRUE,
+		      s, pos + len, lineno, linecharno);
+	    }
+	}
+}
+return;
+}
+/*
+* Consume an Erlang atom (or variable).
+* Return the number of bytes consumed, or -1 if there was an error.
+*/
+int
+erlang_atom (s, pos)
+char *s;
+int pos;
+{
+int origpos;
+origpos = pos;
+if (isalpha (s[pos]) || s[pos] == '_')
+{
+/* The atom is unquoted. */
+pos++;
+while (isalnum (s[pos]) || s[pos] == '_')
+	pos++;
+return pos - origpos;
+}
+else if (s[pos] == '\'')
+{
+pos++;
+while (1)
+	{
+	  if (s[pos] == '\'')
+	    {
+	      pos++;
+	      break;
+	    }
+	  else if (s[pos] == '\0')
+	    /* Multiline quoted atoms are ignored. */
+	    return -1;
+	  else if (s[pos] == '\\')
+	    {
+	      if (s[pos+1] == '\0')
+		return -1;
+	      pos += 2;
+	    }
+	  else
+	    pos++;
+	}
+return pos - origpos;
+}
+else
+return -1;
+}
+/* Consume whitespace.  Return the number of bytes eaten */
+int
+erlang_white (s, pos)
+char *s;
+int pos;
+{
+int origpos;
+origpos = pos;
+while (isspace (s[pos]))
+pos++;
+return pos - origpos;
 }
 #ifdef ETAGS_REGEXPS
 /* Take a string like "/blah/" and turn it into "blah", making sure
 that the first and last characters are the same, and handling
 quoted separator characters.  Actually, stops on the occurrence of
 an unquoted separator.  Also turns "\t" into a Tab character.
 Returns pointer to terminating separator.  Works in place.  Null
 terminates name string. */
-static char *
+char *
-scan_separators (char *name)
+scan_separators (name)
+char *name;
 {
 char sep = name[0];
 char *copyto = name;
 logical quoted = FALSE;
 }
 /* Turn a name, which is an ed-style (but Emacs syntax) regular
 expression, into a real regular expression by compiling it. */
 void
-add_regex (char *regexp_pattern)
+add_regex (regexp_pattern)
+char *regexp_pattern;
 {
 char *name;
 const char *err;
 struct re_pattern_buffer *patbuf;
 return;
 }
 if (regexp_pattern[0] == '\0')
 {
-error ("missing regexp", 0);
+error ("missing regexp", (char *)NULL);
 return;
 }
 if (regexp_pattern[strlen(regexp_pattern)-1] != regexp_pattern[0])
 {
 error ("%s: unterminated regexp", regexp_pattern);
 return;
 }
 name = scan_separators (regexp_pattern);
 if (regexp_pattern[0] == '\0')
 {
-error ("null regexp", 0);
+error ("null regexp", (char *)NULL);
 return;
 }
 (void) scan_separators (name);
 patbuf = xnew (1, struct re_pattern_buffer);
 patbuf->allocated = 0;
 err = re_compile_pattern (regexp_pattern, strlen (regexp_pattern), patbuf);
 if (err != NULL)
 {
-error ("%s while compiling pattern", (void *) err);
+error ("%s while compiling pattern", err);
 return;
 }
 num_patterns += 1;
 if (num_patterns == 1)
 /*
 * Do the substitutions indicated by the regular expression and
 * arguments.
 */
-static char *
+char *
-substitute (char *in, char *out, struct re_registers *regs)
+substitute (in, out, regs)
+char *in, *out;
+struct re_registers *regs;
 {
 char *result = NULL, *t;
 int size = 0;
 /* Pass 1: figure out how much size to allocate. */
 if (*t == '\\')
 	{
 	  ++t;
 	  if (!*t)
 	    {
-	      fprintf (stderr, "%s: pattern subtitution ends prematurely\n",
+	      fprintf (stderr, "%s: pattern substitution ends prematurely\n",
 		       progname);
 	      return NULL;
 	    }
 	  if (isdigit (*t))
 	    {
 }
 #endif /* ETAGS_REGEXPS */
 /* Initialize a linebuffer for use */
 void
-initbuffer (struct linebuffer *linebuffer)
+initbuffer (linebuffer)
+struct linebuffer *linebuffer;
 {
 linebuffer->size = 200;
 linebuffer->buffer = xnew (200, char);
 }
 * Read a line of text from `stream' into `linebuffer'.
 * Return the number of characters read from `stream',
 * which is the length of the line including the newline, if any.
 */
 long
-readline_internal (struct linebuffer *linebuffer, FILE *stream)
+readline_internal (linebuffer, stream)
+struct linebuffer *linebuffer;
+register FILE *stream;
 {
 char *buffer = linebuffer->buffer;
 register char *p = linebuffer->buffer;
 register char *pend;
 int chars_deleted;
 	  pend = buffer + linebuffer->size;
 	  linebuffer->buffer = buffer;
 	}
 if (c == EOF)
 	{
+	  *p = '\0';
 	  chars_deleted = 0;
 	  break;
 	}
 if (c == '\n')
 	{
 	  if (p > buffer && p[-1] == '\r')
 	    {
 	      *--p = '\0';
+#ifdef DOS_NT
+	     /* Assume CRLF->LF translation will be performed by Emacs
+		when loading this file, so CRs won't appear in the buffer.
+		It would be cleaner to compensate within Emacs;
+		however, Emacs does not know how many CRs were deleted
+		before any given point in the file.  */
+	      chars_deleted = 1;
+#else
 	      chars_deleted = 2;
+#endif
 	    }
 	  else
 	    {
 	      *p = '\0';
 	      chars_deleted = 1;
 /*
 * Like readline_internal, above, but try to match the input
 * line against any existing regular expressions.
 */
 long
-readline (struct linebuffer *linebuffer, FILE *stream)
+readline (linebuffer, stream)
+struct linebuffer *linebuffer;
+FILE *stream;
 {
 /* Read new line. */
+long result = readline_internal (linebuffer, stream);
 #ifdef ETAGS_REGEXPS
 int i;
-#endif
-long result = readline_internal (linebuffer, stream);
-#ifdef ETAGS_REGEXPS
 /* Match against all listed patterns. */
 for (i = 0; i < num_patterns; ++i)
 {
 int match = re_match (patterns[i].pattern, linebuffer->buffer,
 			    (int)result, 0, &patterns[i].regs);
 	{
 	case -2:
 	  /* Some error. */
 	  if (!patterns[i].error_signaled)
 	    {
-/* To avoid casting an int to a pointer, format the string
+	      error ("error while matching pattern %d", i);
-* here, and pass the address of the string to `error'. */
-char int_string[12];
-sprintf(int_string, "%d", i);
-	      error ("error while matching pattern %s", int_string);
 	      patterns[i].error_signaled = TRUE;
 	    }
 	  break;
 	case -1:
 	  /* No match. */
 			linebuffer->buffer, match, lineno, linecharno);
 	    }
 	  else
 	    {
 	      /* Make an unnamed tag. */
-	      pfnote (NULL, TRUE,
+	      pfnote ((char *)NULL, TRUE,
 		      linebuffer->buffer, match, lineno, linecharno);
 	    }
 	  break;
 	}
 }
 /*
 * Read a file, but do no processing.  This is used to do regexp
 * matching on files that have no language defined.
 */
 void
-just_read_file (FILE *inf)
+just_read_file (inf)
-{
+FILE *inf;
+{
+lineno = 0;
+charno = 0;
 while (!feof (inf))
 {
 ++lineno;
 linecharno = charno;
 charno += readline (&lb, inf) + 1;
 /*
 * Return a pointer to a space of size strlen(cp)+1 allocated
 * with xnew where the string CP has been copied.
 */
 char *
-savestr (CONST char *cp)
+savestr (cp)
+char *cp;
 {
 return savenstr (cp, strlen (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.
 */
 char *
-savenstr (CONST char *cp, int len)
+savenstr (cp, len)
+char *cp;
+int len;
 {
 register char *dp;
 dp = xnew (len + 1, char);
 strncpy (dp, cp, len);
 * appears; NULL if not found
 *
 * Identical to System V strrchr, included for portability.
 */
 char *
-etags_strrchr (CONST char *sp, char c)
+etags_strrchr (sp, c)
-{
+register char *sp, c;
-register CONST char *r;
+{
+register char *r;
 r = NULL;
 do
 {
 if (*sp == c)
 	r = sp;
 } while (*sp++);
-return (char *)r;
+return r;
 }
 /*
 * Return the ptr in sp at which the character c first
 * appears; NULL if not found
 *
 * Identical to System V strchr, included for portability.
 */
 char *
-etags_strchr (CONST char *sp, char c)
+etags_strchr (sp, c)
+register char *sp, c;
 {
 do
 {
 if (*sp == c)
-	return (char *)sp;
+	return sp;
 } while (*sp++);
 return NULL;
 }
 /* Print error message and exit.  */
 void
-fatal (CONST char *s1, CONST char *s2)
+fatal (s1, s2)
+char *s1, *s2;
 {
 error (s1, s2);
 exit (BAD);
 }
 void
-pfatal (CONST char *s1)
+pfatal (s1)
+char *s1;
 {
 perror (s1);
 exit (BAD);
 }
+void
+suggest_asking_for_help ()
+{
+fprintf (stderr, "\tTry `%s --help' for a complete list of options.\n",
+	   progname);
+exit (BAD);
+}
 /* Print error message.  `s1' is printf control string, `s2' is arg for it. */
 void
-error (CONST char *s1, CONST void *s2)
+error (s1, s2)
+char *s1, *s2;
 {
 fprintf (stderr, "%s: ", progname);
 fprintf (stderr, s1, s2);
 fprintf (stderr, "\n");
 }
 /* Return a newly-allocated string whose contents
 concatenate those of s1, s2, s3.  */
 char *
-concat (CONST char *s1, CONST char *s2, CONST char *s3)
+concat (s1, s2, s3)
+char *s1, *s2, *s3;
 {
 int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
 char *result = xnew (len1 + len2 + len3 + 1, char);
 strcpy (result, s1);
 return result;
 }
 /* Does the same work as the system V getcwd, but does not need to
 guess the buffer size in advance. */
-/* Does the same work as the system V getcwd, but does not need to
-guess the buffer size in advance. */
 char *
-etags_getcwd (void)
+etags_getcwd ()
 {
-#ifdef DOS_NT
+#ifdef HAVE_GETCWD
-char *p, path[MAXPATHLEN + 1]; /* Fixed size is safe on MSDOS.  */
-getwd (path);
-p = path;
-while (*p)
-if (*p == '\\')
-*p++ = '/';
-else
-*p++ = lowcase (*p);
-return strdup (path);
-#else /* not DOS_NT */
-#if HAVE_GETCWD
 int bufsize = 200;
 char *path = xnew (bufsize, char);
 while (getcwd (path, bufsize) == NULL)
 {
 	pfatal ("getcwd");
 bufsize *= 2;
 path = xnew (bufsize, char);
 }
+#if WINDOWSNT
+{
+/* Convert backslashes to slashes.  */
+char *p;
+for (p = path; *p != '\0'; p++)
+if (*p == '\\')
+	*p = '/';
+}
+#endif
 return path;
-#else /* not DOS_NT and not HAVE_GETCWD */
+#else /* not HAVE_GETCWD */
+#ifdef MSDOS
+char *p, path[MAXPATHLEN + 1]; /* Fixed size is safe on MSDOS.  */
+getwd (path);
+for (p = path; *p != '\0'; p++)
+if (*p == '\\')
+*p = '/';
+else
+*p = lowcase (*p);
+return strdup (path);
+#else /* not MSDOS */
 struct linebuffer path;
-FILE *paype;
+FILE *pipe;
 initbuffer (&path);
-paype = (FILE *) popen ("pwd 2>/dev/null", "r");
+pipe = (FILE *) popen ("pwd 2>/dev/null", "r");
-if (paype == NULL || readline_internal (&path, paype) == 0)
+if (pipe == NULL || readline_internal (&path, pipe) == 0)
 pfatal ("pwd");
-pclose (paype);
+pclose (pipe);
 return path.buffer;
+#endif /* not MSDOS */
 #endif /* not HAVE_GETCWD */
-#endif /* not DOS_NT */
 }
 /* Return a newly allocated string containing the filename
 of FILE relative to the absolute directory DIR (which
 should end with a slash). */
 char *
-relative_filename (CONST char *file, CONST char *dir)
+relative_filename (file, dir)
-{
+char *file, *dir;
-char *fp;
+{
-CONST char *dp;
+char *fp, *dp, *abs, *res;
-char *abbs, *res;
+/* Find the common root of file and dir (with a trailing slash). */
-/* Find the common root of file and dir. */
+abs = absolute_filename (file, cwd);
-abbs = absolute_filename (file, cwd);
+fp = abs;
-fp = abbs;
 dp = dir;
 while (*fp++ == *dp++)
 continue;
-do
+fp--, dp--;			/* back to the first differing char */
-{
+do				/* look at the equal chars until / */
-fp--;
+fp--, dp--;
-dp--;
-}
 while (*fp != '/');
 /* Build a sequence of "../" strings for the resulting relative filename. */
-for (dp = etags_strchr (dp + 1, '/'), res = (char *) "";
+for (dp = etags_strchr (dp + 1, '/'), res = "";
 dp != NULL;
 dp = etags_strchr (dp + 1, '/'))
 {
 res = concat (res, "../", "");
 }
 /* Add the filename relative to the common root of file and dir. */
 res = concat (res, fp + 1, "");
-free (abbs);
+free (abs);
 return res;
 }
 /* Return a newly allocated string containing the
 absolute filename of FILE given CWD (which should
 end with a slash). */
 char *
-absolute_filename (CONST char *file, CONST char *cwwd)
+absolute_filename (file, cwd)
+char *file, *cwd;
 {
 char *slashp, *cp, *res;
 if (absolutefn (file))
 res = concat (file, "", "");
+#ifdef DOS_NT
+/* We don't support non-absolute filenames with a drive
+letter, like `d:NAME' (it's too much hassle).  */
+else if (file[1] == ':')
+fatal ("%s: relative filenames with drive letters not supported", file);
+#endif
 else
-res = concat (cwwd, file, "");
+res = concat (cwd, file, "");
 /* Delete the "/dirname/.." and "/." substrings. */
 slashp = etags_strchr (res, '/');
 while (slashp != NULL && slashp[0] != '\0')
 {
 	      && (slashp[3] == '/' || slashp[3] == '\0'))
 	    {
 	      cp = slashp;
 	      do
 		cp--;
-	      while (cp >= res && *cp != '/');
+	      while (cp >= res && !absolutefn (cp));
 	      if (*cp == '/')
 		{
 		  strcpy (cp, slashp + 3);
 		}
+#ifdef DOS_NT
+	      /* Under MSDOS and NT we get `d:/NAME' as absolute
+		 filename, so the luser could say `d:/../NAME'.
+		 We silently treat this as `d:/NAME'.  */
+	      else if (cp[1] == ':')
+		strcpy (cp + 3, slashp + 4);
+#endif
 	      else		/* else (cp == res) */
 		{
 		  if (slashp[3] != '\0')
 		    strcpy (cp, slashp + 4);
 		  else
-		    return (char *) ".";
+		    return ".";
 		}
 	      slashp = cp;
 	      continue;
 	    }
 	  else if (slashp[2] == '/' || slashp[2] == '\0')
 /* Return a newly allocated string containing the absolute
 filename of dir where FILE resides given CWD (which should
 end with a slash). */
 char *
-absolute_dirname (char *file, CONST char *cwwd)
+absolute_dirname (file, cwd)
+char *file, *cwd;
 {
 char *slashp, *res;
 char save;
+#ifdef DOS_NT
+char *p;
+for (p = file; *p != '\0'; p++)
+if (*p == '\\')
+*p = '/';
+#endif
 slashp = etags_strrchr (file, '/');
 if (slashp == NULL)
-return (char *) cwwd;
+return cwd;
 save = slashp[1];
 slashp[1] = '\0';
-res = absolute_filename (file, cwwd);
+res = absolute_filename (file, cwd);
 slashp[1] = save;
 return res;
 }
+/* Increase the size of a linebuffer. */
+void
+grow_linebuffer (bufp, toksize)
+struct linebuffer *bufp;
+int toksize;
+{
+while (bufp->size < toksize)
+bufp->size *= 2;
+bufp->buffer = (char *) xrealloc (bufp->buffer, bufp->size);
+}
 /* Like malloc but get fatal error if memory is exhausted.  */
-void *
+long *
-xmalloc (unsigned int size)
+xmalloc (size)
-{
+unsigned int size;
-void *result = malloc (size);
+{
+long *result = (long *) malloc (size);
 if (result == NULL)
-fatal ("virtual memory exhausted", 0);
+fatal ("virtual memory exhausted", (char *)NULL);
 return result;
 }
-void *
+long *
-xrealloc (void *ptr, unsigned int size)
+xrealloc (ptr, size)
-{
+char *ptr;
-void *result = realloc (ptr, size);
+unsigned int size;
+{
+long *result =  (long *) realloc (ptr, size);
 if (result == NULL)
-fatal ("virtual memory exhausted", 0);
+fatal ("virtual memory exhausted", (char *)NULL);
 return result;
 }

Mercurial > hg > xemacs-beta

comparison lib-src/etags.c @ 4:b82b59fe008d r19-15b3