diff --git a/.fmf/version b/.fmf/version
deleted file mode 100644
index d00491f..0000000
--- a/.fmf/version
+++ /dev/null
@@ -1 +0,0 @@
-1
diff --git a/.gitignore b/.gitignore
index ab96034..fb3f2bc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,19 +2,3 @@ ctags-5.5.4.tar.gz
 ctags-5.6.tar.gz
 ctags-5.7.tar.gz
 ctags-5.8.tar.gz
-/ctags-p5.9.20210307.0.tar.gz
-/ctags-p5.9.20210509.0.tar.gz
-/ctags-p5.9.20210725.0.tar.gz
-/ctags-p5.9.20220206.0.tar.gz
-/ctags-p5.9.20220313.0.tar.gz
-/ctags-p5.9.20220424.0.tar.gz
-/ctags-p5.9.20220508.0.tar.gz
-/ctags-p5.9.20220619.0.tar.gz
-/ctags-p5.9.20220724.0.tar.gz
-/ctags-p5.9.20220911.0.tar.gz
-/ctags-p5.9.20221016.0.tar.gz
-/ctags-p5.9.20221120.0.tar.gz
-/universal-ctags-6.0.0.tar.gz
-/universal-ctags-6.1.0.tar.gz
-/universal-ctags-6.2.0.tar.gz
-/universal-ctags-6.2.1.tar.gz
diff --git a/ctags-5.7-destdir.patch b/ctags-5.7-destdir.patch
new file mode 100644
index 0000000..0aeafab
--- /dev/null
+++ b/ctags-5.7-destdir.patch
@@ -0,0 +1,44 @@
+diff -up ctags-5.7/Makefile.in.destdir ctags-5.7/Makefile.in
+--- ctags-5.7/Makefile.in.destdir	2006-10-12 05:26:40.000000000 +0200
++++ ctags-5.7/Makefile.in	2008-02-15 17:10:23.000000000 +0100
+@@ -59,7 +59,7 @@ include $(srcdir)/source.mak
+ 
+ VPATH	= $(srcdir)
+ 
+-INSTALL		= cp
++INSTALL		= cp -p
+ INSTALL_PROG	= $(INSTALL)
+ INSTALL_DATA	= $(INSTALL)
+ 
+@@ -138,7 +141,8 @@ install-ebin: $(DEST_ETAGS)
+ install-lib: $(DEST_READ_LIB) $(DEST_READ_INC)
+ 
+ $(DEST_CTAGS): $(CTAGS_EXEC) $(bindir) FORCE
+-	$(INSTALL_PROG) $(CTAGS_EXEC) $@  &&  chmod 755 $@
++	$(srcdir)/mkinstalldirs $(DESTDIR)$(bindir)
++	$(INSTALL_PROG) $(CTAGS_EXEC) $(DESTDIR)$@  &&  chmod 755 $(DESTDIR)$@
+ 
+ $(DEST_ETAGS):
+ 	- if [ -x $(DEST_CTAGS) ]; then \
+@@ -153,7 +157,8 @@ install-cman: $(DEST_CMAN)
+ install-eman: $(DEST_EMAN)
+ 
+ $(DEST_CMAN): $(man1dir) $(MANPAGE) FORCE
+-	- $(INSTALL_DATA) $(srcdir)/$(MANPAGE) $@  &&  chmod 644 $@
++	$(srcdir)/mkinstalldirs $(DESTDIR)$(man1dir)
++	- $(INSTALL_DATA) $(srcdir)/$(MANPAGE) $(DESTDIR)$@  &&  chmod 644 $(DESTDIR)$@
+ 
+ $(DEST_EMAN):
+ 	- if [ -f $(DEST_CMAN) ]; then \
+@@ -164,9 +169,11 @@ $(DEST_EMAN):
+ # install the library
+ #
+ $(DEST_READ_LIB): $(READ_LIB) $(libdir) FORCE
++	$(srcdir)/mkinstalldirs $(DESTDIR)$(libdir)
+ 	$(INSTALL_PROG) $(READ_LIB) $@  &&  chmod 644 $@
+ 
+ $(DEST_READ_INC): $(READ_INC) $(incdir) FORCE
++	$(srcdir)/mkinstalldirs $(DESTDIR)$(incdir)
+ 	$(INSTALL_PROG) $(READ_INC) $@  &&  chmod 644 $@
+ 
+ 
diff --git a/ctags-5.7-segment-fault.patch b/ctags-5.7-segment-fault.patch
new file mode 100644
index 0000000..60e8809
--- /dev/null
+++ b/ctags-5.7-segment-fault.patch
@@ -0,0 +1,41 @@
+diff -ruN -x '*~' ctags-5.7/vim.c ctags-5.7/vim.c
+--- ctags-5.7/vim.c	2006-10-26 12:06:21.000000000 +0900
++++ ctags-5.7/vim.c	2009-08-28 22:21:31.000000000 +0900
+@@ -328,7 +328,7 @@
+ 	 */
+ 	const unsigned char *cp = line;
+ 
+-	if ( (int) *cp == '\\' ) 
++	if ( cp && ( (int) *cp == '\\' ) ) 
+ 	{
+ 		/*
+ 		 * We are recursively calling this function is the command
+@@ -350,9 +350,10 @@
+ 		while (*cp && isspace ((int) *cp))
+ 			++cp; 
+ 	}
+-	else if ( (!strncmp ((const char*) line, "comp", (size_t) 4) == 0) && 
+-		     (!strncmp ((const char*) line, "comc", (size_t) 4) == 0) && 
+-				(strncmp ((const char*) line, "com", (size_t) 3) == 0) )
++	else if ( line && 
++                     (!strncmp ((const char*) line, "comp", (size_t) 4) == 0) && 
++		                (!strncmp ((const char*) line, "comc", (size_t) 4) == 0) && 
++				          (strncmp ((const char*) line, "com", (size_t) 3) == 0) )
+ 	{
+ 		cp += 2;
+ 		if ((int) *++cp == 'm' && (int) *++cp == 'a' &&
+@@ -394,6 +395,14 @@
+ 			while (*cp && !isspace ((int) *cp))
+ 				++cp; 
+ 		}
++		else if (!isalnum ((int) *cp))
++		{
++			/*
++			 * Broken syntax: throw away this line
++			 */
++			cmdProcessed = TRUE;
++			goto cleanUp;
++		}
+ 	} while ( *cp &&  !isalnum ((int) *cp) );
+ 
+ 	if ( ! *cp )
diff --git a/ctags-5.8-css.patch b/ctags-5.8-css.patch
new file mode 100644
index 0000000..2744d33
--- /dev/null
+++ b/ctags-5.8-css.patch
@@ -0,0 +1,260 @@
+diff -up ctags-5.8/css.c.me ctags-5.8/css.c
+--- ctags-5.8/css.c.me	2012-02-08 13:59:35.000000000 +0100
++++ ctags-5.8/css.c	2012-02-08 13:55:16.000000000 +0100
+@@ -0,0 +1,226 @@
++/***************************************************************************
++ * css.c
++ * Character-based parser for Css definitions
++ * Author - Iago Rubio <iagorubio(at)users.sourceforge.net>
++ **************************************************************************/
++#include "general.h"
++
++#include <string.h> 
++#include <ctype.h> 
++
++#include "parse.h" 
++#include "read.h" 
++
++
++typedef enum eCssKinds {
++    K_NONE = -1, K_CLASS, K_SELECTOR, K_ID
++} cssKind;
++
++static kindOption CssKinds [] = {
++    { TRUE, 'c', "class", "classes" },
++    { TRUE, 's', "selector",  "selectors"  },
++    { TRUE, 'i', "id",  "identities"  }
++};
++
++typedef enum _CssParserState {  // state of parsing
++  P_STATE_NONE,         // default state
++  P_STATE_IN_COMMENT,     // into a comment, only multi line in CSS
++  P_STATE_IN_SINGLE_STRING, // into a single quoted string
++  P_STATE_IN_DOUBLE_STRING, // into a double quoted string
++  P_STATE_IN_DEFINITION,    // on the body of the style definition, nothing for us
++  P_STATE_IN_MEDIA,     // on a @media declaration, can be multi-line
++  P_STATE_IN_IMPORT,      // on a @import declaration, can be multi-line
++  P_STATE_IN_NAMESPACE,   // on a @namespace declaration  
++  P_STATE_IN_PAGE,      // on a @page declaration
++  P_STATE_IN_FONTFACE,    // on a @font-face declaration
++  P_STATE_AT_END        // end of parsing
++} CssParserState;
++
++static void makeCssSimpleTag( vString *name, cssKind kind, boolean delete )
++{
++  vStringTerminate (name);
++  makeSimpleTag (name, CssKinds, kind);
++  vStringClear (name);
++  if( delete )
++    vStringDelete (name);
++}
++
++static boolean isCssDeclarationAllowedChar( const unsigned char *cp )
++{
++  return  isalnum ((int) *cp) ||
++      isspace ((int) *cp) ||
++      *cp == '_' || // allowed char
++      *cp == '-' || // allowed char     
++      *cp == '+' ||   // allow all sibling in a single tag
++      *cp == '>' ||   // allow all child in a single tag 
++      *cp == '{' ||   // allow the start of the declaration
++      *cp == '.' ||   // allow classes and selectors
++      *cp == ',' ||   // allow multiple declarations
++      *cp == ':' ||   // allow pseudo classes
++      *cp == '*' ||   // allow globs as P + *
++      *cp == '#';   // allow ids 
++}
++
++static CssParserState parseCssDeclaration( const unsigned char **position, cssKind kind )
++{
++  vString *name = vStringNew ();
++  const unsigned char *cp = *position;
++
++  // pick to the end of line including children and sibling
++  // if declaration is multiline go for the next line 
++  while ( isCssDeclarationAllowedChar(cp) || 
++      *cp == '\0' )   // track the end of line into the loop
++  {
++    if( (int) *cp == '\0' )
++    { 
++      cp = fileReadLine ();
++      if( cp == NULL ){
++        makeCssSimpleTag(name, kind, TRUE);
++        *position = cp;
++        return P_STATE_AT_END;
++      }
++    }
++    else if( *cp == ',' )
++    {
++      makeCssSimpleTag(name, kind, TRUE);
++      *position = ++cp;
++      return P_STATE_NONE;
++    }
++    else if( *cp == '{' )
++    {
++      makeCssSimpleTag(name, kind, TRUE);
++      *position = ++cp;
++      return P_STATE_IN_DEFINITION;
++    }
++
++    vStringPut (name, (int) *cp);
++    ++cp;
++  }
++  
++  makeCssSimpleTag(name, kind, TRUE);
++  *position = cp;
++
++  return P_STATE_NONE;
++}
++
++static CssParserState parseCssLine( const unsigned char *line, CssParserState state )
++{
++  vString *aux;
++
++  while( *line != '\0' ) // fileReadLine returns NULL terminated strings
++  {
++    while (isspace ((int) *line))
++      ++line;
++    switch( state )
++    {
++      case P_STATE_NONE:
++        // pick first char if alphanumeric is a selector
++        if( isalnum ((int) *line) )
++          state = parseCssDeclaration( &line, K_SELECTOR );
++        else if( *line == '.' ) // a class
++          state = parseCssDeclaration( &line, K_CLASS );
++        else if( *line == '#' ) // an id
++          state = parseCssDeclaration( &line, K_ID );
++        else if( *line == '@' ) // at-rules, we'll ignore them
++        {
++          ++line;
++          aux = vStringNew();
++          while( !isspace((int) *line) )
++          {
++            vStringPut (aux, (int) *line);
++            ++line;         
++          }
++          vStringTerminate (aux);
++          if( strcmp( aux->buffer, "media" ) == 0 )
++            state = P_STATE_IN_MEDIA;
++          else if ( strcmp( aux->buffer, "import" ) == 0 )
++            state = P_STATE_IN_IMPORT;
++          else if ( strcmp( aux->buffer, "namespace" ) == 0 )
++            state = P_STATE_IN_NAMESPACE; 
++          else if ( strcmp( aux->buffer, "page" ) == 0 )
++            state = P_STATE_IN_PAGE;
++          else if ( strcmp( aux->buffer, "font-face" ) == 0 )
++            state = P_STATE_IN_FONTFACE;
++          vStringDelete (aux);
++        }
++        else if( *line == '*' && *(line-1) == '/' ) // multi-line comment
++          state = P_STATE_IN_COMMENT;
++      break;
++      case P_STATE_IN_COMMENT:
++        if( *line == '/' && *(line-1) == '*')
++          state = P_STATE_NONE;
++      break;
++      case  P_STATE_IN_SINGLE_STRING: 
++        if( *line == '\'' && *(line-1) != '\\' )
++          state = P_STATE_IN_DEFINITION; // PAGE, FONTFACE and DEFINITION are treated the same way
++      break;
++      case  P_STATE_IN_DOUBLE_STRING:
++        if( *line=='"' && *(line-1) != '\\' )
++          state = P_STATE_IN_DEFINITION; // PAGE, FONTFACE and DEFINITION are treated the same way
++      break;
++      case  P_STATE_IN_MEDIA:
++        // skip to start of media body or line end
++        while( *line != '{' )
++        {
++          if( *line == '\0' )
++            break;
++          ++line;
++        }
++        if( *line == '{' )
++            state = P_STATE_NONE;
++      break;
++      case  P_STATE_IN_IMPORT:
++      case  P_STATE_IN_NAMESPACE:
++        // skip to end of declaration or line end
++        while( *line != ';' )
++        {
++          if( *line == '\0' )
++            break;
++          ++line;
++        }
++        if( *line == ';' )
++          state = P_STATE_NONE;
++      break;
++      case P_STATE_IN_PAGE:
++      case P_STATE_IN_FONTFACE:
++      case P_STATE_IN_DEFINITION:
++        if( *line == '}' )
++          state = P_STATE_NONE;
++        else if( *line == '\'' )
++          state = P_STATE_IN_SINGLE_STRING;
++        else if( *line == '"' )
++          state = P_STATE_IN_DOUBLE_STRING;
++      break;
++      case P_STATE_AT_END:
++        return state;
++      break;
++    }   
++    line++;
++  }
++  return state;
++}
++
++static void findCssTags (void)
++{
++    const unsigned char *line;
++  CssParserState state = P_STATE_NONE;
++
++    while ( (line = fileReadLine ()) != NULL )
++    {
++    state = parseCssLine( line, state );
++    if( state==P_STATE_AT_END ) return;
++    }    
++}
++
++/* parser definition */
++extern parserDefinition* CssParser (void)
++{
++    static const char *const extensions [] = { "css", NULL };
++    parserDefinition* def = parserNew ("CSS");
++    def->kinds      = CssKinds;
++    def->kindCount  = KIND_COUNT (CssKinds);
++    def->extensions = extensions;
++    def->parser     = findCssTags;
++    return def;
++}
++
+diff -up ctags-5.8/parsers.h.me ctags-5.8/parsers.h
+--- ctags-5.8/parsers.h.me	2012-02-08 13:56:46.000000000 +0100
++++ ctags-5.8/parsers.h	2012-02-08 13:57:25.000000000 +0100
+@@ -26,6 +26,7 @@
+ 	CppParser, \
+ 	CsharpParser, \
+ 	CobolParser, \
++	CssParser, \
+ 	DosBatchParser, \
+ 	EiffelParser, \
+ 	ErlangParser, \
+diff -up ctags-5.8/source.mak.me ctags-5.8/source.mak
+--- ctags-5.8/source.mak.me	2012-02-08 13:58:02.000000000 +0100
++++ ctags-5.8/source.mak	2012-02-08 13:58:42.000000000 +0100
+@@ -17,6 +17,7 @@ SOURCES = \
+ 	beta.c \
+ 	c.c \
+ 	cobol.c \
++	css.c \
+ 	dosbatch.c \
+ 	eiffel.c \
+ 	entry.c \
+@@ -79,6 +80,7 @@ OBJECTS = \
+ 	beta.$(OBJEXT) \
+ 	c.$(OBJEXT) \
+ 	cobol.$(OBJEXT) \
++	css.$(OBJEXT) \
+ 	dosbatch.$(OBJEXT) \
+ 	eiffel.$(OBJEXT) \
+ 	entry.$(OBJEXT) \
diff --git a/ctags-5.8-cssparse.patch b/ctags-5.8-cssparse.patch
new file mode 100644
index 0000000..f70c374
--- /dev/null
+++ b/ctags-5.8-cssparse.patch
@@ -0,0 +1,16 @@
+diff -up ctags-5.8/css.c.me ctags-5.8/css.c
+--- ctags-5.8/css.c.me	2012-10-18 22:03:20.126163700 +0200
++++ ctags-5.8/css.c	2012-10-18 22:04:03.237107358 +0200
+@@ -73,10 +73,11 @@ static CssParserState parseCssDeclaratio
+   {
+     if( (int) *cp == '\0' )
+     { 
++      /* assign position to the end of line. */
++      *position = cp;
+       cp = fileReadLine ();
+       if( cp == NULL ){
+         makeCssSimpleTag(name, kind, TRUE);
+-        *position = cp;
+         return P_STATE_AT_END;
+       }
+     }
diff --git a/ctags-5.8-format-security.patch b/ctags-5.8-format-security.patch
new file mode 100644
index 0000000..ccd3986
--- /dev/null
+++ b/ctags-5.8-format-security.patch
@@ -0,0 +1,12 @@
+diff -Naur ctags-5.8.orig/lregex.c ctags-5.8/lregex.c
+--- ctags-5.8.orig/lregex.c	2007-09-10 04:36:48.000000000 +0200
++++ ctags-5.8/lregex.c	2014-04-14 21:09:17.716000000 +0200
+@@ -408,7 +408,7 @@
+ 		const char* regexfile = parameter + 1;
+ 		FILE* const fp = fopen (regexfile, "r");
+ 		if (fp == NULL)
+-			error (WARNING | PERROR, regexfile);
++			error (WARNING | PERROR, "%s", regexfile);
+ 		else
+ 		{
+ 			vString* const regex = vStringNew ();
diff --git a/ctags-5.8-memmove.patch b/ctags-5.8-memmove.patch
new file mode 100644
index 0000000..5608f04
--- /dev/null
+++ b/ctags-5.8-memmove.patch
@@ -0,0 +1,19 @@
+diff -r -u ctags-5.8.orig/routines.c ctags-5.8/routines.c
+--- ctags-5.8.orig/routines.c	2013-06-13 10:42:08.048576327 -0400
++++ ctags-5.8/routines.c	2013-06-13 10:48:25.150366836 -0400
+@@ -757,13 +757,13 @@
+ 				else if (cp [0] != PATH_SEPARATOR)
+ 					cp = slashp;
+ #endif
+-				strcpy (cp, slashp + 3);
++				memmove (cp, slashp + 3, strlen(slashp + 3) + 1);
+ 				slashp = cp;
+ 				continue;
+ 			}
+ 			else if (slashp [2] == PATH_SEPARATOR  ||  slashp [2] == '\0')
+ 			{
+-				strcpy (slashp, slashp + 2);
++				memmove (slashp, slashp + 2, strlen(slashp + 2) + 1);
+ 				continue;
+ 			}
+ 		}
diff --git a/ctags-5.8-ocaml-crash.patch b/ctags-5.8-ocaml-crash.patch
new file mode 100644
index 0000000..8263cca
--- /dev/null
+++ b/ctags-5.8-ocaml-crash.patch
@@ -0,0 +1,251 @@
+diff -up ctags-5.8/ocaml.c.me ctags-5.8/ocaml.c
+--- ctags-5.8/ocaml.c.me	2012-08-02 12:42:21.652211192 +0200
++++ ctags-5.8/ocaml.c	2012-08-02 13:06:59.751283639 +0200
+@@ -72,6 +72,7 @@ typedef enum {
+ 	OcaKEYWORD_if,
+ 	OcaKEYWORD_in,
+ 	OcaKEYWORD_let,
++	OcaKEYWORD_value,
+ 	OcaKEYWORD_match,
+ 	OcaKEYWORD_method,
+ 	OcaKEYWORD_module,
+@@ -145,7 +146,7 @@ static const ocaKeywordDesc OcamlKeyword
+ 	{ "try"       , OcaKEYWORD_try       }, 
+ 	{ "type"      , OcaKEYWORD_type      }, 
+ 	{ "val"       , OcaKEYWORD_val       }, 
+-	{ "value"     , OcaKEYWORD_let       }, /* just to handle revised syntax */
++	{ "value"     , OcaKEYWORD_value     }, /* just to handle revised syntax */
+ 	{ "virtual"   , OcaKEYWORD_virtual   }, 
+ 	{ "while"     , OcaKEYWORD_while     }, 
+ 	{ "with"      , OcaKEYWORD_with      }, 
+@@ -297,7 +298,6 @@ static void eatComment (lexingState * st
+ 			if (st->cp == NULL)
+ 				return;
+ 			c = st->cp;
+-			continue;
+ 		}
+ 		/* we've reached the end of the comment */
+ 		else if (*c == ')' && lastIsStar)
+@@ -308,13 +308,33 @@ static void eatComment (lexingState * st
+ 		{
+ 			st->cp = c;
+ 			eatComment (st);
++
+ 			c = st->cp;
++			if (c == NULL)
++			    return;
++
+ 			lastIsStar = FALSE;
++            c++;
+ 		}
++		/* OCaml has a rule which says :
++		 *
++		 *   "Comments do not occur inside string or character literals.
++		 *    Nested comments are handled correctly."
++		 *
++		 * So if we encounter a string beginning, we must parse it to
++		 * get a good comment nesting (bug ID: 3117537)
++		 */
++        else if (*c == '"')
++        {
++            st->cp = c;
++            eatString (st);
++            c = st->cp;
++        }
+ 		else
++        {
+ 			lastIsStar = '*' == *c;
+-
+-		c++;
++            c++;
++        }
+ 	}
+ 
+ 	st->cp = c;
+@@ -554,8 +574,7 @@ static int getLastNamedIndex ( void )
+ 
+ 	for (i = stackIndex - 1; i >= 0; --i)
+ 	{
+-		if (stack[i].contextName->buffer &&
+-			strlen (stack[i].contextName->buffer) > 0)
++        if (vStringLength (stack[i].contextName) > 0)
+ 		{
+ 			return i;
+ 		}
+@@ -866,6 +885,11 @@ static void prepareTag (tagEntryInfo * t
+ 	tag->kindName = OcamlKinds[kind].name;
+ 	tag->kind = OcamlKinds[kind].letter;
+ 
++	if (kind == K_MODULE)
++	{
++		tag->lineNumberEntry = TRUE;
++		tag->lineNumber = 1;
++	}
+ 	parentIndex = getLastNamedIndex ();
+ 	if (parentIndex >= 0)
+ 	{
+@@ -880,9 +904,12 @@ static void prepareTag (tagEntryInfo * t
+  * more information to it in the future */
+ static void addTag (vString * const ident, int kind)
+ {
+-	tagEntryInfo toCreate;
+-	prepareTag (&toCreate, ident, kind);
+-	makeTagEntry (&toCreate);
++	if (OcamlKinds [kind].enabled  &&  ident != NULL  &&  vStringLength (ident) > 0)
++	{
++		tagEntryInfo toCreate;
++		prepareTag (&toCreate, ident, kind);
++		makeTagEntry (&toCreate);
++	}
+ }
+ 
+ boolean needStrongPoping = FALSE;
+@@ -942,15 +969,17 @@ static void typeRecord (vString * const
+ }
+ 
+ /* handle :
+- * exception ExceptionName ... */
++ * exception ExceptionName of ... */
+ static void exceptionDecl (vString * const ident, ocaToken what)
+ {
+ 	if (what == OcaIDENTIFIER)
+ 	{
+ 		addTag (ident, K_EXCEPTION);
+ 	}
+-	/* don't know what to do on else... */
+-
++    else /* probably ill-formed, give back to global scope */
++    { 
++        globalScope (ident, what);
++    }
+ 	toDoNext = &globalScope;
+ }
+ 
+@@ -1006,7 +1035,6 @@ static void constructorValidation (vStri
+  */
+ static void typeDecl (vString * const ident, ocaToken what)
+ {
+-
+ 	switch (what)
+ 	{
+ 		/* parameterized */
+@@ -1046,7 +1074,6 @@ static void typeDecl (vString * const id
+  * let typeRecord handle it. */
+ static void typeSpecification (vString * const ident, ocaToken what)
+ {
+-
+ 	switch (what)
+ 	{
+ 	case OcaIDENTIFIER:
+@@ -1243,8 +1270,14 @@ static void localLet (vString * const id
+  * than the let definitions.
+  * Used after a match ... with, or a function ... or fun ...
+  * because their syntax is similar.  */
+-static void matchPattern (vString * const UNUSED (ident), ocaToken what)
++static void matchPattern (vString * const ident, ocaToken what)
+ {
++    /* keep track of [], as it
++     * can be used in patterns and can
++     * mean the end of match expression in
++     * revised syntax */
++    static int braceCount = 0;
++
+ 	switch (what)
+ 	{
+ 	case Tok_To:
+@@ -1252,6 +1285,14 @@ static void matchPattern (vString * cons
+ 		toDoNext = &mayRedeclare;
+ 		break;
+ 
++    case Tok_BRL:
++        braceCount++;
++        break;
++
++    case OcaKEYWORD_value:
++		popLastNamed ();
++        globalScope (ident, what);
++        break;
+ 
+ 	case OcaKEYWORD_in:
+ 		popLastNamed ();
+@@ -1269,6 +1310,11 @@ static void mayRedeclare (vString * cons
+ {
+ 	switch (what)
+ 	{
++    case OcaKEYWORD_value:
++        /* let globalScope handle it */
++        globalScope (ident, what);
++        break;
++
+ 	case OcaKEYWORD_let:
+ 	case OcaKEYWORD_val:
+ 		toDoNext = localLet;
+@@ -1388,6 +1434,7 @@ static void classSpecif (vString * const
+  * nearly a copy/paste of globalLet. */
+ static void methodDecl (vString * const ident, ocaToken what)
+ {
++
+ 	switch (what)
+ 	{
+ 	case Tok_PARL:
+@@ -1435,6 +1482,7 @@ vString *lastModule;
+  */
+ static void moduleSpecif (vString * const ident, ocaToken what)
+ {
++
+ 	switch (what)
+ 	{
+ 	case OcaKEYWORD_functor:
+@@ -1566,7 +1614,7 @@ static void globalScope (vString * const
+ {
+ 	/* Do not touch, this is used only by the global scope
+ 	 * to handle an 'and' */
+-	static parseNext previousParser = NULL;
++	static parseNext previousParser = &globalScope;
+ 
+ 	switch (what)
+ 	{
+@@ -1608,6 +1656,7 @@ static void globalScope (vString * const
+ 		/* val is mixed with let as global
+ 		 * to be able to handle mli & new syntax */
+ 	case OcaKEYWORD_val:
++	case OcaKEYWORD_value:
+ 	case OcaKEYWORD_let:
+ 		cleanupPreviousParser ();
+ 		toDoNext = &globalLet;
+@@ -1617,7 +1666,7 @@ static void globalScope (vString * const
+ 	case OcaKEYWORD_exception:
+ 		cleanupPreviousParser ();
+ 		toDoNext = &exceptionDecl;
+-		previousParser = NULL;
++		previousParser = &globalScope;
+ 		break;
+ 
+ 		/* must be a #line directive, discard the
+@@ -1769,7 +1818,7 @@ static void computeModuleName ( void )
+ 	if (isLowerAlpha (moduleName->buffer[0]))
+ 		moduleName->buffer[0] += ('A' - 'a');
+ 
+-	makeSimpleTag (moduleName, OcamlKinds, K_MODULE);
++	addTag (moduleName, K_MODULE);
+ 	vStringDelete (moduleName);
+ }
+ 
+@@ -1779,6 +1828,7 @@ static void initStack ( void )
+ 	int i;
+ 	for (i = 0; i < OCAML_MAX_STACK_SIZE; ++i)
+ 		stack[i].contextName = vStringNew ();
++    stackIndex = 0;
+ }
+ 
+ static void clearStack ( void )
+@@ -1794,8 +1844,8 @@ static void findOcamlTags (void)
+ 	lexingState st;
+ 	ocaToken tok;
+ 
+-	computeModuleName ();
+ 	initStack ();
++	computeModuleName ();
+ 	tempIdent = vStringNew ();
+ 	lastModule = vStringNew ();
+ 	lastClass = vStringNew ();
diff --git a/ctags-CVE-2014-7204.patch b/ctags-CVE-2014-7204.patch
new file mode 100644
index 0000000..81c5e6e
--- /dev/null
+++ b/ctags-CVE-2014-7204.patch
@@ -0,0 +1,89 @@
+--- ctags/jscript.c.orig	2008-10-13 00:27:38.000000000 +0200
++++ ctags/jscript.c	2014-09-30 13:49:34.837349283 +0200
+@@ -1,5 +1,5 @@
+ /*
+- *	 $Id: jscript.c 666 2008-05-15 17:47:31Z dfishburn $
++ *	 $Id: jscript.c 791 2012-10-24 01:13:13Z dfishburn $
+  *
+  *	 Copyright (c) 2003, Darren Hiebert
+  *
+@@ -215,6 +215,7 @@
+  *	 Tag generation functions
+  */
+ 
++/*
+ static void makeConstTag (tokenInfo *const token, const jsKind kind)
+ {
+ 	if (JsKinds [kind].enabled && ! token->ignoreTag )
+@@ -238,12 +239,13 @@
+ 
+ 	if (JsKinds [kind].enabled && ! token->ignoreTag )
+ 	{
+-		/*
++		*
+ 		 * If a scope has been added to the token, change the token
+ 		 * string to include the scope when making the tag.
+-		 */
++		 *
+ 		if ( vStringLength(token->scope) > 0 )
+ 		{
++			*
+ 			fulltag = vStringNew ();
+ 			vStringCopy(fulltag, token->scope);
+ 			vStringCatS (fulltag, ".");
+@@ -251,8 +253,54 @@
+ 			vStringTerminate(fulltag);
+ 			vStringCopy(token->string, fulltag);
+ 			vStringDelete (fulltag);
++			*
++ 			jsKind parent_kind = JSTAG_CLASS;
++ 
++ 			* 
++			 * if we're creating a function (and not a method),
++ 			 * guess we're inside another function 
++			 *
++ 			if (kind == JSTAG_FUNCTION)
++ 				parent_kind = JSTAG_FUNCTION;
++ 
++ 			e.extensionFields.scope[0] = JsKinds [parent_kind].name;
++ 			e.extensionFields.scope[1] = vStringValue (token->scope);
+ 		}
+-		makeConstTag (token, kind);
++		* makeConstTag (token, kind); *
++ 		makeTagEntry (&e);
++	}
++}
++*/
++
++static void makeJsTag (tokenInfo *const token, const jsKind kind)
++{
++	if (JsKinds [kind].enabled && ! token->ignoreTag )
++	{
++		const char *const name = vStringValue (token->string);
++		tagEntryInfo e;
++		initTagEntry (&e, name);
++
++		e.lineNumber   = token->lineNumber;
++		e.filePosition = token->filePosition;
++		e.kindName	   = JsKinds [kind].name;
++		e.kind		   = JsKinds [kind].letter;
++
++		if ( vStringLength(token->scope) > 0 )
++		{
++			jsKind parent_kind = JSTAG_CLASS;
++
++			/* 
++			 * If we're creating a function (and not a method),
++			 * guess we're inside another function 
++			 */
++			if (kind == JSTAG_FUNCTION)
++				parent_kind = JSTAG_FUNCTION;
++
++			e.extensionFields.scope[0] = JsKinds [parent_kind].name;
++			e.extensionFields.scope[1] = vStringValue (token->scope);
++		}
++
++		makeTagEntry (&e);
+ 	}
+ }
+ 
diff --git a/ctags.spec b/ctags.spec
index f4e4435..a951622 100644
--- a/ctags.spec
+++ b/ctags.spec
@@ -1,23 +1,19 @@
 Summary: A C programming language indexing and/or cross-reference tool
 Name: ctags
-Version: 6.2.1
-Release: 1%{?dist}
-License: GPL-2.0-or-later
-URL: https://ctags.io/
-Source0: https://github.com/universal-ctags/ctags/releases/download/v%{version}/universal-%{name}-%{version}.tar.gz
-
-BuildRequires: autoconf
-BuildRequires: automake
+Version: 5.8
+Release: 26%{?dist}
+License: GPLv2+ and LGPLv2+ and Public Domain
+URL: http://ctags.sourceforge.net/
+Source0: http://downloads.sourceforge.net/%{name}/%{name}-%{version}.tar.gz
+Patch0: ctags-5.7-destdir.patch
+Patch1: ctags-5.7-segment-fault.patch
+Patch2: ctags-5.8-css.patch
+Patch3: ctags-5.8-ocaml-crash.patch
+Patch4: ctags-5.8-cssparse.patch
+Patch5: ctags-5.8-memmove.patch
+Patch6: ctags-5.8-format-security.patch
+Patch7: ctags-CVE-2014-7204.patch
 BuildRequires: gcc
-BuildRequires: jansson-devel
-BuildRequires: libseccomp-devel
-BuildRequires: libxml2-devel
-BuildRequires: libyaml-devel
-BuildRequires: make
-BuildRequires: pkgconfig
-BuildRequires: python3-docutils
-
-Obsoletes: %{name}-etags <= 5.8
 
 %description
 Ctags generates an index (or tag) file of C language objects found in
@@ -36,137 +32,65 @@ objects found in source files.
 
 Install ctags if you are going to use your system for C programming.
 
+%package etags
+Summary: Exuberant Ctags for emacs tag format
+Requires: ctags = %{version}-%{release}
+Requires: /usr/sbin/alternatives
+
+%description etags
+This package will generate tags in a format which GNU Emacs understand,
+it's a alternativ implementation of the GNU etags program.
+Note: some command line options is not compatible with GNU etags.
+
+
 %prep
-%autosetup -p1 -n universal-%{name}-%{version}
+%setup -q
+%patch0 -p1 -b .destdir
+%patch1 -p1 -b .crash
+%patch2 -p1 -b .css-support
+%patch3 -p1 -b .ocaml-crash
+%patch4 -p1 -b .cssparse-crash
+%patch5 -p1 -b .memmove
+%patch6 -p1 -b .fmt-sec
+%patch7 -p1 -b .CVE-2014-7204
 
 %build
-./autogen.sh
 %configure
 
-%make_build
+make %{?_smp_mflags}
 
 %install
-%make_install
+rm -rf %{buildroot}
 
-%check
-#make check
+make DESTDIR=%{buildroot} install
+
+pushd %{buildroot}%{_bindir}
+ln -s ctags etags.ctags
+popd
+
+pushd %{buildroot}%{_mandir}/man1
+ln -s ctags.1.gz etags.ctags.1.gz
+popd
+
+%posttrans etags
+/usr/sbin/alternatives --install /usr/bin/etags emacs.etags /usr/bin/etags.ctags 20 \
+   --slave /usr/share/man/man1/etags.1.gz emacs.etags.man /usr/share/man/man1/ctags.1.gz
+
+%postun etags
+/usr/sbin/alternatives --remove etags /usr/bin/etags.ctags || :
 
 %files
 %license COPYING
-%doc README.md
+%doc EXTENDING.html FAQ NEWS README
 %{_bindir}/%{name}
-%{_bindir}/optscript
-%{_bindir}/readtags
-%{_mandir}/man1/*
-%{_mandir}/man5/*
-%{_mandir}/man7/*
+%{_mandir}/man1/%{name}.1*
+
+%files etags
+%license COPYING
+%{_bindir}/etags.%{name}
+%{_mandir}/man1/etags.%{name}.1*
 
 %changelog
-* Wed Nov 12 2025 Than Ngo <than@redhat.com> - 6.2.1-1
-- Update to 6.2.1
-
-* Wed Sep 24 2025 Than Ngo <than@redhat.com> - 6.2.0-1
-- Fix rhbz#2397816 - Update to 6.2.0
-
-* Thu Jul 24 2025 Than Ngo <than@redhat.com> - 6.1.0-4
-- Fix rhbz#2382883 - convert STI tests to TMT
-- Fix test failure due to different outputs
-
-* Wed Jul 23 2025 Fedora Release Engineering <releng@fedoraproject.org> - 6.1.0-3
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_43_Mass_Rebuild
-
-* Thu Jan 16 2025 Fedora Release Engineering <releng@fedoraproject.org> - 6.1.0-2
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_42_Mass_Rebuild
-
-* Wed Oct 23 2024 Than Ngo <than@redhat.com> - 6.1.0-1
-- update to 6.1.0
-
-* Tue Oct 22 2024 Richard W.M. Jones <rjones@redhat.com> - 6.0.0-7
-- Rebuild for Jansson 2.14
-  (https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/thread/3PYINSQGKQ4BB25NQUI2A2UCGGLAG5ND/)
-
-* Wed Jul 17 2024 Fedora Release Engineering <releng@fedoraproject.org> - 6.0.0-6
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_41_Mass_Rebuild
-
-* Wed Jan 24 2024 Fedora Release Engineering <releng@fedoraproject.org> - 6.0.0-5
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild
-
-* Fri Jan 19 2024 Fedora Release Engineering <releng@fedoraproject.org> - 6.0.0-4
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_40_Mass_Rebuild
-
-* Wed Jul 19 2023 Fedora Release Engineering <releng@fedoraproject.org> - 6.0.0-3
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild
-
-* Tue Feb 14 2023 Than Ngo <than@redhat.com> - 6.0.0-2
-- migrated to SPDX license
-
-* Wed Feb 01 2023 Than Ngo <than@redhat.com> - 6.0.0-1
-- update to 6.0.0
-
-* Thu Jan 19 2023 Fedora Release Engineering <releng@fedoraproject.org> - 5.9-10.20221120.0
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_38_Mass_Rebuild
-
-* Mon Nov 21 2022 Than Ngo <than@redhat.com> - 5.9-9.20221120.0
-- update to 5.9.20221120.0
-
-* Tue Oct 18 2022 Than Ngo <than@redhat.com> - 5.9-9.20221016.0
-- update to 5.9.20221016.0
-
-* Mon Sep 12 2022 Than Ngo <than@redhat.com> - 5.9-9.20220911.0
-- update to 5.9.20220911.0
-
-* Wed Jul 27 2022 Than Ngo <than@redhat.com> - 5.9-8.20220724.0
-- update to 5.9.20220724.0
-
-* Wed Jul 20 2022 Fedora Release Engineering <releng@fedoraproject.org> - 5.9-7.20220619.0
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_37_Mass_Rebuild
-
-* Thu Jun 23 2022 Than Ngo <than@redhat.com> - 5.9-6.20220619.0
-- update to 5.9.6.20220619.0
-
-* Thu May 12 2022 Than Ngo <than@redhat.com> - 5.9-6.20220508.0
-- update to 5.9.20220508.0
-
-* Tue Apr 26 2022 Than Ngo <than@redhat.com> - 5.9-5.20220424.0
-- 20220424.0
-
-* Mon Mar 21 2022 Than Ngo <than@redhat.com> - 5.9-4.20220313.0
-- update to 5.9-4.20220313.0
-
-* Tue Feb 08 2022 Than Ngo <than@redhat.com> - 5.9-3.20220206.0
-- update to p5.9.20220206.0
-
-* Thu Jan 20 2022 Fedora Release Engineering <releng@fedoraproject.org> - 5.9-2.20210725.0
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_36_Mass_Rebuild
-
-* Tue Jul 27 2021 Than Ngo <than@redhat.com> - 5.9-1.20210725.0
-- update to p5.9-20210725
-
-* Wed Jul 21 2021 Fedora Release Engineering <releng@fedoraproject.org> - 5.9-0.2.20210509.0
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_35_Mass_Rebuild
-
-* Mon May 10 2021 Than Ngo <than@redhat.com> - 5.9-0.1.20210509.0
-- update to 5.9.20210509.0
-
-* Thu Mar 11 2021 Than Ngo <than@redhat.com> - 5.9-0.1.20210307.0
-- switch to universal ctags
-
-* Tue Jan 26 2021 Fedora Release Engineering <releng@fedoraproject.org> - 5.8-31
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild
-
-* Mon Jul 27 2020 Fedora Release Engineering <releng@fedoraproject.org> - 5.8-30
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild
-
-* Mon Jul 13 2020 Tom Stellard <tstellar@redhat.com> - 5.8-29
-- Use make macros
-- https://fedoraproject.org/wiki/Changes/UseMakeBuildInstallMacro
-
-* Tue Jan 28 2020 Fedora Release Engineering <releng@fedoraproject.org> - 5.8-28
-- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild
-
-* Thu Jan 23 2020 Than Ngo <than@redhat.com> - 5.8-27
-- Added gating tests
-
 * Wed Jul 24 2019 Fedora Release Engineering <releng@fedoraproject.org> - 5.8-26
 - Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild
 
diff --git a/sources b/sources
index da0080f..d3a3d61 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-SHA512 (universal-ctags-6.2.1.tar.gz) = 70e1767a72ba804cf4bc5e5c2dfe13498694c67865d5c8ca412d14b7f7f4c01410c94f7d57daad62ce5885166c4e05128d1beb8184f39a11596045a3f4131007
+c00f82ecdcc357434731913e5b48630d  ctags-5.8.tar.gz
diff --git a/tests/Sanity-test-for-ctags/Makefile b/tests/Sanity-test-for-ctags/Makefile
deleted file mode 100644
index 982951b..0000000
--- a/tests/Sanity-test-for-ctags/Makefile
+++ /dev/null
@@ -1,63 +0,0 @@
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-#   Makefile of /CoreOS/ctags/Sanity-test-for-ctags
-#   Description: Sanity test
-#   Author: Than Ngo <than@redhat.com>
-#
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-#
-#   Copyright (c) 2019,2020 Red Hat, Inc. All rights reserved.
-#
-#   This copyrighted material is made available to anyone wishing
-#   to use, modify, copy, or redistribute it subject to the terms
-#   and conditions of the GNU General Public License version 2.
-#
-#   This program is distributed in the hope that it will be
-#   useful, but WITHOUT ANY WARRANTY; without even the implied
-#   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-#   PURPOSE. See the GNU General Public License for more details.
-#
-#   You should have received a copy of the GNU General Public
-#   License along with this program; if not, write to the Free
-#   Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-#   Boston, MA 02110-1301, USA.
-#
-# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-export TEST=/CoreOS/ctags/Sanity-test-for-ctags
-export TESTVERSION=1.0
-
-BUILT_FILES=
-
-FILES=$(METADATA) runtest.sh Makefile PURPOSE ctags-kinds-list ctags-maps-list ctags-lang-list test.python test.c
-
-.PHONY: all install download clean
-
-run: $(FILES) build
-	./runtest.sh
-
-build: $(BUILT_FILES)
-	chmod a+x runtest.sh
-
-clean:
-	rm -f *~ $(BUILT_FILES)
-
-
-include /usr/share/rhts/lib/rhts-make.include
-
-$(METADATA): Makefile
-	@echo "Owner:           Than Ngo <than@redhat.com>" > $(METADATA)
-	@echo "Name:            $(TEST)" >> $(METADATA)
-	@echo "TestVersion:     $(TESTVERSION)" >> $(METADATA)
-	@echo "Path:            $(TEST_DIR)" >> $(METADATA)
-	@echo "Description:     Sanity test" >> $(METADATA)
-	@echo "Type:            Sanity" >> $(METADATA)
-	@echo "TestTime:        3m" >> $(METADATA)
-	@echo "RunFor:          ctags" >> $(METADATA)
-	@echo "Requires:        coreutils man-db" >> $(METADATA)
-	@echo "Priority:        Normal" >> $(METADATA)
-	@echo "License:         GPLv2+ and LGPLv2+" >> $(METADATA)
-	@echo "Confidential:    no" >> $(METADATA)
-	@echo "Destructive:     no" >> $(METADATA)
-
-	rhts-lint $(METADATA)
diff --git a/tests/Sanity-test-for-ctags/PURPOSE b/tests/Sanity-test-for-ctags/PURPOSE
deleted file mode 100644
index 23a869e..0000000
--- a/tests/Sanity-test-for-ctags/PURPOSE
+++ /dev/null
@@ -1,7 +0,0 @@
-PURPOSE of /CoreOS/ctags/Sanity-test-for-ctags
-Description: smoke test, funktion test for CI gating
-Author: Than Ngo <than@redhat.com>
-
-tests following scenarios:
- * smoke test
- * funktion test
diff --git a/tests/Sanity-test-for-ctags/ctags-kinds-list b/tests/Sanity-test-for-ctags/ctags-kinds-list
deleted file mode 100644
index c1b9b48..0000000
--- a/tests/Sanity-test-for-ctags/ctags-kinds-list
+++ /dev/null
@@ -1,1184 +0,0 @@
-Unknown [disabled]
-Abaqus
-    p  Parts
-    a  Assembly
-    s  Steps
-Abc
-    s  sections
-Ada
-    P  package specifications
-    p  packages
-    T  type specifications [off]
-    t  types
-    U  subtype specifications [off]
-    u  subtypes
-    c  record type components
-    l  enum type literals
-    V  variable specifications [off]
-    v  variables
-    f  generic formal parameters
-    n  constants
-    x  user defined exceptions
-    R  subprogram specifications
-    r  subprograms
-    K  task specifications
-    k  tasks
-    O  protected data specifications
-    o  protected data
-    E  task/protected data entry specifications [off]
-    e  task/protected data entries
-    b  labels
-    i  loop/declare identifiers
-    a  automatic variables [off]
-    y  loops and blocks with no identifier [off]
-Ant
-    p  projects
-    t  targets
-    P  properties(global)
-    i  antfiles
-Asciidoc
-    c  chapters
-    s  sections
-    S  level 2 sections
-    t  level 3 sections
-    T  level 4 sections
-    u  level 5 sections
-    a  anchors
-Asm
-    d  defines
-    l  labels
-    m  macros
-    t  types (structs and records)
-    z  parameters for a macro [off]
-Asp
-    d  constants
-    c  classes
-    f  functions
-    s  subroutines
-    v  variables
-Autoconf
-    p  packages
-    t  templates
-    m  autoconf macros
-    w  options specified with --with-...
-    e  options specified with --enable-...
-    s  substitution keys
-    c  automake conditions
-    d  definitions
-AutoIt
-    f  functions
-    r  regions
-    g  global variables
-    l  local variables
-    S  included scripts
-Automake
-    d  directories
-    P  programs
-    M  manuals
-    T  ltlibraries
-    L  libraries
-    S  scripts
-    D  datum
-    c  conditions
-    s  subdirs
-    p  placeholder for EXTRA_, noinst_, and _check_ prefixed primaries (internal use) [off]
-Awk
-    f  functions
-Basic
-    c  constants
-    f  functions
-    l  labels
-    t  types
-    v  variables
-    g  enumerations
-    n  namespace
-Bats
-    t  test cases
-    S  scripts
-BETA
-    f  fragment definitions
-    p  all patterns [off]
-    s  slots (fragment uses)
-    v  patterns (virtual or rebound)
-BibLaTeX
-    A  artworks
-    B  audios
-    C  bibnotes
-    D  bookinbooks
-    E  Booklets
-    G  collections
-    H  commentarys
-    I  datasets
-    J  images
-    K  interferences
-    L  jurisdictions
-    M  legislations
-    N  legals
-    O  letters
-    P  movies
-    Q  musics
-    R  mvbooks
-    S  mvcollections
-    T  mvproceedings
-    U  mvreferences
-    V  onlines
-    W  patents
-    g  performances
-    h  periodicals
-    i  references
-    j  reports
-    k  reviews
-    l  sets
-    m  software
-    n  standards
-    o  suppbooks
-    p  suppcollections
-    q  suppperiodicals
-    r  thesis
-    s  videos
-    t  xdatas
-BibTeX
-    a  article
-    b  book
-    B  booklet
-    c  conference
-    i  inbook
-    I  incollection
-    j  inproceedings
-    m  manual
-    M  mastersthesis
-    n  misc
-    p  phdthesis
-    P  proceedings
-    s  string
-    t  techreport
-    u  unpublished
-Clojure
-    f  functions
-    n  namespaces
-CMake
-    f  functions
-    m  macros
-    t  targets
-    v  variable definitions
-    D  options specified with -D
-    p  projects
-C
-    d  macro definitions
-    e  enumerators (values inside an enumeration)
-    f  function definitions
-    g  enumeration names
-    h  included header files
-    l  local variables [off]
-    m  struct, and union members
-    p  function prototypes [off]
-    s  structure names
-    t  typedefs
-    u  union names
-    v  variable definitions
-    x  external and forward variable declarations [off]
-    z  function parameters inside function or prototype definitions [off]
-    L  goto labels [off]
-    D  parameters inside macro definitions [off]
-C++
-    d  macro definitions
-    e  enumerators (values inside an enumeration)
-    f  function definitions
-    g  enumeration names
-    h  included header files
-    l  local variables [off]
-    m  class, struct, and union members
-    p  function prototypes [off]
-    s  structure names
-    t  typedefs
-    u  union names
-    v  variable definitions
-    x  external and forward variable declarations [off]
-    z  function parameters inside function or prototype definitions [off]
-    L  goto labels [off]
-    D  parameters inside macro definitions [off]
-    c  classes
-    n  namespaces
-    A  namespace aliases [off]
-    N  names imported via using scope::symbol [off]
-    U  using namespace statements [off]
-    Z  template parameters [off]
-CPreProcessor
-    d  macro definitions
-    h  included header files
-    D  macro parameters [off]
-CSS
-    c  classes
-    s  selectors
-    i  identities
-C#
-    c  classes
-    d  macro definitions
-    e  enumerators (values inside an enumeration)
-    E  events
-    f  fields
-    g  enumeration names
-    i  interfaces
-    l  local variables [off]
-    m  methods
-    n  namespaces
-    p  properties
-    s  structure names
-    t  typedefs
-Ctags
-    l  language definitions
-    k  kind definitions
-Cobol
-    f  file descriptions (FD, SD, RD)
-    g  group items
-    P  program ids
-    s  sections
-    D  divisions
-    p  paragraphs
-    d  data items
-    S  source code file
-CobolFree
-    f  file descriptions (FD, SD, RD)
-    g  group items
-    P  program ids
-    s  sections
-    D  divisions
-    p  paragraphs
-    d  data items
-    S  source code file
-CobolVariable
-    f  file descriptions (FD, SD, RD)
-    g  group items
-    P  program ids
-    s  sections
-    D  divisions
-    p  paragraphs
-    d  data items
-    S  source code file
-CUDA
-    d  macro definitions
-    e  enumerators (values inside an enumeration)
-    f  function definitions
-    g  enumeration names
-    h  included header files
-    l  local variables [off]
-    m  struct, and union members
-    p  function prototypes [off]
-    s  structure names
-    t  typedefs
-    u  union names
-    v  variable definitions
-    x  external and forward variable declarations [off]
-    z  function parameters inside function or prototype definitions [off]
-    L  goto labels [off]
-    D  parameters inside macro definitions [off]
-D
-    a  aliases
-    c  classes
-    g  enumeration names
-    e  enumerators (values inside an enumeration)
-    x  external variable declarations [off]
-    f  function definitions
-    i  interfaces
-    l  local variables [off]
-    m  class, struct, and union members
-    X  mixins
-    M  modules
-    n  namespaces
-    p  function prototypes [off]
-    s  structure names
-    T  templates
-    u  union names
-    v  variable definitions
-    V  version statements
-Diff
-    m  modified files
-    n  newly created files
-    d  deleted files
-    h  hunks
-DTD
-    E  entities
-    p  parameter entities
-    e  elements
-    a  attributes
-    n  notations
-DTS
-    p  phandlers
-    l  labels
-DosBatch
-    l  labels
-    v  variables
-Eiffel
-    c  classes
-    f  features
-    l  local entities [off]
-Elixir
-    p  protocols (defprotocol...)
-    m  modules (defmodule ...)
-    f  functions (def ...)
-    c  callbacks (defcallback ...)
-    d  delegates (defdelegate ...)
-    e  exceptions (defexception ...)
-    g  guards (defguard ...)
-    i  implementations (defimpl ...)
-    a  macros (defmacro ...)
-    o  operators (e.g. "defmacro a <<< b")
-    r  records (defrecord...)
-    t  tests (test ...)
-    y  types (@type ...)
-EmacsLisp
-    Y  unknown type of definitions
-    f  functions
-    v  variables
-    c  constants
-    m  macros
-    a  aliases for functions
-    V  aliases for variables
-    s  inline function
-    i  inline function
-    e  errors
-    M  minor modes
-    D  derived major mode
-    C  customizable variables
-    G  customization groups
-    H  customizable faces
-    T  custom themes
-Erlang
-    d  macro definitions
-    f  functions
-    m  modules
-    r  record definitions
-    t  type definitions
-Falcon
-    c  classes
-    f  functions
-    m  class members
-    v  variables
-    i  imports
-Flex
-    f  functions
-    c  classes
-    i  interfaces
-    P  packages
-    m  methods
-    p  properties
-    v  global variables
-    l  local variables [off]
-    C  constants
-    I  imports
-    x  mxtags
-Forth
-    w  words
-    v  variables
-    c  constants
-Fortran
-    b  block data
-    c  common blocks
-    e  entry points
-    E  enumerations
-    f  functions
-    i  interface contents, generic names, and operators
-    k  type and structure components
-    l  labels
-    L  local, common block, and namelist variables [off]
-    m  modules
-    M  type bound procedures
-    n  namelists
-    N  enumeration values
-    p  programs
-    P  subprogram prototypes [off]
-    s  subroutines
-    t  derived types and structures
-    v  program (global) and module variables
-    S  submodules
-FrontMatter
-    t  titles
-FunctionParameters
-    m  methods
-    f  functions
-Fypp
-    m  macros
-Gdbinit
-    d  definitions
-    D  documents [off]
-    t  toplevel variables
-    l  local variables [off]
-GDScript
-    c  classes
-    m  methods
-    v  variables
-    C  constants
-    g  enumeration names
-    e  enumerated values
-    z  function parameters [off]
-    l  local variables [off]
-    s  signals
-GemSpec
-    g  gems
-Go
-    p  packages
-    f  functions
-    c  constants
-    t  types
-    v  variables
-    s  structs
-    i  interfaces
-    m  struct members
-    M  struct anonymous members
-    n  interface method specification
-    Y  unknown
-    P  name for specifying imported package
-    a  type aliases
-    R  receivers [off]
-GPerf
-    k  keywords
-    h  hash function names
-    l  lookup function names
-    c  class names
-    s  string pool names
-Haskell
-    t  types
-    c  type constructors
-    f  functions
-    m  modules
-Haxe
-    m  methods
-    c  classes
-    e  enumerations
-    v  variables
-    i  interfaces
-    t  typedefs
-HTML
-    a  named anchors
-    c  classes
-    t  titles
-    h  H1 headings
-    i  H2 headings
-    j  H3 headings
-    C  stylesheets
-    I  identifiers
-    J  scripts
-Iniconf
-    s  sections
-    k  keys
-Inko
-    o  Class definition
-    m  Method definition
-    t  Trait definition
-    a  Attribute definition
-    c  Constant definition
-    r  Reopen class
-IPythonCell
-    c  cells
-ITcl
-    c  classes
-    m  methods
-    v  object-specific variables
-    C  common variables
-    p  procedures within the  class  namespace
-Java
-    a  annotation declarations
-    c  classes
-    e  enum constants
-    f  fields
-    g  enum types
-    i  interfaces
-    l  local variables [off]
-    m  methods
-    p  packages
-JavaProperties
-    k  keys
-JavaScript
-    f  functions
-    c  classes
-    m  methods
-    p  properties
-    C  constants
-    v  global variables
-    g  generators
-    G  getters
-    S  setters
-    M  fields
-JSON
-    o  objects
-    a  arrays
-    n  numbers
-    s  strings
-    b  booleans
-    z  nulls
-Julia
-    c  Constants
-    f  Functions
-    g  Fields
-    m  Macros
-    n  Modules
-    s  Structures
-    t  Types
-    Y  name defined in other modules
-Kconfig
-    c  configs
-    m  menus
-    M  the main menu
-    k  kconfig file
-    C  choices
-    v  macro variables
-LdScript
-    S  sections
-    s  symbols
-    v  versions
-    i  input sections
-LEX
-    r  named regular expression
-    c  start or exclusive condition
-Lisp
-    Y  unknown type of definitions
-    f  functions
-    v  variables
-    m  macros
-    c  constants
-LiterateHaskell
-    t  types
-    c  type constructors
-    f  functions
-    m  modules
-Lua
-    f  functions
-    Y  unknown language object [off]
-M4
-    d  macros
-    I  macro files
-Man
-    t  titles
-    s  sections
-    S  sub sections
-Make
-    m  macros
-    t  targets
-    I  makefiles
-Markdown
-    c  chapters
-    s  sections
-    S  level 2 sections
-    t  level 3 sections
-    T  level 4 sections
-    u  level 5 sections
-    n  footnotes
-    h  hashtags
-MatLab
-    f  function
-    v  variable
-    c  class
-Meson
-    P  projects
-    V  variables
-    S  subdirs
-    B  build targets
-    c  custom targets
-    t  tests
-    b  benchmark targets
-    r  run targets
-    m  modules
-MesonOptions
-    s  strings
-    b  booleans
-    c  combos
-    i  integers
-    a  arrays
-    f  features
-Moose
-    c  classes
-    m  methods
-    a  attributes
-    w  wrappers
-    r  roles
-Myrddin
-    f  functions
-    c  constants
-    v  variables
-    t  types
-    r  traits
-    p  packages
-NSIS
-    s  sections
-    f  functions
-    v  variables
-    d  definitions
-    m  macros
-    S  section groups
-    p  macro parameters [off]
-    l  language strings
-    i  NSIS scripts
-ObjectiveC
-    i  class interface
-    I  class implementation
-    P  Protocol
-    m  Object's method
-    c  Class' method
-    v  Global variable
-    E  Object field
-    f  A function
-    p  A property
-    t  A type alias
-    s  A type structure
-    e  An enumeration
-    M  A preprocessor macro
-    C  categories
-OCaml
-    c  classes
-    m  Object's method
-    M  Module or functor
-    v  Global variable
-    p  Signature item
-    t  Type name
-    f  A function
-    C  A constructor
-    r  A 'structure' field
-    e  An exception
-Org
-    d  definitions
-    p  parts
-    c  chapters
-    s  sections
-    u  subsections
-    b  subsubsections
-    P  paragraphs
-    G  subparagraphs
-Passwd
-    u  user names
-Pascal
-    f  functions
-    p  procedures
-Perl
-    c  constants
-    f  formats
-    l  labels
-    p  packages
-    s  subroutines
-    d  subroutine declarations [off]
-    M  modules [off]
-    h  marker for here document [off]
-Perl6
-    c  classes
-    g  grammars
-    m  methods
-    o  modules
-    p  packages
-    r  roles
-    u  rules
-    b  submethods
-    s  subroutines
-    t  tokens
-PHP
-    c  classes
-    d  constant definitions
-    f  functions
-    i  interfaces
-    l  local variables [off]
-    n  namespaces
-    t  traits
-    v  variables
-    a  aliases
-PkgConfig
-    N  display names
-    p  packages
-    v  variabels
-Pod
-    c  chapters
-    s  sections
-    S  subsections
-    t  subsubsections
-PowerShell
-    f  functions
-    v  variables
-    c  classes
-    i  filter
-    g  enum names
-Protobuf
-    p  packages
-    m  messages
-    f  fields
-    e  enum constants
-    g  enum types
-    s  services
-    r  RPC methods
-    o  oneof names
-    G  groups
-    D  .proto definition
-PuppetManifest
-    c  classes
-    d  definitions
-    n  nodes
-    r  resources
-    v  variables
-    p  parameters
-    V  virtual resources
-    t  type aliases
-Python
-    c  classes
-    f  functions
-    m  class members
-    v  variables
-    I  name referring a module defined in other file
-    i  modules
-    Y  name referring a class/variable/function/module defined in other module
-    z  function parameters [off]
-    l  local variables [off]
-PythonLoggingConfig
-    L  logger sections
-    q  logger qualnames
-QemuHX
-    q  QEMU Management Protocol dispatch table entries
-    i  item in texinfo doc
-QtMoc
-    s  slots
-    S  signals
-    p  properties
-Quarto
-    l  chunk labels
-RMarkdown
-    l  chunk labels
-R
-    f  functions
-    l  libraries
-    s  sources
-    g  global variables having values other than function()
-    v  function variables having values other than function()
-    z  function parameters inside function definitions [off]
-    c  vectors explicitly created with `c()'
-    L  lists explicitly created with `list()'
-    d  data frame explicitly created with `data.frame()'
-    n  names attribtes in vectors, lists, or dataframes
-Rake
-    t  tasks
-    n  namespaces
-    f  file tasks
-    d  directory tasks
-    m  multi tasks
-    x  tasks defined with special constructor
-Raku
-    c  classes
-    g  grammars
-    m  methods
-    o  modules
-    p  packages
-    r  roles
-    u  rules
-    b  submethods
-    s  subroutines
-    t  tokens
-R6Class
-    c  classes
-    m  methods
-    f  fields
-    a  active binding functions
-RSpec
-    d  describes
-    c  contexts
-    i  things described with "it"
-REXX
-    s  subroutines
-Robot
-    t  testcases
-    k  keywords
-    v  variables
-RpmMacros
-    m  macros
-RpmSpec
-    t  tags
-    m  macros
-    p  packages
-    g  global macros
-    p  patch files
-ReStructuredText
-    H  titles
-    h  sub titles
-    c  chapters
-    s  sections
-    S  subsections
-    t  subsubsections
-    C  citations
-    T  targets
-    d  substitute definitions
-Ruby
-    c  classes
-    f  methods
-    m  modules
-    S  singleton methods
-    C  constants
-    A  accessors
-    a  aliases
-    L  libraries
-Rust
-    n  module
-    s  structural type
-    i  trait interface
-    c  implementation
-    f  Function
-    g  Enum
-    t  Type Alias
-    v  Global variable
-    M  Macro Definition
-    m  A struct field
-    e  An enum variant
-    P  A method
-    C  A constant
-S4Class
-    c  classes
-    r  representations
-    g  generics
-    m  methods
-Scheme
-    f  functions
-    s  sets
-SCSS
-    m  mixins
-    f  functions
-    v  variables
-    c  classes
-    P  placeholder classes
-    i  identities
-    z  function parameters
-Sh
-    a  aliases
-    f  functions
-    s  script files
-    h  label for here document
-SLang
-    f  functions
-    n  namespaces
-SML
-    e  exception declarations
-    f  function definitions
-    c  functor definitions
-    s  signature declarations
-    r  structure declarations
-    t  type definitions
-    v  value bindings
-SQL
-    C  PLSQL_CCFLAGS
-    D  domains
-    E  record fields
-    L  block label
-    P  packages
-    R  services
-    S  schemas
-    T  triggers
-    U  publications
-    V  views
-    b  database
-    c  cursors
-    d  prototypes [off]
-    e  events
-    f  functions
-    i  indexes
-    l  local variables [off]
-    n  synonyms
-    p  procedures
-    r  records [off]
-    s  subtypes
-    t  tables
-    v  variables
-    x  MobiLink Table Scripts
-    y  MobiLink Conn Scripts
-    z  MobiLink Properties
-SystemdUnit
-    u  units
-SystemTap
-    p  probe aliases
-    f  functions
-    v  variables
-    m  macros
-Tcl
-    p  procedures
-    n  namespaces
-    z  procedure parameters [off]
-TclOO
-    c  classes
-    m  methods
-Terraform
-    r  resources
-    d  data
-    v  variables
-    p  providers
-    m  modules
-    o  output
-TerraformVariables
-Tex
-    p  parts
-    c  chapters
-    s  sections
-    u  subsections
-    b  subsubsections
-    P  paragraphs
-    G  subparagraphs
-    l  labels
-    i  external input files
-    B  bibliography items
-    C  command created with \newcommand
-    o  math operator created with \DeclareMathOperator
-    e  environment created with \newenvironment
-    t  theorem created with \newtheorem
-    N  counter created with \newcounter
-TeXBeamer
-    f  frametitles
-    g  framesubtitles
-TTCN
-    M  module definition
-    t  type definition
-    c  constant definition
-    d  template definition
-    f  function definition
-    s  signature definition
-    C  testcase definition
-    a  altstep definition
-    G  group definition
-    P  module parameter definition
-    v  variable instance
-    T  timer instance
-    p  port instance
-    m  record/set/union member
-    e  enumeration value
-Txt2tags
-    s  sections
-TypeScript
-    f  functions
-    c  classes
-    i  interfaces
-    g  enums
-    e  enumerators (values inside an enumeration)
-    m  methods
-    n  namespaces
-    z  function parameters inside function definitions [off]
-    p  properties
-    v  variables
-    l  local variables [off]
-    C  constants
-    G  generators
-    a  aliases
-V
-    f  functions
-    p  modules
-    v  variables
-    c  constants
-    R  receivers in functions
-    l  labels
-    s  structs
-    m  struct/interface members
-    n  interface methods
-    e  enumerators (values inside an enumeration)
-    g  enumeration names
-    a  type aliases
-    i  interfaces
-    u  union names
-    Y  unknown (imported) variables, types and functions
-Vera
-    c  classes
-    d  macro definitions
-    e  enumerators (values inside an enumeration)
-    f  function definitions
-    g  enumeration names
-    i  interfaces
-    l  local variables [off]
-    m  class, struct, and union members
-    p  programs
-    P  function prototypes [off]
-    s  signals
-    t  tasks
-    T  typedefs
-    v  variable definitions
-    x  external variable declarations [off]
-    h  included header files
-    D  cpp macro parameters [off]
-Verilog
-    c  constants (parameter, specparam)
-    d  text macros
-    e  events
-    f  functions
-    m  modules
-    n  net data types
-    p  ports
-    r  variable data types
-    t  tasks
-    b  blocks (begin, fork)
-    i  instances of module
-SystemVerilog
-    c  constants (parameter, specparam, enum values)
-    d  text macros
-    e  events
-    f  functions
-    m  modules
-    n  net data types
-    p  ports
-    r  variable data types
-    t  tasks
-    b  blocks (begin, fork)
-    i  instances of module or interface
-    A  assertions (assert, assume, cover, restrict)
-    C  classes
-    V  covergroups
-    E  enumerators
-    I  interfaces
-    M  modports
-    K  packages
-    P  programs
-    Q  prototypes (extern, pure) [off]
-    R  properties
-    S  structs and unions
-    T  type declarations
-    H  checkers
-    L  clocking
-    q  sequences
-    w  struct and union members
-    l  interface class
-    O  constraints
-    N  nettype declarations
-VHDL
-    c  constant declarations
-    t  type definitions
-    T  subtype definitions
-    r  record names
-    e  entity declarations
-    C  component declarations [off]
-    d  prototypes [off]
-    f  function prototypes and declarations
-    p  procedure prototypes and declarations
-    P  package definitions
-    l  local definitions [off]
-    a  architectures
-    q  port declarations
-    g  generic declarations
-    s  signal declarations
-    Q  processes
-    v  variables
-    A  aliases
-Vim
-    a  autocommand groups
-    c  user-defined commands
-    f  function definitions
-    m  maps
-    v  variable definitions
-    n  vimball filename
-    C  constant definitions
-WindRes
-    d  dialogs
-    m  menus
-    i  icons
-    b  bitmaps
-    c  cursors
-    f  fonts
-    v  versions
-    a  accelerators
-YACC
-    t  tokens
-    l  labels
-YumRepo
-    r  repository id
-Zephir
-    c  classes
-    d  constant definitions
-    f  functions
-    i  interfaces
-    l  local variables [off]
-    n  namespaces
-    t  traits
-    v  variables
-    a  aliases
-Zsh
-    a  aliases
-    f  functions
-    s  script files
-    h  label for here document
-DBusIntrospect
-    a  arguments
-    i  interfaces
-    m  methods
-    s  signals
-    p  properties
-    n  nodes
-Glade
-    c  classes
-    h  handlers
-Maven2
-    g  group identifiers
-    a  artifact identifiers
-    p  properties
-    r  repository identifiers
-PlistXML
-    k  keys
-RelaxNG
-    e  elements
-    a  attributes
-    n  named patterns
-SVG
-    d  ids in defs tags
-XRC
-    o  objects
-XML
-    i  id attributes
-    n  namespace prefixes
-    r  root elements
-XSLT
-    s  stylesheets
-    p  parameters
-    m  matched template
-    n  named template
-    v  variables
-Yaml
-    a  anchors
-AnsiblePlaybook
-    p  plays
-I18nRubyGem
-    k  translation keys at the leafs
-    m  the middle component of keys [off]
-    l  the root element representing a locale [off]
-OpenAPI
-    d  schemas
-    p  paths
-    R  responses
-    P  parameters
-    t  titles
-    s  servers (or hosts in swagger)
-    T  tags
-Varlink
-    i  interfaces
-    m  methods
-    I  input parameters
-    O  output parameters
-    s  structs
-    f  fields
-    g  enumeration names
-    e  enumerators (values inside an enumeration)
-    E  errors
-    d  error descriptors
-Kotlin
-    p  packages
-    i  interfaces
-    c  classes
-    o  objects
-    m  methods
-    T  typealiases
-    C  constants
-    v  variables
-Thrift
-    s  structs
-    x  exceptions
-    u  unions
-    n  namespaces
-    e  enumerators (values inside an enumeration)
-    g  enumeration names
-    m  members
-    C  constants
-    t  typedefs
-    v  services
-    f  functions
-    z  parameters [off]
-    Z  parameters in throws list [off]
-    T  thrift files
-Elm
-    m  modules
-    n  modules renamed
-    t  types
-    c  constructors
-    a  aliases
-    p  ports
-    f  functions
diff --git a/tests/Sanity-test-for-ctags/ctags-lang-list b/tests/Sanity-test-for-ctags/ctags-lang-list
deleted file mode 100644
index 804037b..0000000
--- a/tests/Sanity-test-for-ctags/ctags-lang-list
+++ /dev/null
@@ -1,155 +0,0 @@
-Abaqus
-Abc
-Ada
-AnsiblePlaybook
-Ant
-Asciidoc
-Asm
-Asp
-Autoconf
-AutoIt
-Automake
-Awk
-Basic
-Bats
-BETA
-BibLaTeX
-BibTeX
-C
-C#
-C++
-Clojure
-CMake
-Cobol
-CobolFree
-CobolVariable
-CPreProcessor
-CSS
-Ctags
-CUDA
-D
-DBusIntrospect
-Diff
-DosBatch
-DTD
-DTS
-Eiffel
-Elixir
-Elm
-EmacsLisp
-Erlang
-Falcon
-Flex
-Forth
-Fortran
-FrontMatter
-FunctionParameters
-Fypp
-Gdbinit
-GDScript
-GemSpec
-Glade
-Go
-GPerf
-Haskell
-Haxe
-HTML
-I18nRubyGem
-Iniconf
-Inko
-IPythonCell
-ITcl
-Java
-JavaProperties
-JavaScript
-JSON
-Julia
-Kconfig
-Kotlin
-LdScript
-LEX
-Lisp
-LiterateHaskell
-Lua
-M4
-Make
-Man
-Markdown
-MatLab
-Maven2
-Meson
-MesonOptions
-Moose
-Myrddin
-NSIS
-ObjectiveC
-OCaml
-OpenAPI
-Org
-Pascal
-Passwd
-Perl
-Perl6
-PHP
-PkgConfig
-PlistXML
-Pod
-PowerShell
-Protobuf
-PuppetManifest
-Python
-PythonLoggingConfig
-QemuHX
-QtMoc
-Quarto
-R
-R6Class
-Rake
-Raku
-RelaxNG
-ReStructuredText
-REXX
-RMarkdown
-Robot
-RpmMacros
-RpmSpec
-RSpec
-Ruby
-Rust
-S4Class
-Scheme
-SCSS
-Sh
-SLang
-SML
-SQL
-SVG
-SystemdUnit
-SystemTap
-SystemVerilog
-Tcl
-TclOO
-Terraform
-TerraformVariables
-Tex
-TeXBeamer
-Thrift
-TTCN
-Txt2tags
-TypeScript
-Unknown [disabled]
-V
-Varlink
-Vera
-Verilog
-VHDL
-Vim
-WindRes
-XML
-XRC
-XSLT
-YACC
-Yaml
-YumRepo
-Zephir
-Zsh
diff --git a/tests/Sanity-test-for-ctags/ctags-maps-list b/tests/Sanity-test-for-ctags/ctags-maps-list
deleted file mode 100644
index 6d9096b..0000000
--- a/tests/Sanity-test-for-ctags/ctags-maps-list
+++ /dev/null
@@ -1,155 +0,0 @@
-Unknown 
-Abaqus   *.inp
-Abc      *.abc *.abc
-Ada      *.adb *.ads *.Ada *.ada
-Ant      build.xml *.build.xml *.ant *.xml
-Asciidoc *.asc *.adoc *.asciidoc *.asc *.adoc *.asciidoc
-Asm      *.A51 *.29[kK] *.[68][68][kKsSxX] *.[xX][68][68] *.asm *.ASM *.s *.S
-Asp      *.asp *.asa
-Autoconf configure.in *.ac
-AutoIt   *.au3 *.AU3 *.aU3 *.Au3
-Automake Makefile.am GNUmakefile.am *.am
-Awk      *.awk *.gawk *.mawk
-Basic    *.bas *.bi *.bm *.bb *.pb
-Bats     *.bats
-BETA     *.bet
-BibLaTeX
-BibTeX   *.bib
-Clojure  *.clj *.cljs *.cljc
-CMake    CMakeLists.txt *.cmake
-C        *.c
-C++      *.c++ *.cc *.cp *.cpp *.cxx *.h *.h++ *.hh *.hp *.hpp *.hxx *.inl *.C *.H *.CPP *.CXX
-CPreProcessor
-CSS      *.css
-C#       *.cs
-Ctags    *.ctags
-Cobol    *.cbl *.cob *.CBL *.COB
-CobolFree
-CobolVariable
-CUDA     *.cu *.cuh
-D        *.d *.di
-Diff     *.diff *.patch
-DTD      *.dtd *.mod
-DTS      *.dts *.dtsi
-DosBatch *.bat *.cmd
-Eiffel   *.e
-Elixir   *.ex *.exs
-EmacsLisp *.el
-Erlang   *.erl *.ERL *.hrl *.HRL
-Falcon   *.fal *.ftd
-Flex     *.as *.mxml
-Forth    *.fth *.forth *.fs *.4th *.f
-Fortran  *.f *.for *.ftn *.f77 *.f90 *.f95 *.f03 *.f08 *.f15 *.F *.FOR *.FTN *.F77 *.F90 *.F95 *.F03 *.F08 *.F15
-FrontMatter
-FunctionParameters
-Fypp     *.fy
-Gdbinit  .gdbinit *.gdb
-GDScript *.gd
-GemSpec  *.gemspec
-Go       *.go
-GPerf    *.perf *.gperf
-Haskell  *.hs
-Haxe     *.hx
-HTML     *.htm *.html
-Iniconf  *.ini *.conf
-Inko     *.inko
-IPythonCell
-ITcl     *.itcl
-Java     *.java
-JavaProperties *.properties
-JavaScript *.js *.jsx *.mjs
-JSON     *.json
-Julia    *.jl
-Kconfig  Kconfig*
-LdScript *.lds.S ld.script *.lds *.scr *.ld *.ldi
-LEX      *.lex *.l
-Lisp     *.cl *.clisp *.l *.lisp *.lsp
-LiterateHaskell *.lhs
-Lua      *.lua
-M4       *.m4 *.spt
-Man      *.1 *.2 *.3 *.4 *.5 *.6 *.7 *.8 *.9 *.3pm *.3stap *.7stap
-Make     [Mm]akefile GNUmakefile *.mak *.mk
-Markdown *.md *.markdown
-MatLab   *.m
-Meson    meson.build
-MesonOptions meson_options.txt
-Moose   
-Myrddin  *.myr
-NSIS     *.nsi *.nsh
-ObjectiveC *.mm *.m *.h
-OCaml    *.ml *.mli *.aug
-Org      *.org
-Passwd   passwd
-Pascal   *.p *.pas
-Perl     *.pl *.pm *.ph *.plx *.perl
-Perl6    *.p6 *.pm6 *.pm *.pl6 *.t6
-PHP      *.php *.php3 *.php4 *.php5 *.php7 *.phtml
-PkgConfig *.pc
-Pod      *.pod
-PowerShell *.ps1 *.psm1
-Protobuf *.proto
-PuppetManifest *.pp
-Python   *.py *.pyx *.pxd *.pxi *.scons *.wsgi
-PythonLoggingConfig
-QemuHX   *.hx
-QtMoc   
-Quarto   *.qmd
-RMarkdown *.rmd
-R        *.r *.R *.s *.q
-Rake     Rakefile *.rake
-Raku     *.raku *.rakumod *.rakutest *.rakudoc
-R6Class 
-RSpec   
-REXX     *.cmd *.rexx *.rx
-Robot    *.robot
-RpmMacros
-RpmSpec  *.spec
-ReStructuredText *.rest *.reST *.rst
-Ruby     *.rb *.ruby
-Rust     *.rs
-S4Class 
-Scheme   *.SCM *.SM *.sch *.scheme *.scm *.sm *.rkt
-SCSS     *.scss
-Sh       *.sh *.SH *.bsh *.bash *.ksh *.ash
-SLang    *.sl
-SML      *.sml *.sig
-SQL      *.sql
-SystemdUnit *.service *.socket *.device *.mount *.automount *.swap *.target *.path *.timer *.snapshot *.slice
-SystemTap *.stp *.stpm
-Tcl      *.tcl *.tk *.wish *.exp
-TclOO   
-Terraform *.tf
-TerraformVariables *.tfvars
-Tex      *.tex
-TeXBeamer
-TTCN     *.ttcn *.ttcn3
-Txt2tags *.t2t *.t2t
-TypeScript *.ts
-V        *.v
-Vera     *.vr *.vri *.vrh
-Verilog  *.v
-SystemVerilog *.sv *.svh *.svi
-VHDL     *.vhdl *.vhd
-Vim      vimrc [._]vimrc gvimrc [._]gvimrc *.vim *.vba
-WindRes  *.rc
-YACC     *.y
-YumRepo  *.repo
-Zephir   *.zep
-Zsh      *.zsh
-DBusIntrospect *.xml
-Glade    *.glade
-Maven2   pom.xml *.pom *.xml
-PlistXML *.plist
-RelaxNG  *.rng
-SVG      *.svg
-XRC      *.xrc
-XML      *.xml
-XSLT     *.xsl *.xslt
-Yaml     *.yml *.yaml
-AnsiblePlaybook
-I18nRubyGem
-OpenAPI  openapi.yaml
-Varlink  *.varlink
-Kotlin   *.kt *.kts
-Thrift   *.thrift
-Elm      *.elm
diff --git a/tests/Sanity-test-for-ctags/main.fmf b/tests/Sanity-test-for-ctags/main.fmf
deleted file mode 100644
index a15acec..0000000
--- a/tests/Sanity-test-for-ctags/main.fmf
+++ /dev/null
@@ -1,13 +0,0 @@
-summary: Run tests in all contexts
-description: ''
-contact: Than Ngo <than@redhat.com>
-component:
-  - ctags
-test: ./runtest.sh
-framework: beakerlib
-recommend:
-  - ctags
-  - man-db
-duration: 5m
-extra-summary: /CoreOS/ctags/Sanity-test-for-ctags
-extra-task: /CoreOS/ctags/Sanity-test-for-ctags
diff --git a/tests/Sanity-test-for-ctags/runtest.sh b/tests/Sanity-test-for-ctags/runtest.sh
deleted file mode 100755
index 52c366e..0000000
--- a/tests/Sanity-test-for-ctags/runtest.sh
+++ /dev/null
@@ -1,50 +0,0 @@
-#! /bin/bash
-# ctags basics
-
-PACKAGES="ctags"
-# SERVICES=""
-
-# source the test script helpers
-# requires beakerlib package
-. /usr/share/beakerlib/beakerlib.sh || exit 1
-
-rlJournalStart
-	rlPhaseStartSetup
-		for p in $PACKAGES ; do
-			rlAssertRpm $p
-		done
-		rlRun "TmpDir=\$(mktemp -d)" 0 "Creating tmp directory"
-      rlRun "cp * $TmpDir"
-		rlRun "pushd $TmpDir"
-	rlPhaseEnd
-
-	rlPhaseStartTest "Smoke, sanity and function tests"
-      rlRun "ctags --version" 0 "Show version"
-      rlRun "ctags --help" 0 "Show help"
-      rlRun "ctags --license" 0 "Show license"
-      rlRun -s "ctags --list-kinds" 0 "Output a list of all tag kinds for all languages"
-      rlAssertNotDiffer ctags-kinds-list $rlRun_LOG
-      rlRun -s "ctags --list-languages" 0 "Output list of supported languages"
-      rlAssertNotDiffer ctags-lang-list $rlRun_LOG
-      rlRun -s "ctags --list-maps" 0 "Output list of language mappings"
-      rlAssertNotDiffer ctags-maps-list $rlRun_LOG
-      for l in python c ; do
-         rlRun "ctags -f test test.$l" 0 "Language: $l, $lWrite tags to file test"
-         rlAssertExists test
-         rlRun "ctags --fields=k test.%l" 0 "Language: $l, Include selected extension fields=k"
-         rlRun "ctags --fields=+afmikKlnsSz test.$l" 0 "Language: $l, Check extension fields=+afmikKlnsSz"
-         rlRun "ctags --extra=+fq --format=1 test.$l" 0 "Language: $l, Check options --extra=+fq --format=1"
-      done
-		# check man page
-		rlRun "man -P head ctags" 0 "Show the ctags man page"
-		# check for sane license and readme file
-		rlRun "head /usr/share/licenses/ctags/COPYING" 0 "Check for license file"
-	rlPhaseEnd
-
-	rlPhaseStartCleanup
-		rlRun "popd"
-		rlRun "rm -fr $TmpDir" 0 "Removing tmp directory"
-	rlPhaseEnd
-
-rlJournalPrintText
-rlJournalEnd
diff --git a/tests/Sanity-test-for-ctags/test.c b/tests/Sanity-test-for-ctags/test.c
deleted file mode 100644
index 7cfe76d..0000000
--- a/tests/Sanity-test-for-ctags/test.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include<stdio.h>
-
-int main() {
-	printf("Hello World\n");
-	return 0;
-}
diff --git a/tests/Sanity-test-for-ctags/test.python b/tests/Sanity-test-for-ctags/test.python
deleted file mode 100644
index 0d73c24..0000000
--- a/tests/Sanity-test-for-ctags/test.python
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/usr/bin/env python
-
-def main():
-	
-	return 0
-
-if __name__ == '__main__': main()
-
-var = 'hi'
-var2 = 'hi' # blah = blah