ctags.rb 1.0.0

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

@@ -0,0 +1,103 @@
+/*
+*   $Id: entry.h 443 2006-05-30 04:37:13Z darren $
+*
+*   Copyright (c) 1998-2002, Darren Hiebert
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License.
+*
+*   External interface to entry.c
+*/
+#ifndef _ENTRY_H
+#define _ENTRY_H
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+
+#include <stdio.h>
+
+#include "vstring.h"
+
+/*
+*   MACROS
+*/
+#define WHOLE_FILE  -1L
+
+/*
+*   DATA DECLARATIONS
+*/
+
+/*  Maintains the state of the tag file.
+ */
+typedef struct eTagFile {
+	char *name;
+	char *directory;
+	FILE *fp;
+	struct sNumTags { unsigned long added, prev; } numTags;
+	struct sMax { size_t line, tag, file; } max;
+	struct sEtags {
+		char *name;
+		FILE *fp;
+		size_t byteCount;
+	} etags;
+	vString *vLine;
+} tagFile;
+
+typedef struct sTagFields {
+	unsigned int count;        /* number of additional extension flags */
+	const char *const *label;  /* list of labels for extension flags */
+	const char *const *value;  /* list of values for extension flags */
+} tagFields;
+
+/*  Information about the current tag candidate.
+ */
+typedef struct sTagEntryInfo {
+	boolean     lineNumberEntry;  /* pattern or line number entry */
+	unsigned long lineNumber;     /* line number of tag */
+	fpos_t      filePosition;     /* file position of line containing tag */
+	const char* language;         /* language of source file */
+	boolean     isFileScope;      /* is tag visibile only within source file? */
+	boolean     isFileEntry;      /* is this just an entry for a file name? */
+	boolean     truncateLine;     /* truncate tag line at end of tag name? */
+	const char *sourceFileName;   /* name of source file */
+	const char *name;             /* name of the tag */
+	const char *kindName;         /* kind of tag */
+	char        kind;             /* single character representation of kind */
+	struct {
+		const char* access;
+		const char* fileScope;
+		const char* implementation;
+		const char* inheritance;
+		const char* scope [2];    /* value and key */
+		const char* signature;
+
+		/* type (union/struct/etc.) and name for a variable or typedef. */
+		const char* typeRef [2];  /* e.g., "struct" and struct name */
+
+	} extensionFields;  /* list of extension fields*/
+} tagEntryInfo;
+
+/*
+*   GLOBAL VARIABLES
+*/
+extern tagFile TagFile;
+
+/*
+*   FUNCTION PROTOTYPES
+*/
+extern void freeTagFileResources (void);
+extern const char *tagFileName (void);
+extern void copyBytes (FILE* const fromFp, FILE* const toFp, const long size);
+extern void copyFile (const char *const from, const char *const to, const long size);
+extern void openTagFile (void);
+extern void closeTagFile (const boolean resize);
+extern void beginEtagsFile (void);
+extern void endEtagsFile (const char *const name);
+extern void makeTagEntry (const tagEntryInfo *const tag);
+extern void initTagEntry (tagEntryInfo *const e, const char *const name);
+
+#endif  /* _ENTRY_H */
+
+/* vi:set tabstop=4 shiftwidth=4: */

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

@@ -0,0 +1,189 @@
+/*
+*   $Id: erlang.c 443 2006-05-30 04:37:13Z darren $
+*
+*   Copyright (c) 2003, Brent Fulgham <bfulgham@debian.org>
+*
+*   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 Erlang language
+*   files.  Some of the parsing constructs are based on the Emacs 'etags'
+*   program by Francesco Potori <pot@gnu.org>
+*/
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+
+#include <string.h>
+
+#include "entry.h"
+#include "options.h"
+#include "read.h"
+#include "routines.h"
+#include "vstring.h"
+
+/*
+*   DATA DEFINITIONS
+*/
+typedef enum {
+	K_MACRO, K_FUNCTION, K_MODULE, K_RECORD
+} erlangKind;
+
+static kindOption ErlangKinds[] = {
+	{TRUE, 'd', "macro",    "macro definitions"},
+	{TRUE, 'f', "function", "functions"},
+	{TRUE, 'm', "module",   "modules"},
+	{TRUE, 'r', "record",   "record definitions"},
+};
+
+/*
+*   FUNCTION DEFINITIONS
+*/
+/* tagEntryInfo and vString should be preinitialized/preallocated but not
+ * necessary. If successful you will find class name in vString
+ */
+
+static boolean isIdentifierFirstCharacter (int c)
+{
+	return (boolean) (isalpha (c));
+}
+
+static boolean isIdentifierCharacter (int c)
+{
+	return (boolean) (isalnum (c) || c == '_' || c == ':');
+}
+
+static const unsigned char *skipSpace (const unsigned char *cp)
+{
+	while (isspace ((int) *cp))
+		++cp;
+	return cp;
+}
+
+static const unsigned char *parseIdentifier (
+		const unsigned char *cp, vString *const identifier)
+{
+	vStringClear (identifier);
+	while (isIdentifierCharacter ((int) *cp))
+	{
+		vStringPut (identifier, (int) *cp);
+		++cp;
+	}
+	vStringTerminate (identifier);
+	return cp;
+}
+
+static void makeMemberTag (
+		vString *const identifier, erlangKind kind, vString *const module)
+{
+	if (ErlangKinds [kind].enabled  &&  vStringLength (identifier) > 0)
+	{
+		tagEntryInfo tag;
+		initTagEntry (&tag, vStringValue (identifier));
+		tag.kindName = ErlangKinds[kind].name;
+		tag.kind = ErlangKinds[kind].letter;
+
+		if (module != NULL  &&  vStringLength (module) > 0)
+		{
+			tag.extensionFields.scope [0] = "module";
+			tag.extensionFields.scope [1] = vStringValue (module);
+		}
+		makeTagEntry (&tag);
+	}
+}
+
+static void parseModuleTag (const unsigned char *cp, vString *const module)
+{
+	vString *const identifier = vStringNew ();
+	parseIdentifier (cp, identifier);
+	makeSimpleTag (identifier, ErlangKinds, K_MODULE);
+
+	/* All further entries go in the new module */
+	vStringCopy (module, identifier);
+	vStringDelete (identifier);
+}
+
+static void parseSimpleTag (const unsigned char *cp, erlangKind kind)
+{
+	vString *const identifier = vStringNew ();
+	parseIdentifier (cp, identifier);
+	makeSimpleTag (identifier, ErlangKinds, kind);
+	vStringDelete (identifier);
+}
+
+static void parseFunctionTag (const unsigned char *cp, vString *const module)
+{
+	vString *const identifier = vStringNew ();
+	parseIdentifier (cp, identifier);
+	makeMemberTag (identifier, K_FUNCTION, module);
+	vStringDelete (identifier);
+}
+
+/*
+ * Directives are of the form:
+ * -module(foo)
+ * -define(foo, bar)
+ * -record(graph, {vtab = notable, cyclic = true}).
+ */
+static void parseDirective (const unsigned char *cp, vString *const module)
+{
+	/*
+	 * A directive will be either a record definition or a directive.
+	 * Record definitions are handled separately
+	 */
+	vString *const directive = vStringNew ();
+	const char *const drtv = vStringValue (directive);
+	cp = parseIdentifier (cp, directive);
+	cp = skipSpace (cp);
+	if (*cp == '(')
+		++cp;
+
+	if (strcmp (drtv, "record") == 0)
+		parseSimpleTag (cp, K_RECORD);
+	else if (strcmp (drtv, "define") == 0)
+		parseSimpleTag (cp, K_MACRO);
+	else if (strcmp (drtv, "module") == 0)
+		parseModuleTag (cp, module);
+	/* Otherwise, it was an import, export, etc. */
+	
+	vStringDelete (directive);
+}
+
+static void findErlangTags (void)
+{
+	vString *const module = vStringNew ();
+	const unsigned char *line;
+
+	while ((line = fileReadLine ()) != NULL)
+	{
+		const unsigned char *cp = line;
+
+		if (*cp == '%')  /* skip initial comment */
+			continue;
+		if (*cp == '"')  /* strings sometimes start in column one */
+			continue;
+
+		if ( *cp == '-')
+		{
+			++cp;  /* Move off of the '-' */
+			parseDirective(cp, module);
+		}
+		else if (isIdentifierFirstCharacter ((int) *cp))
+			parseFunctionTag (cp, module);
+	}
+	vStringDelete (module);
+}
+
+extern parserDefinition *ErlangParser (void)
+{
+	static const char *const extensions[] = { "erl", "ERL", "hrl", "HRL", NULL };
+	parserDefinition *def = parserNew ("Erlang");
+	def->kinds = ErlangKinds;
+	def->kindCount = KIND_COUNT (ErlangKinds);
+	def->extensions = extensions;
+	def->parser = findErlangTags;
+	return def;
+}
+
+/* vi:set tabstop=4 shiftwidth=4: */