ctags.rb 1.0.0

data/ext/vendor/exuberant-ctags/parse.h

@@ -0,0 +1,129 @@
+/*
+*   $Id: parse.h 443 2006-05-30 04:37:13Z darren $
+*
+*   Copyright (c) 1998-2003, Darren Hiebert
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License.
+*
+*   Private definitions for parsing support.
+*/
+#ifndef _PARSE_H
+#define _PARSE_H
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+#include "parsers.h"  /* contains list of parsers */
+#include "strlist.h"
+
+/*
+*   MACROS
+*/
+#define KIND_COUNT(kindTable) (sizeof(kindTable)/sizeof(kindOption))
+
+#define LANG_AUTO   (-1)
+#define LANG_IGNORE (-2)
+
+/*
+*   DATA DECLARATIONS
+*/
+typedef int langType;
+
+typedef void (*createRegexTag) (const vString* const name);
+typedef void (*simpleParser) (void);
+typedef boolean (*rescanParser) (const unsigned int passCount);
+typedef void (*parserInitialize) (langType language);
+
+typedef struct sKindOption {
+	boolean enabled;          /* are tags for kind enabled? */
+	int letter;               /* kind letter */
+	const char* name;         /* kind name */
+	const char* description;  /* displayed in --help output */
+} kindOption;
+
+typedef struct {
+	/* defined by parser */
+	char* name;                    /* name of language */
+	kindOption* kinds;             /* tag kinds handled by parser */
+	unsigned int kindCount;        /* size of `kinds' list */
+	const char *const *extensions; /* list of default extensions */
+	const char *const *patterns;   /* list of default file name patterns */
+	parserInitialize initialize;   /* initialization routine, if needed */
+	simpleParser parser;           /* simple parser (common case) */
+	rescanParser parser2;          /* rescanning parser (unusual case) */
+	boolean regex;                 /* is this a regex parser? */
+
+	/* used internally */
+	unsigned int id;               /* id assigned to language */
+	boolean enabled;               /* currently enabled? */
+	stringList* currentPatterns;   /* current list of file name patterns */
+	stringList* currentExtensions; /* current list of extensions */
+} parserDefinition;
+
+typedef parserDefinition* (parserDefinitionFunc) (void);
+
+typedef struct {
+	size_t start;   /* character index in line where match starts */
+	size_t length;  /* length of match */
+} regexMatch;
+
+typedef void (*regexCallback) (const char *line, const regexMatch *matches, unsigned int count);
+
+/*
+*   FUNCTION PROTOTYPES
+*/
+
+/* Each parsers' definition function is called. The routine is expected to
+ * return a structure allocated using parserNew(). This structure must,
+ * at minimum, set the `parser' field.
+ */
+extern parserDefinitionFunc PARSER_LIST;
+
+/* Legacy interface */
+extern boolean includingDefineTags (void);
+
+/* Language processing and parsing */
+extern void makeSimpleTag (const vString* const name, kindOption* const kinds, const int kind);
+extern parserDefinition* parserNew (const char* name);
+extern const char *getLanguageName (const langType language);
+extern langType getNamedLanguage (const char *const name);
+extern langType getFileLanguage (const char *const fileName);
+extern void installLanguageMapDefault (const langType language);
+extern void installLanguageMapDefaults (void);
+extern void clearLanguageMap (const langType language);
+extern boolean removeLanguageExtensionMap (const char *const extension);
+extern void addLanguageExtensionMap (const langType language, const char* extension);
+extern void addLanguagePatternMap (const langType language, const char* ptrn);
+extern void printLanguageMap (const langType language);
+extern void printLanguageMaps (const langType language);
+extern void enableLanguages (const boolean state);
+extern void enableLanguage (const langType language, const boolean state);
+extern void initializeParsing (void);
+extern void freeParserResources (void);
+extern void processLanguageDefineOption (const char *const option, const char *const parameter);
+extern boolean processKindOption (const char *const option, const char *const parameter);
+extern void printKindOptions (void);
+extern void printLanguageKinds (const langType language);
+extern void printLanguageList (void);
+extern boolean parseFile (const char *const fileName);
+
+/* Regex interface */
+#ifdef HAVE_REGEX
+extern void findRegexTags (void);
+extern boolean matchRegex (const vString* const line, const langType language);
+#endif
+extern boolean processRegexOption (const char *const option, const char *const parameter);
+extern void addLanguageRegex (const langType language, const char* const regex);
+extern void addTagRegex (const langType language, const char* const regex, const char* const name, const char* const kinds, const char* const flags);
+extern void addCallbackRegex (const langType language, const char *const regex, const char *const flags, const regexCallback callback);
+extern void disableRegexKinds (const langType language);
+extern boolean enableRegexKind (const langType language, const int kind, const boolean mode);
+extern void printRegexKinds (const langType language, boolean indent);
+extern void freeRegexResources (void);
+extern void checkRegex (void);
+
+#endif  /* _PARSE_H */
+
+/* vi:set tabstop=4 shiftwidth=4: */

data/ext/vendor/exuberant-ctags/parsers.h

@@ -0,0 +1,63 @@
+/*
+*   $Id: parsers.h 717 2009-07-07 03:40:50Z dhiebert $
+*
+*   Copyright (c) 2000-2003, Darren Hiebert
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License.
+*
+*   External interface to all language parsing modules.
+*
+*   To add a new language parser, you need only modify this single source
+*   file to add the name of the parser definition function.
+*/
+#ifndef _PARSERS_H
+#define _PARSERS_H
+
+/* Add the name of any new parser definition function here */
+#define PARSER_LIST \
+	AntParser, \
+	AsmParser, \
+	AspParser, \
+	AwkParser, \
+	BasicParser, \
+	BetaParser, \
+	CParser, \
+	CppParser, \
+	CsharpParser, \
+	CobolParser, \
+	DosBatchParser, \
+	EiffelParser, \
+	ErlangParser, \
+	FlexParser, \
+	FortranParser, \
+	HtmlParser, \
+	JavaParser, \
+	JavaScriptParser, \
+	LispParser, \
+	LuaParser, \
+	MakefileParser, \
+	MatLabParser, \
+	OcamlParser, \
+	PascalParser, \
+	PerlParser, \
+	PhpParser, \
+	PythonParser, \
+	RexxParser, \
+	RubyParser, \
+	SchemeParser, \
+	ShParser, \
+	SlangParser, \
+	SmlParser, \
+	SqlParser, \
+	TclParser, \
+	TexParser, \
+	VeraParser, \
+	VerilogParser, \
+	VhdlParser, \
+	VimParser, \
+	YaccParser
+
+#endif  /* _PARSERS_H */
+
+/* vi:set tabstop=4 shiftwidth=4: */

data/ext/vendor/exuberant-ctags/pascal.c

@@ -0,0 +1,267 @@
+/*
+*   $Id: pascal.c 536 2007-06-02 06:09:00Z elliotth $
+*
+*   Copyright (c) 2001-2002, Darren Hiebert
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License.
+*
+*   This module contains functions for generating tags for the Pascal language,
+*   including some extensions for Object Pascal.
+*/
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+
+#include <string.h>
+
+#include "entry.h"
+#include "parse.h"
+#include "read.h"
+#include "vstring.h"
+
+/*
+*   DATA DEFINITIONS
+*/
+typedef enum {
+	K_FUNCTION, K_PROCEDURE
+} pascalKind;
+
+static kindOption PascalKinds [] = {
+	{ TRUE, 'f', "function",  "functions"},
+	{ TRUE, 'p', "procedure", "procedures"}
+};
+
+/*
+*   FUNCTION DEFINITIONS
+*/
+
+static void createPascalTag (
+		tagEntryInfo* const tag, const vString* const name, const int kind)
+{
+	if (PascalKinds [kind].enabled  &&  name != NULL  &&  vStringLength (name) > 0)
+	{
+	    initTagEntry (tag, vStringValue (name));
+	    tag->kindName = PascalKinds [kind].name;
+	    tag->kind     = PascalKinds [kind].letter;
+	}
+	else
+	    initTagEntry (tag, NULL);
+}
+
+static void makePascalTag (const tagEntryInfo* const tag)
+{
+	if (tag->name != NULL)
+		makeTagEntry (tag);
+}
+
+static const unsigned char* dbp;
+
+#define starttoken(c) (isalpha ((int) c) || (int) c == '_')
+#define intoken(c)    (isalnum ((int) c) || (int) c == '_' || (int) c == '.')
+#define endtoken(c)   (! intoken (c)  &&  ! isdigit ((int) c))
+
+static boolean tail (const char *cp)
+{
+	boolean result = FALSE;
+	register int len = 0;
+
+	while (*cp != '\0' && tolower ((int) *cp) == tolower ((int) dbp [len]))
+		cp++, len++;
+	if (*cp == '\0' && !intoken (dbp [len]))
+	{
+		dbp += len;
+		result = TRUE;
+	}
+	return result;
+}
+
+/* Algorithm adapted from from GNU etags.
+ * 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.
+ */
+static void findPascalTags (void)
+{
+	vString *name = vStringNew ();
+	tagEntryInfo tag;
+	pascalKind kind = K_FUNCTION;
+		/* each of these flags is TRUE iff: */
+	boolean incomment = FALSE;  /* point is inside a comment */
+	int comment_char = '\0';    /* type of current comment */
+	boolean inquote = FALSE;    /* point is inside '..' string */
+	boolean get_tagname = FALSE;/* point is after PROCEDURE/FUNCTION
+		keyword, so next item = potential tag */
+	boolean found_tag = FALSE;  /* point is after a potential tag */
+	boolean inparms = FALSE;    /* point is within parameter-list */
+	boolean verify_tag = FALSE;
+		/* point has passed the parm-list, so the next token will determine
+		 * whether this is a FORWARD/EXTERN to be ignored, or whether it is a
+		 * real tag
+		 */
+
+	dbp = fileReadLine ();
+	while (dbp != NULL)
+	{
+		int c = *dbp++;
+
+		if (c == '\0')  /* if end of line */
+		{
+			dbp = fileReadLine ();
+			if (dbp == NULL  ||  *dbp == '\0')
+				continue;
+			if (!((found_tag && verify_tag) || get_tagname))
+				c = *dbp++;
+					/* only if don't need *dbp pointing to the beginning of
+					 * the name of the procedure or function
+					 */
+		}
+		if (incomment)
+		{
+			if (comment_char == '{' && c == '}')
+				incomment = FALSE;
+			else if (comment_char == '(' && c == '*' && *dbp == ')')
+			{
+				dbp++;
+				incomment = FALSE;
+			}
+			continue;
+		}
+		else if (inquote)
+		{
+			if (c == '\'')
+				inquote = FALSE;
+			continue;
+		}
+		else switch (c)
+		{
+			case '\'':
+				inquote = TRUE;  /* found first quote */
+				continue;
+			case '{':  /* found open { comment */
+				incomment = TRUE;
+				comment_char = c;
+				continue;
+			case '(':
+				if (*dbp == '*')  /* found open (* comment */
+				{
+					incomment = TRUE;
+					comment_char = c;
+					dbp++;
+				}
+				else if (found_tag)  /* found '(' after tag, i.e., parm-list */
+					inparms = TRUE;
+				continue;
+			case ')':  /* end of parms list */
+				if (inparms)
+					inparms = FALSE;
+				continue;
+			case ';':
+				if (found_tag && !inparms)  /* end of proc or fn stmt */
+				{
+					verify_tag = TRUE;
+					break;
+				}
+				continue;
+		}
+		if (found_tag && verify_tag && *dbp != ' ')
+		{
+			/* check if this is an "extern" declaration */
+			if (*dbp == '\0')
+				continue;
+			if (tolower ((int) *dbp == 'e'))
+			{
+				if (tail ("extern"))  /* superfluous, really! */
+				{
+					found_tag = FALSE;
+					verify_tag = FALSE;
+				}
+			}
+			else if (tolower ((int) *dbp) == 'f')
+			{
+				if (tail ("forward"))  /*  check for forward reference */
+				{
+					found_tag = FALSE;
+					verify_tag = FALSE;
+				}
+			}
+			if (found_tag && verify_tag)  /* not external proc, so make tag */
+			{
+				found_tag = FALSE;
+				verify_tag = FALSE;
+				makePascalTag (&tag);
+				continue;
+			}
+		}
+		if (get_tagname)  /* grab name of proc or fn */
+		{
+			const unsigned char *cp;
+
+			if (*dbp == '\0')
+				continue;
+
+			/* grab block name */
+			while (isspace ((int) *dbp))
+				++dbp;
+			for (cp = dbp  ;  *cp != '\0' && !endtoken (*cp)  ;  cp++)
+				continue;
+			vStringNCopyS (name, (const char*) dbp,  cp - dbp);
+			createPascalTag (&tag, name, kind);
+			dbp = cp;  /* set dbp to e-o-token */
+			get_tagname = FALSE;
+			found_tag = TRUE;
+			/* and proceed to check for "extern" */
+		}
+		else if (!incomment && !inquote && !found_tag)
+		{
+			switch (tolower ((int) c))
+			{
+				case 'c':
+					if (tail ("onstructor"))
+					{
+						get_tagname = TRUE;
+						kind = K_PROCEDURE;
+					}
+					break;
+				case 'd':
+					if (tail ("estructor"))
+					{
+						get_tagname = TRUE;
+						kind = K_PROCEDURE;
+					}
+					break;
+				case 'p':
+					if (tail ("rocedure"))
+					{
+						get_tagname = TRUE;
+						kind = K_PROCEDURE;
+					}
+					break;
+				case 'f':
+					if (tail ("unction"))
+					{
+						get_tagname = TRUE;
+						kind = K_FUNCTION;
+					}
+					break;
+			}
+		}  /* while not eof */
+	}
+	vStringDelete (name);
+}
+
+extern parserDefinition* PascalParser (void)
+{
+	static const char *const extensions [] = { "p", "pas", NULL };
+	parserDefinition* def = parserNew ("Pascal");
+	def->extensions = extensions;
+	def->kinds      = PascalKinds;
+	def->kindCount  = KIND_COUNT (PascalKinds);
+	def->parser     = findPascalTags;
+	return def;
+}
+
+/* vi:set tabstop=4 shiftwidth=4: */