emacs: lib-src/etags.c comparison

comparison lib-src/etags.c @ 90234:b1c1fc853d2f

Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-86 Merge from emacs--cvs-trunk--0 Patches applied: * emacs--cvs-trunk--0 (patch 562-568) - Update from CVS - Merge from gnus--rel--5.10 * gnus--rel--5.10 (patch 125-128) - Merge from emacs--cvs-trunk--0 - Update from CVS

author	Miles Bader <miles@gnu.org>
date	Fri, 30 Sep 2005 11:43:45 +0000
parents	2d92f5c9d6ae fbae8bd411de
children	0ca0d9181b5e

comparison

equal deleted inserted replaced

-:ee12d75eb214
+:b1c1fc853d2f
 * If you want to add support for a new language, start by looking at the LUA
 * language, which is the simplest.  Alternatively, consider shipping a
 * configuration file containing regexp definitions for etags.
 */
-char pot_etags_version[] = "@(#) pot revision number is 17.5";
+char pot_etags_version[] = "@(#) pot revision number is 17.14";
 #define	TRUE	1
 #define	FALSE	0
 #ifdef DEBUG
 static void Cjava_entries __P((FILE *));
 static void Cobol_paragraphs __P((FILE *));
 static void Cplusplus_entries __P((FILE *));
 static void Cstar_entries __P((FILE *));
 static void Erlang_functions __P((FILE *));
+static void Forth_words __P((FILE *));
 static void Fortran_functions __P((FILE *));
 static void HTML_labels __P((FILE *));
 static void Lisp_functions __P((FILE *));
 static void Lua_functions __P((FILE *));
 static void Makefile_targets __P((FILE *));
 #endif /* ETAGS_REGEXPS */
 #if LONG_OPTIONS
 static struct option longopts[] =
 {
+{ "append",		  no_argument,	     NULL,	     	 'a'   },
 { "packages-only",      no_argument,	     &packages_only, 	 TRUE  },
 { "c++",		  no_argument,	     NULL,	     	 'C'   },
 { "declarations",	  no_argument,	     &declarations,  	 TRUE  },
 { "no-line-directive",  no_argument,	     &no_line_directive, TRUE  },
 { "help",		  no_argument,	     NULL,     	     	 'h'   },
 { "ignore-case-regex",  required_argument, NULL,	     	 'c'   },
 #endif /* ETAGS_REGEXPS */
 { "parse-stdin",        required_argument, NULL,               STDIN },
 { "version",		  no_argument,	     NULL,     	     	 'V'   },
-#if CTAGS /* Etags options */
+#if CTAGS /* Ctags options */
 { "backward-search",	  no_argument,	     NULL,	     	 'B'   },
 { "cxref",		  no_argument,	     NULL,	     	 'x'   },
 { "defines",		  no_argument,	     NULL,	     	 'd'   },
 { "globals",		  no_argument,	     &globals, 	     	 TRUE  },
 { "typedefs",		  no_argument,	     NULL,	     	 't'   },
 { "typedefs-and-c++",	  no_argument,	     NULL,     	     	 'T'   },
 { "update",		  no_argument,	     NULL,     	     	 'u'   },
 { "vgrind",		  no_argument,	     NULL,     	     	 'v'   },
 { "no-warn",		  no_argument,	     NULL,	     	 'w'   },
-#else /* Ctags options */
+#else /* Etags options */
-{ "append",		  no_argument,	     NULL,	     	 'a'   },
 { "no-defines",	  no_argument,	     NULL,	     	 'D'   },
 { "no-globals",	  no_argument,	     &globals, 	     	 FALSE },
 { "include",		  required_argument, NULL,     	     	 'i'   },
 #endif
 { NULL }
 { "erl", "hrl", NULL };
 static char Erlang_help [] =
 "In Erlang code, the tags are the functions, records and macros\n\
 defined in the file.";
+char *Forth_suffixes [] =
+{ "fth", "tok", NULL };
+static char Forth_help [] =
+"In Forth code, tags are words defined by `:',\n\
+constant, code, create, defer, value, variable, buffer:, field.";
 static char *Fortran_suffixes [] =
 { "F", "f", "f90", "for", NULL };
 static char Fortran_help [] =
 "In Fortran code, functions, subroutines and block data are tags.";
 { "c",         default_C_help, default_C_entries, default_C_suffixes },
 { "c++",       Cplusplus_help, Cplusplus_entries, Cplusplus_suffixes },
 { "c*",        no_lang_help,   Cstar_entries,     Cstar_suffixes     },
 { "cobol",     Cobol_help,     Cobol_paragraphs,  Cobol_suffixes     },
 { "erlang",    Erlang_help,    Erlang_functions,  Erlang_suffixes    },
+{ "forth",     Forth_help,     Forth_words,       Forth_suffixes     },
 { "fortran",   Fortran_help,   Fortran_functions, Fortran_suffixes   },
 { "html",      HTML_help,      HTML_labels,       HTML_suffixes      },
 { "java",      Cjava_help,     Cjava_entries,     Cjava_suffixes     },
 { "lisp",      Lisp_help,      Lisp_functions,    Lisp_suffixes      },
 { "lua",       Lua_help,       Lua_functions,     Lua_suffixes       },
 linked with GNU getopt.");
 puts ("  A - as file name means read names from stdin (one per line).\n\
 Absolute names are stored in the output file as they are.\n\
 Relative ones are stored relative to the output file's directory.\n");
-if (!CTAGS)
+puts ("-a, --append\n\
-puts ("-a, --append\n\
 Append tag entries to existing tags file.");
 puts ("--packages-only\n\
 For Ada files, only generate tags for packages.");
 {
 typedefs = typedefs_or_cplusplus = constantypedefs = TRUE;
 globals = TRUE;
 }
+/* When the optstring begins with a '-' getopt_long does not rearrange the
+non-options arguments to be at the end, but leaves them alone. */
 optstring = "-";
 #ifdef ETAGS_REGEXPS
 optstring = "-r:Rc:";
 #endif /* ETAGS_REGEXPS */
 if (!LONG_OPTIONS)
-optstring += 1;
+optstring += 1;		/* remove the initial '-' */
 optstring = concat (optstring,
-		      "Cf:Il:o:SVhH",
+		      "aCf:Il:o:SVhH",
-		      (CTAGS) ? "BxdtTuvw" : "aDi:");
+		      (CTAGS) ? "BxdtTuvw" : "Di:");
-while ((opt = getopt_long (argc, argv, optstring, longopts, 0)) != EOF)
+while ((opt = getopt_long (argc, argv, optstring, longopts, NULL)) != EOF)
 switch (opt)
 {
 case 0:
 	/* If getopt returns 0, then it has already processed a
 	   long-named option.  We should do nothing.  */
 	  fatal ("cannot parse standard input more than once", (char *)NULL);
 	parsing_stdin = TRUE;
 	break;
 	/* Common options. */
+case 'a': append_to_tagfile = TRUE;	break;
 case 'C': cplusplus = TRUE;		break;
 case 'f':		/* for compatibility with old makefiles */
 case 'o':
 	if (tagfile)
 	  {
 case 'H':
 	help_asked = TRUE;
 	break;
 	/* Etags options */
-case 'a': append_to_tagfile = TRUE;			break;
 case 'D': constantypedefs = FALSE;			break;
 case 'i': included_files[nincluded_files++] = optarg;	break;
 	/* Ctags options. */
 case 'B': searchar = '?';					break;
 default:
 	suggest_asking_for_help ();
 	/* NOTREACHED */
 }
+/* No more options.  Store the rest of arguments. */
 for (; optind < argc; optind++)
 {
 argbuffer[current_arg].arg_type = at_filename;
 argbuffer[current_arg].what = argv[optind];
 ++current_arg;
 free (filebuf.buffer);
 free (token_name.buffer);
 if (!CTAGS || cxref_style)
 {
-put_entries (nodehead);	/* write the remainig tags (ETAGS) */
+put_entries (nodehead);	/* write the remaining tags (ETAGS) */
 free_tree (nodehead);
 nodehead = NULL;
 if (!CTAGS)
 	{
 	  fdesc *fdp;
 free_tree (nodehead);
 nodehead = NULL;
 if (fclose (tagf) == EOF)
 pfatal (tagfile);
-if (update)
+if (CTAGS)
-{
+if (append_to_tagfile || update)
-char cmd[2*BUFSIZ+10];
+{
-sprintf (cmd, "sort -o %.*s %.*s", BUFSIZ, tagfile, BUFSIZ, tagfile);
+	char cmd[2*BUFSIZ+10];
-exit (system (cmd));
+	sprintf (cmd, "sort -o %.*s %.*s", BUFSIZ, tagfile, BUFSIZ, tagfile);
-}
+	exit (system (cmd));
+}
 return EXIT_SUCCESS;
 }
 /*
 &&			/* instructions at start of loop */	\
 	  (readline (&line_buffer, file_pointer),			\
 char_pointer = line_buffer.buffer,				\
 	   TRUE);							\
 )
-#define LOOKING_AT(cp, keyword)	/* keyword is a constant string */	\
-(strneq ((cp), keyword, sizeof(keyword)-1) /* cp points at keyword */	\
+#define LOOKING_AT(cp, kw)  /* kw is the keyword, a literal string */	\
-&& notinname ((cp)[sizeof(keyword)-1])	/* end of keyword */	\
+((assert("" kw), TRUE)   /* syntax error if not a literal string */	\
-&& ((cp) = skip_spaces((cp)+sizeof(keyword)-1))) /* skip spaces */
+&& strneq ((cp), kw, sizeof(kw)-1)		/* cp points at kw */	\
+&& notinname ((cp)[sizeof(kw)-1])		/* end of kw */		\
+&& ((cp) = skip_spaces((cp)+sizeof(kw)-1)))	/* skip spaces */
+/* Similar to LOOKING_AT but does not use notinname, does not skip */
+#define LOOKING_AT_NOCASE(cp, kw) /* the keyword is a literal string */	\
+((assert("" kw), TRUE)     /* syntax error if not a literal string */	\
+&& strncaseeq ((cp), kw, sizeof(kw)-1)	/* cp points at kw */	\
+&& ((cp) += sizeof(kw)-1))			/* skip spaces */
 /*
 * Read a file, but do no processing.  This is used to do regexp
 * matching on files that have no language defined.
 */
 }
 }
 /*
-* Postscript tag functions
+* Postscript tags
 * Just look for lines where the first character is '/'
 * Also look at "defineps" for PSWrap
 * Ideas by:
 *   Richard Mlynarik <mly@adoc.xerox.com> (1997)
 *   Masatake Yamato <masata-y@is.aist-nara.ac.jp> (1999)
 }
 }
 /*
+* Forth tags
+* Ignore anything after \ followed by space or in ( )
+* Look for words defined by :
+* Look for constant, code, create, defer, value, and variable
+* OBP extensions:  Look for buffer:, field,
+* Ideas by Eduardo Horvath <eeh@netbsd.org> (2004)
+*/
+static void
+Forth_words (inf)
+FILE *inf;
+{
+register char *bp;
+LOOP_ON_INPUT_LINES (inf, lb, bp)
+while ((bp = skip_spaces (bp))[0] != '\0')
+if (bp[0] == '\\' && iswhite(bp[1]))
+	break;			/* read next line */
+else if (bp[0] == '(' && iswhite(bp[1]))
+	do			/* skip to ) or eol */
+	  bp++;
+	while (*bp != ')' && *bp != '\0');
+else if ((bp[0] == ':' && iswhite(bp[1]) && bp++)
+	       || LOOKING_AT_NOCASE (bp, "constant")
+	       || LOOKING_AT_NOCASE (bp, "code")
+	       || LOOKING_AT_NOCASE (bp, "create")
+	       || LOOKING_AT_NOCASE (bp, "defer")
+	       || LOOKING_AT_NOCASE (bp, "value")
+	       || LOOKING_AT_NOCASE (bp, "variable")
+	       || LOOKING_AT_NOCASE (bp, "buffer:")
+	       || LOOKING_AT_NOCASE (bp, "field"))
+	get_tag (skip_spaces (bp), NULL); /* Yay!  A definition! */
+else
+	bp = skip_non_spaces (bp);
+}
+/*
 * Scheme tag functions
 * look for (def... xyzzy
 *          (def... (xyzzy
 *          (def ... ((...(xyzzy ....
 *          (set! xyzzy
 * Original code by Ken Haase (1985?)
 */
 static void
 Scheme_functions (inf)
 FILE *inf;
 {
 register char *bp;
 		  lb.buffer, cp - lb.buffer + 1, lineno, linecharno);
 }
 }
-/* Similar to LOOKING_AT but does not use notinname, does not skip */
-#define LOOKING_AT_NOCASE(cp, kw)	/* kw is a constant string */	\
-(strncaseeq ((cp), kw, sizeof(kw)-1)	/* cp points at kw */		\
-&& ((cp) += sizeof(kw)-1))		/* skip spaces */
 /*
 * HTML support.
 * Contents of <title>, <h1>, <h2>, <h3> are tags.
 * Contents of <a name=xxx> are tags with name xxx.
 *
 if ((s[pos] == '.'
 || (s[pos] == '(' && (pos += 1))
 || (s[pos] == ':' && s[pos + 1] == '-' && (pos += 2)))
 && (last == NULL		/* save only the first clause */
-	  || len != strlen (last)
+	  || len != (int)strlen (last)
 	  || !strneq (s, last, len)))
 	{
 	  make_tag (s, len, TRUE, s, pos, lineno, linecharno);
 	  return len;
 	}
 return (ISALPHA (*s1) && ISALPHA (*s2)
 	    ? lowcase (*s1) - lowcase (*s2)
 	    : *s1 - *s2);
 }
-/* Skip spaces, return new pointer. */
+/* Skip spaces (end of string is not space), return new pointer. */
 static char *
 skip_spaces (cp)
 char *cp;
 {
 while (iswhite (*cp))
 cp++;
 return cp;
 }
-/* Skip non spaces, return new pointer. */
+/* Skip non spaces, except end of string, return new pointer. */
 static char *
 skip_non_spaces (cp)
 char *cp;
 {
 while (*cp != '\0' && !iswhite (*cp))

Mercurial > emacs

comparison lib-src/etags.c @ 90234:b1c1fc853d2f