From 19b9bd1de7a1930788bab10c43aee7f79348ff50 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Oct 21 2019 22:42:17 +0000 Subject: import ctags-5.8-13.el7 --- diff --git a/.ctags.metadata b/.ctags.metadata new file mode 100644 index 0000000..aff99d6 --- /dev/null +++ b/.ctags.metadata @@ -0,0 +1 @@ +482da1ecd182ab39bbdc09f2f02c9fba8cd20030 SOURCES/ctags-5.8.tar.gz diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..17c94cb --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +SOURCES/ctags-5.8.tar.gz diff --git a/SOURCES/ctags-5.7-destdir.patch b/SOURCES/ctags-5.7-destdir.patch new file mode 100644 index 0000000..0aeafab --- /dev/null +++ b/SOURCES/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/SOURCES/ctags-5.7-segment-fault.patch b/SOURCES/ctags-5.7-segment-fault.patch new file mode 100644 index 0000000..60e8809 --- /dev/null +++ b/SOURCES/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/SOURCES/ctags-5.8-css.patch b/SOURCES/ctags-5.8-css.patch new file mode 100644 index 0000000..2744d33 --- /dev/null +++ b/SOURCES/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 ++ **************************************************************************/ ++#include "general.h" ++ ++#include ++#include ++ ++#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/SOURCES/ctags-5.8-cssparse.patch b/SOURCES/ctags-5.8-cssparse.patch new file mode 100644 index 0000000..f70c374 --- /dev/null +++ b/SOURCES/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/SOURCES/ctags-5.8-memmove.patch b/SOURCES/ctags-5.8-memmove.patch new file mode 100644 index 0000000..5608f04 --- /dev/null +++ b/SOURCES/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/SOURCES/ctags-5.8-ocaml-crash.patch b/SOURCES/ctags-5.8-ocaml-crash.patch new file mode 100644 index 0000000..8263cca --- /dev/null +++ b/SOURCES/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/SPECS/ctags.spec b/SPECS/ctags.spec new file mode 100644 index 0000000..0efba18 --- /dev/null +++ b/SPECS/ctags.spec @@ -0,0 +1,279 @@ +Summary: A C programming language indexing and/or cross-reference tool +Name: ctags +Version: 5.8 +Release: 13%{?dist} +License: GPLv2+ and LGPLv2+ and Public Domain +Group: Development/Tools +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 +Buildroot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) + +%description +Ctags generates an index (or tag) file of C language objects found in +C source and header files. The index makes it easy for text editors or +other utilities to locate the indexed items. Ctags can also generate a +cross reference file which lists information about the various objects +found in a set of C language files in human readable form. Exuberant +Ctags improves on ctags because it can find all types of C language tags, +including macro definitions, enumerated values (values inside enum{...}), +function and method definitions, enum/struct/union tags, external +function prototypes, typedef names and variable declarations. Exuberant +Ctags is far less likely to be fooled by code containing #if preprocessor +conditional constructs than ctags. Exuberant ctags supports output of +Emacs style TAGS files and can be used to print out a list of selected +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 +Group: Development/Tools +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 +%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 + +%build +%configure + +make %{?_smp_mflags} + +%install +rm -rf %{buildroot} + +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 || : + +%clean +rm -rf %{buildroot} + +%files +%defattr(-, root, root, -) +%doc COPYING EXTENDING.html FAQ NEWS README +%{_bindir}/%{name} +%{_mandir}/man1/%{name}.1* + +%files etags +%defattr(-, root, root, -) +%doc COPYING +%{_bindir}/etags.%{name} +%{_mandir}/man1/etags.%{name}.1* + +%changelog +* Fri Jan 24 2014 Daniel Mach - 5.8-13 +- Mass rebuild 2014-01-24 + +* Fri Dec 27 2013 Daniel Mach - 5.8-12 +- Mass rebuild 2013-12-27 + +* Thu Jun 13 2013 John Dennis - 5.8-11 +- add ctags-5.8-memmove.patch + bug #284 absoluteFilename uses strcpy on overlapping strings + http://sourceforge.net/p/ctags/bugs/284/ + The bug was fixed upstream on 2012-03-26 in the following commit + http://sourceforge.net/p/ctags/code/782/ + ctags-5.8-memmove.patch simply adds the same patch as the above commit. + +* Wed Feb 13 2013 Fedora Release Engineering - 5.8-10 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Mon Nov 5 2012 Marcela Mašláňová - 5.8-9 +- fix license field again + +* Thu Oct 18 2012 Than Ngo - 5.8-8 +- fix the crash in cssparse + +* Thu Aug 02 2012 Than Ngo - 5.8-7 +- backport from upstream to fix several crashes in ocaml + +* Wed Jul 18 2012 Fedora Release Engineering - 5.8-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Wed Feb 08 2012 Than Ngo - 5.8-5 +- bz#786451, add css support + +* Fri Jan 13 2012 Fedora Release Engineering - 5.8-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild + +* Tue Feb 08 2011 Fedora Release Engineering - 5.8-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Mon Jan 4 2010 Marcela Mašláňová - 5.8-2 +- fix license tag + +* Tue Sep 01 2009 Than Ngo - 5.8-1 +- 5.8 +- apply patch to fix segment fault, thanks to Masatake YAMATO + +* Fri Jul 24 2009 Fedora Release Engineering - 5.7-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Tue Feb 24 2009 Fedora Release Engineering - 5.7-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_11_Mass_Rebuild + +* Tue Jul 29 2008 Than Ngo 5.7-3 +- add subpackage ctags-etags + +* Tue Jul 15 2008 Tom "spot" Callaway 5.7-2 +- fix license tag + +* Fri Feb 15 2008 Than Ngo 5.7-1 +- 5.7 +- merge review: ctags + +* Mon Jul 17 2006 Nalin Dahyabhai 5.6-1.1 +- rebuild + +* Tue Jun 06 2006 Than Ngo 5.6-1 +- update to 5.6 + +* Fri Feb 10 2006 Jesse Keating - 5.5.4-4.2.1 +- bump again for double-long bug on ppc(64) + +* Tue Feb 07 2006 Jesse Keating - 5.5.4-4.2 +- rebuilt for new gcc4.1 snapshot and glibc changes + +* Fri Dec 09 2005 Jesse Keating +- rebuilt + +* Sun Jul 31 2005 Florian La Roche +- remove etags + +* Thu Mar 03 2005 Than Ngo 5.5.4-3 +- rebuilt + +* Wed Feb 09 2005 Than Ngo 5.5.4-2 +- rebuilt + +* Thu Jun 17 2004 Florian La Roche +- 5.5.4 + +* Tue Jun 15 2004 Elliot Lee +- rebuilt + +* Fri Feb 13 2004 Elliot Lee +- rebuilt + +* Sat Sep 27 2003 Florian La Roche +- 5.5.2, no patch needed anymore + +* Wed Jun 04 2003 Elliot Lee +- rebuilt + +* Tue May 6 2003 Than Ngo 5.5-1 +- 5.5 + +* Wed Jan 22 2003 Tim Powers +- rebuilt + +* Wed Nov 13 2002 Karsten Hopp +- update to 5.4 + +* Fri Jun 21 2002 Tim Powers +- automated rebuild + +* Tue Jun 18 2002 Than Ngo 5.2.3-3 +- don't forcibly strip binaries + +* Sun May 26 2002 Tim Powers +- automated rebuild + +* Wed May 22 2002 Harald Hoyer +- 5.2.3 + +* Tue Feb 26 2002 Than Ngo 5.2.2-2 +- rebuild in new enviroment + +* Tue Feb 19 2002 Bernhard Rosenkraenzer 5.2.2-1 +- 5.2.2 + +* Wed Jan 09 2002 Tim Powers +- automated rebuild + +* Wed Jul 11 2001 Jakub Jelinek +- rebuilt against binutils-2.11.90.0.8-3 to reserve .dynamic space + +* Mon Jun 11 2001 Preston Brown +- 5.0.1 + +* Thu Jan 04 2001 Preston Brown +- 4.0.3 +- remove etags, it is not fully compatible with cmd line of GNU etags. + +* Sun Jul 16 2000 Florian La Roche +- update to 4.0.2 from sourceforge + +* Wed Jul 12 2000 Prospector +- automatic rebuild + +* Sat Jun 17 2000 Matt Wilson +- added defattr + +* Mon Jun 12 2000 Preston Brown +- FHS paths + +* Mon May 8 2000 Bernhard Rosenkränzer +- Update to 3.5.2 +- minor cleanups to spec file + +* Tue Feb 16 2000 Bernhard Rosenkränzer +- Update to 3.4 to fix bug #9446 + +* Thu Feb 03 2000 Preston Brown +- compress man page. + +* Sun Mar 21 1999 Cristian Gafton +- auto rebuild in the new build environment (release 4) +- version 3.2 + +* Wed Feb 24 1999 Preston Brown +- Injected new description and group. + +* Fri Apr 24 1998 Prospector System +- translations modified for de, fr, tr + +* Thu Apr 09 1998 Cristian Gafton +- upgraded to 2.0.3 + +* Mon Nov 03 1997 Michael K. Johnson +- removed etags. Emacs provides its own; and needs to support + more than just C. + +* Thu Oct 23 1997 Donnie Barnes +- updated from 1.5 to 1.6 + +* Thu Jul 10 1997 Erik Troan +- built against glibc