ctags.rb 1.0.0 → 1.0.6

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

@@ -108,7 +108,7 @@ typedef struct sOptionValues {
 	boolean tagRelative;    /* --tag-relative file paths relative to tag file */
 	boolean printTotals;    /* --totals  print cumulative statistics */
 	boolean lineDirectives; /* --linedirectives  process #line directives */
-	char* stdinFileName;    /* --from-stdin  use this as the filename and get the file content from stdin */
+	boolean json;           /* --json interactive mode */
 #ifdef DEBUG
 	long debugLevel;        /* -D  debugging output */
 	unsigned long breakLine;/* -b  source line at which to call lineBreak() */

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

@@ -660,12 +660,12 @@ extern boolean parseFile (const char *const fileName)
 		verbose ("ignoring %s (language disabled)\n", fileName);
 	else
 	{
-		if (Option.filter)
+		if (Option.filter && ! Option.json)
 			openTagFile ();
 
 		tagFileResized = createTagsWithFallback (fileName, language);
 
-		if (Option.filter)
+		if (Option.filter && ! Option.json)
 			closeTagFile (tagFileResized);
 		addTotals (1, 0L, 0L);
 

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

@@ -240,6 +240,10 @@ static boolean parseLineDirective (void)
  *   Source file I/O operations
  */
 
+#ifdef HAVE_FMEMOPEN_C
+#include <fmemopen.c> /* hax */
+#endif
+
 /*  This function opens a source file, and resets the line counter.  If it
  *  fails, it will display an error message and leave the File.fp set to NULL.
  */
@@ -260,10 +264,11 @@ extern boolean fileOpen (const char *const fileName, const langType language)
 		File.fp = NULL;
 	}
 	
-	if (Option.stdinFileName) {
-	  File.fp = stdin;
+	if (File.buffer) {
+		File.fp = fmemopen (File.buffer, File.buffer_size, openMode);
 	} else {
-	  File.fp = fopen (fileName, openMode);
+		File.fp = fopen (fileName, openMode);
+		File.buffer = NULL;
 	}
 
 	if (File.fp == NULL)

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

@@ -72,6 +72,8 @@ typedef struct sInputFile {
 	vString    *line;          /* last line read from file */
 	const unsigned char* currentLine;  /* current line being worked on */
 	FILE       *fp;            /* stream used for reading the file */
+	char       *buffer;        /* buffer backing the stream */
+	size_t     buffer_size;    /* size of stream buffer */
 	unsigned long lineNumber;  /* line number in the input file */
 	fpos_t      filePosition;  /* file position of current line */
 	int         ungetch;       /* a single character that was ungotten */
@@ -95,7 +97,8 @@ typedef struct sInputFile {
 /*
 *   GLOBAL VARIABLES
 */
-extern CONST_FILE inputFile File;
+//extern CONST_FILE inputFile File;
+extern inputFile File; // remove CONST_FILE for File.buffer hack
 
 /*
 *   FUNCTION PROTOTYPES

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

@@ -61,6 +61,8 @@
 #endif
 #include "debug.h"
 #include "routines.h"
+#include "options.h"
+#include <jansson.h>
 
 /*
 *   MACROS
@@ -214,18 +216,39 @@ extern void error (
 	va_list ap;
 
 	va_start (ap, format);
-	fprintf (errout, "%s: %s", getExecutableName (),
-			selected (selection, WARNING) ? "Warning: " : "");
-	vfprintf (errout, format, ap);
-	if (selected (selection, PERROR))
+	if (Option.json) {
+		char *reason;
+		vasprintf (&reason, format, ap);
+
+		json_t *response = json_object ();
+		json_object_set_new (response, "error", json_string (reason));
+		if (selected (selection, WARNING))
+			json_object_set_new (response, "warning", json_true ());
+		if (selected (selection, FATAL))
+			json_object_set_new (response, "fatal", json_true ());
+		if (selected (selection, PERROR)) {
+			json_object_set_new (response, "errno", json_integer (errno));
+			json_object_set_new (response, "perror", json_string (strerror (errno)));
+		}
+		json_dumpf (response, stdout, 0);
+		fprintf (stdout, "\n");
+
+		json_decref (response);
+		free (reason);
+	} else {
+		fprintf (errout, "%s: %s", getExecutableName (),
+				selected (selection, WARNING) ? "Warning: " : "");
+		vfprintf (errout, format, ap);
+		if (selected (selection, PERROR))
 #ifdef HAVE_STRERROR
-		fprintf (errout, " : %s", strerror (errno));
+			fprintf (errout, " : %s", strerror (errno));
 #else
-		perror (" ");
+			perror (" ");
 #endif
-	fputs ("\n", errout);
+		fputs ("\n", errout);
+	}
 	va_end (ap);
-	if (selected (selection, FATAL))
+	if (! Option.json && selected (selection, FATAL))
 		exit (1);
 }
 

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

@@ -87,7 +87,7 @@ static boolean canMatch (const unsigned char** s, const char* literal)
 	    return FALSE;
 	}
 	/* Additionally check that we're at the end of a token. */
-	if ( ! (next_char == 0 || isspace (next_char) || next_char == '('))
+	if ( ! (next_char == 0 || isspace (next_char) || next_char == '(' || next_char == ';'))
 	{
 	    return FALSE;
 	}
@@ -134,11 +134,26 @@ static void emitRubyTag (vString* name, rubyKind kind)
 {
 	tagEntryInfo tag;
 	vString* scope;
+	const char *this_name;
 
 	vStringTerminate (name);
 	scope = stringListToScope (nesting);
 
-	initTagEntry (&tag, vStringValue (name));
+	/* extract scope and actual name from tag name in case of tags like
+	 * "class Foo::Bar::Baz" which are parsed as a single name, "Foo.Bar.Baz" */
+	this_name = strrchr (vStringValue (name), '.');
+	if (this_name)
+	{
+		if (vStringLength (scope) > 0)
+			vStringPut (scope, '.');
+		vStringNCat (scope, name, this_name - vStringValue (name));
+		vStringTerminate (scope);
+		this_name ++;
+	}
+	else
+		this_name = vStringValue (name);
+
+	initTagEntry (&tag, this_name);
 	if (vStringLength (scope) > 0) {
 	    tag.extensionFields.scope [0] = "class";
 	    tag.extensionFields.scope [1] = vStringValue (scope);
@@ -180,7 +195,7 @@ static rubyKind parseIdentifier (
 	 * point or equals sign. These are all part of the name.
 	 * A method name may also contain a period if it's a singleton method.
 	 */
-	const char* also_ok = (kind == K_METHOD) ? "_.?!=" : "_";
+	const char* also_ok = (kind == K_METHOD || kind == K_SINGLETON) ? "_.?!=" : "_";
 
 	skipWhitespace (cp);
 
@@ -232,7 +247,26 @@ static void readAndEmitTag (const unsigned char** cp, rubyKind expected_kind)
 	if (isspace (**cp))
 	{
 		vString *name = vStringNew ();
-		rubyKind actual_kind = parseIdentifier (cp, name, expected_kind);
+		vString *chunk = vStringNew ();
+		rubyKind actual_kind;
+		unsigned int i = 0;
+
+		/* parse the identifier, allowing scoping like "class Foo::Bar::Baz" */
+		while (1)
+		{
+			actual_kind = parseIdentifier (cp, chunk, expected_kind);
+			if (i++ > 0)
+				vStringPut (name, '.');
+			vStringCat (name, chunk);
+			vStringClear (chunk);
+
+			if (actual_kind != K_UNDEFINED && (*cp)[0] == ':' && (*cp)[1] == ':')
+				*cp += 2;
+			else
+				break;
+		}
+		vStringDelete (chunk);
+		vStringTerminate (name);
 
 		if (actual_kind == K_UNDEFINED || vStringLength (name) == 0)
 		{
@@ -289,6 +323,9 @@ static void findRubyTags (void)
 	while ((line = fileReadLine ()) != NULL)
 	{
 		const unsigned char *cp = line;
+		/* if we expect a separator after a while, for, or until statement
+		 * separators are "do", ";" or newline */
+		boolean expect_separator = FALSE;
 
 		if (canMatch (&cp, "=begin"))
 		{
@@ -320,9 +357,14 @@ static void findRubyTags (void)
 		*   puts("hello") \
 		*       unless <exp>
 		*/
-		if (canMatch (&cp, "case") || canMatch (&cp, "for") ||
-			canMatch (&cp, "if") || canMatch (&cp, "unless") ||
+		if (canMatch (&cp, "for") || canMatch (&cp, "until") ||
 			canMatch (&cp, "while"))
+		{
+			expect_separator = TRUE;
+			enterUnnamedScope ();
+		}
+		else if (canMatch (&cp, "case") || canMatch (&cp, "if") ||
+				 canMatch (&cp, "unless"))
 		{
 			enterUnnamedScope ();
 		}
@@ -364,10 +406,17 @@ static void findRubyTags (void)
 				*/
 				break;
 			}
-			else if (canMatch (&cp, "begin") || canMatch (&cp, "do"))
+			else if (canMatch (&cp, "begin"))
 			{
 				enterUnnamedScope ();
 			}
+			else if (canMatch (&cp, "do"))
+			{
+				if (! expect_separator)
+					enterUnnamedScope ();
+				else
+					expect_separator = FALSE;
+			}
 			else if (canMatch (&cp, "end") && stringListCount (nesting) > 0)
 			{
 				/* Leave the most recent scope. */
@@ -382,6 +431,12 @@ static void findRubyTags (void)
 				do {
 					++cp;
 				} while (*cp != 0 && *cp != '"');
+				if (*cp == '"') ++cp;
+			}
+			else if (*cp == ';')
+			{
+				++cp;
+				expect_separator = FALSE;
 			}
 			else if (*cp != '\0')
 			{

data/ext/vendor/fmemopen/README.md

@@ -0,0 +1,49 @@
+fmemopen for Mac OS and iOS
+===========================
+
+Originally ported from [ingenuitas python-tesseract](https://github.com/ingenuitas/python-tesseract/blob/master/fmemopen.c). Ported by Jeff Verkoeyen under the Apache 2.0 License.
+
+From the fmemopen man page:
+
+> FILE *fmemopen(void *buf, size_t size, const char *mode);
+>
+> The fmemopen() function opens a stream that permits the access specified by mode. The stream
+> allows I/O to be performed on the string or memory buffer pointed to by buf. This buffer must be
+> at least size bytes long.
+
+Alas, this method does not exist on BSD operating systems (specifically Mac OS X and iOS). It is
+possible to recreate this functionality using a BSD-specific method called `funopen`.
+
+From the funopen man page:
+
+> FILE * funopen(const void *cookie, int (*readfn)(void *, char *, int),
+>                int (*writefn)(void *, const char *, int), fpos_t (*seekfn)(void *, fpos_t, int),
+>                int (*closefn)(void *));
+>
+> The funopen() function associates a stream with up to four ``I/O functions''.  Either readfn or
+> writefn must be specified; the others can be given as an appropriately-typed NULL pointer.  These
+> I/O functions will be used to read, write, seek and close the new stream.
+
+fmemopen.c provides a simple implementation of fmemopen using funopen so that you can create FILE
+pointers to blocks of memory.
+
+Adding it to your Project
+=========================
+
+Drag fmemopen.h and fmemopen.c to your project and add them to your target. `#include "fmemopen.h"`
+wherever you need to use `fmemopen`.
+
+Examples
+========
+
+```obj-c
+#import "fmemopen.h"
+
+NSString* string = @"fmemopen in Objective-C";
+const char* cstr = [string UTF8String];
+FILE* file = fmemopen((void *)cstr, sizeof(char) * (string.length + 1), "r");
+
+// fread on file will now read the contents of the NSString
+
+fclose(file);
+```

data/ext/vendor/fmemopen/fmemopen.c

@@ -0,0 +1,92 @@
+//
+// Copyright 2012 Jeff Verkoeyen
+// Originally ported from https://github.com/ingenuitas/python-tesseract/blob/master/fmemopen.c
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+
+struct fmem {
+  size_t pos;
+  size_t size;
+  char *buffer;
+};
+typedef struct fmem fmem_t;
+
+static int readfn(void *handler, char *buf, int size) {
+  fmem_t *mem = handler;
+  size_t available = mem->size - mem->pos;
+  
+  if (size > available) {
+    size = available;
+  }
+  memcpy(buf, mem->buffer + mem->pos, sizeof(char) * size);
+  mem->pos += size;
+  
+  return size;
+}
+
+static int writefn(void *handler, const char *buf, int size) {
+  fmem_t *mem = handler;
+  size_t available = mem->size - mem->pos;
+
+  if (size > available) {
+    size = available;
+  }
+  memcpy(mem->buffer + mem->pos, buf, sizeof(char) * size);
+  mem->pos += size;
+
+  return size;
+}
+
+static fpos_t seekfn(void *handler, fpos_t offset, int whence) {
+  size_t pos;
+  fmem_t *mem = handler;
+
+  switch (whence) {
+    case SEEK_SET: pos = offset; break;
+    case SEEK_CUR: pos = mem->pos + offset; break;
+    case SEEK_END: pos = mem->size + offset; break;
+    default: return -1;
+  }
+
+  if (pos > mem->size) {
+    return -1;
+  }
+
+  mem->pos = pos;
+  return (fpos_t)pos;
+}
+
+static int closefn(void *handler) {
+  free(handler);
+  return 0;
+}
+
+FILE *fmemopen(void *buf, size_t size, const char *mode) {
+  // This data is released on fclose.
+  fmem_t* mem = (fmem_t *) malloc(sizeof(fmem_t));
+
+  // Zero-out the structure.
+  memset(mem, 0, sizeof(fmem_t));
+
+  mem->size = size;
+  mem->buffer = buf;
+
+  // funopen's man page: https://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/funopen.3.html
+  return funopen(mem, readfn, writefn, seekfn, closefn);
+}

data/ext/vendor/fmemopen/fmemopen.h

@@ -0,0 +1,52 @@
+//
+// Copyright 2012 Jeff Verkoeyen
+// Originally ported from https://github.com/ingenuitas/python-tesseract/blob/master/fmemopen.c
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef FMEMOPEN_H_
+#define FMEMOPEN_H_
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * A BSD port of the fmemopen Linux method using funopen.
+ *
+ * man docs for fmemopen:
+ * http://linux.die.net/man/3/fmemopen
+ *
+ * man docs for funopen:
+ * https://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man3/funopen.3.html
+ *
+ * This method is ported from ingenuitas' python-tesseract project.
+ *
+ * You must call fclose on the returned file pointer or memory will be leaked.
+ *
+ *      @param buf The data that will be used to back the FILE* methods. Must be at least
+ *                 @c size bytes.
+ *      @param size The size of the @c buf data.
+ *      @param mode The permitted stream operation modes.
+ *      @returns A pointer that can be used in the fread/fwrite/fseek/fclose family of methods.
+ *               If a failure occurred NULL will be returned.
+ */
+FILE *fmemopen(void *buf, size_t size, const char *mode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // #ifndef FMEMOPEN_H_