* etags.c (Cplusplus_suffixes): Add .M suffix for Objective C++.

	(gperf): Added keywords for Objective C and GNU macros.
	(sym_type): Added values to account for Objective C and GNU macros.
	(begtk): The '@' character can start a token.
	(objdef, methodlen, objtag): New variables for Objective C.
	(consider_token, C_entries): Added code for Objective C.
	(plain_C_suffixes): Add .m and .lm for Objective C.
	(Yacc_suffixes): Add .ym for Objective yacc.
	(GROW_LINEBUFFER): New macro.
	(consider_token, C_entries, Pascal_functions): Use the new macro.
	(consider_token): Take one more argument.  Caller changed.
	(consider_token): Use the hashing function to spot GNU macros.
	(C_entries): Consider // as a comment start even in plain C for
	the sake of Objective C parsing.
	(pfnote): Don't make a tag for ctags if there is no name.
	(getit, Asm_labels, Perl_functions, Pascal_functions, L_getit,
	get_scheme, prolog_getit): Name the tag in ctags mode.
	(pfnote): Truncate ctags lines to 50 chars, like it worked once.
	(Perl_interpreters): Accept "@PERL@" as an interpreter.
	(suggest_asking_for_help): New function.
	(main, get_language_from_name): Use suggest_asking_for_help.
	(main): Let get_language_from_name make language existence check.
	(streq, strneq): Check the arguments #if DEBUG.

1 files changed, 417 insertions, 227 deletions

diff --git a/lib-src/etags.c b/lib-src/etags.c
index 61218c90f1d..7a7c30b157d 100644
--- a/lib-src/etags.c
+++ b/lib-src/etags.c
@@ -25,17 +25,16 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  *	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.
  */
 
-char pot_etags_version[] = "@(#) pot revision number is 11.45";
+char pot_etags_version[] = "@(#) pot revision number is 11.53";
 
 #define	TRUE	1
 #define	FALSE	0
+
 #ifndef DEBUG
 # define DEBUG FALSE
 #endif
@@ -102,8 +101,8 @@ extern int errno;
 #define C_STAR	0x00003		/* C* */
 #define YACC	0x10000		/* yacc file */
 
-#define streq(s,t)	(strcmp (s, t) == 0)
-#define strneq(s,t,n)	(strncmp (s, t, n) == 0)
+#define streq(s,t)	((DEBUG &&!(s)&&!(t)&&(abort(),1)) || !strcmp(s,t))
+#define strneq(s,t,n)	((DEBUG &&!(s)&&!(t)&&(abort(),1)) || !strncmp(s,t,n))
 
 #define lowcase(c)	tolower ((unsigned char)c)
 
@@ -129,7 +128,7 @@ extern int errno;
 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	*/
@@ -194,6 +193,7 @@ void add_regex ();
 #endif
 void add_node ();
 void error ();
+void suggest_asking_for_help ();
 void fatal (), pfatal ();
 void find_entries ();
 void free_tree ();
@@ -228,6 +228,9 @@ NODE *head;			/* the head of the binary tree of tags */
  * `readline' reads a line from a stream into a linebuffer and works
  * regardless of the length of the line.
  */
+#define GROW_LINEBUFFER(buf,toksize)					\
+while (buf.size < toksize)						\
+  buf.buffer = (char *) xrealloc (buf.buffer, buf.size *= 2)
 struct linebuffer
 {
   long size;
@@ -235,7 +238,7 @@ struct linebuffer
 };
 
 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;
@@ -245,12 +248,14 @@ struct
 /* boolean "functions" (see init)	*/
 logical _wht[0177], _etk[0177], _itk[0177], _btk[0177];
 char
- *white = " \f\t\n\013",	/* white chars				*/
- *endtk = " \t\n\013\"'#()[]{}=-+%*/&|^~!<>;,.:?", /* token ending chars */
-				/* token starting chars			*/
- *begtk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$~",
-				/* valid in-token chars			*/
- *intk = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz$0123456789";
+  /* white chars */
+  *white = " \f\t\n\013",
+  /* token ending chars */
+  *endtk = " \t\n\013\"'#()[]{}=-+%*/&|^~!<>;,.:?",
+  /* token starting chars */
+  *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.  */
@@ -334,52 +339,45 @@ char *Asm_suffixes [] = { "a",	/* Unix assembler */
 char *default_C_suffixes [] =
   { "c", "h", NULL };
 
-/* C++ file */
+/* .M is for Objective C++ files. */
 char *Cplusplus_suffixes [] =
-  { "C", "H", "c++", "cc", "cpp", "cxx", "h++", "hh", "hpp", "hxx", NULL };
+  { "C", "H", "c++", "cc", "cpp", "cxx", "h++", "hh", "hpp", "hxx", "M", NULL};
 
-/* C* file */
 char *Cstar_suffixes [] =
   { "cs", "hs", NULL };
 
-/* Fortran */
 char *Fortran_suffixes [] =
   { "F", "f", "f90", "for", NULL };
 
-/* Lisp source code */
 char *Lisp_suffixes [] =
   { "cl", "clisp", "el", "l", "lisp", "lsp", "ml", NULL };
 
-/* Pascal file */
 char *Pascal_suffixes [] =
   { "p", "pas", NULL };
 
-/* Perl file */
 char *Perl_suffixes [] =
   { "pl", "pm", NULL };
 char *Perl_interpreters [] =
-  { "perl", NULL };
+  { "perl", "@PERL@", NULL };
 
-/* Pro*C file. */
 char *plain_C_suffixes [] =
-  { "pc", NULL };
+  { "pc",			/* Pro*C file */
+    "m",			/* Objective C file */
+    "lm",			/* Objective lex file */
+     NULL };
 
-/* Prolog source code */
 char *Prolog_suffixes [] =
   { "prolog", NULL };
 
-/* Scheme source code */
-/* FIXME Can't do the `SCM' or `scm' prefix with a version number */
+/* Can't do the `SCM' or `scm' prefix with a version number. */
 char *Scheme_suffixes [] =
   { "SCM", "SM", "oak", "sch", "scheme", "scm", "sm", "t", NULL };
 
-/* TeX/LaTeX source code */
 char *TeX_suffixes [] =
-  { "bib", "clo", "cls", "ltx", "sty", "TeX", "tex", NULL };
+  { "TeX", "bib", "clo", "cls", "ltx", "sty", "tex", NULL };
 
-/* Yacc file */
 char *Yacc_suffixes [] =
-  { "y", NULL };
+  { "y", "ym", NULL };		/* .ym is Objective yacc file */
 
 /* Table of language names and corresponding functions, file suffixes
    and interpreter names.
@@ -395,22 +393,22 @@ struct lang_entry
 
 struct lang_entry lang_names [] =
 {
-  { "asm", Asm_labels, Asm_suffixes },
-  { "c", default_C_entries, default_C_suffixes },
-  { "c++", Cplusplus_entries, Cplusplus_suffixes },
-  { "c*", Cstar_entries, Cstar_suffixes },
-  { "fortran", Fortran_functions, Fortran_suffixes },
-  { "lisp", Lisp_functions, Lisp_suffixes },
-  { "pascal", Pascal_functions, Pascal_suffixes },
-  { "perl", Perl_functions, Perl_suffixes, Perl_interpreters },
-  { "proc", plain_C_entries, plain_C_suffixes },
-  { "prolog", Prolog_functions, Prolog_suffixes },
-  { "scheme" , Scheme_functions, Scheme_suffixes },
-  { "tex", TeX_functions, TeX_suffixes },
-  { "yacc", Yacc_entries, Yacc_suffixes },
-  { "auto", NULL },		/* default guessing scheme */
-  { "none", just_read_file },	/* regexp matching only */
-  { NULL, NULL }		/* end of list */
+  { "asm",     Asm_labels,	    Asm_suffixes,	  NULL              },
+  { "c",       default_C_entries,   default_C_suffixes,	  NULL              },
+  { "c++",     Cplusplus_entries,   Cplusplus_suffixes,	  NULL              },
+  { "c*",      Cstar_entries,	    Cstar_suffixes,	  NULL              },
+  { "fortran", Fortran_functions,   Fortran_suffixes,	  NULL              },
+  { "lisp",    Lisp_functions,	    Lisp_suffixes,	  NULL              },
+  { "pascal",  Pascal_functions,    Pascal_suffixes,	  NULL              },
+  { "perl",    Perl_functions,	    Perl_suffixes,	  Perl_interpreters },
+  { "proc",    plain_C_entries,	    plain_C_suffixes,	  NULL              },
+  { "prolog",  Prolog_functions,    Prolog_suffixes,	  NULL              },
+  { "scheme",  Scheme_functions,    Scheme_suffixes,	  NULL              },
+  { "tex",     TeX_functions,	    TeX_suffixes,	  NULL              },
+  { "yacc",    Yacc_entries,	    Yacc_suffixes,	  NULL              },
+  { "auto", NULL },             /* default guessing scheme */
+  { "none", just_read_file },   /* regexp matching only */
+  { NULL, NULL }                /* end of list */
 };
 
 
@@ -763,7 +761,7 @@ main (argc, argv)
 	    {
 	      fprintf (stderr, "%s: -%c option may only be given once.\n",
 		       progname, opt);
-	      goto usage;
+	      suggest_asking_for_help ();
 	    }
 	  tagfile = optarg;
 	  break;
@@ -773,12 +771,6 @@ main (argc, argv)
 	  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;
@@ -831,7 +823,7 @@ main (argc, argv)
 	  break;
 #endif /* CTAGS */
 	default:
-	  goto usage;
+	  suggest_asking_for_help ();
 	}
     }
 
@@ -846,11 +838,7 @@ main (argc, argv)
   if (nincluded_files == 0 && file_count == 0)
     {
       fprintf (stderr, "%s: No input files specified.\n", progname);
-
-    usage:
-      fprintf (stderr, "\tTry `%s --help' for a complete list of options.\n",
-	       progname);
-      exit (BAD);
+      suggest_asking_for_help ();
     }
 
   if (tagfile == NULL)
@@ -992,15 +980,22 @@ get_language_from_name (name)
 {
   struct lang_entry *lang;
 
-  if (name == NULL)
-    return NULL;
-  for (lang = lang_names; lang->name != NULL; lang++)
-    {
-      if (streq (name, lang->name))
-	return lang->function;
-    }
+  if (name != NULL)
+    for (lang = lang_names; lang->name != NULL; lang++)
+      {
+	if (streq (name, lang->name))
+	  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 */
 }
 
 
@@ -1145,6 +1140,7 @@ find_entries (file, inf)
   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. */
@@ -1222,14 +1218,19 @@ find_entries (file, inf)
 /* Record a tag. */
 void
 pfnote (name, is_func, linestart, linelen, lno, cno)
-     char *name;		/* tag name, if different from definition */
+     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 */
 {
-  register NODE *np = xnew (1, NODE);
+  register NODE *np;
+
+  if (CTAGS && name == NULL)
+    return;
+
+  np = xnew (1, NODE);
 
   /* If ctags mode, change name "main" to M<thisfilename>. */
   if (CTAGS && !cxref_style && streq (name, "main"))
@@ -1253,7 +1254,15 @@ pfnote (name, is_func, linestart, linelen, lno, cno)
      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);
 }
@@ -1369,36 +1378,44 @@ put_entries (node)
 	fprintf (tagf, "%s\177%d,%d\n",
 		 node->pat, node->lno, node->cno);
     }
-  else if (!cxref_style)
+  else
     {
-      fprintf (tagf, "%s\t%s\t",
-	       node->name, node->file);
-
-      if (node->is_func)
-	{			/* a function */
-	  putc (searchar, tagf);
-	  putc ('^', tagf);
+      if (node->name == NULL)
+	error ("internal error: NULL name in ctags mode.", 0);
 
-	  for (sp = node->pat; *sp; sp++)
-	    {
-	      if (*sp == '\\' || *sp == searchar)
-		putc ('\\', tagf);
-	      putc (*sp, tagf);
-	    }
-	  putc (searchar, tagf);
+      if (cxref_style)
+	{
+	  if (vgrind_style)
+	    fprintf (stdout, "%s %s %d\n",
+		     node->name, node->file, (node->lno + 63) / 64);
+	  else
+	    fprintf (stdout, "%-16s %3d %-16s %s\n",
+		     node->name, node->lno, node->file, node->pat);
 	}
       else
-	{			/* a typedef; text pattern inadequate */
-	  fprintf (tagf, "%d", node->lno);
+	{
+	  fprintf (tagf, "%s\t%s\t", node->name, node->file);
+
+	  if (node->is_func)
+	    {			/* a function */
+	      putc (searchar, tagf);
+	      putc ('^', tagf);
+
+	      for (sp = node->pat; *sp; sp++)
+		{
+		  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);
 	}
-      putc ('\n', tagf);
     }
-  else if (vgrind_style)
-    fprintf (stdout, "%s %s %d\n",
-	     node->name, node->file, (node->lno + 63) / 64);
-  else
-    fprintf (stdout, "%-16s %3d %-16s %s\n",
-	     node->name, node->lno, node->file, node->pat);
 
   /* Output subentries that follow this one */
   put_entries (node->right);
@@ -1454,7 +1471,8 @@ total_size_of_entries (node)
  */
 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:
@@ -1462,6 +1480,10 @@ enum sym_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
 domain, 	C_STAR,	st_C_struct
 union,  	0,	st_C_struct
@@ -1483,6 +1505,15 @@ extern,  	0,	st_C_typespec
 static,  	0,	st_C_typespec
 const,   	0,	st_C_typespec
 volatile,	0,	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. */
 /*%<*/
@@ -1493,12 +1524,12 @@ and replace lines between %< and %> with its output. */
 struct C_stab_entry { char *name; int c_ext; enum sym_type type; };
 
 #define MIN_WORD_LENGTH 3
-#define MAX_WORD_LENGTH 8
-#define MIN_HASH_VALUE 10
-#define MAX_HASH_VALUE 62
+#define MAX_WORD_LENGTH 15
+#define MIN_HASH_VALUE 7
+#define MAX_HASH_VALUE 63
 /*
-   21 keywords
-   53 is the maximum key range
+   29 keywords
+   57 is the maximum key range
 */
 
 static int
@@ -1508,19 +1539,19 @@ hash (str, len)
 {
   static unsigned char hash_table[] =
     {
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
-     62, 62, 62, 62, 62, 62, 62,  2, 62,  7,
-      6,  9, 15, 30, 62, 24, 62, 62,  1, 24,
-      7, 27, 13, 62, 19, 26, 18, 27,  1, 62,
-     62, 62, 62, 62, 62, 62, 62, 62,
+     63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+     63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+     63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+     63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+     63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+     63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+     63, 63, 63, 63, 17, 63, 63, 63,  4, 14,
+      4, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+      8, 63, 63,  0, 23, 63, 63, 63, 63, 63,
+     63, 63, 63, 63, 63, 63, 63, 28, 63, 28,
+     10, 31, 27, 18, 63,  6, 63, 63, 26,  1,
+     11,  2, 29, 63, 29, 16, 26, 13, 15, 63,
+     63, 63, 63, 63, 63, 63, 63, 63,
   };
   return len + hash_table[str[2]] + hash_table[str[0]];
 }
@@ -1533,43 +1564,47 @@ in_word_set  (str, len)
 
   static struct C_stab_entry  wordlist[] =
     {
-      {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
-      {"",},
-      {"volatile", 	0,	st_C_typespec},
-      {"",},
-      {"long",     	0,	st_C_typespec},
-      {"char",     	0,	st_C_typespec},
-      {"class",   	C_PLPL,	st_C_struct},
-      {"",}, {"",}, {"",}, {"",},
-      {"const",    	0,	st_C_typespec},
-      {"",}, {"",}, {"",}, {"",},
-      {"auto",     	0,	st_C_typespec},
-      {"",}, {"",},
-      {"define",   	0,	st_C_define},
-      {"",},
-      {"void",     	0,	st_C_typespec},
+      {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
+      {"SYSCALL", 	0,	st_C_gnumacro},
+      {"",}, {"",}, {"",}, {"",}, {"",},
+      {"DEFUN", 		0,	st_C_gnumacro},
       {"",}, {"",}, {"",},
-      {"extern",   	0,	st_C_typespec},
-      {"static",   	0,	st_C_typespec},
-      {"",},
       {"domain",  	C_STAR,	st_C_struct},
-      {"",},
-      {"typedef",  	0,	st_C_typedef},
+      {"",}, {"",}, {"",}, {"",}, {"",},
+      {"short",    	0,	st_C_typespec},
+      {"union",   	0,	st_C_struct},
+      {"void",     	0,	st_C_typespec},
+      {"",}, {"",},
+      {"PSEUDO", 		0,	st_C_gnumacro},
       {"double",   	0,	st_C_typespec},
-      {"enum",     	0,	st_C_enum},
-      {"",}, {"",}, {"",}, {"",},
+      {"",}, {"",},
+      {"@end", 		0,	st_C_objend},
+      {"@implementation", 0,	st_C_objimpl},
+      {"float",    	0,	st_C_typespec},
       {"int",      	0,	st_C_typespec},
       {"",},
-      {"float",    	0,	st_C_typespec},
+      {"unsigned", 	0,	st_C_typespec},
+      {"@interface", 	0,	st_C_objprot},
+      {"",},
+      {"signed",   	0,	st_C_typespec},
+      {"long",     	0,	st_C_typespec},
+      {"ENTRY", 		0,	st_C_gnumacro},
+      {"define",   	0,	st_C_define},
+      {"const",    	0,	st_C_typespec},
       {"",}, {"",}, {"",},
+      {"enum",     	0,	st_C_enum},
+      {"volatile", 	0,	st_C_typespec},
+      {"static",   	0,	st_C_typespec},
       {"struct",  	0,	st_C_struct},
-      {"",}, {"",}, {"",}, {"",},
-      {"union",   	0,	st_C_struct},
-      {"",},
-      {"short",    	0,	st_C_typespec},
+      {"",}, {"",}, {"",},
+      {"@protocol", 	0,	st_C_objprot},
       {"",}, {"",},
-      {"unsigned", 	0,	st_C_typespec},
-      {"signed",   	0,	st_C_typespec},
+      {"auto",     	0,	st_C_typespec},
+      {"",},
+      {"char",     	0,	st_C_typespec},
+      {"class",   	C_PLPL,	st_C_struct},
+      {"typedef",  	0,	st_C_typedef},
+      {"extern",   	0,	st_C_typespec},
     };
 
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
@@ -1580,7 +1615,7 @@ in_word_set  (str, len)
         {
           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];
         }
     }
@@ -1605,7 +1640,7 @@ C_symtype(str, len, c_ext)
   * 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 */
@@ -1613,23 +1648,21 @@ typedef enum
   finlist,			/* in parameter list */
   flistseen,			/* after parameter list */
   fignore			/* before open brace */
-} FUNCST;
-FUNCST funcdef;
+} funcdef;
 
 
  /*
   * typedefs are recognized using a simple finite automaton.
   * typeddef 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;
-TYPEDST typdef;
+} typdef;
 
 
  /*
@@ -1637,15 +1670,14 @@ TYPEDST typdef;
   * 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;
-STRUCTST structdef;
+} structdef;
 
 /*
  * When structdef is stagseen, scolonseen, or sinbody, structtag is the
@@ -1656,16 +1688,39 @@ 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;
-DEFINEST definedef;
+} 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.
@@ -1679,6 +1734,11 @@ logical next_token_is_func;
 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
@@ -1697,16 +1757,18 @@ logical yacc_rules;
  *	structdef		IN OUT
  *	definedef		IN OUT
  *	typdef			IN OUT
+ *	objdef			IN OUT
  *	next_token_is_func	IN OUT
  */
 
 logical
-consider_token (str, len, c, c_ext, cblev, is_func)
+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 */
 {
   enum sym_type toktype = C_symtype (str, len, c_ext);
@@ -1831,22 +1893,11 @@ consider_token (str, len, c, c_ext, cblev, is_func)
     }
 
   /* Detect GNU macros. */
-  if (definedef == dnone)
-    if (strneq (str, "DEFUN", len)	/* Used in emacs */
-#if FALSE
-	   These are defined inside C functions, so currently they
-	   are not met anyway.
-	|| strneq (str, "EXFUN", len) /* Used in glibc */
-	|| strneq (str, "DEFVAR_", 7) /* Used in emacs */
-#endif
-	|| strneq (str, "SYSCALL", len) /* Used in glibc (mach) */
-	|| strneq (str, "ENTRY", len) /* Used in glibc */
-	|| strneq (str, "PSEUDO", len)) /* Used in glibc */
-
-      {
-	next_token_is_func = TRUE;
-	return FALSE;
-      }
+  if (definedef == dnone && toktype == st_C_gnumacro)
+    {
+      next_token_is_func = TRUE;
+      return FALSE;
+    }
   if (next_token_is_func)
     {
       next_token_is_func = FALSE;
@@ -1855,6 +1906,78 @@ consider_token (str, len, c, c_ext, cblev, is_func)
       return TRUE;
     }
 
+  /*
+   * Detecting 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 lenghts of the
+	     class tags.
+	  free (objtag); */
+	  objdef = onone;
+	}
+      return FALSE;
+    }
+
   /* A function? */
   switch (toktype)
     {
@@ -1922,16 +2045,14 @@ do {									\
   definedef = dnone;							\
 } while (0)
 
+/* Ideally this macro should never be called wihen tok.valid is FALSE,
+   but this would mean that the state machines always guess right. */
 #define make_tag(isfun)  do \
-{									\
-  if (tok.valid)							\
-    {									\
-      char *name = NULL;						\
-      if (tok.named)							\
-	name = savestr (token_name.buffer);				\
-      pfnote (name, isfun, tok.buffer, tok.linelen, tok.lineno, tok.linepos); \
-    }									\
-  else if (DEBUG) abort ();						\
+if (tok.valid) {							\
+  char *name = NULL;							\
+  if (CTAGS || tok.named)						\
+    name = savestr (token_name.buffer);					\
+  pfnote (name, isfun, tok.buffer, tok.linelen, tok.lineno, tok.linepos); \
   tok.valid = FALSE;							\
 } while (0)
 
@@ -1959,7 +2080,8 @@ C_entries (c_ext, inf)
   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;
@@ -2052,9 +2174,9 @@ C_entries (c_ext, inf)
 		incomm = TRUE;
 		continue;
 	      }
-	    else if (cplpl && *lp == '/')
+	    else if (/* cplpl && */ *lp == '/')
 	      {
-		c = 0;
+		c = '\0';
 		break;
 	      }
 	    else
@@ -2114,7 +2236,7 @@ C_entries (c_ext, inf)
 	    {
 	      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
@@ -2128,37 +2250,43 @@ C_entries (c_ext, inf)
 		      logical is_func = FALSE;
 
 		      if (yacc_rules
-			  || consider_token (newlb.buffer + tokoff, toklen,
-					     c, c_ext, cblev, &is_func))
+			  || consider_token (newlb.buffer + tokoff, toklen, c,
+					     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;
-			      while (token_name.size < strsize)
-				{
-				  token_name.size *= 2;
-				  token_name.buffer
-				    = (char *) xrealloc (token_name.buffer,
-							 token_name.size);
-				}
+			      GROW_LINEBUFFER (token_name,
+					       strlen(structtag)+2+toklen+1);
 			      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)
-				{
-				  token_name.size *= 2;
-				  token_name.buffer
-				    = (char *) xrealloc (token_name.buffer,
-							 token_name.size);
-				}
+			      GROW_LINEBUFFER (token_name, toklen+1);
 			      strncpy (token_name.buffer,
 				       newlb.buffer+tokoff, toklen);
 			      token_name.buffer[toklen] = '\0';
@@ -2179,7 +2307,8 @@ C_entries (c_ext, inf)
 			  if (definedef == dnone
 			      && (funcdef == ftagseen
 				  || structdef == stagseen
-				  || typdef == tend))
+				  || typdef == tend
+				  || objdef != onone))
 			    {
 			      if (current_lb_is_new)
 				switch_line_buffers ();
@@ -2238,6 +2367,20 @@ C_entries (c_ext, inf)
 	case ':':
 	  if (definedef != dnone)
 	    break;
+	  switch (objdef)
+	    {
+	    case  otagseen:
+	      objdef = oignore;
+	      make_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
@@ -2281,6 +2424,14 @@ C_entries (c_ext, inf)
 	case ',':
 	  if (definedef != dnone)
 	    break;
+	  switch (objdef)
+	    {
+	    case omethodtag:
+	    case omethodparm:
+	      make_tag (TRUE);
+	      objdef = oinbody;
+	      break;
+	    }
 	  if (funcdef != finlist && funcdef != fignore)
 	    funcdef = fnone;
 	  if (structdef == stagseen)
@@ -2303,6 +2454,8 @@ C_entries (c_ext, inf)
 	case '(':
 	  if (definedef != dnone)
 	    break;
+	  if (objdef == otagseen && parlev == 0)
+	    objdef = oparenseen;
 	  switch (funcdef)
 	    {
 	    case fnone:
@@ -2333,6 +2486,11 @@ C_entries (c_ext, inf)
 	case ')':
 	  if (definedef != dnone)
 	    break;
+	  if (objdef == ocatseen && parlev == 1)
+	    {
+	      make_tag (TRUE);
+	      objdef = oignore;
+	    }
 	  if (--parlev == 0)
 	    {
 	      switch (funcdef)
@@ -2377,9 +2535,22 @@ C_entries (c_ext, inf)
 	      funcdef = fnone;
 	      break;
 	    case fnone:
-	      /* Neutralize `extern "C" {' grot and look inside structs. */
-	      if (cblev == 0 && structdef == snone && typdef == tnone)
-		cblev = -1;
+	      switch (objdef)
+		{
+		case otagseen:
+		  make_tag (TRUE);
+		  objdef = oignore;
+		  break;
+		case omethodtag:
+		case omethodparm:
+		  make_tag (TRUE);
+		  objdef = oinbody;
+		  break;
+		default:
+		  /* Neutralize `extern "C" {' grot and look inside structs. */
+		  if (cblev == 0 && structdef == snone && typdef == tnone)
+		    cblev = -1;
+		}
 	    }
 	  cblev++;
 	  break;
@@ -2415,8 +2586,15 @@ C_entries (c_ext, inf)
 	      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;
@@ -2425,6 +2603,11 @@ C_entries (c_ext, inf)
 	    funcdef = fnone;
 	  break;
 	case '\0':
+	  if (objdef == otagseen)
+	    {
+	      make_tag (TRUE);
+	      objdef = oignore;
+	    }
 	  /* If a macro spans multiple lines don't reset its state. */
 	  if (quotednl)
 	    CNL_SAVE_DEFINEDEF;
@@ -2553,7 +2736,8 @@ getit (inf)
 	&& (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
@@ -2669,7 +2853,7 @@ Asm_labels (inf)
  	  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);
  	    }
  	}
@@ -2702,7 +2886,7 @@ Perl_functions (inf)
 	    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);
 	}
     }
@@ -2731,7 +2915,7 @@ Pascal_functions (inf)
   struct linebuffer tline;	/* mostly copied from C_entries */
   long save_lcno;
   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 */
@@ -2845,32 +3029,27 @@ Pascal_functions (inf)
 	    {
 	      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;
-	  while (size > tline.size)
-	    {
-	      tline.size *= 2;
-	      tline.buffer = (char *) xrealloc (tline.buffer, tline.size);
-	    }
+	  GROW_LINEBUFFER (tline, strlen (lb.buffer) + 1);
 	  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;
@@ -2943,7 +3122,8 @@ L_getit ()
   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
@@ -3060,7 +3240,8 @@ get_scheme ()
        *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.  */
@@ -3319,7 +3500,8 @@ prolog_getit (s)
       else
 	s++;
     }
-  pfnote (NULL, TRUE, save_s, s-save_s, lineno, linecharno);
+  pfnote ((CTAGS) ? savenstr (save_s, s-save_s) : NULL, TRUE,
+	  save_s, s-save_s, lineno, linecharno);
 }
 
 /* It is assumed that prolog predicate starts from column 0. */
@@ -3604,10 +3786,10 @@ readline (linebuffer, stream)
      FILE *stream;
 {
   /* Read new line. */
-  int i;
   long result = readline_internal (linebuffer, stream);
-
 #ifdef ETAGS_REGEXPS
+  int i;
+
   /* Match against all listed patterns. */
   for (i = 0; i < num_patterns; ++i)
     {
@@ -3754,6 +3936,14 @@ pfatal (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 (s1, s2)