SLFO-pool/ctags
SHA256
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Sync from SUSE:SLFO:Main ctags revision 54c266584b1171503298880781f3af63

Browse Source
This commit is contained in:
Adrian Schröter 2024-05-03 11:56:31 +02:00
commit 4ecea757b7
26 changed files with 5941 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
.gitattributes vendored Normal file
View File

@ -0,0 +1,23 @@
## Default LFS
*.7z filter=lfs diff=lfs merge=lfs -text
*.bsp filter=lfs diff=lfs merge=lfs -text
*.bz2 filter=lfs diff=lfs merge=lfs -text
*.gem filter=lfs diff=lfs merge=lfs -text
*.gz filter=lfs diff=lfs merge=lfs -text
*.jar filter=lfs diff=lfs merge=lfs -text
*.lz filter=lfs diff=lfs merge=lfs -text
*.lzma filter=lfs diff=lfs merge=lfs -text
*.obscpio filter=lfs diff=lfs merge=lfs -text
*.oxt filter=lfs diff=lfs merge=lfs -text
*.pdf filter=lfs diff=lfs merge=lfs -text
*.png filter=lfs diff=lfs merge=lfs -text
*.rpm filter=lfs diff=lfs merge=lfs -text
*.tbz filter=lfs diff=lfs merge=lfs -text
*.tbz2 filter=lfs diff=lfs merge=lfs -text
*.tgz filter=lfs diff=lfs merge=lfs -text
*.ttf filter=lfs diff=lfs merge=lfs -text
*.txz filter=lfs diff=lfs merge=lfs -text
*.whl filter=lfs diff=lfs merge=lfs -text
*.xz filter=lfs diff=lfs merge=lfs -text
*.zip filter=lfs diff=lfs merge=lfs -text
*.zst filter=lfs diff=lfs merge=lfs -text

2868
0001-Mixing-with-anjuta-tags-https-git.gnome.org-browse-a.patch Normal file
View File

File diff suppressed because it is too large Load Diff

26
0002-Making-inline-behave-like-an-attribute.-Fixes-1.patch Normal file
View File

@ -0,0 +1,26 @@
From 9362fa70eaa37250afd5b36adb68295b54ae5c99 Mon Sep 17 00:00:00 2001
From: Federico Fissore <federico@fissore.org>
Date: Mon, 5 Oct 2015 11:27:36 +0200
Subject: [PATCH 02/19] Making "inline" behave like an attribute. Fixes #1
---
c.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/c.c b/c.c
index ccca3a4..af46dc4 100644
--- a/c.c
+++ b/c.c
@@ -1732,7 +1732,8 @@ static void processToken (tokenInfo *const token, statementInfo *const st)
case KEYWORD_NONE: processName (st); break;
case KEYWORD_ABSTRACT: st->implementation = IMP_ABSTRACT; break;
- case KEYWORD_ATTRIBUTE: skipParens (); initToken (token); break;
+ case KEYWORD_ATTRIBUTE:
+ case KEYWORD_INLINE: skipParens (); initToken (token); break;
case KEYWORD_BIND: st->declaration = DECL_BASE; break;
case KEYWORD_BIT: st->declaration = DECL_BASE; break;
case KEYWORD_CATCH: skipParens (); skipBraces (); break;
--
2.11.0

28
0003-Treat-typename-as-an-attribute.patch Normal file
View File

@ -0,0 +1,28 @@
From 8c205231b591e954f763df794fc59a9f6a7e983b Mon Sep 17 00:00:00 2001
From: Chris--A <chris@genx.biz>
Date: Thu, 8 Oct 2015 22:38:26 +1000
Subject: [PATCH 03/19] Treat 'typename' as an attribute.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Relates to #1
---
c.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/c.c b/c.c
index af46dc4..ef81067 100644
--- a/c.c
+++ b/c.c
@@ -1733,6 +1733,7 @@ static void processToken (tokenInfo *const token, statementInfo *const st)
case KEYWORD_NONE: processName (st); break;
case KEYWORD_ABSTRACT: st->implementation = IMP_ABSTRACT; break;
case KEYWORD_ATTRIBUTE:
+ case KEYWORD_TYPENAME:
case KEYWORD_INLINE: skipParens (); initToken (token); break;
case KEYWORD_BIND: st->declaration = DECL_BASE; break;
case KEYWORD_BIT: st->declaration = DECL_BASE; break;
--
2.11.0

57
0004-parseReturnType-should-start-from-the-first-non-brac.patch Normal file
View File

@ -0,0 +1,57 @@
From 3b6e9256061bfcb70d2540c49b074b4be0ace4be Mon Sep 17 00:00:00 2001
From: Federico Fissore <federico@fissore.org>
Date: Wed, 4 Nov 2015 12:48:02 +0100
Subject: [PATCH 04/19] parseReturnType should start from the first non-brace
token
---
c.c | 19 ++++++++++++++++---
1 file changed, 16 insertions(+), 3 deletions(-)
diff --git a/c.c b/c.c
index ef81067..727d6bb 100644
--- a/c.c
+++ b/c.c
@@ -567,7 +567,6 @@ static const char *implementationString (const impType imp)
/*
* Debugging functions
*/
-#define DEBUG
#ifdef DEBUG
#define boolString(c) ((c) ? "TRUE" : "FALSE")
@@ -2120,6 +2119,7 @@ static void parseReturnType (statementInfo *const st)
{
int i;
int lower_bound;
+ int upper_bound;
tokenInfo * finding_tok;
/* FIXME TODO: if java language must be supported then impement this here
@@ -2161,8 +2161,21 @@ static void parseReturnType (statementInfo *const st)
}
else
lower_bound = 1;
-
- for (i = (unsigned int) NumTokens; i > lower_bound; i--)
+
+ upper_bound = -1;
+ for (i = 0; i < NumTokens; i++) {
+ tokenInfo *curr_tok;
+ curr_tok = prevToken (st, i);
+ if (curr_tok->type == TOKEN_BRACE_CLOSE || curr_tok->type == TOKEN_BRACE_OPEN) {
+ upper_bound = i - 1;
+ break;
+ }
+ }
+ if (upper_bound < 0) {
+ upper_bound = NumTokens - 1;
+ }
+
+ for (i = upper_bound; i > lower_bound; i--)
{
tokenInfo * curr_tok;
curr_tok = prevToken (st, i);
--
2.11.0

32
0005-Ensuring-a-space-is-printed-in-return-type-AFTER-the.patch Normal file
View File

@ -0,0 +1,32 @@
From b27f1a9c3468618eb6b2a02b33a9058f3ca567e6 Mon Sep 17 00:00:00 2001
From: Federico Fissore <federico@fissore.org>
Date: Mon, 23 Nov 2015 10:47:18 +0100
Subject: [PATCH 05/19] Ensuring a space is printed in return type AFTER the
keyword
---
c.c | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/c.c b/c.c
index 727d6bb..c40cc42 100644
--- a/c.c
+++ b/c.c
@@ -2202,11 +2202,11 @@ static void parseReturnType (statementInfo *const st)
vStringPut (ReturnType, '&');
break;
- case TOKEN_KEYWORD:
- vStringPut (ReturnType, ' ');
-
default:
vStringCat (ReturnType, curr_tok->name);
+ if (curr_tok->type == TOKEN_KEYWORD) {
+ vStringPut (ReturnType, ' ');
+ }
break;
}
}
--
2.11.0

42
0006-Prevent-C-static_assert-from-stopping-parsing.patch Normal file
View File

@ -0,0 +1,42 @@
From ef67b47e61a1a5f6258e7034ddb520a57b0a477e Mon Sep 17 00:00:00 2001
From: Ivan Grokhotkov <igrokhotkov@gmail.com>
Date: Wed, 20 Jan 2016 12:19:13 +0300
Subject: [PATCH 06/19] Prevent C++ static_assert from stopping parsing
Manual cherry-pick of https://github.com/geany/geany/commit/fa0f92def2bf584ed1f6ae836e509f38324f8b6c
---
c.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/c.c b/c.c
index c40cc42..6bc8b76 100644
--- a/c.c
+++ b/c.c
@@ -83,7 +83,7 @@ typedef enum eKeywordId {
KEYWORD_PROGRAM, KEYWORD_PROTECTED, KEYWORD_PUBLIC,
KEYWORD_REGISTER, KEYWORD_RETURN,
KEYWORD_SHADOW, KEYWORD_STATE,
- KEYWORD_SHORT, KEYWORD_SIGNED, KEYWORD_STATIC, KEYWORD_STRING,
+ KEYWORD_SHORT, KEYWORD_SIGNED, KEYWORD_STATIC, KEYWORD_STATIC_ASSERT, KEYWORD_STRING,
KEYWORD_STRUCT, KEYWORD_SWITCH, KEYWORD_SYNCHRONIZED,
KEYWORD_TASK, KEYWORD_TEMPLATE, KEYWORD_THIS, KEYWORD_THROW,
KEYWORD_THROWS, KEYWORD_TRANSIENT, KEYWORD_TRANS, KEYWORD_TRANSITION,
@@ -437,6 +437,7 @@ static const keywordDesc KeywordTable [] = {
{ "signed", KEYWORD_SIGNED, { 1, 1, 0, 0, 0 } },
{ "state", KEYWORD_STATE, { 0, 0, 0, 0, 1 } },
{ "static", KEYWORD_STATIC, { 1, 1, 1, 1, 1 } },
+ { "static_assert", KEYWORD_STATIC_ASSERT, { 0, 1, 0, 0, 0} },
{ "string", KEYWORD_STRING, { 0, 0, 1, 0, 1 } },
{ "struct", KEYWORD_STRUCT, { 1, 1, 1, 0, 0 } },
{ "switch", KEYWORD_SWITCH, { 1, 1, 1, 1, 0 } },
@@ -1764,6 +1765,7 @@ static void processToken (tokenInfo *const token, statementInfo *const st)
case KEYWORD_RETURN: skipStatement (st); break;
case KEYWORD_SHORT: st->declaration = DECL_BASE; break;
case KEYWORD_SIGNED: st->declaration = DECL_BASE; break;
+ case KEYWORD_STATIC_ASSERT: skipParens(); break;
case KEYWORD_STRING: st->declaration = DECL_BASE; break;
case KEYWORD_STRUCT: st->declaration = DECL_STRUCT; break;
case KEYWORD_TASK: st->declaration = DECL_TASK; break;
--
2.11.0

42
0007-c-Handle-C-11-noexcept.patch Normal file
View File

@ -0,0 +1,42 @@
From 3a843374f200b80b7e155059cd4e73171597880d Mon Sep 17 00:00:00 2001
From: Ivan Grokhotkov <igrokhotkov@gmail.com>
Date: Wed, 20 Jan 2016 12:21:26 +0300
Subject: [PATCH 07/19] c++: Handle C++11 noexcept
Manual cherry-pick of https://github.com/geany/geany/commit/f60b31385e4da74d3b926c8e0c8f97c00a508d7b
---
c.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/c.c b/c.c
index 6bc8b76..0dd84d7 100644
--- a/c.c
+++ b/c.c
@@ -77,7 +77,7 @@ typedef enum eKeywordId {
KEYWORD_LOCAL, KEYWORD_LONG,
KEYWORD_M_BAD_STATE, KEYWORD_M_BAD_TRANS, KEYWORD_M_STATE, KEYWORD_M_TRANS,
KEYWORD_MUTABLE,
- KEYWORD_NAMESPACE, KEYWORD_NEW, KEYWORD_NEWCOV, KEYWORD_NATIVE,
+ KEYWORD_NAMESPACE, KEYWORD_NEW, KEYWORD_NEWCOV, KEYWORD_NATIVE, KEYWORD_NOEXCEPT,
KEYWORD_OPERATOR, KEYWORD_OUTPUT, KEYWORD_OVERLOAD, KEYWORD_OVERRIDE,
KEYWORD_PACKED, KEYWORD_PORT, KEYWORD_PACKAGE, KEYWORD_PRIVATE,
KEYWORD_PROGRAM, KEYWORD_PROTECTED, KEYWORD_PUBLIC,
@@ -419,6 +419,7 @@ static const keywordDesc KeywordTable [] = {
{ "native", KEYWORD_NATIVE, { 0, 0, 0, 1, 0 } },
{ "new", KEYWORD_NEW, { 0, 1, 1, 1, 0 } },
{ "newcov", KEYWORD_NEWCOV, { 0, 0, 0, 0, 1 } },
+ { "noexcept", KEYWORD_NOEXCEPT, { 0, 1, 0, 0, 0 } },
{ "operator", KEYWORD_OPERATOR, { 0, 1, 1, 0, 0 } },
{ "output", KEYWORD_OUTPUT, { 0, 0, 0, 0, 1 } },
{ "overload", KEYWORD_OVERLOAD, { 0, 1, 0, 0, 0 } },
@@ -1967,6 +1968,7 @@ static boolean skipPostArgumentStuff (
case KEYWORD_NAMESPACE:
case KEYWORD_NEW:
case KEYWORD_NEWCOV:
+ case KEYWORD_NOEXCEPT:
case KEYWORD_OPERATOR:
case KEYWORD_OVERLOAD:
case KEYWORD_PRIVATE:
--
2.11.0

56
0008-c-Properly-parse-C-11-override-and-final-members.patch Normal file
View File

@ -0,0 +1,56 @@
From ce27db2946ae2ebc2766138af451d7d981201134 Mon Sep 17 00:00:00 2001
From: Ivan Grokhotkov <igrokhotkov@gmail.com>
Date: Wed, 20 Jan 2016 12:25:18 +0300
Subject: [PATCH 08/19] c++: Properly parse C++11 override and final members
Manual cherry-pick of
- https://github.com/geany/geany/commit/95a0d4db7e2188a62cf7770496ee2a51591f1962
- https://github.com/geany/geany/commit/641863c2647c21abb36aedc40ac93e6cc478f920
---
c.c | 22 ++++++++++++++++++++--
1 file changed, 20 insertions(+), 2 deletions(-)
diff --git a/c.c b/c.c
index 0dd84d7..6e8b5aa 100644
--- a/c.c
+++ b/c.c
@@ -1986,7 +1986,13 @@ static boolean skipPostArgumentStuff (
break;
default:
- if (isType (token, TOKEN_NONE))
+ /* "override" and "final" are only keywords in the declaration of a virtual
+ * member function, so need to be handled specially, not as keywords */
+ if (isLanguage(Lang_cpp) && isType (token, TOKEN_NAME) &&
+ (strcmp ("override", vStringValue (token->name)) == 0 ||
+ strcmp ("final", vStringValue (token->name)) == 0))
+ ;
+ else if (isType (token, TOKEN_NONE))
;
else if (info->isKnrParamList && info->parameterCount > 0)
++elementCount;
@@ -2839,8 +2845,20 @@ static void tagCheck (statementInfo *const st)
st->declaration == DECL_NAMESPACE ||
st->declaration == DECL_PROGRAM)
{
- if (isType (prev, TOKEN_NAME))
+ tokenInfo *name_token = (tokenInfo *)prev;
+
+ /* C++ 11 allows class <name> final { ... } */
+ if (isLanguage (Lang_cpp) && isType (prev, TOKEN_NAME) &&
+ strcmp("final", vStringValue(prev->name)) == 0 &&
+ isType(prev2, TOKEN_NAME))
+ {
+ name_token = (tokenInfo *)prev2;
+ copyToken (st->blockName, name_token);
+ }
+ else if (isType (name_token, TOKEN_NAME))
+ {
copyToken (st->blockName, prev);
+ }
else
{
/* For an anonymous struct or union we use a unique ID
--
2.11.0

33
0009-Parse-C-11-enums-with-type-specifier.patch Normal file
View File

@ -0,0 +1,33 @@
From cf9442ccad73448ff22ee96fa743893b29df5cfc Mon Sep 17 00:00:00 2001
From: Ivan Grokhotkov <igrokhotkov@gmail.com>
Date: Thu, 4 Feb 2016 19:36:35 +0300
Subject: [PATCH 09/19] Parse C++11 enums with type specifier
Manual cherry-pick of https://github.com/geany/geany/commit/f2f22d34ab9063852279bc6c5a45c8d3cfafdc0a
---
c.c | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/c.c b/c.c
index 6e8b5aa..ff7aa24 100644
--- a/c.c
+++ b/c.c
@@ -2528,6 +2528,15 @@ static void processColon (statementInfo *const st)
else if (c == ';')
setToken (st, TOKEN_SEMICOLON);
}
+ else if (isLanguage (Lang_cpp) && st->declaration == DECL_ENUM)
+ {
+ /* skip enum's base type */
+ c = skipToOneOf ("{;");
+ if (c == '{')
+ setToken (st, TOKEN_BRACE_OPEN);
+ else if (c == ';')
+ setToken (st, TOKEN_SEMICOLON);
+ }
else
{
const tokenInfo *const prev = prevToken (st, 1);
--
2.11.0

48
0010-Parse-C-11-classed-enums.patch Normal file
View File

@ -0,0 +1,48 @@
From 688ba978ea2394eb7144c964811e2c531e5c9c19 Mon Sep 17 00:00:00 2001
From: Ivan Grokhotkov <igrokhotkov@gmail.com>
Date: Thu, 4 Feb 2016 19:40:15 +0300
Subject: [PATCH 10/19] Parse C++11 classed enums
Manual cherry-pick of https://github.com/geany/geany/commit/6c7f69578d8e142f5994cc9cf0e0abc83a606a1b
---
c.c | 10 ++++++++--
1 file changed, 8 insertions(+), 2 deletions(-)
diff --git a/c.c b/c.c
index ff7aa24..40db0e5 100644
--- a/c.c
+++ b/c.c
@@ -1725,6 +1725,12 @@ static void processInterface (statementInfo *const st)
st->declaration = DECL_INTERFACE;
}
+static void checkIsClassEnum (statementInfo *const st, const declType decl)
+{
+ if (! isLanguage (Lang_cpp) || st->declaration != DECL_ENUM)
+ st->declaration = decl;
+}
+
static void processToken (tokenInfo *const token, statementInfo *const st)
{
switch (token->keyword) /* is it a reserved word? */
@@ -1740,7 +1746,7 @@ static void processToken (tokenInfo *const token, statementInfo *const st)
case KEYWORD_BIT: st->declaration = DECL_BASE; break;
case KEYWORD_CATCH: skipParens (); skipBraces (); break;
case KEYWORD_CHAR: st->declaration = DECL_BASE; break;
- case KEYWORD_CLASS: st->declaration = DECL_CLASS; break;
+ case KEYWORD_CLASS: checkIsClassEnum (st, DECL_CLASS); break;
case KEYWORD_CONST: st->declaration = DECL_BASE; break;
case KEYWORD_DOUBLE: st->declaration = DECL_BASE; break;
case KEYWORD_ENUM: st->declaration = DECL_ENUM; break;
@@ -1768,7 +1774,7 @@ static void processToken (tokenInfo *const token, statementInfo *const st)
case KEYWORD_SIGNED: st->declaration = DECL_BASE; break;
case KEYWORD_STATIC_ASSERT: skipParens(); break;
case KEYWORD_STRING: st->declaration = DECL_BASE; break;
- case KEYWORD_STRUCT: st->declaration = DECL_STRUCT; break;
+ case KEYWORD_STRUCT: checkIsClassEnum (st, DECL_STRUCT); break;
case KEYWORD_TASK: st->declaration = DECL_TASK; break;
case KEYWORD_THROWS: discardTypeList (token); break;
case KEYWORD_UNION: st->declaration = DECL_UNION; break;
--
2.11.0

62
0011-Handle-template-expressions-that-may-use-the-or-oper.patch Normal file
View File

@ -0,0 +1,62 @@
From e304e5ffff9718d99ab5767c8399225b79204c1f Mon Sep 17 00:00:00 2001
From: Daniel Garcia <danielgarcia@gmail.com>
Date: Tue, 23 Feb 2016 17:16:58 -0800
Subject: [PATCH 11/19] Handle template expressions that may use the << or >>
operators
---
c.c | 34 ++++++++++++++++++++++++----------
1 file changed, 24 insertions(+), 10 deletions(-)
diff --git a/c.c b/c.c
index 40db0e5..b975453 100644
--- a/c.c
+++ b/c.c
@@ -1392,20 +1392,34 @@ static void skipToMatch (const char *const pair)
if (c == begin)
{
- ++matchLevel;
- if (braceFormatting && getDirectiveNestLevel () != initialLevel)
- {
- skipToFormattedBraceMatch ();
- break;
+ // watch out for '<<' in template arguments
+ int x = cppGetc ();
+ if(c == '<' && x == '<') {
+ // we've found a << - do nothing
+ } else {
+ cppUngetc (x);
+ ++matchLevel;
+ if (braceFormatting && getDirectiveNestLevel () != initialLevel)
+ {
+ skipToFormattedBraceMatch ();
+ break;
+ }
}
}
else if (c == end)
{
- --matchLevel;
- if (braceFormatting && getDirectiveNestLevel () != initialLevel)
- {
- skipToFormattedBraceMatch ();
- break;
+ // watch out for '>>' in template arguments
+ int x = cppGetc ();
+ if(c == '>' && x == '>') {
+ // we've found a >> in a template - skip it
+ } else {
+ cppUngetc (x);
+ --matchLevel;
+ if (braceFormatting && getDirectiveNestLevel () != initialLevel)
+ {
+ skipToFormattedBraceMatch ();
+ break;
+ }
}
}
}
--
2.11.0

39
0012-Make-sure-we-don-t-throw-things-away-while-collectin.patch Normal file
View File

@ -0,0 +1,39 @@
From fe0ba956daf1f3940543e3dce8ec0befcab4d386 Mon Sep 17 00:00:00 2001
From: Daniel Garcia <danielgarcia@gmail.com>
Date: Wed, 24 Feb 2016 00:59:15 -0800
Subject: [PATCH 12/19] Make sure we don't throw things away while collecting
the signature, though
---
c.c | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/c.c b/c.c
index b975453..386af29 100644
--- a/c.c
+++ b/c.c
@@ -1395,7 +1395,9 @@ static void skipToMatch (const char *const pair)
// watch out for '<<' in template arguments
int x = cppGetc ();
if(c == '<' && x == '<') {
- // we've found a << - do nothing
+ // we've found a << - do nothing except record the signature
+ if (CollectingSignature)
+ vStringPut(Signature, x);
} else {
cppUngetc (x);
++matchLevel;
@@ -1411,7 +1413,9 @@ static void skipToMatch (const char *const pair)
// watch out for '>>' in template arguments
int x = cppGetc ();
if(c == '>' && x == '>') {
- // we've found a >> in a template - skip it
+ // we've found a >> - do nothing except record the signature
+ if (CollectingSignature)
+ vStringPut(Signature, x);
} else {
cppUngetc (x);
--matchLevel;
--
2.11.0

35
0013-C-mitigate-matching-error-on-generics-containing-an-.patch Normal file
View File

@ -0,0 +1,35 @@
From f928218c753e54968289a73285bf7c4345a8d553 Mon Sep 17 00:00:00 2001
From: Martino Facchin <m.facchin@arduino.cc>
Date: Tue, 23 Feb 2016 12:58:40 +0100
Subject: [PATCH 13/19] C++: mitigate matching error on generics containing an
expression
backport of https://github.com/geany/geany/commit/d40932ce4d05e57573a6d6c8f89f4aea8c42d4f3
---
c.c | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/c.c b/c.c
index 386af29..1386ddd 100644
--- a/c.c
+++ b/c.c
@@ -1426,6 +1426,16 @@ static void skipToMatch (const char *const pair)
}
}
}
+ /* early out if matching "<>" and we encounter a ";" or "{" to mitigate
+ * match problems with C++ generics containing a static expression like
+ * foo<X<Y> bar;
+ * normally neither ";" nor "{" could appear inside "<>" anyway. */
+ else if (isLanguage (Lang_cpp) && begin == '<' &&
+ (c == ';' || c == '{'))
+ {
+ cppUngetc (c);
+ break;
+ }
}
if (c == EOF)
{
--
2.11.0

44
0014-fix-wrongly-interpreted-in-template.patch Normal file
View File

@ -0,0 +1,44 @@
From 5dbd71201f79e976a728802ca8638b14db0728dc Mon Sep 17 00:00:00 2001
From: Martino Facchin <m.facchin@arduino.cc>
Date: Wed, 9 Mar 2016 15:03:07 +0100
Subject: [PATCH 14/19] fix wrongly interpreted >> in template
---
c.c | 20 +++++++-------------
1 file changed, 7 insertions(+), 13 deletions(-)
diff --git a/c.c b/c.c
index 1386ddd..6add5f3 100644
--- a/c.c
+++ b/c.c
@@ -1410,20 +1410,14 @@ static void skipToMatch (const char *const pair)
}
else if (c == end)
{
- // watch out for '>>' in template arguments
+ // don't care if you find a '>>' (the important thing is closing the brackets)
int x = cppGetc ();
- if(c == '>' && x == '>') {
- // we've found a >> - do nothing except record the signature
- if (CollectingSignature)
- vStringPut(Signature, x);
- } else {
- cppUngetc (x);
- --matchLevel;
- if (braceFormatting && getDirectiveNestLevel () != initialLevel)
- {
- skipToFormattedBraceMatch ();
- break;
- }
+ cppUngetc (x);
+ --matchLevel;
+ if (braceFormatting && getDirectiveNestLevel () != initialLevel)
+ {
+ skipToFormattedBraceMatch ();
+ break;
}
}
/* early out if matching "<>" and we encounter a ";" or "{" to mitigate
--
2.11.0

41
0015-Added-constexpr-as-keyword.patch Normal file
View File

@ -0,0 +1,41 @@
From 83aa36d14a6b82e10b3ac55d54e0641648c56fcf Mon Sep 17 00:00:00 2001
From: Eric Sorton <esorton@gmail.com>
Date: Mon, 1 Aug 2016 23:04:35 -0400
Subject: [PATCH 15/19] Added constexpr as keyword.
---
c.c | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/c.c b/c.c
index 6add5f3..105bfa8 100644
--- a/c.c
+++ b/c.c
@@ -62,7 +62,7 @@ typedef enum eKeywordId {
KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT,
KEYWORD_BOOLEAN, KEYWORD_BYTE, KEYWORD_BAD_STATE, KEYWORD_BAD_TRANS,
KEYWORD_BIND, KEYWORD_BIND_VAR, KEYWORD_BIT,
- KEYWORD_CASE, KEYWORD_CATCH, KEYWORD_CHAR, KEYWORD_CLASS, KEYWORD_CONST,
+ KEYWORD_CASE, KEYWORD_CATCH, KEYWORD_CHAR, KEYWORD_CLASS, KEYWORD_CONST, KEYWORD_CONSTEXPR,
KEYWORD_CONSTRAINT, KEYWORD_COVERAGE_BLOCK, KEYWORD_COVERAGE_DEF,
KEYWORD_DEFAULT, KEYWORD_DELEGATE, KEYWORD_DELETE, KEYWORD_DO,
KEYWORD_DOUBLE,
@@ -377,6 +377,7 @@ static const keywordDesc KeywordTable [] = {
{ "char", KEYWORD_CHAR, { 1, 1, 1, 1, 0 } },
{ "class", KEYWORD_CLASS, { 0, 1, 1, 1, 1 } },
{ "const", KEYWORD_CONST, { 1, 1, 1, 1, 0 } },
+ { "constexpr", KEYWORD_CONSTEXPR, { 0, 1, 0, 0, 0 } },
{ "constraint", KEYWORD_CONSTRAINT, { 0, 0, 0, 0, 1 } },
{ "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 1 } },
{ "coverage_def", KEYWORD_COVERAGE_DEF, { 0, 0, 0, 0, 1 } },
@@ -1770,6 +1771,7 @@ static void processToken (tokenInfo *const token, statementInfo *const st)
case KEYWORD_CHAR: st->declaration = DECL_BASE; break;
case KEYWORD_CLASS: checkIsClassEnum (st, DECL_CLASS); break;
case KEYWORD_CONST: st->declaration = DECL_BASE; break;
+ case KEYWORD_CONSTEXPR: st->declaration = DECL_BASE; break;
case KEYWORD_DOUBLE: st->declaration = DECL_BASE; break;
case KEYWORD_ENUM: st->declaration = DECL_ENUM; break;
case KEYWORD_EXTENDS: readParents (st, '.');
--
2.11.0

98
0016-CVE-2014-7204.patch Normal file
View File

@ -0,0 +1,98 @@
From 7f6e3f1177f0ed53cf2a66ac207f6834591c568c Mon Sep 17 00:00:00 2001
From: dfishburn <dfishburn@sf.net>
Date: Wed, 24 Oct 2012 01:13:00 +0000
Subject: [PATCH 16/19] CVE-2014-7204
git-svn-id: svn://svn.code.sf.net/p/ctags/code/trunk@791 c5d04d22-be80-434c-894e-aa346cc9e8e8
Signed-off-by: Petr Uzel <petr.uzel@suse.cz>
---
jscript.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 51 insertions(+), 3 deletions(-)
diff --git a/jscript.c b/jscript.c
index c4e5b1a..901641a 100644
--- a/jscript.c
+++ b/jscript.c
@@ -215,6 +215,7 @@ static void deleteToken (tokenInfo *const token)
* Tag generation functions
*/
+/*
static void makeConstTag (tokenInfo *const token, const jsKind kind)
{
if (JsKinds [kind].enabled && ! token->ignoreTag )
@@ -238,12 +239,13 @@ static void makeJsTag (tokenInfo *const token, const jsKind kind)
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 @@ static void makeJsTag (tokenInfo *const token, const jsKind kind)
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); *
+ 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);
}
- makeConstTag (token, kind);
+
+ makeTagEntry (&e);
}
}
--
2.11.0

731
0017-Go-language-support.patch Normal file
View File

@ -0,0 +1,731 @@
From 829234bfb8d481413bf0466562fe87e8c396defd Mon Sep 17 00:00:00 2001
From: Graham Anderson <graham@andtech.eu>
Date: Thu, 16 Aug 2012 12:04:00 +0000
Subject: [PATCH 17/19] Go language support
---
go.c | 670 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
parsers.h | 2 +
source.mak | 2 +
3 files changed, 674 insertions(+)
create mode 100644 go.c
diff --git a/go.c b/go.c
new file mode 100644
index 0000000..6bd3a36
--- /dev/null
+++ b/go.c
@@ -0,0 +1,670 @@
+/*
+* INCLUDE FILES
+*/
+#include "general.h" /* must always come first */
+#include <setjmp.h>
+
+#include "debug.h"
+#include "entry.h"
+#include "keyword.h"
+#include "read.h"
+#include "main.h"
+#include "routines.h"
+#include "vstring.h"
+#include "options.h"
+
+/*
+ * MACROS
+ */
+#define isType(token,t) (boolean) ((token)->type == (t))
+#define isKeyword(token,k) (boolean) ((token)->keyword == (k))
+
+/*
+ * DATA DECLARATIONS
+ */
+
+typedef enum eException { ExceptionNone, ExceptionEOF } exception_t;
+
+typedef enum eKeywordId {
+ KEYWORD_NONE = -1,
+ KEYWORD_package,
+ KEYWORD_import,
+ KEYWORD_const,
+ KEYWORD_type,
+ KEYWORD_var,
+ KEYWORD_func,
+ KEYWORD_struct,
+ KEYWORD_interface,
+ KEYWORD_map,
+ KEYWORD_chan
+} keywordId;
+
+/* Used to determine whether keyword is valid for the current language and
+ * what its ID is.
+ */
+typedef struct sKeywordDesc {
+ const char *name;
+ keywordId id;
+} keywordDesc;
+
+typedef enum eTokenType {
+ TOKEN_NONE = -1,
+ TOKEN_CHARACTER,
+ // Don't need TOKEN_FORWARD_SLASH
+ TOKEN_FORWARD_SLASH,
+ TOKEN_KEYWORD,
+ TOKEN_IDENTIFIER,
+ TOKEN_STRING,
+ TOKEN_OPEN_PAREN,
+ TOKEN_CLOSE_PAREN,
+ TOKEN_OPEN_CURLY,
+ TOKEN_CLOSE_CURLY,
+ TOKEN_OPEN_SQUARE,
+ TOKEN_CLOSE_SQUARE,
+ TOKEN_SEMICOLON,
+ TOKEN_STAR,
+ TOKEN_LEFT_ARROW,
+ TOKEN_DOT,
+ TOKEN_COMMA
+} tokenType;
+
+typedef struct sTokenInfo {
+ tokenType type;
+ keywordId keyword;
+ vString *string; /* the name of the token */
+ unsigned long lineNumber; /* line number of tag */
+ fpos_t filePosition; /* file position of line containing name */
+} tokenInfo;
+
+/*
+* DATA DEFINITIONS
+*/
+
+static int Lang_go;
+static jmp_buf Exception;
+static vString *scope;
+
+typedef enum {
+ GOTAG_UNDEFINED = -1,
+ GOTAG_PACKAGE,
+ GOTAG_FUNCTION,
+ GOTAG_CONST,
+ GOTAG_TYPE,
+ GOTAG_VAR,
+} goKind;
+
+static kindOption GoKinds[] = {
+ {TRUE, 'p', "package", "packages"},
+ {TRUE, 'f', "func", "functions"},
+ {TRUE, 'c', "const", "constants"},
+ {TRUE, 't', "type", "types"},
+ {TRUE, 'v', "var", "variables"}
+};
+
+static keywordDesc GoKeywordTable[] = {
+ {"package", KEYWORD_package},
+ {"import", KEYWORD_import},
+ {"const", KEYWORD_const},
+ {"type", KEYWORD_type},
+ {"var", KEYWORD_var},
+ {"func", KEYWORD_func},
+ {"struct", KEYWORD_struct},
+ {"interface", KEYWORD_interface},
+ {"map", KEYWORD_map},
+ {"chan", KEYWORD_chan}
+};
+
+/*
+* FUNCTION DEFINITIONS
+*/
+
+// XXX UTF-8
+static boolean isIdentChar (const int c)
+{
+ return (boolean)
+ (isalpha (c) || isdigit (c) || c == '$' ||
+ c == '@' || c == '_' || c == '#' || c > 128);
+}
+
+static void initialize (const langType language)
+{
+ size_t i;
+ const size_t count =
+ sizeof (GoKeywordTable) / sizeof (GoKeywordTable[0]);
+ Lang_go = language;
+ for (i = 0; i < count; ++i)
+ {
+ const keywordDesc *const p = &GoKeywordTable[i];
+ addKeyword (p->name, language, (int) p->id);
+ }
+}
+
+static tokenInfo *newToken (void)
+{
+ tokenInfo *const token = xMalloc (1, tokenInfo);
+ token->type = TOKEN_NONE;
+ token->keyword = KEYWORD_NONE;
+ token->string = vStringNew ();
+ token->lineNumber = getSourceLineNumber ();
+ token->filePosition = getInputFilePosition ();
+ return token;
+}
+
+static void deleteToken (tokenInfo * const token)
+{
+ if (token != NULL)
+ {
+ vStringDelete (token->string);
+ eFree (token);
+ }
+}
+
+/*
+ * Parsing functions
+ */
+
+static void parseString (vString *const string, const int delimiter)
+{
+ boolean end = FALSE;
+ while (!end)
+ {
+ int c = fileGetc ();
+ if (c == EOF)
+ end = TRUE;
+ else if (c == '\\' && delimiter != '`')
+ {
+ c = fileGetc (); /* This maybe a ' or ". */
+ vStringPut (string, c);
+ }
+ else if (c == delimiter)
+ end = TRUE;
+ else
+ vStringPut (string, c);
+ }
+ vStringTerminate (string);
+}
+
+static void parseIdentifier (vString *const string, const int firstChar)
+{
+ int c = firstChar;
+ //Assert (isIdentChar (c));
+ do
+ {
+ vStringPut (string, c);
+ c = fileGetc ();
+ } while (isIdentChar (c));
+ vStringTerminate (string);
+ fileUngetc (c); /* always unget, LF might add a semicolon */
+}
+
+static void readToken (tokenInfo *const token)
+{
+ int c;
+ static tokenType lastTokenType = TOKEN_NONE;
+
+ token->type = TOKEN_NONE;
+ token->keyword = KEYWORD_NONE;
+ vStringClear (token->string);
+
+getNextChar:
+ do
+ {
+ c = fileGetc ();
+ token->lineNumber = getSourceLineNumber ();
+ token->filePosition = getInputFilePosition ();
+ if (c == '\n' && (lastTokenType == TOKEN_IDENTIFIER ||
+ lastTokenType == TOKEN_STRING ||
+ lastTokenType == TOKEN_CLOSE_PAREN ||
+ lastTokenType == TOKEN_CLOSE_CURLY ||
+ lastTokenType == TOKEN_CLOSE_SQUARE))
+ {
+ token->type = TOKEN_SEMICOLON;
+ goto done;
+ }
+ }
+ while (c == '\t' || c == ' ' || c == '\r' || c == '\n');
+
+ switch (c)
+ {
+ case EOF:
+ longjmp (Exception, (int)ExceptionEOF);
+ break;
+
+ case '/':
+ {
+ boolean hasNewline = FALSE;
+ int d = fileGetc ();
+ switch (d)
+ {
+ case '/':
+ fileSkipToCharacter ('\n');
+ /* Line comments start with the
+ * character sequence // and
+ * continue through the next
+ * newline. A line comment acts
+ * like a newline. */
+ fileUngetc ('\n');
+ goto getNextChar;
+ case '*':
+ do
+ {
+ int d;
+ do
+ {
+ d = fileGetc ();
+ if (d == '\n')
+ {
+ hasNewline = TRUE;
+ }
+ } while (d != EOF && d != '*');
+
+ c = fileGetc ();
+ if (c == '/')
+ break;
+ else
+ fileUngetc (c);
+ } while (c != EOF && c != '\0');
+
+ fileUngetc (hasNewline ? '\n' : ' ');
+ goto getNextChar;
+ default:
+ token->type = TOKEN_FORWARD_SLASH;
+ fileUngetc (d);
+ break;
+ }
+ }
+ break;
+
+ case '"':
+ case '\'':
+ case '`':
+ token->type = TOKEN_STRING;
+ parseString (token->string, c);
+ token->lineNumber = getSourceLineNumber ();
+ token->filePosition = getInputFilePosition ();
+ break;
+
+ case '<':
+ {
+ int d = fileGetc ();
+ if (d == '-')
+ {
+ token->type = TOKEN_LEFT_ARROW;
+ break;
+ }
+ else
+ goto getNextChar;
+ }
+
+ case '(':
+ token->type = TOKEN_OPEN_PAREN;
+ break;
+
+ case ')':
+ token->type = TOKEN_CLOSE_PAREN;
+ break;
+
+ case '{':
+ token->type = TOKEN_OPEN_CURLY;
+ break;
+
+ case '}':
+ token->type = TOKEN_CLOSE_CURLY;
+ break;
+
+ case '[':
+ token->type = TOKEN_OPEN_SQUARE;
+ break;
+
+ case ']':
+ token->type = TOKEN_CLOSE_SQUARE;
+ break;
+
+ case '*':
+ token->type = TOKEN_STAR;
+ break;
+
+ case '.':
+ token->type = TOKEN_DOT;
+ break;
+
+ case ',':
+ token->type = TOKEN_COMMA;
+ break;
+
+ default:
+ parseIdentifier (token->string, c);
+ token->lineNumber = getSourceLineNumber ();
+ token->filePosition = getInputFilePosition ();
+ token->keyword = lookupKeyword (vStringValue (token->string), Lang_go);
+ if (isKeyword (token, KEYWORD_NONE))
+ token->type = TOKEN_IDENTIFIER;
+ else
+ token->type = TOKEN_KEYWORD;
+ break;
+ }
+
+done:
+ lastTokenType = token->type;
+}
+
+static void skipToMatched (tokenInfo *const token)
+{
+ int nest_level = 0;
+ tokenType open_token;
+ tokenType close_token;
+
+ switch (token->type)
+ {
+ case TOKEN_OPEN_PAREN:
+ open_token = TOKEN_OPEN_PAREN;
+ close_token = TOKEN_CLOSE_PAREN;
+ break;
+ case TOKEN_OPEN_CURLY:
+ open_token = TOKEN_OPEN_CURLY;
+ close_token = TOKEN_CLOSE_CURLY;
+ break;
+ case TOKEN_OPEN_SQUARE:
+ open_token = TOKEN_OPEN_SQUARE;
+ close_token = TOKEN_CLOSE_SQUARE;
+ break;
+ default:
+ return;
+ }
+
+ /*
+ * This routine will skip to a matching closing token.
+ * It will also handle nested tokens like the (, ) below.
+ * ( name varchar(30), text binary(10) )
+ */
+ if (isType (token, open_token))
+ {
+ nest_level++;
+ while (!(isType (token, close_token) && (nest_level == 0)))
+ {
+ readToken (token);
+ if (isType (token, open_token))
+ {
+ nest_level++;
+ }
+ if (isType (token, close_token))
+ {
+ if (nest_level > 0)
+ {
+ nest_level--;
+ }
+ }
+ }
+ readToken (token);
+ }
+}
+
+static void skipType (tokenInfo *const token)
+{
+again:
+ // Type = TypeName | TypeLit | "(" Type ")" .
+ if (isType (token, TOKEN_OPEN_PAREN))
+ {
+ skipToMatched (token);
+ return;
+ }
+
+ // TypeName = QualifiedIdent.
+ // QualifiedIdent = [ PackageName "." ] identifier .
+ // PackageName = identifier .
+ if (isType (token, TOKEN_IDENTIFIER))
+ {
+ readToken (token);
+ if (isType (token, TOKEN_DOT))
+ {
+ readToken (token);
+ Assert (isType (token, TOKEN_IDENTIFIER));
+ readToken (token);
+ }
+ return;
+ }
+
+ // StructType = "struct" "{" { FieldDecl ";" } "}"
+ // InterfaceType = "interface" "{" { MethodSpec ";" } "}" .
+ if (isKeyword (token, KEYWORD_struct) || isKeyword (token, KEYWORD_interface))
+ {
+ readToken (token);
+ Assert (isType (token, TOKEN_OPEN_CURLY));
+ skipToMatched (token);
+ return;
+ }
+
+ // ArrayType = "[" ArrayLength "]" ElementType .
+ // SliceType = "[" "]" ElementType .
+ // ElementType = Type .
+ if (isType (token, TOKEN_OPEN_SQUARE))
+ {
+ skipToMatched (token);
+ goto again;
+ }
+
+ // PointerType = "*" BaseType .
+ // BaseType = Type .
+ // ChannelType = ( "chan" [ "<-" ] | "<-" "chan" ) ElementType .
+ if (isType (token, TOKEN_STAR) || isKeyword (token, KEYWORD_chan) || isType (token, TOKEN_LEFT_ARROW))
+ {
+ readToken (token);
+ goto again;
+ }
+
+ // MapType = "map" "[" KeyType "]" ElementType .
+ // KeyType = Type .
+ if (isKeyword (token, KEYWORD_map))
+ {
+ readToken (token);
+ Assert (isType (token, TOKEN_OPEN_SQUARE));
+ skipToMatched (token);
+ goto again;
+ }
+
+ // FunctionType = "func" Signature .
+ // Signature = Parameters [ Result ] .
+ // Result = Parameters | Type .
+ // Parameters = "(" [ ParameterList [ "," ] ] ")" .
+ if (isKeyword (token, KEYWORD_func))
+ {
+ readToken (token);
+ Assert (isType (token, TOKEN_OPEN_PAREN));
+ // Parameters
+ skipToMatched (token);
+ // Result is parameters or type or nothing. skipType treats anything
+ // surrounded by parentheses as a type, and does nothing if what
+ // follows is not a type.
+ goto again;
+ }
+}
+
+// Skip to the next semicolon, skipping over matching brackets.
+static void skipToTopLevelSemicolon (tokenInfo *const token)
+{
+ while (!isType (token, TOKEN_SEMICOLON))
+ {
+ readToken (token);
+ skipToMatched (token);
+ }
+}
+
+static void makeTag (tokenInfo *const token, const goKind kind)
+{
+ const char *const name = vStringValue (token->string);
+
+ tagEntryInfo e;
+ initTagEntry (&e, name);
+
+ if (!GoKinds [kind].enabled)
+ return;
+
+ e.lineNumber = token->lineNumber;
+ e.filePosition = token->filePosition;
+ e.kindName = GoKinds [kind].name;
+ e.kind = GoKinds [kind].letter;
+
+ makeTagEntry (&e);
+
+ if (scope && Option.include.qualifiedTags)
+ {
+ vString *qualifiedName = vStringNew ();
+ vStringCopy (qualifiedName, scope);
+ vStringCatS (qualifiedName, ".");
+ vStringCat (qualifiedName, token->string);
+ e.name = vStringValue (qualifiedName);
+ makeTagEntry (&e);
+ vStringDelete (qualifiedName);
+ }
+}
+
+static void parsePackage (tokenInfo *const token)
+{
+ tokenInfo *const name = newToken ();
+
+ readToken (name);
+ Assert (isType (name, TOKEN_IDENTIFIER));
+ makeTag (name, GOTAG_PACKAGE);
+ if (!scope && Option.include.qualifiedTags)
+ {
+ scope = vStringNew ();
+ vStringCopy (scope, name->string);
+ }
+
+ deleteToken (name);
+}
+
+static void parseFunctionOrMethod (tokenInfo *const token)
+{
+ // FunctionDecl = "func" identifier Signature [ Body ] .
+ // Body = Block.
+ //
+ // MethodDecl = "func" Receiver MethodName Signature [ Body ] .
+ // Receiver = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
+ // BaseTypeName = identifier .
+ tokenInfo *const name = newToken ();
+
+ // Skip over receiver.
+ readToken (name);
+ if (isType (name, TOKEN_OPEN_PAREN))
+ skipToMatched (name);
+
+ Assert (isType (name, TOKEN_IDENTIFIER));
+
+ // Skip over parameters.
+ readToken (token);
+ skipToMatched (token);
+
+ // Skip over result.
+ skipType (token);
+
+ // Skip over function body.
+ if (isType (token, TOKEN_OPEN_CURLY))
+ skipToMatched (token);
+
+ makeTag (name, GOTAG_FUNCTION);
+
+ deleteToken (name);
+}
+
+static void parseConstTypeVar (tokenInfo *const token, goKind kind)
+{
+ // ConstDecl = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
+ // ConstSpec = IdentifierList [ [ Type ] "=" ExpressionList ] .
+ // IdentifierList = identifier { "," identifier } .
+ // ExpressionList = Expression { "," Expression } .
+ // TypeDecl = "type" ( TypeSpec | "(" { TypeSpec ";" } ")" ) .
+ // TypeSpec = identifier Type .
+ // VarDecl = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
+ // VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .
+ tokenInfo *const name = newToken ();
+ boolean usesParens = FALSE;
+
+ readToken (name);
+
+ if (isType (name, TOKEN_OPEN_PAREN))
+ {
+ usesParens = TRUE;
+ readToken (name);
+ }
+
+again:
+ while (1)
+ {
+ makeTag (name, kind);
+ readToken (token);
+ if (!isType (token, TOKEN_COMMA) && !isType (token, TOKEN_CLOSE_PAREN))
+ break;
+ readToken (name);
+ }
+
+ skipType (token);
+ skipToTopLevelSemicolon (token);
+
+ if (usesParens)
+ {
+ readToken (name);
+ if (!isType (name, TOKEN_CLOSE_PAREN))
+ goto again;
+ }
+
+ deleteToken (name);
+}
+
+static void parseGoFile (tokenInfo *const token)
+{
+ do
+ {
+ readToken (token);
+
+ if (isType (token, TOKEN_KEYWORD))
+ {
+ switch (token->keyword)
+ {
+ case KEYWORD_package:
+ parsePackage (token);
+ break;
+ case KEYWORD_func:
+ parseFunctionOrMethod (token);
+ break;
+ case KEYWORD_const:
+ parseConstTypeVar (token, GOTAG_CONST);
+ break;
+ case KEYWORD_type:
+ parseConstTypeVar (token, GOTAG_TYPE);
+ break;
+ case KEYWORD_var:
+ parseConstTypeVar (token, GOTAG_VAR);
+ break;
+ default:
+ break;
+ }
+ }
+ } while (TRUE);
+}
+
+static void findGoTags (void)
+{
+ tokenInfo *const token = newToken ();
+ exception_t exception;
+
+ exception = (exception_t) (setjmp (Exception));
+ while (exception == ExceptionNone)
+ parseGoFile (token);
+
+ deleteToken (token);
+ vStringDelete (scope);
+ scope = NULL;
+}
+
+extern parserDefinition *GoParser (void)
+{
+ static const char *const extensions[] = { "go", NULL };
+ parserDefinition *def = parserNew ("Go");
+ def->kinds = GoKinds;
+ def->kindCount = KIND_COUNT (GoKinds);
+ def->extensions = extensions;
+ def->parser = findGoTags;
+ def->initialize = initialize;
+ return def;
+}
diff --git a/parsers.h b/parsers.h
index e4a50e1..b150506 100644
--- a/parsers.h
+++ b/parsers.h
@@ -32,6 +32,7 @@
ErlangParser, \
FlexParser, \
FortranParser, \
+ GoParser, \
HtmlParser, \
JavaParser, \
JavaScriptParser, \
@@ -76,6 +77,7 @@
FlexParser, \
FortranParser, \
GenieParser, \
+ GoParser, \
HtmlParser, \
JavaParser, \
JavaScriptParser, \
diff --git a/source.mak b/source.mak
index 3e5f740..d4c4c26 100644
--- a/source.mak
+++ b/source.mak
@@ -24,6 +24,7 @@ SOURCES = \
flex.c \
fortran.c \
get.c \
+ go.c \
html.c \
jscript.c \
keyword.c \
@@ -86,6 +87,7 @@ OBJECTS = \
flex.$(OBJEXT) \
fortran.$(OBJEXT) \
get.$(OBJEXT) \
+ go.$(OBJEXT) \
html.$(OBJEXT) \
jscript.$(OBJEXT) \
keyword.$(OBJEXT) \
--
2.11.0

76
0018-SUSE-man-page-changes.patch Normal file
View File

@ -0,0 +1,76 @@
From e63684e0d8924dd6a56bda52ebfc81fb6c35811b Mon Sep 17 00:00:00 2001
From: Stepan Kasal <kasal@suse.cz>
Date: Mon, 31 Jan 2000 12:41:54 +0100
Subject: [PATCH 18/19] SUSE man page changes
---
ctags.1 | 35 +++++++++++++++++++++++++++++------
1 file changed, 29 insertions(+), 6 deletions(-)
diff --git a/ctags.1 b/ctags.1
index 2d89006..138e6ce 100644
--- a/ctags.1
+++ b/ctags.1
@@ -9,12 +9,29 @@ ctags \- Generate tag files for source code
.TP 6
\fBctags\fP [\fBoptions\fP] [\fIfile(s)\fP]
.TP 6
-\fBetags\fP [\fBoptions\fP] [\fIfile(s)\fP]
-
+\fBctags\fP \fB-e\fP [\fBoptions\fP] [\fIfile(s)\fP]
+
+.SH NOTE
+There are three different versions of the
+\fBctags\fP program on SuSE Linux.
+Besides this one you might want to use either
+.BR gnuctags (1),
+supporting wide variety of programming languages
+and originaly distributed with emacs, or
+.BR gctags (1),
+which comes with
+.BR global (1)
+and supports for example Yacc.
+
+For use with
+.BR emacs (1)
+the best choice is perhaps
+.BR etags (1),
+but it's also possible to use \fBctags\ \-e\fP,
+as described herein, since it supports for example Eiffel.
.SH "DESCRIPTION"
-The \fBctags\fP and \fBetags\fP programs (hereinafter collectively referred to
-as \fBctags\fP, except where distinguished) generate an index (or "tag") file
+The \fBctags\fP program generates an index (or "tag") file
for a variety of language objects found in \fIfile(s)\fP.
This tag file allows these items to be quickly and easily located by a text
editor or other utility. A "tag" signifies a language object for which an
@@ -1081,7 +1098,7 @@ embedded space. If this is a problem, use a configuration file instead.
.TP 8
.B ETAGS
Similar to the \fBCTAGS\fP variable above, this variable, if found, will be
-read when \fBetags\fP starts. If this variable is not found, \fBetags\fP will
+read when \fBctags\ \-e\fP starts. If this variable is not found, \fBctags\ \-e\fP will
try to use \fBCTAGS\fP instead.
.TP 8
@@ -1136,9 +1153,15 @@ lines to indicate separate command-line arguments.
The default tag file created by \fBctags\fP.
.TP
.I TAGS
-The default tag file created by \fBetags\fP.
+The default tag file created by \fBctags -e\fP.
.SH "SEE ALSO"
+.BR etags (1),
+.BR gctags (1),
+.BR global (1),
+.BR gnuctags (1).
+
+.PP
The official Exuberant Ctags web site at:
.RS
--
2.11.0

47
0019-Do-not-include-build-time-in-binary.patch Normal file
View File

@ -0,0 +1,47 @@
From 2814d01a6cdb52a336dc6d6243ecc3cad44e60f1 Mon Sep 17 00:00:00 2001
From: Unknown Lost in OBS Migration <unk@nown.net>
Date: Sun, 26 Feb 2017 05:34:04 +0100
Subject: [PATCH 19/19] Do not include build time in binary.
---
main.c | 11 -----------
options.c | 1 -
2 files changed, 12 deletions(-)
diff --git a/main.c b/main.c
index 79948fe..8bca242 100644
--- a/main.c
+++ b/main.c
@@ -93,17 +93,6 @@
*/
static struct { long files, lines, bytes; } Totals = { 0, 0, 0 };
-#ifdef AMIGA
-# include "ctags.h"
- static const char *VERsion = "$VER: "PROGRAM_NAME" "PROGRAM_VERSION" "
-# ifdef __SASC
- __AMIGADATE__
-# else
- __DATE__
-# endif
- " "AUTHOR_NAME" $";
-#endif
-
/*
* FUNCTION PROTOTYPES
*/
diff --git a/options.c b/options.c
index 1bee61d..0fc8e0c 100644
--- a/options.c
+++ b/options.c
@@ -926,7 +926,6 @@ static void printProgramIdentification (void)
printf ("%s %s, %s %s\n",
PROGRAM_NAME, PROGRAM_VERSION,
PROGRAM_COPYRIGHT, AUTHOR_NAME);
- printf (" Compiled: %s, %s\n", __DATE__, __TIME__);
printf (" Addresses: <%s>, %s\n", AUTHOR_EMAIL, PROGRAM_URL);
printFeatureList ();
}
--
2.11.0

209
CVE-2022-4515.patch Normal file
View File

@ -0,0 +1,209 @@
Based on
From e00c55d7a0204dc1d0ae316141323959e1e16162 Mon Sep 17 00:00:00 2001
From: Masatake YAMATO <yamato@redhat.com>
Date: Mon, 24 Oct 2016 23:52:23 +0900
Subject: [PATCH] main: quote output file name before passing it to system(3)
function
Following command line doesn't work:
$ ctags -o 'a b' ...
because a shell lauched from system(3) deals a whitespace between 'a'
and 'b' as a separator. The output file name is passed to system(3)
to run external sort command.
This commit adds code to put double and single quoets around the output
file name before passing it to system(3).
The issue is reported by Lorenz Hipp <lhipp@idealbonn.de> in a private mail.
Signed-off-by: Masatake YAMATO <yamato@redhat.com>
---
Tmain/abnormal-output-file-names.d/input.c | 1 +
Tmain/abnormal-output-file-names.d/run.sh | 39 ++++++++++
.../stderr-expected.txt | 0
.../stdout-expected.txt | 8 +++
main/sort.c | 72 ++++++++++++++-----
5 files changed, 102 insertions(+), 18 deletions(-)
create mode 100644 Tmain/abnormal-output-file-names.d/input.c
create mode 100644 Tmain/abnormal-output-file-names.d/run.sh
create mode 100644 Tmain/abnormal-output-file-names.d/stderr-expected.txt
create mode 100644 Tmain/abnormal-output-file-names.d/stdout-expected.txt
Index: ctags-5.8/Tmain/abnormal-output-file-names.d/input.c
===================================================================
--- /dev/null
+++ ctags-5.8/Tmain/abnormal-output-file-names.d/input.c
@@ -0,0 +1 @@
+int x;
Index: ctags-5.8/Tmain/abnormal-output-file-names.d/run.sh
===================================================================
--- /dev/null
+++ ctags-5.8/Tmain/abnormal-output-file-names.d/run.sh
@@ -0,0 +1,39 @@
+# Copyright: 2016 Masatake YAMATO
+# License: GPL-2
+
+CTAGS=$1
+
+rm -f ./"'"
+rm -f ./'"'
+rm -f ./'$(ls)'
+rm -f ./'a b'
+
+${CTAGS} --options=NONE -o ./"'" --extra=-pF input.c
+${CTAGS} --options=NONE -o ./'"' --extra=-pF input.c
+${CTAGS} --options=NONE -o ./'$(ls)' --extra=-pF input.c
+${CTAGS} --options=NONE -o ./'a b' --extra=-pF input.c
+
+echo '#' SINGLE QUOTE
+if [ -e "'" ]; then
+ cat "'"
+fi
+
+echo '#' DOUBLE QUOTES
+if [ -e '"' ]; then
+ cat '"'
+fi
+
+echo '#' PROCESS SUBSTITUTION
+if [ -e '$(ls)' ]; then
+ cat '$(ls)'
+fi
+
+echo '#' SPACE
+if [ -e 'a b' ]; then
+ cat 'a b'
+fi
+
+rm -f ./"'"
+rm -f ./'"'
+rm -f ./'$(ls)'
+rm -f ./'a b'
Index: ctags-5.8/Tmain/abnormal-output-file-names.d/stdout-expected.txt
===================================================================
--- /dev/null
+++ ctags-5.8/Tmain/abnormal-output-file-names.d/stdout-expected.txt
@@ -0,0 +1,8 @@
+# SINGLE QUOTE
+x input.c /^int x;$/;" v typeref:typename:int
+# DOUBLE QUOTES
+x input.c /^int x;$/;" v typeref:typename:int
+# PROCESS SUBSTITUTION
+x input.c /^int x;$/;" v typeref:typename:int
+# SPACE
+x input.c /^int x;$/;" v typeref:typename:int
Index: ctags-5.8/sort.c
===================================================================
--- ctags-5.8.orig/sort.c
+++ ctags-5.8/sort.c
@@ -19,6 +19,7 @@
#endif
#include <string.h>
#include <stdio.h>
+#include <unistd.h>
#include "debug.h"
#include "entry.h"
@@ -53,41 +54,83 @@ extern void catFile (const char *const n
# define PE_CONST const
#endif
+/*
+ Output file name should not be evaluated in system(3) function.
+ The name must be used as is. Quotations are required to block the
+ evaluation.
+
+ Normal single-quotes are used to quote a cstring:
+ a => 'a'
+ " => '"'
+
+ If a single-quote is included in the cstring, use double quotes for quoting it.
+ ' => ''"'"''
+*/
+static void appendCstringWithQuotes (vString *dest, const char* cstr)
+{
+ const char* o;
+
+ vStringPut (dest, '\'');
+ for (o = cstr; *o; o++)
+ {
+ if (*o == '\'')
+ vStringCatS (dest, "'\"'\"'");
+ else
+ vStringPut (dest, *o);
+ }
+ vStringPut (dest, '\'');
+}
+
extern void externalSortTags (const boolean toStdout)
{
- const char *const sortNormalCommand = "sort -u -o";
- const char *const sortFoldedCommand = "sort -u -f -o";
+ const char *const sortNormalCommand = "/usr/bin/sort -u";
+ const char *const sortFoldedCommand = "/usr/bin/sort -u -f";
const char *sortCommand =
Option.sorted == SO_FOLDSORTED ? sortFoldedCommand : sortNormalCommand;
+# ifndef HAVE_SETENV
PE_CONST char *const sortOrder1 = "LC_COLLATE=C";
PE_CONST char *const sortOrder2 = "LC_ALL=C";
- const size_t length = 4 + strlen (sortOrder1) + strlen (sortOrder2) +
- strlen (sortCommand) + (2 * strlen (tagFileName ()));
- char *const cmd = (char *) malloc (length + 1);
+# endif
+ vString *cmd = vStringNew ();
int ret = -1;
if (cmd != NULL)
{
/* Ensure ASCII value sort order.
*/
-#ifdef HAVE_SETENV
+#if defined(HAVE_SETENV) || defined(HAVE_PUTENV)
+# if HAVE_SETENV
setenv ("LC_COLLATE", "C", 1);
setenv ("LC_ALL", "C", 1);
- sprintf (cmd, "%s %s %s", sortCommand, tagFileName (), tagFileName ());
-#else
-# ifdef HAVE_PUTENV
+# else
putenv (sortOrder1);
putenv (sortOrder2);
- sprintf (cmd, "%s %s %s", sortCommand, tagFileName (), tagFileName ());
-# else
- sprintf (cmd, "%s %s %s %s %s", sortOrder1, sortOrder2, sortCommand,
- tagFileName (), tagFileName ());
# endif
+ vStringCatS (cmd, sortCommand);
+// if (! toStdout)
+ {
+ vStringCatS (cmd, " -o ");
+ appendCstringWithQuotes (cmd, tagFileName ());
+ vStringPut (cmd, ' ');
+ appendCstringWithQuotes (cmd, tagFileName ());
+ }
+#else
+ vStringCatS (cmd, sortOrder1);
+ vStringPut (cmd, ' ');
+ vStringCatS (cmd, sortOrder2);
+ vStringPut (cmd, ' ');
+ vStringCatS (cmd, sortCommand);
+// if (! toStdout)
+ {
+ vStringCats (cmd, " -o ");
+ appendCstringWithQuotes (cmd, tagFileName ());
+ vStringPut (cmd, ' ');
+ appendCstringWithQuotes (cmd, tagFileName ());
+ }
#endif
- verbose ("system (\"%s\")\n", cmd);
- ret = system (cmd);
- free (cmd);
-
+ verbose ("system (\"%s\")\n", vStringValue(cmd));
+ ret = system (vStringValue(cmd));
+ vStringDelete (cmd);
}
if (ret != 0)
error (FATAL | PERROR, "cannot sort tag file");

BIN
ctags-5.8.tar.gz (Stored with Git LFS) Normal file
View File

Binary file not shown.

268
ctags-gcc11.patch Normal file
View File

@ -0,0 +1,268 @@
diff -u ctags-5.8.orig/c.c ctags-5.8/c.c
--- ctags-5.8.orig/c.c 2021-09-27 10:44:24.772898854 +0200
+++ ctags-5.8/c.c 2021-09-27 10:58:15.168499970 +0200
@@ -624,7 +624,7 @@
return name;
}
-static void __unused__ pt (tokenInfo *const token)
+static void __maybe_unused__ pt (tokenInfo *const token)
{
if (isType (token, TOKEN_NAME))
printf ("type: %-12s: %-13s line: %lu\n",
@@ -639,7 +639,7 @@
tokenString (token->type), token->lineNumber);
}
-static void __unused__ ps (statementInfo *const st)
+static void __maybe_unused__ ps (statementInfo *const st)
{
unsigned int i;
printf ("scope: %s decl: %s gotName: %s gotParenName: %s isPointer: %s\n",
diff -u ctags-5.8.orig/eiffel.c ctags-5.8/eiffel.c
--- ctags-5.8.orig/eiffel.c 2021-09-27 10:44:24.732898295 +0200
+++ ctags-5.8/eiffel.c 2021-09-27 10:58:15.168499970 +0200
@@ -807,7 +807,7 @@
static boolean parseType (tokenInfo *const token);
-static void parseGeneric (tokenInfo *const token, boolean declaration __unused__)
+static void parseGeneric (tokenInfo *const token, boolean declaration __maybe_unused__)
{
unsigned int depth = 0;
#ifdef TYPE_REFERENCE_TOOL
diff -u ctags-5.8.orig/general.h ctags-5.8/general.h
--- ctags-5.8.orig/general.h 2007-05-03 05:21:08.000000000 +0200
+++ ctags-5.8/general.h 2021-09-27 10:57:03.851490665 +0200
@@ -57,10 +57,10 @@
* to prevent warnings about unused variables.
*/
#if (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)) && !defined (__GNUG__)
-# define __unused__ __attribute__((unused))
+# define __maybe_unused__ __attribute__((unused))
# define __printf__(s,f) __attribute__((format (printf, s, f)))
#else
-# define __unused__
+# define __maybe_unused__
# define __printf__(s,f)
#endif
Common subdirectories: ctags-5.8.orig/gnu_regex and ctags-5.8/gnu_regex
diff -u ctags-5.8.orig/lregex.c ctags-5.8/lregex.c
--- ctags-5.8.orig/lregex.c 2021-09-27 10:44:24.732898295 +0200
+++ ctags-5.8/lregex.c 2021-09-27 10:58:15.176500083 +0200
@@ -538,11 +538,11 @@
#endif /* HAVE_REGEX */
extern void addTagRegex (
- const langType language __unused__,
- const char* const regex __unused__,
- const char* const name __unused__,
- const char* const kinds __unused__,
- const char* const flags __unused__)
+ const langType language __maybe_unused__,
+ const char* const regex __maybe_unused__,
+ const char* const name __maybe_unused__,
+ const char* const kinds __maybe_unused__,
+ const char* const flags __maybe_unused__)
{
#ifdef HAVE_REGEX
Assert (regex != NULL);
@@ -564,10 +564,10 @@
}
extern void addCallbackRegex (
- const langType language __unused__,
- const char* const regex __unused__,
- const char* const flags __unused__,
- const regexCallback callback __unused__)
+ const langType language __maybe_unused__,
+ const char* const regex __maybe_unused__,
+ const char* const flags __maybe_unused__,
+ const regexCallback callback __maybe_unused__)
{
#ifdef HAVE_REGEX
Assert (regex != NULL);
@@ -581,7 +581,7 @@
}
extern void addLanguageRegex (
- const langType language __unused__, const char* const regex __unused__)
+ const langType language __maybe_unused__, const char* const regex __maybe_unused__)
{
#ifdef HAVE_REGEX
if (! regexBroken)
@@ -602,7 +602,7 @@
*/
extern boolean processRegexOption (const char *const option,
- const char *const parameter __unused__)
+ const char *const parameter __maybe_unused__)
{
boolean handled = FALSE;
const char* const dash = strchr (option, '-');
@@ -624,7 +624,7 @@
return handled;
}
-extern void disableRegexKinds (const langType language __unused__)
+extern void disableRegexKinds (const langType language __maybe_unused__)
{
#ifdef HAVE_REGEX
if (language <= SetUpper && Sets [language].count > 0)
@@ -639,8 +639,8 @@
}
extern boolean enableRegexKind (
- const langType language __unused__,
- const int kind __unused__, const boolean mode __unused__)
+ const langType language __maybe_unused__,
+ const int kind __maybe_unused__, const boolean mode __maybe_unused__)
{
boolean result = FALSE;
#ifdef HAVE_REGEX
@@ -660,7 +660,7 @@
return result;
}
-extern void printRegexKinds (const langType language __unused__, boolean indent __unused__)
+extern void printRegexKinds (const langType language __maybe_unused__, boolean indent __maybe_unused__)
{
#ifdef HAVE_REGEX
if (language <= SetUpper && Sets [language].count > 0)
diff -u ctags-5.8.orig/lua.c ctags-5.8/lua.c
--- ctags-5.8.orig/lua.c 2006-10-12 05:26:40.000000000 +0200
+++ ctags-5.8/lua.c 2021-09-27 10:58:15.176500083 +0200
@@ -37,7 +37,7 @@
*/
/* for debugging purposes */
-static void __unused__ print_string (char *p, char *q)
+static void __maybe_unused__ print_string (char *p, char *q)
{
for ( ; p != q; p++)
fprintf (errout, "%c", *p);
diff -u ctags-5.8.orig/main.c ctags-5.8/main.c
--- ctags-5.8.orig/main.c 2021-09-27 10:44:24.784899021 +0200
+++ ctags-5.8/main.c 2021-09-27 10:58:15.176500083 +0200
@@ -511,7 +511,7 @@
* Start up code
*/
-extern int main (int __unused__ argc, char **argv)
+extern int main (int __maybe_unused__ argc, char **argv)
{
cookedArgs *args;
#ifdef VMS
diff -u ctags-5.8.orig/options.c ctags-5.8/options.c
--- ctags-5.8.orig/options.c 2021-09-27 10:44:24.784899021 +0200
+++ ctags-5.8/options.c 2021-09-27 10:58:15.180500140 +0200
@@ -731,7 +731,7 @@
}
static void processExcludeOption (
- const char *const option __unused__, const char *const parameter)
+ const char *const option __maybe_unused__, const char *const parameter)
{
const char *const fileName = parameter + 1;
if (parameter [0] == '\0')
@@ -869,7 +869,7 @@
}
static void processFilterTerminatorOption (
- const char *const option __unused__, const char *const parameter)
+ const char *const option __maybe_unused__, const char *const parameter)
{
freeString (&Option.filterTerminator);
Option.filterTerminator = stringCopy (parameter);
@@ -931,8 +931,8 @@
}
static void processHelpOption (
- const char *const option __unused__,
- const char *const parameter __unused__)
+ const char *const option __maybe_unused__,
+ const char *const parameter __maybe_unused__)
{
printProgramIdentification ();
putchar ('\n');
@@ -1140,8 +1140,8 @@
}
static void processLicenseOption (
- const char *const option __unused__,
- const char *const parameter __unused__)
+ const char *const option __maybe_unused__,
+ const char *const parameter __maybe_unused__)
{
printProgramIdentification ();
puts ("");
@@ -1167,8 +1167,8 @@
}
static void processListMapsOption (
- const char *const __unused__ option,
- const char *const __unused__ parameter)
+ const char *const __maybe_unused__ option,
+ const char *const __maybe_unused__ parameter)
{
if (parameter [0] == '\0' || strcasecmp (parameter, "all") == 0)
printLanguageMaps (LANG_AUTO);
@@ -1184,8 +1184,8 @@
}
static void processListLanguagesOption (
- const char *const option __unused__,
- const char *const parameter __unused__)
+ const char *const option __maybe_unused__,
+ const char *const parameter __maybe_unused__)
{
printLanguageList ();
exit (0);
@@ -1359,8 +1359,8 @@
}
static void processVersionOption (
- const char *const option __unused__,
- const char *const parameter __unused__)
+ const char *const option __maybe_unused__,
+ const char *const parameter __maybe_unused__)
{
printProgramIdentification ();
exit (0);
diff -u ctags-5.8.orig/parse.c ctags-5.8/parse.c
--- ctags-5.8.orig/parse.c 2007-07-31 07:35:33.000000000 +0200
+++ ctags-5.8/parse.c 2021-09-27 10:58:15.180500140 +0200
@@ -376,7 +376,7 @@
*/
extern void processLanguageDefineOption (
- const char *const option, const char *const parameter __unused__)
+ const char *const option, const char *const parameter __maybe_unused__)
{
#ifdef HAVE_REGEX
if (parameter [0] == '\0')
diff -u ctags-5.8.orig/python.c ctags-5.8/python.c
--- ctags-5.8.orig/python.c 2021-09-27 10:44:24.736898351 +0200
+++ ctags-5.8/python.c 2021-09-27 10:58:15.180500140 +0200
@@ -135,7 +135,7 @@
* extract all relevant information and create a tag.
*/
static void makeFunctionTag (vString *const function,
- vString *const parent, int is_class_parent, const char *arglist __unused__)
+ vString *const parent, int is_class_parent, const char *arglist __maybe_unused__)
{
tagEntryInfo tag;
initTagEntry (&tag, vStringValue (function));
diff -u ctags-5.8.orig/routines.c ctags-5.8/routines.c
--- ctags-5.8.orig/routines.c 2007-06-07 06:35:21.000000000 +0200
+++ ctags-5.8/routines.c 2021-09-27 10:58:15.184500196 +0200
@@ -526,7 +526,7 @@
#if ! defined (HAVE_STAT_ST_INO)
-static void canonicalizePath (char *const path __unused__)
+static void canonicalizePath (char *const path __maybe_unused__)
{
#if defined (MSDOS_STYLE_PATH)
char *p;

491
ctags-ycp-parser.diff Normal file
View File

@ -0,0 +1,491 @@
--- c.c
+++ c.c
@@ -59,35 +59,39 @@ typedef enum eException {
*/
typedef enum eKeywordId {
KEYWORD_NONE = -1,
- KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT,
- KEYWORD_BOOLEAN, KEYWORD_BYTE, KEYWORD_BAD_STATE, KEYWORD_BAD_TRANS,
- KEYWORD_BIND, KEYWORD_BIND_VAR, KEYWORD_BIT,
+ KEYWORD_ATTRIBUTE, KEYWORD_ABSTRACT, KEYWORD_ANY,
+ KEYWORD_BOOLEAN, KEYWORD_BYTE, KEYWORD_BYTEBLOCK, KEYWORD_BAD_STATE,
+ KEYWORD_BAD_TRANS,
+ KEYWORD_BIND, KEYWORD_BIND_VAR, KEYWORD_BIT, KEYWORD_BLOCK,
KEYWORD_CASE, KEYWORD_CATCH, KEYWORD_CHAR, KEYWORD_CLASS, KEYWORD_CONST,
KEYWORD_CONSTRAINT, KEYWORD_COVERAGE_BLOCK, KEYWORD_COVERAGE_DEF,
- KEYWORD_DEFAULT, KEYWORD_DELEGATE, KEYWORD_DELETE, KEYWORD_DO,
+ KEYWORD_DEFAULT, KEYWORD_DECLARATION, KEYWORD_DELEGATE, KEYWORD_DELETE,
+ KEYWORD_DO,
KEYWORD_DOUBLE,
- KEYWORD_ELSE, KEYWORD_ENUM, KEYWORD_EXPLICIT, KEYWORD_EXTERN,
+ KEYWORD_ELSE, KEYWORD_ENUM, KEYWORD_EXPLICIT, KEYWORD_EXPRESSION,
+ KEYWORD_EXTERN,
KEYWORD_EXTENDS, KEYWORD_EVENT,
KEYWORD_FINAL, KEYWORD_FLOAT, KEYWORD_FOR, KEYWORD_FRIEND, KEYWORD_FUNCTION,
KEYWORD_GOTO,
KEYWORD_IF, KEYWORD_IMPLEMENTS, KEYWORD_IMPORT, KEYWORD_INLINE, KEYWORD_INT,
KEYWORD_INOUT, KEYWORD_INPUT, KEYWORD_INTEGER, KEYWORD_INTERFACE,
KEYWORD_INTERNAL,
- KEYWORD_LOCAL, KEYWORD_LONG,
+ KEYWORD_LIST, KEYWORD_LOCAL, KEYWORD_LOCALE, KEYWORD_LONG,
KEYWORD_M_BAD_STATE, KEYWORD_M_BAD_TRANS, KEYWORD_M_STATE, KEYWORD_M_TRANS,
- KEYWORD_MUTABLE,
+ KEYWORD_MAP, KEYWORD_MUTABLE,
KEYWORD_NAMESPACE, KEYWORD_NEW, KEYWORD_NEWCOV, KEYWORD_NATIVE,
KEYWORD_OPERATOR, KEYWORD_OUTPUT, KEYWORD_OVERLOAD, KEYWORD_OVERRIDE,
- KEYWORD_PACKED, KEYWORD_PORT, KEYWORD_PACKAGE, KEYWORD_PRIVATE,
- KEYWORD_PROGRAM, KEYWORD_PROTECTED, KEYWORD_PUBLIC,
+ KEYWORD_PACKED, KEYWORD_PATH, KEYWORD_PORT, KEYWORD_PACKAGE,
+ KEYWORD_PRIVATE,
+ KEYWORD_PROGRAM, KEYWORD_PROTECTED, KEYWORD_PUBLIC, KEYWORD_REPEAT,
KEYWORD_REGISTER, KEYWORD_RETURN,
KEYWORD_SHADOW, KEYWORD_STATE,
KEYWORD_SHORT, KEYWORD_SIGNED, KEYWORD_STATIC, KEYWORD_STRING,
- KEYWORD_STRUCT, KEYWORD_SWITCH, KEYWORD_SYNCHRONIZED,
- KEYWORD_TASK, KEYWORD_TEMPLATE, KEYWORD_THIS, KEYWORD_THROW,
+ KEYWORD_STRUCT, KEYWORD_SWITCH, KEYWORD_SYNCHRONIZED, KEYWORD_SYMBOL,
+ KEYWORD_TASK, KEYWORD_TEMPLATE, KEYWORD_TERM, KEYWORD_THIS, KEYWORD_THROW,
KEYWORD_THROWS, KEYWORD_TRANSIENT, KEYWORD_TRANS, KEYWORD_TRANSITION,
KEYWORD_TRY, KEYWORD_TYPEDEF, KEYWORD_TYPENAME,
- KEYWORD_UINT, KEYWORD_ULONG, KEYWORD_UNION, KEYWORD_UNSIGNED, KEYWORD_USHORT,
+ KEYWORD_UINT, KEYWORD_ULONG, KEYWORD_UNION, KEYWORD_UNSIGNED, KEYWORD_UNTIL, KEYWORD_USHORT,
KEYWORD_USING,
KEYWORD_VIRTUAL, KEYWORD_VOID, KEYWORD_VOLATILE,
KEYWORD_WCHAR_T, KEYWORD_WHILE
@@ -99,7 +103,7 @@ typedef enum eKeywordId {
typedef struct sKeywordDesc {
const char *name;
keywordId id;
- short isValid [5]; /* indicates languages for which kw is valid */
+ short isValid [6]; /* indicates languages for which kw is valid */
} keywordDesc;
/* Used for reporting the type of object parsed by nextToken ().
@@ -135,6 +139,7 @@ typedef enum eTagScope {
typedef enum eDeclaration {
DECL_NONE,
DECL_BASE, /* base type (default) */
+ DECL_BLOCK, /* YCP unnamed block */
DECL_CLASS,
DECL_ENUM,
DECL_EVENT,
@@ -256,6 +261,7 @@ static langType Lang_cpp;
static langType Lang_csharp;
static langType Lang_java;
static langType Lang_vera;
+static langType Lang_ycp;
static vString *Signature;
static boolean CollectingSignature;
@@ -354,110 +360,138 @@ static kindOption VeraKinds [] = {
{ FALSE, 'x', "externvar", "external variable declarations"}
};
+/* Used to index into the YCPKinds table. */
+typedef enum {
+ YK_UNDEFINED = -1,
+ YK_FUNCTION, YK_PROTOTYPE,
+ YK_LOCAL,
+ YK_VARIABLE
+} ycpKind;
+
+static kindOption YCPKinds [] = {
+ { TRUE, 'f', "function", "function definitions"},
+ { FALSE, 'p', "prototype", "function prototypes"},
+ { FALSE, 'l', "local", "local variables"},
+ { TRUE, 'v', "variable", "variable definitions"},
+};
+
static const keywordDesc KeywordTable [] = {
- /* C++ */
- /* ANSI C | C# Java */
- /* | | | | Vera */
- /* keyword keyword ID | | | | | */
- { "__attribute__", KEYWORD_ATTRIBUTE, { 1, 1, 1, 0, 0 } },
- { "abstract", KEYWORD_ABSTRACT, { 0, 0, 1, 1, 0 } },
- { "bad_state", KEYWORD_BAD_STATE, { 0, 0, 0, 0, 1 } },
- { "bad_trans", KEYWORD_BAD_TRANS, { 0, 0, 0, 0, 1 } },
- { "bind", KEYWORD_BIND, { 0, 0, 0, 0, 1 } },
- { "bind_var", KEYWORD_BIND_VAR, { 0, 0, 0, 0, 1 } },
- { "bit", KEYWORD_BIT, { 0, 0, 0, 0, 1 } },
- { "boolean", KEYWORD_BOOLEAN, { 0, 0, 0, 1, 0 } },
- { "byte", KEYWORD_BYTE, { 0, 0, 0, 1, 0 } },
- { "case", KEYWORD_CASE, { 1, 1, 1, 1, 0 } },
- { "catch", KEYWORD_CATCH, { 0, 1, 1, 0, 0 } },
- { "char", KEYWORD_CHAR, { 1, 1, 1, 1, 0 } },
- { "class", KEYWORD_CLASS, { 0, 1, 1, 1, 1 } },
- { "const", KEYWORD_CONST, { 1, 1, 1, 1, 0 } },
- { "constraint", KEYWORD_CONSTRAINT, { 0, 0, 0, 0, 1 } },
- { "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 1 } },
- { "coverage_def", KEYWORD_COVERAGE_DEF, { 0, 0, 0, 0, 1 } },
- { "do", KEYWORD_DO, { 1, 1, 1, 1, 0 } },
- { "default", KEYWORD_DEFAULT, { 1, 1, 1, 1, 0 } },
- { "delegate", KEYWORD_DELEGATE, { 0, 0, 1, 0, 0 } },
- { "delete", KEYWORD_DELETE, { 0, 1, 0, 0, 0 } },
- { "double", KEYWORD_DOUBLE, { 1, 1, 1, 1, 0 } },
- { "else", KEYWORD_ELSE, { 1, 1, 0, 1, 0 } },
- { "enum", KEYWORD_ENUM, { 1, 1, 1, 1, 1 } },
- { "event", KEYWORD_EVENT, { 0, 0, 1, 0, 1 } },
- { "explicit", KEYWORD_EXPLICIT, { 0, 1, 1, 0, 0 } },
- { "extends", KEYWORD_EXTENDS, { 0, 0, 0, 1, 1 } },
- { "extern", KEYWORD_EXTERN, { 1, 1, 1, 0, 1 } },
- { "final", KEYWORD_FINAL, { 0, 0, 0, 1, 0 } },
- { "float", KEYWORD_FLOAT, { 1, 1, 1, 1, 0 } },
- { "for", KEYWORD_FOR, { 1, 1, 1, 1, 0 } },
- { "friend", KEYWORD_FRIEND, { 0, 1, 0, 0, 0 } },
- { "function", KEYWORD_FUNCTION, { 0, 0, 0, 0, 1 } },
- { "goto", KEYWORD_GOTO, { 1, 1, 1, 1, 0 } },
- { "if", KEYWORD_IF, { 1, 1, 1, 1, 0 } },
- { "implements", KEYWORD_IMPLEMENTS, { 0, 0, 0, 1, 0 } },
- { "import", KEYWORD_IMPORT, { 0, 0, 0, 1, 0 } },
- { "inline", KEYWORD_INLINE, { 0, 1, 0, 0, 0 } },
- { "inout", KEYWORD_INOUT, { 0, 0, 0, 0, 1 } },
- { "input", KEYWORD_INPUT, { 0, 0, 0, 0, 1 } },
- { "int", KEYWORD_INT, { 1, 1, 1, 1, 0 } },
- { "integer", KEYWORD_INTEGER, { 0, 0, 0, 0, 1 } },
- { "interface", KEYWORD_INTERFACE, { 0, 0, 1, 1, 1 } },
- { "internal", KEYWORD_INTERNAL, { 0, 0, 1, 0, 0 } },
- { "local", KEYWORD_LOCAL, { 0, 0, 0, 0, 1 } },
- { "long", KEYWORD_LONG, { 1, 1, 1, 1, 0 } },
- { "m_bad_state", KEYWORD_M_BAD_STATE, { 0, 0, 0, 0, 1 } },
- { "m_bad_trans", KEYWORD_M_BAD_TRANS, { 0, 0, 0, 0, 1 } },
- { "m_state", KEYWORD_M_STATE, { 0, 0, 0, 0, 1 } },
- { "m_trans", KEYWORD_M_TRANS, { 0, 0, 0, 0, 1 } },
- { "mutable", KEYWORD_MUTABLE, { 0, 1, 0, 0, 0 } },
- { "namespace", KEYWORD_NAMESPACE, { 0, 1, 1, 0, 0 } },
- { "native", KEYWORD_NATIVE, { 0, 0, 0, 1, 0 } },
- { "new", KEYWORD_NEW, { 0, 1, 1, 1, 0 } },
- { "newcov", KEYWORD_NEWCOV, { 0, 0, 0, 0, 1 } },
- { "operator", KEYWORD_OPERATOR, { 0, 1, 1, 0, 0 } },
- { "output", KEYWORD_OUTPUT, { 0, 0, 0, 0, 1 } },
- { "overload", KEYWORD_OVERLOAD, { 0, 1, 0, 0, 0 } },
- { "override", KEYWORD_OVERRIDE, { 0, 0, 1, 0, 0 } },
- { "package", KEYWORD_PACKAGE, { 0, 0, 0, 1, 0 } },
- { "packed", KEYWORD_PACKED, { 0, 0, 0, 0, 1 } },
- { "port", KEYWORD_PORT, { 0, 0, 0, 0, 1 } },
- { "private", KEYWORD_PRIVATE, { 0, 1, 1, 1, 0 } },
- { "program", KEYWORD_PROGRAM, { 0, 0, 0, 0, 1 } },
- { "protected", KEYWORD_PROTECTED, { 0, 1, 1, 1, 1 } },
- { "public", KEYWORD_PUBLIC, { 0, 1, 1, 1, 1 } },
- { "register", KEYWORD_REGISTER, { 1, 1, 0, 0, 0 } },
- { "return", KEYWORD_RETURN, { 1, 1, 1, 1, 0 } },
- { "shadow", KEYWORD_SHADOW, { 0, 0, 0, 0, 1 } },
- { "short", KEYWORD_SHORT, { 1, 1, 1, 1, 0 } },
- { "signed", KEYWORD_SIGNED, { 1, 1, 0, 0, 0 } },
- { "state", KEYWORD_STATE, { 0, 0, 0, 0, 1 } },
- { "static", KEYWORD_STATIC, { 1, 1, 1, 1, 1 } },
- { "string", KEYWORD_STRING, { 0, 0, 1, 0, 1 } },
- { "struct", KEYWORD_STRUCT, { 1, 1, 1, 0, 0 } },
- { "switch", KEYWORD_SWITCH, { 1, 1, 1, 1, 0 } },
- { "synchronized", KEYWORD_SYNCHRONIZED, { 0, 0, 0, 1, 0 } },
- { "task", KEYWORD_TASK, { 0, 0, 0, 0, 1 } },
- { "template", KEYWORD_TEMPLATE, { 0, 1, 0, 0, 0 } },
- { "this", KEYWORD_THIS, { 0, 1, 1, 1, 0 } },
- { "throw", KEYWORD_THROW, { 0, 1, 1, 1, 0 } },
- { "throws", KEYWORD_THROWS, { 0, 0, 0, 1, 0 } },
- { "trans", KEYWORD_TRANS, { 0, 0, 0, 0, 1 } },
- { "transition", KEYWORD_TRANSITION, { 0, 0, 0, 0, 1 } },
- { "transient", KEYWORD_TRANSIENT, { 0, 0, 0, 1, 0 } },
- { "try", KEYWORD_TRY, { 0, 1, 1, 0, 0 } },
- { "typedef", KEYWORD_TYPEDEF, { 1, 1, 1, 0, 1 } },
- { "typename", KEYWORD_TYPENAME, { 0, 1, 0, 0, 0 } },
- { "uint", KEYWORD_UINT, { 0, 0, 1, 0, 0 } },
- { "ulong", KEYWORD_ULONG, { 0, 0, 1, 0, 0 } },
- { "union", KEYWORD_UNION, { 1, 1, 0, 0, 0 } },
- { "unsigned", KEYWORD_UNSIGNED, { 1, 1, 1, 0, 0 } },
- { "ushort", KEYWORD_USHORT, { 0, 0, 1, 0, 0 } },
- { "using", KEYWORD_USING, { 0, 1, 1, 0, 0 } },
- { "virtual", KEYWORD_VIRTUAL, { 0, 1, 1, 0, 1 } },
- { "void", KEYWORD_VOID, { 1, 1, 1, 1, 1 } },
- { "volatile", KEYWORD_VOLATILE, { 1, 1, 1, 1, 0 } },
- { "wchar_t", KEYWORD_WCHAR_T, { 1, 1, 1, 0, 0 } },
- { "while", KEYWORD_WHILE, { 1, 1, 1, 1, 0 } }
+ /* C++ YCP */
+ /* ANSI C | C# Java | */
+ /* | | | | Vera */
+ /* keyword keyword ID | | | | | | */
+ { "__attribute__", KEYWORD_ATTRIBUTE, { 1, 1, 1, 0, 0, 0 } },
+ { "abstract", KEYWORD_ABSTRACT, { 0, 0, 1, 1, 0, 0 } },
+ { "any", KEYWORD_ANY, { 0, 0, 0, 0, 0, 1 } },
+ { "bad_state", KEYWORD_BAD_STATE, { 0, 0, 0, 0, 1, 0 } },
+ { "bad_trans", KEYWORD_BAD_TRANS, { 0, 0, 0, 0, 1, 0 } },
+ { "bind", KEYWORD_BIND, { 0, 0, 0, 0, 1, 0 } },
+ { "bind_var", KEYWORD_BIND_VAR, { 0, 0, 0, 0, 1, 0 } },
+ { "bit", KEYWORD_BIT, { 0, 0, 0, 0, 1, 0 } },
+ { "block", KEYWORD_BLOCK, { 0, 0, 0, 0, 0, 1 } },
+ { "boolean", KEYWORD_BOOLEAN, { 0, 0, 0, 1, 0, 1 } },
+ { "byte", KEYWORD_BYTE, { 0, 0, 0, 1, 0, 0 } },
+ { "byteblock", KEYWORD_BYTEBLOCK, { 0, 0, 0, 0, 0, 1 } },
+ { "case", KEYWORD_CASE, { 1, 1, 1, 1, 0, 0 } },
+ { "catch", KEYWORD_CATCH, { 0, 1, 1, 0, 0, 0 } },
+ { "char", KEYWORD_CHAR, { 1, 1, 1, 1, 0, 0 } },
+ { "class", KEYWORD_CLASS, { 0, 1, 1, 1, 1, 0 } },
+ { "const", KEYWORD_CONST, { 1, 1, 1, 1, 0, 0 } },
+ { "constraint", KEYWORD_CONSTRAINT, { 0, 0, 0, 0, 1, 0 } },
+ { "coverage_block", KEYWORD_COVERAGE_BLOCK, { 0, 0, 0, 0, 1, 0 } },
+ { "coverage_def", KEYWORD_COVERAGE_DEF, { 0, 0, 0, 0, 1, 0 } },
+ { "declaration", KEYWORD_DECLARATION, { 0, 0, 0, 0, 0, 1 } },
+ { "do", KEYWORD_DO, { 1, 1, 1, 1, 0, 1 } },
+ { "default", KEYWORD_DEFAULT, { 1, 1, 1, 1, 0, 0 } },
+ { "delegate", KEYWORD_DELEGATE, { 0, 0, 1, 0, 0, 0 } },
+ { "delete", KEYWORD_DELETE, { 0, 1, 0, 0, 0, 0 } },
+ { "double", KEYWORD_DOUBLE, { 1, 1, 1, 1, 0, 0 } },
+ { "else", KEYWORD_ELSE, { 1, 1, 0, 1, 0, 1 } },
+ { "enum", KEYWORD_ENUM, { 1, 1, 1, 1, 1, 1 } },
+ { "event", KEYWORD_EVENT, { 0, 0, 1, 0, 1, 0 } },
+ { "explicit", KEYWORD_EXPLICIT, { 0, 1, 1, 0, 0, 0 } },
+ { "expression", KEYWORD_EXPRESSION, { 0, 0, 0, 0, 0, 1 } },
+ { "extends", KEYWORD_EXTENDS, { 0, 0, 0, 1, 1, 0 } },
+ { "extern", KEYWORD_EXTERN, { 1, 1, 1, 0, 1, 0 } },
+ { "final", KEYWORD_FINAL, { 0, 0, 0, 1, 0, 1 } },
+ { "float", KEYWORD_FLOAT, { 1, 1, 1, 1, 0, 1 } },
+ { "for", KEYWORD_FOR, { 1, 1, 1, 1, 0, 0 } },
+ { "friend", KEYWORD_FRIEND, { 0, 1, 0, 0, 0, 0 } },
+ { "function", KEYWORD_FUNCTION, { 0, 0, 0, 0, 1, 0 } },
+ { "goto", KEYWORD_GOTO, { 1, 1, 1, 1, 0, 0 } },
+ { "if", KEYWORD_IF, { 1, 1, 1, 1, 0, 1 } },
+ { "implements", KEYWORD_IMPLEMENTS, { 0, 0, 0, 1, 0, 0 } },
+ { "import", KEYWORD_IMPORT, { 0, 0, 0, 1, 0, 1 } },
+ { "inline", KEYWORD_INLINE, { 0, 1, 0, 0, 0, 0 } },
+ { "inout", KEYWORD_INOUT, { 0, 0, 0, 0, 1, 0 } },
+ { "input", KEYWORD_INPUT, { 0, 0, 0, 0, 1, 0 } },
+ { "int", KEYWORD_INT, { 1, 1, 1, 1, 0, 0 } },
+ { "integer", KEYWORD_INTEGER, { 0, 0, 0, 0, 1, 1 } },
+ { "interface", KEYWORD_INTERFACE, { 0, 0, 1, 1, 1, 0 } },
+ { "internal", KEYWORD_INTERNAL, { 0, 0, 1, 0, 0, 0 } },
+ { "list", KEYWORD_LIST, { 0, 0, 0, 0, 0, 1 } },
+ { "local", KEYWORD_LOCAL, { 0, 0, 0, 0, 1, 0 } },
+ { "locale", KEYWORD_LOCALE, { 0, 0, 0, 0, 0, 1 } },
+ { "long", KEYWORD_LONG, { 1, 1, 1, 1, 0, 0 } },
+ { "m_bad_state", KEYWORD_M_BAD_STATE, { 0, 0, 0, 0, 1, 0 } },
+ { "m_bad_trans", KEYWORD_M_BAD_TRANS, { 0, 0, 0, 0, 1, 0 } },
+ { "m_state", KEYWORD_M_STATE, { 0, 0, 0, 0, 1, 0 } },
+ { "m_trans", KEYWORD_M_TRANS, { 0, 0, 0, 0, 1, 0 } },
+ { "map", KEYWORD_MAP, { 0, 0, 0, 0, 0, 1 } },
+ { "mutable", KEYWORD_MUTABLE, { 0, 1, 0, 0, 0, 0 } },
+ { "namespace", KEYWORD_NAMESPACE, { 0, 1, 1, 0, 0, 0 } },
+ { "native", KEYWORD_NATIVE, { 0, 0, 0, 1, 0, 0 } },
+ { "new", KEYWORD_NEW, { 0, 1, 1, 1, 0, 0 } },
+ { "newcov", KEYWORD_NEWCOV, { 0, 0, 0, 0, 1, 0 } },
+ { "operator", KEYWORD_OPERATOR, { 0, 1, 1, 0, 0, 0 } },
+ { "output", KEYWORD_OUTPUT, { 0, 0, 0, 0, 1, 0 } },
+ { "overload", KEYWORD_OVERLOAD, { 0, 1, 0, 0, 0, 0 } },
+ { "override", KEYWORD_OVERRIDE, { 0, 0, 1, 0, 0, 0 } },
+ { "package", KEYWORD_PACKAGE, { 0, 0, 0, 1, 0, 0 } },
+ { "packed", KEYWORD_PACKED, { 0, 0, 0, 0, 1, 0 } },
+ { "path", KEYWORD_PATH, { 0, 0, 0, 0, 0, 1 } },
+ { "port", KEYWORD_PORT, { 0, 0, 0, 0, 1, 0 } },
+ { "private", KEYWORD_PRIVATE, { 0, 1, 1, 1, 0, 0 } },
+ { "program", KEYWORD_PROGRAM, { 0, 0, 0, 0, 1, 0 } },
+ { "protected", KEYWORD_PROTECTED, { 0, 1, 1, 1, 1, 0 } },
+ { "public", KEYWORD_PUBLIC, { 0, 1, 1, 1, 1, 0 } },
+ { "repeat", KEYWORD_REPEAT, { 0, 0, 0, 0, 0, 1 } },
+ { "register", KEYWORD_REGISTER, { 1, 1, 0, 0, 0, 0 } },
+ { "return", KEYWORD_RETURN, { 1, 1, 1, 1, 0, 1 } },
+ { "shadow", KEYWORD_SHADOW, { 0, 0, 0, 0, 1, 0 } },
+ { "short", KEYWORD_SHORT, { 1, 1, 1, 1, 0, 0 } },
+ { "signed", KEYWORD_SIGNED, { 1, 1, 0, 0, 0, 0 } },
+ { "state", KEYWORD_STATE, { 0, 0, 0, 0, 1, 0 } },
+ { "static", KEYWORD_STATIC, { 1, 1, 1, 1, 1, 0 } },
+ { "string", KEYWORD_STRING, { 0, 0, 1, 0, 1, 1 } },
+ { "struct", KEYWORD_STRUCT, { 1, 1, 1, 0, 0, 0 } },
+ { "switch", KEYWORD_SWITCH, { 1, 1, 1, 1, 0, 0 } },
+ { "synchronized", KEYWORD_SYNCHRONIZED, { 0, 0, 0, 1, 0, 0 } },
+ { "symbol", KEYWORD_SYMBOL, { 0, 0, 0, 0, 0, 1 } },
+ { "task", KEYWORD_TASK, { 0, 0, 0, 0, 1, 0 } },
+ { "template", KEYWORD_TEMPLATE, { 0, 1, 0, 0, 0, 0 } },
+ { "term", KEYWORD_TERM, { 0, 0, 0, 0, 0, 1 } },
+ { "this", KEYWORD_THIS, { 0, 1, 1, 1, 0, 0 } },
+ { "throw", KEYWORD_THROW, { 0, 1, 1, 1, 0, 0 } },
+ { "throws", KEYWORD_THROWS, { 0, 0, 0, 1, 0, 0 } },
+ { "trans", KEYWORD_TRANS, { 0, 0, 0, 0, 1, 0 } },
+ { "transition", KEYWORD_TRANSITION, { 0, 0, 0, 0, 1, 0 } },
+ { "transient", KEYWORD_TRANSIENT, { 0, 0, 0, 1, 0, 0 } },
+ { "try", KEYWORD_TRY, { 0, 1, 1, 0, 0, 0 } },
+ { "typedef", KEYWORD_TYPEDEF, { 1, 1, 1, 0, 1, 0 } },
+ { "typename", KEYWORD_TYPENAME, { 0, 1, 0, 0, 0, 0 } },
+ { "uint", KEYWORD_UINT, { 0, 0, 1, 0, 0, 0 } },
+ { "ulong", KEYWORD_ULONG, { 0, 0, 1, 0, 0, 0 } },
+ { "union", KEYWORD_UNION, { 1, 1, 0, 0, 0, 0 } },
+ { "unsigned", KEYWORD_UNSIGNED, { 1, 1, 1, 0, 0, 0 } },
+ { "until", KEYWORD_UNTIL, { 0, 0, 0, 0, 0, 1 } },
+ { "ushort", KEYWORD_USHORT, { 0, 0, 1, 0, 0, 0 } },
+ { "using", KEYWORD_USING, { 0, 1, 1, 0, 0, 0 } },
+ { "virtual", KEYWORD_VIRTUAL, { 0, 1, 1, 0, 1, 0 } },
+ { "void", KEYWORD_VOID, { 1, 1, 1, 1, 1, 1 } },
+ { "volatile", KEYWORD_VOLATILE, { 1, 1, 1, 1, 0, 0 } },
+ { "wchar_t", KEYWORD_WCHAR_T, { 1, 1, 1, 0, 0, 0 } },
+ { "while", KEYWORD_WHILE, { 1, 1, 1, 1, 0, 1 } }
};
/*
@@ -881,6 +915,21 @@ static veraKind veraTagKind (const tagTy
return result;
}
+static ycpKind ycpTagKind (const tagType type)
+{
+ ycpKind result = YK_UNDEFINED;
+ switch (type)
+ {
+ case TAG_FUNCTION: result = YK_FUNCTION; break;
+ case TAG_PROTOTYPE: result = YK_PROTOTYPE; break;
+ case TAG_LOCAL: result = YK_LOCAL; break;
+ case TAG_VARIABLE: result = YK_VARIABLE; break;
+
+ default: Assert ("Bad YCP tag type" == NULL); break;
+ }
+ return result;
+}
+
static const char *tagName (const tagType type)
{
const char* result;
@@ -890,6 +939,8 @@ static const char *tagName (const tagTyp
result = JavaKinds [javaTagKind (type)].name;
else if (isLanguage (Lang_vera))
result = VeraKinds [veraTagKind (type)].name;
+ else if (isLanguage (Lang_ycp))
+ result = YCPKinds [ycpTagKind (type)].name;
else
result = CKinds [cTagKind (type)].name;
return result;
@@ -904,6 +955,8 @@ static int tagLetter (const tagType type
result = JavaKinds [javaTagKind (type)].letter;
else if (isLanguage (Lang_vera))
result = VeraKinds [veraTagKind (type)].letter;
+ else if (isLanguage (Lang_ycp))
+ result = YCPKinds [ycpTagKind (type)].letter;
else
result = CKinds [cTagKind (type)].letter;
return result;
@@ -959,7 +1012,8 @@ static const char* accessField (const st
static void addContextSeparator (vString *const scope)
{
- if (isLanguage (Lang_c) || isLanguage (Lang_cpp))
+ if (isLanguage (Lang_c) || isLanguage (Lang_cpp) ||
+ isLanguage (Lang_ycp))
vStringCatS (scope, "::");
else if (isLanguage (Lang_java) || isLanguage (Lang_csharp))
vStringCatS (scope, ".");
@@ -1717,9 +1771,11 @@ static void processToken (tokenInfo *con
case KEYWORD_NONE: processName (st); break;
case KEYWORD_ABSTRACT: st->implementation = IMP_ABSTRACT; break;
+ case KEYWORD_ANY: st->declaration = DECL_BASE; break;
case KEYWORD_ATTRIBUTE: skipParens (); initToken (token); break;
case KEYWORD_BIND: st->declaration = DECL_BASE; break;
case KEYWORD_BIT: st->declaration = DECL_BASE; break;
+ case KEYWORD_BYTEBLOCK: st->declaration = DECL_BASE; break;
case KEYWORD_CATCH: skipParens (); skipBraces (); break;
case KEYWORD_CHAR: st->declaration = DECL_BASE; break;
case KEYWORD_CLASS: st->declaration = DECL_CLASS; break;
@@ -1738,9 +1794,13 @@ static void processToken (tokenInfo *con
case KEYWORD_INT: st->declaration = DECL_BASE; break;
case KEYWORD_INTEGER: st->declaration = DECL_BASE; break;
case KEYWORD_INTERFACE: processInterface (st); break;
+ case KEYWORD_LIST: st->declaration = DECL_BASE; break;
case KEYWORD_LOCAL: setAccess (st, ACCESS_LOCAL); break;
+ case KEYWORD_LOCALE: st->declaration = DECL_BASE; break;
case KEYWORD_LONG: st->declaration = DECL_BASE; break;
+ case KEYWORD_MAP: st->declaration = DECL_BASE; break;
case KEYWORD_OPERATOR: readOperator (st); break;
+ case KEYWORD_PATH: st->declaration = DECL_BASE; break;
case KEYWORD_PRIVATE: setAccess (st, ACCESS_PRIVATE); break;
case KEYWORD_PROGRAM: st->declaration = DECL_PROGRAM; break;
case KEYWORD_PROTECTED: setAccess (st, ACCESS_PROTECTED); break;
@@ -1750,7 +1810,9 @@ static void processToken (tokenInfo *con
case KEYWORD_SIGNED: st->declaration = DECL_BASE; break;
case KEYWORD_STRING: st->declaration = DECL_BASE; break;
case KEYWORD_STRUCT: st->declaration = DECL_STRUCT; break;
+ case KEYWORD_SYMBOL: st->declaration = DECL_BASE; break;
case KEYWORD_TASK: st->declaration = DECL_TASK; break;
+ case KEYWORD_TERM: st->declaration = DECL_BASE; break;
case KEYWORD_THROWS: discardTypeList (token); break;
case KEYWORD_UNION: st->declaration = DECL_UNION; break;
case KEYWORD_UNSIGNED: st->declaration = DECL_BASE; break;
@@ -1793,7 +1855,9 @@ static void processToken (tokenInfo *con
case KEYWORD_FOR:
case KEYWORD_IF:
+ case KEYWORD_REPEAT:
case KEYWORD_SWITCH:
+ case KEYWORD_UNTIL:
case KEYWORD_WHILE:
{
int c = skipToNonWhite ();
@@ -2302,7 +2366,8 @@ static void addContext (statementInfo *c
{
if (vStringLength (st->context->name) > 0)
{
- if (isLanguage (Lang_c) || isLanguage (Lang_cpp))
+ if (isLanguage (Lang_c) || isLanguage (Lang_cpp) ||
+ isLanguage (Lang_ycp))
vStringCatS (st->context->name, "::");
else if (isLanguage (Lang_java) || isLanguage (Lang_csharp))
vStringCatS (st->context->name, ".");
@@ -2637,7 +2702,12 @@ static void nest (statementInfo *const s
st->inFunction = TRUE;
/* fall through */
default:
- if (includeTag (TAG_LOCAL, FALSE))
+ if (isLanguage (Lang_ycp) && ! st->haveQualifyingName)
+ {
+ st->declaration = DECL_BLOCK;
+ createTags (nestLevel, st);
+ }
+ else if (includeTag (TAG_LOCAL, FALSE))
createTags (nestLevel, st);
else
skipToMatch ("{}");
@@ -2678,6 +2748,7 @@ static void tagCheck (statementInfo *con
}
}
else if (isContextualStatement (st) ||
+ st->declaration == DECL_BLOCK ||
st->declaration == DECL_NAMESPACE ||
st->declaration == DECL_PROGRAM)
{
@@ -2844,6 +2915,12 @@ static void initializeVeraParser (const
buildKeywordHash (language, 4);
}
+static void initializeYcpParser (const langType language)
+{
+ Lang_ycp = language;
+ buildKeywordHash (language, 5);
+}
+
extern parserDefinition* CParser (void)
{
static const char *const extensions [] = { "c", NULL };
@@ -2910,4 +2987,16 @@ extern parserDefinition* VeraParser (voi
return def;
}
+extern parserDefinition* YcpParser (void)
+{
+ static const char *const extensions [] = { "ycp", NULL };
+ parserDefinition* def = parserNew ("YCP");
+ def->kinds = YCPKinds;
+ def->kindCount = KIND_COUNT (YCPKinds);
+ def->extensions = extensions;
+ def->parser2 = findCTags;
+ def->initialize = initializeYcpParser;
+ return def;
+}
+
/* vi:set tabstop=4 shiftwidth=4 noexpandtab: */
--- parsers.h
+++ parsers.h
@@ -49,7 +49,8 @@
VeraParser, \
VerilogParser, \
VimParser, \
- YaccParser
+ YaccParser, \
+ YcpParser
#endif /* _PARSERS_H */

438
ctags.changes Normal file
View File

@ -0,0 +1,438 @@
-------------------------------------------------------------------
Thu Feb 2 10:40:02 UTC 2023 - Dirk Müller <dmueller@suse.com>
- mark u-a generics as non-%ghost
-------------------------------------------------------------------
Wed Jan 18 13:06:30 UTC 2023 - Adam Majer <adam.majer@suse.de>
- CVE-2022-4515.patch: fixes arbitrary command execution via
a tag file with a crafted filename (bsc#1206543, CVE-2022-4515)
- Stop resetting ctags update-alternative priority back to auto.
These are admin settings.
- Remove u-a links in the correct scriptlet
-------------------------------------------------------------------
Mon Sep 27 08:59:35 UTC 2021 - Michal Suchanek <msuchanek@suse.com>
- Fix build with gcc 11
+ ctags-gcc11.patch
-------------------------------------------------------------------
Tue May 4 11:15:01 UTC 2021 - Stefan Brüns <stefan.bruens@rwth-aachen.de>
- Revert ghosting changes, fix real cause for build failure
instead (symlinks pointing to itself).
- Clean spec file: remove historic cruft, use %license for COPYING,
use %make_build/%make_install macros
-------------------------------------------------------------------
Thu Jan 28 09:54:49 UTC 2021 - Adam Majer <adam.majer@suse.de>
- Ship symlinks that are not to be ghosted in the first place
-------------------------------------------------------------------
Mon Jan 11 12:09:50 UTC 2021 - Michal Suchanek <msuchanek@suse.com>
- Fix build on Tumbleweed - do not ship ghost symlinks.
-------------------------------------------------------------------
Sun Feb 26 04:37:26 UTC 2017 - msuchanek@suse.com
- merge with arduino-ctags https://github.com/arduino/ctags
* provide arduino-ctags
* redo patch queue http://repo.or.cz/git-browser/by-commit.html?r=arduino-ctags/SUSE.git
+ new patches
0001-Mixing-with-anjuta-tags-https-git.gnome.org-browse-a.patch
- add vala support
- update many existing tags with new features
0002-Making-inline-behave-like-an-attribute.-Fixes-1.patch
0003-Treat-typename-as-an-attribute.patch
0004-parseReturnType-should-start-from-the-first-non-brac.patch
0005-Ensuring-a-space-is-printed-in-return-type-AFTER-the.patch
0006-Prevent-C-static_assert-from-stopping-parsing.patch
0007-c-Handle-C-11-noexcept.patch
0008-c-Properly-parse-C-11-override-and-final-members.patch
0009-Parse-C-11-enums-with-type-specifier.patch
0010-Parse-C-11-classed-enums.patch
0011-Handle-template-expressions-that-may-use-the-or-oper.patch
0012-Make-sure-we-don-t-throw-things-away-while-collectin.patch
0013-C-mitigate-matching-error-on-generics-containing-an-.patch
0014-fix-wrongly-interpreted-in-template.patch
0015-Added-constexpr-as-keyword.patch
+ refreshed existing patches
0016-CVE-2014-7204.patch
0017-Go-language-support.patch (go-tags.patch)
0018-SUSE-man-page-changes.patch (ctags-5.7.diff)
0019-Do-not-include-build-time-in-binary.patch (ctags-date-time.patch)
-------------------------------------------------------------------
Thu Aug 18 08:25:26 UTC 2016 - adam.majer@suse.de
- Own our update-alternatives symlink (bnc#994261)
- Use conflict-free symlinks instead of touch files for
placeholders.
-------------------------------------------------------------------
Tue May 24 15:26:39 UTC 2016 - mpluskal@suse.com
- Cleanup spec file with spec-cleaner
-------------------------------------------------------------------
Tue May 24 10:10:43 UTC 2016 - adam.majer@suse.com
- Add missing Requires(post) on coreutils as it is using `rm`.
(boo #976920)
-------------------------------------------------------------------
Tue Oct 7 05:45:51 UTC 2014 - puzel@suse.com
- Fix endless loop in javascript parser
(bnc#899486, CVE-2014-7204)
- Added CVE-2014-7204.patch
-------------------------------------------------------------------
Sat Apr 27 10:12:43 UTC 2013 - schwab@linux-m68k.org
- Remove etags and gnuctags, provided by etags package now
- Install ctags as ctags-exuberant and provide ctags via
update-alternatives
-------------------------------------------------------------------
Fri Mar 22 08:46:26 UTC 2013 - mmeister@suse.com
- Added url as source.
Please see http://en.opensuse.org/SourceUrls
-------------------------------------------------------------------
Thu Aug 16 12:04:00 UTC 2012 - graham@andtech.eu
- go-tags.patch: Add patch supporting Go language
-------------------------------------------------------------------
Sun Sep 18 00:06:54 UTC 2011 - jengelh@medozas.de
- Remove redundant tags/sections from specfile
-------------------------------------------------------------------
Tue Aug 2 15:33:11 UTC 2011 - puzel@novell.com
- add etags-strcpy-overlap.patch (bnc#705308)
-------------------------------------------------------------------
Fri Jul 29 16:49:36 UTC 2011 - puzel@novell.com
- update to ctags-5.8
- Removed ".ml" as a Lisp extension (now OCaml) [Lisp].
- Added support for Ant language, contributed by David Fishburn.
- Added support for DOS Batch language, contributed by David
Fishburn.
- Added support for Flex (Adobe) language, contributed by David
Fishburn.
- Added support for MATLAB language, contributed by David Fishburn.
- Added support for Objective Camel (OCaml), provided by Vincent
Berthoux
- Added support for TeX language, contributed by David Fishburn.
- Added support for VHDL language, contributed by Nicolas Vincent
- Added support for Pyrex/Cython declarations [Python].
- Added support for "v" kind, for variables [Python].
- Added support for class and member variables
- Added support for recent enhancements to Eiffel language
[Eiffel].
- Added support for ASP classes, contributed by Zendhi Nagao;
changes meaning of 'c' kind flag [ASP].
- Added regex support when compiling with MinGW. Gnu regex module
now included in all distributions.
- Fixed detection of triple strings inside other strings
- Fixed an endless loop with comments in triple strings
- Fixed bug where functions were sometimes seen as methods
- Fixed parsing of method parameter annotations, fix contributed by
Paolo "blaisorblade" Giarrusso
- Fixed parsing of global scope qualifiers in base class lists
- Fixed bug where namespace members were given kinds corresponding
to globals
- Fixed parsing of "else"
- Fixed parsing of derived enums
- Fixed parsing of "foreach"
- Fixed parsing of simple generic classes
- Fixed bug with detecting identifiers inside variables
- Fixed bug with detecting identifiers at the start of variables
- Fixed parsing of triple single-quoted multi-line strings
- disabled YCP parser for now (does not apply)
- add ctags-date-time.patch
- use spec-cleaner
-------------------------------------------------------------------
Fri Dec 18 16:44:25 CET 2009 - jengelh@medozas.de
- enable parallel building
-------------------------------------------------------------------
Wed Aug 26 12:53:54 CEST 2009 - mls@suse.de
- make patch0 usage consistent
-------------------------------------------------------------------
Fri Sep 5 13:56:30 CEST 2008 - schwab@suse.de
- Update to etags 17.38.1.4.
-------------------------------------------------------------------
Wed Jan 9 13:59:22 CET 2008 - schwab@suse.de
- Update to etags 17.38.
-------------------------------------------------------------------
Tue Nov 13 14:22:21 CET 2007 - schwab@suse.de
- Update etags from Emacs trunk.
-------------------------------------------------------------------
Mon Nov 12 21:43:02 CET 2007 - bwalle@suse.de
- update to ctags 5.7
* Added support for DIM AS [Freebasic]
* Added support for arbitrary nesting depth [Python]
* Added support for verbatim string literals [C#]
* Added support for .ctags as well as ctags.cnf on Windows
* Added support for non-extern, non-static functions returning
wchar_t, contributed by Aaron Peromsik [C++]
* Added support for numerous revision control systems including
Bazaar and Mercurial
* Added support for enums [Java]
* Added support for multiple-level namespace declarations [C#]
* Added .svn to list of directories ignored during recursion
(--recurse).
* Added support for BlitzBasic, PureBasic and FreeBasic
* Added support for interfaces and static/public/protected/
private functions [PHP].
* Added support for 'package' keyword [Perl].
* Added support for multi-line subroutine, package, and constant
definitions [Perl].
* Added support for optional subroutine declarations [Perl].
* Added support for formats [Perl].
* Added support for new convert keyword [Eiffel].
* Added optional tags for forward variable declarations [C, C++].
* Changed parsing of option input file (-L) to strip trailing
white space.
* Ignore comments mixed into definitions and declarations [Perl].
* Fixed detecting labels with whitespace after label name [Perl]
* Fixed parsing of generic classes/interfaces [Java]
* Fixed misidentification of fully qualified function calls as
labels [Perl].
* Fixed parsing of inner classes [Python]
* Fixed line continuation [Python]
* Fixed parsing of annotations [Java]
* Fixed block-comment parsing [Verilog]
* Fixed typo in man page
* Fixed missing chunk of text in man page and over-use of hyphens
in UTF-8 locales
* Fixed parsing of ` as a method name [Ruby].
* Fixed parsing of keywords in string literals [Ruby]
* Fixed potential segmentation violation
* Fixed parsing of destructors with whitespace after the '~' [C++]
* Fixed default access of unions to be public [C++]
* Fixed various memory leaks, mostly contributed by Dmitry Antipov.
* Fixed parsing of `define [Verilog]
* Fixed crashes involving '/' [Verilog]
* Fixed compilation problem on MinGW
* Fixed generation of HTML-formatted man page
* Fixed recognition of Python scripts having '#!/usr/bin/python'
as first line
* Fixed parsing of Fortran comment-to-end-of-line with no newline
before EOF [Debian]
* Fixed parsing of << [C/C++]
* Fixed parsing of fully-qualified type names [Java]
* Fixed handling of lone carriage-return characters in file
-------------------------------------------------------------------
Tue Feb 6 13:27:01 CET 2007 - schwab@suse.de
- Update etags from CVS.
-------------------------------------------------------------------
Tue Jan 9 13:48:55 CET 2007 - schwab@suse.de
- More etags fixes from CVS.
-------------------------------------------------------------------
Sat Dec 30 10:36:34 CET 2006 - schwab@suse.de
- Fix handling of relative names in #line.
-------------------------------------------------------------------
Wed Dec 20 12:49:51 CET 2006 - schwab@suse.de
- Update etags from CVS.
-------------------------------------------------------------------
Tue May 30 15:10:42 CEST 2006 - schwab@suse.de
- Update to ctags 5.6
* Reformatted code for independence of tab stop setting.
* Changed default configuration to disable installation of etags links.
* Changed --langmap to first unmap each supplied extension from other
languages.
* Added support for ASP constants [ASP, Patch #961842].
* Added support for GNU make extensions [Make].
* Added .mk as extension recognized as a make language file [Make].
* Added missing help for list-maps options [Bug #1201826].
* Added new extension field "typeref" [thanks to Bram Moolenaar].
* Extended functionality of Ruby parser with patch from Elliot Hughes
[Ruby].
* Fixed creation of TAGS file with etags-include but no files [Bug
#941233].
* Fixed problem reading last line of list file (-L) without final
newline.
* Fixed infinite loop that could occur on files without final newline
[C, Java].
* Fixed incorrect tag for first field of table [SQL].
* Fixed missing tags for functions beginning with underscore [Sh].
* Fixed missing tags for functions with variable arg list [C, Bug
#1201689].
* Fixed parsing problem with parentheses in argument list [C, Bug
#1085585].
* Fixed problem in preprocessor directive handling [C, Bug #1086609].
- Update etags to 17.17.
-------------------------------------------------------------------
Tue Mar 7 23:18:46 CET 2006 - od@suse.de
- wrote and added a YCP parser based on the C code parser
(ctags-5.5.4-ycp-parser.diff)
-------------------------------------------------------------------
Wed Jan 25 21:35:15 CET 2006 - mls@suse.de
- converted neededforbuild to BuildRequires
-------------------------------------------------------------------
Wed Dec 7 20:46:09 CET 2005 - od@suse.de
- Added option -A/--allow-duplicates to gnuctags
-------------------------------------------------------------------
Wed Dec 7 02:28:07 CET 2005 - od@suse.de
- Don't strip etags/gnuctags
-------------------------------------------------------------------
Tue Oct 18 12:44:46 CEST 2005 - schwab@suse.de
- Update to etags 17.14.
-------------------------------------------------------------------
Mon Nov 15 17:06:34 CET 2004 - schwab@suse.de
- Update to etags 17.5.
-------------------------------------------------------------------
Tue May 4 22:17:18 CEST 2004 - schwab@suse.de
- Update to ctags 5.5.4.
-------------------------------------------------------------------
Sat Jan 10 20:57:54 CET 2004 - adrian@suse.de
- add %defattr
-------------------------------------------------------------------
Fri Sep 26 09:32:30 CEST 2003 - schwab@suse.de
- Update to ctags 5.5.2.
-------------------------------------------------------------------
Tue Aug 5 20:47:31 CEST 2003 - schwab@suse.de
- Update to ctags 5.5.1.
-------------------------------------------------------------------
Wed Apr 2 13:29:55 CEST 2003 - schwab@suse.de
- Update to ctags 5.5.
- Update to etags 16.56.
-------------------------------------------------------------------
Tue Sep 17 17:34:28 CEST 2002 - ro@suse.de
- removed bogus self-provides
-------------------------------------------------------------------
Tue Sep 17 17:11:00 CEST 2002 - schwab@suse.de
- Update to ctags 5.3.1.
-------------------------------------------------------------------
Thu Jul 18 10:53:15 CEST 2002 - schwab@suse.de
- Update to ctags 5.3.
-------------------------------------------------------------------
Fri Dec 14 15:59:05 CET 2001 - schwab@suse.de
- Update ctags to 5.1.
- Update etags to 14.21.
-------------------------------------------------------------------
Thu May 18 13:26:59 CEST 2000 - schwab@suse.de
- Use BuildRoot.
- Remove etags.c changes again.
-------------------------------------------------------------------
Wed May 17 19:33:55 CEST 2000 - kasal@suse.cz
- strip etags/gnuctags
- Fixed etags.c changes
-------------------------------------------------------------------
Mon May 15 16:49:20 CEST 2000 - schwab@suse.de
- Discard etags.c changes (#2772).
-------------------------------------------------------------------
Mon Jan 31 18:15:00 CET 2000 - werner@suse.de
- Really rename gctags to gnuctags
-------------------------------------------------------------------
Mon Jan 31 12:41:54 CET 2000 - kasal@suse.cz
- fixed spec file to really use the *dif files
- gctags renamed to gnuctags
- rewrote the NOTEs in the manpages and added
"see also (gnu)ctags(1), gctags(1) and global(1)"
- etags.c now uses #ifdef's
-------------------------------------------------------------------
Wed Jan 26 19:15:48 CET 2000 - werner@suse.de
- New ctags version 3.3.1
* Disable etags (is usable with `ctags -e')
- Add etags/ctags from Emacs sources
* rename this ctags with gctags
- Make some NOTEs within the manual pages of both packages
- Add a README.SuSE to explain why we have two versions
-------------------------------------------------------------------
Mon Sep 13 17:23:57 CEST 1999 - bs@suse.de
- ran old prepare_spec on spec file to switch to new prepare_spec.
-------------------------------------------------------------------
Wed Sep 8 11:59:42 CEST 1999 - schwab@suse.de
- specfile cleanup
-------------------------------------------------------------------
Tue Jun 15 16:55:26 MEST 1999 - uli@suse.de
- update -> 3.2.2
----------------------------------------------------------------------------
Sun Apr 13 23:04:29 MEST 1997 - florian@suse.de
- new package with ctags 1.5 (used to be together with vim.tgz)

104
ctags.spec Normal file
View File

@ -0,0 +1,104 @@
#
# spec file for package ctags
#
# Copyright (c) 2023 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
# upon. The license for this file, and modifications and additions to the
# file, is the same license as for the pristine package itself (unless the
# license for the pristine package is not an Open Source License, in which
# case the license is the MIT License). An "Open Source License" is a
# license that conforms to the Open Source Definition (Version 1.9)
# published by the Open Source Initiative.
# Please submit bugfixes or comments via https://bugs.opensuse.org/
#
Name: ctags
Version: 5.8
Release: 0
Summary: A Program to Generate Tag Files for Use with vi and Other Editors
License: GPL-2.0-or-later
Group: Development/Tools/Navigators
URL: http://ctags.sourceforge.net/
Source0: http://downloads.sourceforge.net/project/%{name}/%{name}/%{version}/%{name}-%{version}.tar.gz
# No resources to make this patch work with ctags-5.8 (applied to ctags-5.7)
# Anyone is welcome to make it work again.
Source2: ctags-ycp-parser.diff
Patch1: 0001-Mixing-with-anjuta-tags-https-git.gnome.org-browse-a.patch
Patch2: 0002-Making-inline-behave-like-an-attribute.-Fixes-1.patch
Patch3: 0003-Treat-typename-as-an-attribute.patch
Patch4: 0004-parseReturnType-should-start-from-the-first-non-brac.patch
Patch5: 0005-Ensuring-a-space-is-printed-in-return-type-AFTER-the.patch
Patch6: 0006-Prevent-C-static_assert-from-stopping-parsing.patch
Patch7: 0007-c-Handle-C-11-noexcept.patch
Patch8: 0008-c-Properly-parse-C-11-override-and-final-members.patch
Patch9: 0009-Parse-C-11-enums-with-type-specifier.patch
Patch10: 0010-Parse-C-11-classed-enums.patch
Patch11: 0011-Handle-template-expressions-that-may-use-the-or-oper.patch
Patch12: 0012-Make-sure-we-don-t-throw-things-away-while-collectin.patch
Patch13: 0013-C-mitigate-matching-error-on-generics-containing-an-.patch
Patch14: 0014-fix-wrongly-interpreted-in-template.patch
Patch15: 0015-Added-constexpr-as-keyword.patch
Patch16: 0016-CVE-2014-7204.patch
Patch17: 0017-Go-language-support.patch
Patch18: 0018-SUSE-man-page-changes.patch
Patch19: 0019-Do-not-include-build-time-in-binary.patch
Patch20: ctags-gcc11.patch
Patch21: CVE-2022-4515.patch
BuildRequires: update-alternatives
Requires(pre): update-alternatives
Requires(post): update-alternatives
Requires(post): coreutils
Provides: arduino-ctags
%description
CTags (from Darren Hiebert) generates tag files from source code in C,
C++, Eiffel, Fortran, and Java to be used with vi and its derivatives,
Emacs, and several other editors.
%prep
%setup -q
%autopatch -p1
%build
%configure
%make_build
%install
# Makefile ignores DESTDIR ...
%make_install \
prefix=%{buildroot}%{_prefix} \
bindir=%{buildroot}%{_bindir} \
mandir=%{buildroot}%{_mandir}
mv %{buildroot}%{_bindir}/ctags{,-exuberant}
mv %{buildroot}%{_mandir}/man1/ctags{,-exuberant}.1
mkdir -p %{buildroot}%{_sysconfdir}/alternatives/
ln -s %{_sysconfdir}/alternatives/ctags %{buildroot}%{_bindir}/ctags
ln -s %{_sysconfdir}/alternatives/ctags.1%{ext_man} %{buildroot}%{_mandir}/man1/ctags.1%{ext_man}
%post
test -L %{_bindir}/ctags || rm -f %{_bindir}/ctags
update-alternatives --install %{_bindir}/ctags ctags %{_bindir}/ctags-exuberant 20 \
--slave %{_mandir}/man1/ctags.1.gz ctags.1 %{_mandir}/man1/ctags-exuberant.1.gz
%postun
if [ ! -f %{_bindir}/ctags-exuberant ]; then
update-alternatives --remove ctags %{_bindir}/ctags-exuberant
fi
%files
%license COPYING
%doc EXTENDING.html FAQ README
%{_bindir}/ctags
%{_bindir}/ctags-exuberant
%{_mandir}/man1/ctags-exuberant.1%{ext_man}
%{_mandir}/man1/ctags.1%{ext_man}
%ghost %{_sysconfdir}/alternatives/ctags
%ghost %{_sysconfdir}/alternatives/ctags.1%{ext_man}
%changelog