ctags.rb 1.1.3 → 1.1.4

data/ext/vendor/ctags/main/field.h

@@ -55,7 +55,8 @@ typedef enum eFieldType { /* extension field content control */
 
 typedef const char* (* renderEscaped) (const tagEntryInfo *const tag,
 				       const char *value,
-				       vString * buffer);
+				       vString * buffer,
+					   bool *rejected);
 typedef bool (* isValueAvailable) (const struct sTagEntryInfo *const tag);
 
 #define FIELD_LETTER_NO_USE '\0'
@@ -99,7 +100,8 @@ extern void printFields (int language);
 extern bool isFieldRenderable (fieldType type);
 
 extern bool doesFieldHaveValue (fieldType type, const tagEntryInfo *tag);
-extern const char* renderFieldEscaped (writerType writer, fieldType type, const tagEntryInfo *tag, int index);
+extern const char* renderFieldEscaped (writerType writer, fieldType type, const tagEntryInfo *tag, int index,
+									   bool *rejected);
 
 extern void initFieldDescs (void);
 extern int countFields (void);

data/ext/vendor/ctags/main/fmt.c

@@ -60,7 +60,7 @@ static int printTagField (fmtSpec* fspec, MIO* fp, const tagEntryInfo * tag)
 
 	if (isCommonField (ftype))
 		/* TODO: Don't use WRITER_XREF directly */
-		str = renderFieldEscaped (WRITER_XREF, ftype, tag, NO_PARSER_FIELD);
+		str = renderFieldEscaped (WRITER_XREF, ftype, tag, NO_PARSER_FIELD, NULL);
 	else
 	{
 		unsigned int findex;
@@ -76,7 +76,7 @@ static int printTagField (fmtSpec* fspec, MIO* fp, const tagEntryInfo * tag)
 		else if (isFieldEnabled (tag->parserFields [findex].ftype))
 			/* TODO: Don't use WRITER_XREF directly */
 			str = renderFieldEscaped (WRITER_XREF, tag->parserFields [findex].ftype,
-						  tag, findex);
+						  tag, findex, NULL);
 	}
 
 	if (str == NULL)

data/ext/vendor/ctags/main/main.c

@@ -516,17 +516,17 @@ void interactiveLoop (cookedArgs *args, void *user CTAGS_ATTR_UNUSED)
       goto next;
     }
 
-    if (!strcmp ("list-parsers", json_string_value (command))) {
-            /* todo */
-    } else if (!strcmp ("generate-tags", json_string_value (command))) {
+    if (!strcmp ("generate-tags", json_string_value (command))) {
       json_int_t size = -1;
       const char *filename;
 
-      if (json_unpack (request, "{s?I ss}", "size", &size, "filename", &filename) == -1) {
+      if (json_unpack (request, "{ss}", "filename", &filename) == -1) {
         error (FATAL, "invalid generate-tags request");
         goto next;
       }
 
+      json_unpack (request, "{sI}", "size", &size);
+
       openTagFile ();
       if (size == -1) { /* read from disk */
         createTagsForEntry (filename);
@@ -614,7 +614,7 @@ extern int main (int argc CTAGS_ATTR_UNUSED, char **argv)
 
 	setErrorPrinter (stderrDefaultErrorPrinter, NULL);
 	setMainLoop (batchMakeTags, NULL);
-	setTagWriter (WRITER_CTAGS);
+	setTagWriter (WRITER_U_CTAGS);
 
 	setCurrentDirectory ();
 	setExecutableName (*argv++);

data/ext/vendor/ctags/main/options.c

@@ -360,12 +360,12 @@ static optionDescription LongOptionDescription [] = {
  {1,"      The encoding to write the tag file in. Defaults to UTF-8 if --input-encoding"},
  {1,"      is specified, otherwise no conversion is performed."},
 #endif
- {0,"  --output-format=ctags|etags|xref"
+ {0,"  --output-format=u-ctags|e-ctags|etags|xref"
 #ifdef HAVE_JANSSON
   "|json"
 #endif
  },
- {0,"      Specify the output format. [ctags]"},
+ {0,"      Specify the output format. [u-ctags]"},
  {1,"  --param-<LANG>=name:argument"},
  {1,"       Set <LANG> specific parameter. Available parameters can be listed with --list-params."},
  {0,"  --pattern-length-limit=N"},
@@ -763,6 +763,7 @@ static void setXrefMode (void)
 static void setJsonMode (void)
 {
 	enablePtag (PTAG_JSON_OUTPUT_VERSION, true);
+	enablePtag (PTAG_OUTPUT_MODE, false);
 	setTagWriter (WRITER_JSON);
 }
 #endif
@@ -2090,8 +2091,10 @@ static void processOutputFormat (const char *const option CTAGS_ATTR_UNUSED,
 	if (parameter [0] == '\0')
 		error (FATAL, "no output format name supplied for \"%s\"", option);
 
-	if (strcmp (parameter, "ctags") == 0)
+	if (strcmp (parameter, "u-ctags") == 0)
 		;
+	else if (strcmp (parameter, "e-ctags") == 0)
+		setTagWriter (WRITER_E_CTAGS);
 	else if (strcmp (parameter, "etags") == 0)
 		setEtagsMode ();
 	else if (strcmp (parameter, "xref") == 0)

data/ext/vendor/ctags/main/parse.c

@@ -2436,7 +2436,7 @@ extern bool parseFileWithMio (const char *const fileName, MIO *mio)
 			tagFileResized = createTagsWithXcmd (fileName, language, mio)? true: tagFileResized;
 #endif
 
-		teardownWriter (fileName);
+		tagFileResized = teardownWriter (fileName)? true: tagFileResized;
 
 		if (Option.filter && ! Option.interactive)
 			closeTagFile (tagFileResized);

data/ext/vendor/ctags/main/ptag.c

@@ -160,6 +160,10 @@ static ptagDesc ptagDescs [] = {
 	  "the letters, names and descriptions of kinds in a parser",
 	  ptagMakeKindDescriptions,
 	  false },
+	{ true, "TAG_OUTPUT_MODE",
+	  "the output mode: u-ctags or e-ctags",
+	  ptagMakeCtagsOutputMode,
+	  true },
 };
 
 extern bool makePtagIfEnabled (ptagType type, void *data)

data/ext/vendor/ctags/main/ptag.h

@@ -35,6 +35,7 @@ typedef enum ePtagType { /* pseudo tag content control */
 #endif
 	PTAG_KIND_SEPARATOR,
 	PTAG_KIND_DESCRIPTION,
+	PTAG_OUTPUT_MODE,
 	PTAG_COUNT
 } ptagType;
 

data/ext/vendor/ctags/main/writer-ctags.c

@@ -17,33 +17,73 @@
 #include "writer.h"
 
 
-static int writeCtagsEntry (MIO * mio, const tagEntryInfo *const tag, void *data CTAGS_ATTR_UNUSED);
-static int writeCtagsPtagEntry (MIO * mio, const ptagDesc *desc,
+static int writeCtagsEntry (tagWriter *writer CTAGS_ATTR_UNUSED,
+							MIO * mio, const tagEntryInfo *const tag);
+static int writeCtagsPtagEntry (tagWriter *writer CTAGS_ATTR_UNUSED,
+								MIO * mio, const ptagDesc *desc,
 								const char *const fileName,
 								const char *const pattern,
-								const char *const parserName, void *data CTAGS_ATTR_UNUSED);
+								const char *const parserName);
+static void buildCtagsFqTagCache (tagWriter *writer CTAGS_ATTR_UNUSED, tagEntryInfo *const tag);
 
-tagWriter ctagsWriter = {
+struct rejection {
+	bool rejectedInThisRendering;
+	bool rejectedInThisInput;
+};
+
+tagWriter uCtagsWriter = {
 	.writeEntry = writeCtagsEntry,
 	.writePtagEntry = writeCtagsPtagEntry,
 	.preWriteEntry = NULL,
 	.postWriteEntry = NULL,
+	.buildFqTagCache = buildCtagsFqTagCache,
 	.useStdoutByDefault = false,
 };
 
-static const char* escapeFieldValue (const tagEntryInfo * tag, fieldType ftype)
+static void *beginECtagsFile (tagWriter *writer, MIO * mio)
 {
-	return renderFieldEscaped (ctagsWriter.type, ftype, tag, NO_PARSER_FIELD);
+	static struct rejection rej;
+
+	rej.rejectedInThisInput = false;;
+
+	return &rej;
+}
+
+static bool endECTagsFile (tagWriter *writer, MIO * mio, const char* filename)
+{
+	struct rejection *rej = writer->private;
+	return rej->rejectedInThisInput;
+}
+
+tagWriter eCtagsWriter = {
+	.writeEntry = writeCtagsEntry,
+	.writePtagEntry = writeCtagsPtagEntry,
+	.preWriteEntry = beginECtagsFile,
+	.postWriteEntry = endECTagsFile,
+	.buildFqTagCache = buildCtagsFqTagCache,
+	.useStdoutByDefault = false,
+};
+
+static const char* escapeFieldValue (tagWriter *writer, const tagEntryInfo * tag, fieldType ftype)
+{
+	bool *reject = NULL;
+
+	if (writer->private)
+	{
+		struct rejection * rej = writer->private;
+		reject = &rej->rejectedInThisRendering;
+	}
+	return renderFieldEscaped (writer->type, ftype, tag, NO_PARSER_FIELD, reject);
 }
 
-static int renderExtensionFieldMaybe (int xftype, const tagEntryInfo *const tag, char sep[2], MIO *mio)
+static int renderExtensionFieldMaybe (tagWriter *writer, int xftype, const tagEntryInfo *const tag, char sep[2], MIO *mio)
 {
 	if (isFieldEnabled (xftype) && doesFieldHaveValue (xftype, tag))
 	{
 		int len;
 		len = mio_printf (mio, "%s\t%s:%s", sep,
 				  getFieldName (xftype),
-				  escapeFieldValue (tag, xftype));
+				  escapeFieldValue (writer, tag, xftype));
 		sep[0] = '\0';
 		return len;
 	}
@@ -51,11 +91,18 @@ static int renderExtensionFieldMaybe (int xftype, const tagEntryInfo *const tag,
 		return 0;
 }
 
-static int addParserFields (MIO * mio, const tagEntryInfo *const tag)
+static int addParserFields (tagWriter *writer, MIO * mio, const tagEntryInfo *const tag)
 {
 	unsigned int i;
 	unsigned int ftype;
 	int length = 0;
+	bool *reject = NULL;
+
+	if (writer->private)
+	{
+		struct rejection *rej = writer->private;
+		reject = &rej->rejectedInThisRendering;
+	}
 
 	for (i = 0; i < tag->usedParserFields; i++)
 	{
@@ -65,16 +112,16 @@ static int addParserFields (MIO * mio, const tagEntryInfo *const tag)
 
 		length += mio_printf(mio, "\t%s:%s",
 							 getFieldName (ftype),
-							 renderFieldEscaped (ctagsWriter.type,
-												 tag->parserFields [i].ftype, tag, i));
+							 renderFieldEscaped (writer->type,
+												 tag->parserFields [i].ftype, tag, i, reject));
 	}
 	return length;
 }
 
-static int writeLineNumberEntry (MIO * mio, const tagEntryInfo *const tag)
+static int writeLineNumberEntry (tagWriter *writer, MIO * mio, const tagEntryInfo *const tag)
 {
 	if (Option.lineDirectives)
-		return mio_printf (mio, "%s", escapeFieldValue (tag, FIELD_LINE_NUMBER));
+		return mio_printf (mio, "%s", escapeFieldValue (writer, tag, FIELD_LINE_NUMBER));
 	else
 		return mio_printf (mio, "%lu", tag->lineNumber);
 }
@@ -92,7 +139,7 @@ static int file_puts (const char* s, void *data)
 	return mio_puts (fp, s);
 }
 
-static int addExtensionFields (MIO *mio, const tagEntryInfo *const tag)
+static int addExtensionFields (tagWriter *writer, MIO *mio, const tagEntryInfo *const tag)
 {
 	bool isKindKeyEnabled = isFieldEnabled (FIELD_KIND_KEY);
 	bool isScopeEnabled = isFieldEnabled   (FIELD_SCOPE_KEY);
@@ -135,14 +182,14 @@ static int addExtensionFields (MIO *mio, const tagEntryInfo *const tag)
 		sep [0] = '\0';
 	}
 
-	length += renderExtensionFieldMaybe (FIELD_LANGUAGE, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_LANGUAGE, tag, sep, mio);
 
 	if (isFieldEnabled (FIELD_SCOPE))
 	{
 		const char* k = NULL, *v = NULL;
 
-		k = escapeFieldValue (tag, FIELD_SCOPE_KIND_LONG);
-		v = escapeFieldValue (tag, FIELD_SCOPE);
+		k = escapeFieldValue (writer, tag, FIELD_SCOPE_KIND_LONG);
+		v = escapeFieldValue (writer, tag, FIELD_SCOPE);
 		if (k && v)
 		{
 			length += mio_printf (mio, scopeFmt, sep, scopeKey, k, v);
@@ -155,7 +202,7 @@ static int addExtensionFields (MIO *mio, const tagEntryInfo *const tag)
 		length += mio_printf (mio, "%s\t%s:%s:%s", sep,
 				      getFieldName (FIELD_TYPE_REF),
 				      tag->extensionFields.typeRef [0],
-				      escapeFieldValue (tag, FIELD_TYPE_REF));
+				      escapeFieldValue (writer, tag, FIELD_TYPE_REF));
 		sep [0] = '\0';
 	}
 
@@ -166,14 +213,14 @@ static int addExtensionFields (MIO *mio, const tagEntryInfo *const tag)
 		sep [0] = '\0';
 	}
 
-	length += renderExtensionFieldMaybe (FIELD_INHERITANCE, tag, sep, mio);
-	length += renderExtensionFieldMaybe (FIELD_ACCESS, tag, sep, mio);
-	length += renderExtensionFieldMaybe (FIELD_IMPLEMENTATION, tag, sep, mio);
-	length += renderExtensionFieldMaybe (FIELD_SIGNATURE, tag, sep, mio);
-	length += renderExtensionFieldMaybe (FIELD_ROLE, tag, sep, mio);
-	length += renderExtensionFieldMaybe (FIELD_EXTRA, tag, sep, mio);
-	length += renderExtensionFieldMaybe (FIELD_XPATH, tag, sep, mio);
-	length += renderExtensionFieldMaybe (FIELD_END, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_INHERITANCE, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_ACCESS, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_IMPLEMENTATION, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_SIGNATURE, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_ROLE, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_EXTRA, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_XPATH, tag, sep, mio);
+	length += renderExtensionFieldMaybe (writer, FIELD_END, tag, sep, mio);
 
 	return length;
 }
@@ -183,14 +230,26 @@ static int writePatternEntry (MIO *mio, const tagEntryInfo *const tag)
 	return makePatternStringCommon (tag, file_putc, file_puts, mio);
 }
 
-static int writeCtagsEntry (MIO * mio, const tagEntryInfo *const tag, void *data CTAGS_ATTR_UNUSED)
+static int writeCtagsEntry (tagWriter *writer,
+							MIO * mio, const tagEntryInfo *const tag)
 {
+	long origin = 0;
+
+	if (writer->private)
+	{
+		struct rejection *rej = writer->private;
+
+		origin = mio_tell (mio);
+		rej->rejectedInThisRendering = false;
+
+	}
+
 	int length = mio_printf (mio, "%s\t%s\t",
-			      escapeFieldValue (tag, FIELD_NAME),
-			      escapeFieldValue (tag, FIELD_INPUT_FILE));
+			      escapeFieldValue (writer, tag, FIELD_NAME),
+			      escapeFieldValue (writer, tag, FIELD_INPUT_FILE));
 
 	if (tag->lineNumberEntry)
-		length += writeLineNumberEntry (mio, tag);
+		length += writeLineNumberEntry (writer, mio, tag);
 	else if (tag->pattern)
 		length += mio_printf(mio, "%s", tag->pattern);
 	else
@@ -198,19 +257,30 @@ static int writeCtagsEntry (MIO * mio, const tagEntryInfo *const tag, void *data
 
 	if (includeExtensionFlags ())
 	{
-		length += addExtensionFields (mio, tag);
-		length += addParserFields (mio, tag);
+		length += addExtensionFields (writer, mio, tag);
+		length += addParserFields (writer, mio, tag);
 	}
 
 	length += mio_printf (mio, "\n");
 
+	if (writer->private
+		&& ((struct rejection *)(writer->private))->rejectedInThisRendering)
+	{
+		mio_seek (mio, origin, SEEK_SET);
+
+		/* Truncation is needed. */
+		((struct rejection *)(writer->private))->rejectedInThisInput = true;
+
+		length = 0;
+	}
 	return length;
 }
 
-static int writeCtagsPtagEntry (MIO * mio, const ptagDesc *desc,
+static int writeCtagsPtagEntry (tagWriter *writer CTAGS_ATTR_UNUSED,
+				MIO * mio, const ptagDesc *desc,
 				const char *const fileName,
 				const char *const pattern,
-				const char *const parserName, void *data CTAGS_ATTR_UNUSED)
+				const char *const parserName)
 {
 	return parserName
 
@@ -223,3 +293,9 @@ static int writeCtagsPtagEntry (MIO * mio, const ptagDesc *desc,
 			      OPT(fileName), OPT(pattern));
 #undef OPT
 }
+
+static void buildCtagsFqTagCache (tagWriter *writer CTAGS_ATTR_UNUSED, tagEntryInfo *const tag)
+{
+	escapeFieldValue (writer, tag, FIELD_SCOPE_KIND_LONG);
+	escapeFieldValue (writer, tag, FIELD_SCOPE);
+}

data/ext/vendor/ctags/main/writer-etags.c

@@ -20,9 +20,9 @@
 #include "writer.h"
 
 
-static int writeEtagsEntry (MIO * mio, const tagEntryInfo *const tag, void *data);
-static void *beginEtagsFile (MIO * mio);
-static void  endEtagsFile   (MIO * mio, const char* filename, void *data);
+static int writeEtagsEntry  (tagWriter *writer, MIO * mio, const tagEntryInfo *const tag);
+static void *beginEtagsFile (tagWriter *writer, MIO * mio);
+static bool  endEtagsFile   (tagWriter *writer, MIO * mio, const char* filename);
 
 tagWriter etagsWriter = {
 	.writeEntry = writeEtagsEntry,
@@ -40,7 +40,7 @@ struct sEtags {
 
 
 
-static void *beginEtagsFile (MIO *mio)
+static void *beginEtagsFile (tagWriter *writer CTAGS_ATTR_UNUSED, MIO *mio)
 {
 	static struct sEtags etags = { NULL, NULL, 0, NULL };
 
@@ -50,10 +50,11 @@ static void *beginEtagsFile (MIO *mio)
 	return &etags;
 }
 
-static void endEtagsFile (MIO *mainfp, const char *filename, void *data)
+static bool endEtagsFile (tagWriter *writer,
+						  MIO *mainfp, const char *filename)
 {
 	const char *line;
-	struct sEtags *etags = data;
+	struct sEtags *etags = writer->private;
 
 	mio_printf (mainfp, "\f\n%s,%ld\n", filename, (long) etags->byteCount);
 	abort_if_ferror (mainfp);
@@ -73,12 +74,14 @@ static void endEtagsFile (MIO *mainfp, const char *filename, void *data)
 		etags->mio = NULL;
 		etags->name = NULL;
 	}
+	return false;
 }
 
-static int writeEtagsEntry (MIO * mio, const tagEntryInfo *const tag, void *data)
+static int writeEtagsEntry (tagWriter *writer,
+							MIO * mio, const tagEntryInfo *const tag)
 {
 	int length;
-	struct sEtags *etags = data;
+	struct sEtags *etags = writer->private;
 
 	mio = etags->mio;
 

data/ext/vendor/ctags/main/writer-json.c

@@ -24,12 +24,14 @@
 #endif
 
 
-static int writeJsonEntry  (MIO * mio, const tagEntryInfo *const tag, void *data CTAGS_ATTR_UNUSED);
+static int writeJsonEntry  (tagWriter *writer CTAGS_ATTR_UNUSED,
+				MIO * mio, const tagEntryInfo *const tag);
 
-static int writeJsonPtagEntry (MIO * mio, const ptagDesc *desc,
+static int writeJsonPtagEntry (tagWriter *writer CTAGS_ATTR_UNUSED,
+				MIO * mio, const ptagDesc *desc,
 				const char *const fileName,
 				const char *const pattern,
-				const char *const parserName, void *data CTAGS_ATTR_UNUSED);
+				const char *const parserName);
 
 tagWriter jsonWriter = {
 	.writeEntry = writeJsonEntry,
@@ -42,7 +44,7 @@ tagWriter jsonWriter = {
 
 static json_t* escapeFieldValue (const tagEntryInfo * tag, fieldType ftype)
 {
-	const char *str = renderFieldEscaped (jsonWriter.type, ftype, tag, NO_PARSER_FIELD);
+	const char *str = renderFieldEscaped (jsonWriter.type, ftype, tag, NO_PARSER_FIELD, NULL);
 	if (str)
 		return json_string (str);
 	else
@@ -111,14 +113,21 @@ static void addExtensionFields (json_t *response, const tagEntryInfo *const tag)
 		renderExtensionFieldMaybe (k, tag, response);
 }
 
-static int writeJsonEntry (MIO * mio, const tagEntryInfo *const tag, void *data CTAGS_ATTR_UNUSED)
+static int writeJsonEntry (tagWriter *writer CTAGS_ATTR_UNUSED,
+			       MIO * mio, const tagEntryInfo *const tag)
 {
+	const char *pattern = tag->pattern;
+	if (!pattern)
+	{
+		pattern = makePatternString (tag);
+	}
+
 	json_t *response = json_pack ("{ss ss ss ss}",
 		"_type", "tag",
 		"name", tag->name,
 		"path", tag->sourceFileName,
 		/* --extra=f option can generates a tag with NULL pattern. */
-		"pattern", tag->pattern? tag->pattern: ""
+		"pattern", pattern? pattern: ""
 	);
 
 	if (includeExtensionFlags ())
@@ -136,10 +145,11 @@ static int writeJsonEntry (MIO * mio, const tagEntryInfo *const tag, void *data
 	return length;
 }
 
-static int writeJsonPtagEntry (MIO * mio, const ptagDesc *desc,
+static int writeJsonPtagEntry (tagWriter *writer CTAGS_ATTR_UNUSED,
+			       MIO * mio, const ptagDesc *desc,
 			       const char *const fileName,
 			       const char *const pattern,
-			       const char *const parserName, void *data CTAGS_ATTR_UNUSED)
+			       const char *const parserName)
 {
 #define OPT(X) ((X)?(X):"")
 	json_t *response;