ctags.rb 1.0.0

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

@@ -0,0 +1,115 @@
+/*
+*   $Id: sh.c 443 2006-05-30 04:37:13Z darren $
+*
+*   Copyright (c) 2000-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 scripts for the
+*   Bourne shell (and its derivatives, the Korn and Z shells).
+*/
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+
+#include <string.h>
+
+#include "parse.h"
+#include "read.h"
+#include "routines.h"
+#include "vstring.h"
+
+/*
+*   DATA DEFINITIONS
+*/
+typedef enum {
+	K_FUNCTION
+} shKind;
+
+static kindOption ShKinds [] = {
+	{ TRUE, 'f', "function", "functions"}
+};
+
+/*
+*   FUNCTION DEFINITIONS
+*/
+
+/*  Reject any tag "main" from a file named "configure". These appear in
+ *  here-documents in GNU autoconf scripts and will add a haystack to the
+ *  needle.
+ */
+static boolean hackReject (const vString* const tagName)
+{
+	const char *const scriptName = baseFilename (vStringValue (File.name));
+	boolean result = (boolean) (
+			strcmp (scriptName, "configure") == 0  &&
+			strcmp (vStringValue (tagName), "main") == 0);
+	return result;
+}
+
+static void findShTags (void)
+{
+	vString *name = vStringNew ();
+	const unsigned char *line;
+
+	while ((line = fileReadLine ()) != NULL)
+	{
+		const unsigned char* cp = line;
+		boolean functionFound = FALSE;
+
+		if (line [0] == '#')
+			continue;
+
+		while (isspace (*cp))
+			cp++;
+		if (strncmp ((const char*) cp, "function", (size_t) 8) == 0  &&
+			isspace ((int) cp [8]))
+		{
+			functionFound = TRUE;
+			cp += 8;
+			if (! isspace ((int) *cp))
+				continue;
+			while (isspace ((int) *cp))
+				++cp;
+		}
+		if (! (isalnum ((int) *cp) || *cp == '_'))
+			continue;
+		while (isalnum ((int) *cp)  ||  *cp == '_')
+		{
+			vStringPut (name, (int) *cp);
+			++cp;
+		}
+		vStringTerminate (name);
+		while (isspace ((int) *cp))
+			++cp;
+		if (*cp++ == '(')
+		{
+			while (isspace ((int) *cp))
+				++cp;
+			if (*cp == ')'  && ! hackReject (name))
+				functionFound = TRUE;
+		}
+		if (functionFound)
+			makeSimpleTag (name, ShKinds, K_FUNCTION);
+		vStringClear (name);
+	}
+	vStringDelete (name);
+}
+
+extern parserDefinition* ShParser (void)
+{
+	static const char *const extensions [] = {
+		"sh", "SH", "bsh", "bash", "ksh", "zsh", NULL
+	};
+	parserDefinition* def = parserNew ("Sh");
+	def->kinds      = ShKinds;
+	def->kindCount  = KIND_COUNT (ShKinds);
+	def->extensions = extensions;
+	def->parser     = findShTags;
+	return def;
+}
+
+/* vi:set tabstop=4 shiftwidth=4: */

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

@@ -0,0 +1,41 @@
+/*
+ *   $Id: slang.c 443 2006-05-30 04:37:13Z darren $
+ *
+ *   Copyright (c) 2000-2001, Francesc Rocher
+ *
+ *   Author: Francesc Rocher <f.rocher@computer.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 S-Lang files.
+ */
+
+/*
+ *   INCLUDE FILES
+ */
+#include "general.h"  /* must always come first */
+#include "parse.h"
+
+/*
+ *   FUNCTION DEFINITIONS
+ */
+static void installSlangRegex (const langType language)
+{
+	addTagRegex (language,
+		"^.*define[ \t]+([A-Z_][A-Z0-9_]*)[^;]*$",
+		"\\1", "f,function,functions", "i");
+	addTagRegex (language,
+		"^[ \t]*implements[ \t]+\\([ \t]*\"([^\"]*)\"[ \t]*\\)[ \t]*;",
+		"\\1", "n,namespace,namespaces", NULL);
+}
+
+extern parserDefinition* SlangParser (void)
+{
+	static const char *const extensions [] = { "sl", NULL };
+	parserDefinition* const def = parserNew ("SLang");
+	def->extensions = extensions;
+	def->initialize = installSlangRegex;
+	def->regex      = TRUE;
+	return def;
+}

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

@@ -0,0 +1,212 @@
+/*
+*   $Id: sml.c 536 2007-06-02 06:09:00Z elliotth $
+*
+*   Copyright (c) 2002, Venkatesh Prasad Ranganath and 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 SML language files.
+*/
+
+/*
+ *   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 DECLARATIONS
+ */
+typedef enum {
+	K_AND = -2,
+	K_NONE = -1,
+	K_EXCEPTION,
+	K_FUNCTION,
+	K_FUNCTOR,
+	K_SIGNATURE,
+	K_STRUCTURE,
+	K_TYPE,
+	K_VAL
+} smlKind;
+
+/*
+ *   DATA DEFINITIONS
+ */
+static kindOption SmlKinds[] = {
+	{ TRUE, 'e', "exception", "exception declarations" },
+	{ TRUE, 'f', "function",  "function definitions" },
+	{ TRUE, 'c', "functor",   "functor definitions" },
+	{ TRUE, 's', "signature", "signature declarations" },
+	{ TRUE, 'r', "structure", "structure declarations" },
+	{ TRUE, 't', "type",      "type definitions" },
+	{ TRUE, 'v', "value",     "value bindings" }
+};
+
+static struct {
+	const char *keyword;
+	smlKind kind;
+} SmlKeywordTypes [] = {
+	{ "abstype",   K_TYPE      },
+	{ "and",       K_AND       },
+	{ "datatype",  K_TYPE      },
+	{ "exception", K_EXCEPTION },
+	{ "functor",   K_FUNCTOR   },
+	{ "fun",       K_FUNCTION  },
+	{ "signature", K_SIGNATURE },
+	{ "structure", K_STRUCTURE },
+	{ "type",      K_TYPE      },
+	{ "val",       K_VAL       }
+};
+
+static unsigned int CommentLevel = 0;
+
+/*
+ * FUNCTION DEFINITIONS
+ */
+
+static void makeSmlTag (smlKind type, vString *name)
+{
+	tagEntryInfo tag;
+	initTagEntry (&tag, vStringValue (name));
+	tag.kindName = SmlKinds [type].name;
+	tag.kind = SmlKinds [type].letter;
+	makeTagEntry (&tag);
+}
+
+static const unsigned char *skipSpace (const unsigned char *cp)
+{
+	while (isspace ((int) *cp))
+		++cp;
+	return cp;
+}
+
+static boolean isIdentifier (int c)
+{
+	boolean result = FALSE;
+	/* Consider '_' as an delimiter to aid user in tracking it's usage. */
+	const char *const alternateIdentifiers = "!%&$#+-<>=/?@\\~'^|*_";
+	if (isalnum (c))
+		result = TRUE;
+	else if (c != '\0'  &&  strchr (alternateIdentifiers, c) != NULL)
+		result = TRUE;
+	return result;
+}
+
+static const unsigned char *parseIdentifier (
+		const unsigned char *cp, vString *const identifier)
+{
+	boolean stringLit = FALSE;
+	vStringClear (identifier);
+	while (*cp != '\0'  &&  (!isIdentifier ((int) *cp) || stringLit))
+	{
+		int oneback = *cp;
+		cp++;
+		if (oneback == '('  &&  *cp == '*'  &&  stringLit == FALSE)
+		{
+			CommentLevel++;
+			return ++cp;
+		}
+		if (*cp == '"' && oneback != '\\')
+		{
+			stringLit = TRUE;
+			continue;
+		}
+		if (stringLit && *cp == '"' && oneback != '\\')
+			stringLit = FALSE;
+	}
+	if (strcmp ((const char *) cp, "") == 0 || cp == NULL)
+		return cp;
+
+	while (isIdentifier ((int) *cp))
+	{
+		vStringPut (identifier, (int) *cp);
+		cp++;
+	}
+	vStringTerminate (identifier);
+	return cp;
+}
+
+static smlKind findNextIdentifier (const unsigned char **cp)
+{
+	smlKind result = K_NONE;
+	vString *const identifier = vStringNew ();
+	unsigned int count = sizeof (SmlKeywordTypes) / sizeof (SmlKeywordTypes [0]);
+	unsigned int i;
+	*cp = parseIdentifier (*cp, identifier);
+	for (i = 0  ;  i < count  &&  result == K_NONE ;  ++i)
+	{
+		const char *id = vStringValue (identifier);
+		if (strcmp (id, SmlKeywordTypes [i].keyword) == 0)
+			result = SmlKeywordTypes [i].kind;
+	}
+	vStringDelete (identifier);
+	return result;
+}
+
+static void findSmlTags (void)
+{
+	vString *const identifier = vStringNew ();
+	const unsigned char *line;
+	smlKind lastTag = K_NONE;
+
+	while ((line = fileReadLine ()) != NULL)
+	{
+		const unsigned char *cp = skipSpace (line);
+		do
+		{
+			smlKind foundTag;
+			if (CommentLevel != 0)
+			{
+				cp = (const unsigned char *) strstr ((const char *) cp, "*)");
+				if (cp == NULL)
+					continue;
+				else
+				{
+					--CommentLevel;
+					cp += 2;
+				}
+			}
+			foundTag = findNextIdentifier (&cp);
+			if (foundTag != K_NONE)
+			{
+				cp = skipSpace (cp);
+				cp = parseIdentifier (cp, identifier);
+				if (foundTag == K_AND)
+					makeSmlTag (lastTag, identifier);
+				else
+				{
+					makeSmlTag (foundTag, identifier);
+					lastTag = foundTag;
+				}
+			}
+			if (strstr ((const char *) cp, "(*") != NULL)
+			{
+				cp += 2;
+				cp = (const unsigned char *) strstr ((const char *) cp, "*)");
+				if (cp == NULL)
+					++CommentLevel;
+			}
+		} while (cp != NULL  &&  strcmp ((const char *) cp, "") != 0);
+	}
+	vStringDelete (identifier);
+}
+
+extern parserDefinition *SmlParser (void)
+{
+	static const char *const extensions[] = { "sml", "sig", NULL };
+	parserDefinition *def = parserNew ("SML");
+	def->kinds = SmlKinds;
+	def->kindCount = KIND_COUNT (SmlKinds);
+	def->extensions = extensions;
+	def->parser = findSmlTags;
+	return def;
+}
+
+/* vi:set tabstop=4 shiftwidth=4: */

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

@@ -0,0 +1,230 @@
+/*
+*   $Id: sort.c 498 2007-02-17 22:43:15Z dhiebert $
+*
+*   Copyright (c) 1996-2002, Darren Hiebert
+*
+*   This source code is released for free distribution under the terms of the
+*   GNU General Public License.
+*
+*   This module contains functions to sort the tag entries.
+*/
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+
+#if defined (HAVE_STDLIB_H)
+# include <stdlib.h>  /* to declare malloc () */
+#endif
+#include <string.h>
+#include <stdio.h>
+
+#include "debug.h"
+#include "entry.h"
+#include "options.h"
+#include "read.h"
+#include "routines.h"
+#include "sort.h"
+
+/*
+*   FUNCTION DEFINITIONS
+*/
+
+extern void catFile (const char *const name)
+{
+	FILE *const fp = fopen (name, "r");
+
+	if (fp != NULL)
+	{
+		int c;
+		while ((c = getc (fp)) != EOF)
+			putchar (c);
+		fflush (stdout);
+		fclose (fp);
+	}
+}
+
+#ifdef EXTERNAL_SORT
+
+#ifdef NON_CONST_PUTENV_PROTOTYPE
+# define PE_CONST
+#else
+# define PE_CONST const
+#endif
+
+extern void externalSortTags (const boolean toStdout)
+{
+	const char *const sortNormalCommand = "sort -u -o";
+	const char *const sortFoldedCommand = "sort -u -f -o";
+	const char *sortCommand =
+		Option.sorted == SO_FOLDSORTED ? sortFoldedCommand : sortNormalCommand;
+	PE_CONST char *const sortOrder1 = "LC_COLLATE=C";
+	PE_CONST char *const sortOrder2 = "LC_ALL=C";
+	const size_t length = 4 + strlen (sortOrder1) + strlen (sortOrder2) +
+			strlen (sortCommand) + (2 * strlen (tagFileName ()));
+	char *const cmd = (char *) malloc (length + 1);
+	int ret = -1;
+
+	if (cmd != NULL)
+	{
+		/*  Ensure ASCII value sort order.
+		 */
+#ifdef HAVE_SETENV
+		setenv ("LC_COLLATE", "C", 1);
+		setenv ("LC_ALL", "C", 1);
+		sprintf (cmd, "%s %s %s", sortCommand, tagFileName (), tagFileName ());
+#else
+# ifdef HAVE_PUTENV
+		putenv (sortOrder1);
+		putenv (sortOrder2);
+		sprintf (cmd, "%s %s %s", sortCommand, tagFileName (), tagFileName ());
+# else
+		sprintf (cmd, "%s %s %s %s %s", sortOrder1, sortOrder2, sortCommand,
+				tagFileName (), tagFileName ());
+# endif
+#endif
+		verbose ("system (\"%s\")\n", cmd);
+		ret = system (cmd);
+		free (cmd);
+
+	}
+	if (ret != 0)
+		error (FATAL | PERROR, "cannot sort tag file");
+	else if (toStdout)
+		catFile (tagFileName ());
+}
+
+#else
+
+/*
+ *  These functions provide a basic internal sort. No great memory
+ *  optimization is performed (e.g. recursive subdivided sorts),
+ *  so have lots of memory if you have large tag files.
+ */
+
+static void failedSort (FILE *const fp, const char* msg)
+{
+	const char* const cannotSort = "cannot sort tag file";
+	if (fp != NULL)
+		fclose (fp);
+	if (msg == NULL)
+		error (FATAL | PERROR, cannotSort);
+	else
+		error (FATAL, "%s: %s", msg, cannotSort);
+}
+
+static int compareTagsFolded(const void *const one, const void *const two)
+{
+	const char *const line1 = *(const char* const*) one;
+	const char *const line2 = *(const char* const*) two;
+
+	return struppercmp (line1, line2);
+}
+
+static int compareTags (const void *const one, const void *const two)
+{
+	const char *const line1 = *(const char* const*) one;
+	const char *const line2 = *(const char* const*) two;
+
+	return strcmp (line1, line2);
+}
+
+static void writeSortedTags (
+		char **const table, const size_t numTags, const boolean toStdout)
+{
+	FILE *fp;
+	size_t i;
+
+	/*  Write the sorted lines back into the tag file.
+	 */
+	if (toStdout)
+		fp = stdout;
+	else
+	{
+		fp = fopen (tagFileName (), "w");
+		if (fp == NULL)
+			failedSort (fp, NULL);
+	}
+	for (i = 0 ; i < numTags ; ++i)
+	{
+		/*  Here we filter out identical tag *lines* (including search
+		 *  pattern) if this is not an xref file.
+		 */
+		if (i == 0  ||  Option.xref  ||  strcmp (table [i], table [i-1]) != 0)
+			if (fputs (table [i], fp) == EOF)
+				failedSort (fp, NULL);
+	}
+	if (toStdout)
+		fflush (fp);
+	else
+		fclose (fp);
+}
+
+extern void internalSortTags (const boolean toStdout)
+{
+	vString *vLine = vStringNew ();
+	FILE *fp = NULL;
+	const char *line;
+	size_t i;
+	int (*cmpFunc)(const void *, const void *);
+
+	/*  Allocate a table of line pointers to be sorted.
+	 */
+	size_t numTags = TagFile.numTags.added + TagFile.numTags.prev;
+	const size_t tableSize = numTags * sizeof (char *);
+	char **const table = (char **) malloc (tableSize);  /* line pointers */
+	DebugStatement ( size_t mallocSize = tableSize; )  /* cumulative total */
+
+
+	cmpFunc = Option.sorted == SO_FOLDSORTED ? compareTagsFolded : compareTags;
+	if (table == NULL)
+		failedSort (fp, "out of memory");
+
+	/*  Open the tag file and place its lines into allocated buffers.
+	 */
+	fp = fopen (tagFileName (), "r");
+	if (fp == NULL)
+		failedSort (fp, NULL);
+	for (i = 0  ;  i < numTags  &&  ! feof (fp)  ;  )
+	{
+		line = readLine (vLine, fp);
+		if (line == NULL)
+		{
+			if (! feof (fp))
+				failedSort (fp, NULL);
+			break;
+		}
+		else if (*line == '\0'  ||  strcmp (line, "\n") == 0)
+			;  /* ignore blank lines */
+		else
+		{
+			const size_t stringSize = strlen (line) + 1;
+
+			table [i] = (char *) malloc (stringSize);
+			if (table [i] == NULL)
+				failedSort (fp, "out of memory");
+			DebugStatement ( mallocSize += stringSize; )
+			strcpy (table [i], line);
+			++i;
+		}
+	}
+	numTags = i;
+	fclose (fp);
+	vStringDelete (vLine);
+
+	/*  Sort the lines.
+	 */
+	qsort (table, numTags, sizeof (*table), cmpFunc);
+
+	writeSortedTags (table, numTags, toStdout);
+
+	PrintStatus (("sort memory: %ld bytes\n", (long) mallocSize));
+	for (i = 0 ; i < numTags ; ++i)
+		free (table [i]);
+	free (table);
+}
+
+#endif
+
+/* vi:set tabstop=4 shiftwidth=4: */

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

@@ -0,0 +1,32 @@
+/*
+*   $Id: sort.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 sort.c
+*/
+#ifndef _SORT_H
+#define _SORT_H
+
+/*
+*   INCLUDE FILES
+*/
+#include "general.h"  /* must always come first */
+
+/*
+*   FUNCTION PROTOTYPES
+*/
+extern void catFile (const char *const name);
+
+#ifdef EXTERNAL_SORT
+extern void externalSortTags (const boolean toStdout);
+#else
+extern void internalSortTags (const boolean toStdout);
+#endif
+
+#endif  /* _SORT_H */
+
+/* vi:set tabstop=4 shiftwidth=4: */