From 9fb1721d84fb8ff9e268aef62460b173c77b7780 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 03:15:05 +0900 Subject: [PATCH 01/44] main,comment: fix wrong comments Signed-off-by: Masatake YAMATO --- main/tokeninfo.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/main/tokeninfo.c b/main/tokeninfo.c index 0a0e01d5de..30e09f8470 100644 --- a/main/tokeninfo.c +++ b/main/tokeninfo.c @@ -5,8 +5,6 @@ * This source code is released for free distribution under the terms of the * GNU General Public License version 2 or (at your option) any later version. * -* This module contains functions for generating tags for Python language -* files. */ #include "general.h" From e1c74605fc5e267b101e785aca454046736d66d5 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 03:15:39 +0900 Subject: [PATCH 02/44] tokeninfo: add functions to make a tag from a tokeninfo Signed-off-by: Masatake YAMATO --- main/tokeninfo.c | 16 ++++++++++++++++ main/tokeninfo.h | 3 +++ 2 files changed, 19 insertions(+) diff --git a/main/tokeninfo.c b/main/tokeninfo.c index 30e09f8470..b561495ea4 100644 --- a/main/tokeninfo.c +++ b/main/tokeninfo.c @@ -207,3 +207,19 @@ bool tokenSkipOverPairFull (tokenInfo *token, void *data) return (depth == 0)? true: false; } + +void initTagEntryFromToken (tagEntryInfo *e, tokenInfo *const token, int kindIndex, + int scopeIndex) +{ + initTagEntry (e, tokenString (token), kindIndex); + e->lineNumber = token->lineNumber; + e->filePosition = token->filePosition; + e->extensionFields.scopeIndex = scopeIndex; +} + +int makeSimpleTagFromToken (tokenInfo *const token, int kindIndex, int scopeIndex) +{ + tagEntryInfo e; + initTagEntryFromToken (&e, token, kindIndex, scopeIndex); + return makeTagEntry (&e); +} diff --git a/main/tokeninfo.h b/main/tokeninfo.h index 51360106b7..bba7a01ce4 100644 --- a/main/tokeninfo.h +++ b/main/tokeninfo.h @@ -102,4 +102,7 @@ bool tokenSkipToTypeFull (tokenInfo *token, tokenType t, void *data); bool tokenSkipOverPair (tokenInfo *token); bool tokenSkipOverPairFull (tokenInfo *token, void *data); +/* Making a tag from a token */ +void initTagEntryFromToken (tagEntryInfo *e, tokenInfo *const token, int kindIndex, int scopeIndex); +int makeSimpleTagFromToken (tokenInfo *const token, int kindIndex, int scopeIndex); #endif From 4a4dbab4ab7e81182b7a97c4e39ce270881e3af2 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 19 Dec 2020 18:06:30 +0900 Subject: [PATCH 03/44] tokeninfo: add functions to skip multiple types Signed-off-by: Masatake YAMATO --- main/tokeninfo.c | 22 ++++++++++++++++++++++ main/tokeninfo.h | 3 +++ 2 files changed, 25 insertions(+) diff --git a/main/tokeninfo.c b/main/tokeninfo.c index b561495ea4..ed5b359002 100644 --- a/main/tokeninfo.c +++ b/main/tokeninfo.c @@ -208,6 +208,28 @@ bool tokenSkipOverPairFull (tokenInfo *token, void *data) return (depth == 0)? true: false; } +bool tokenSkipToTypes (tokenInfo *token, const tokenType ts[], size_t count) +{ + return tokenSkipToTypesFull (token, ts, count, NULL); +} + +static bool tokenTypeIsMember (tokenType t, const tokenType ts[], size_t count) +{ + for (size_t i = 0; i < count; i++) + if (ts [i] == t) + return true; + return false; +} + +bool tokenSkipToTypesFull (tokenInfo *token, const tokenType ts[], size_t count, void *data) +{ + while (! (tokenIsEOF (token) + || tokenTypeIsMember (token->type, ts, count))) + tokenReadFull (token, data); + + return tokenIsEOF (token)? false: true; +} + void initTagEntryFromToken (tagEntryInfo *e, tokenInfo *const token, int kindIndex, int scopeIndex) { diff --git a/main/tokeninfo.h b/main/tokeninfo.h index bba7a01ce4..04ba9dcf4f 100644 --- a/main/tokeninfo.h +++ b/main/tokeninfo.h @@ -102,6 +102,9 @@ bool tokenSkipToTypeFull (tokenInfo *token, tokenType t, void *data); bool tokenSkipOverPair (tokenInfo *token); bool tokenSkipOverPairFull (tokenInfo *token, void *data); +bool tokenSkipToTypes (tokenInfo *token, const tokenType ts[], size_t count); +bool tokenSkipToTypesFull (tokenInfo *token, const tokenType ts[], size_t count, void *data); + /* Making a tag from a token */ void initTagEntryFromToken (tagEntryInfo *e, tokenInfo *const token, int kindIndex, int scopeIndex); int makeSimpleTagFromToken (tokenInfo *const token, int kindIndex, int scopeIndex); From 9bf678a30146100b3a212d61e19064f116d1e7a4 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 19 Dec 2020 18:07:20 +0900 Subject: [PATCH 04/44] tokeninfo: add functions to skip multiple types over pairs Signed-off-by: Masatake YAMATO --- main/tokeninfo.c | 49 ++++++++++++++++++++++++++++++++++++++++++++---- main/tokeninfo.h | 4 ++++ 2 files changed, 49 insertions(+), 4 deletions(-) diff --git a/main/tokeninfo.c b/main/tokeninfo.c index ed5b359002..6a29a1ea64 100644 --- a/main/tokeninfo.c +++ b/main/tokeninfo.c @@ -183,15 +183,26 @@ bool tokenSkipOverPair (tokenInfo *token) return tokenSkipOverPairFull(token, NULL); } +static struct tokenTypePair *tokenTypeIsStarterOfPairs (tokenType t, + struct tokenTypePair pairs [], + size_t count) +{ + for (size_t i = 0; i < count; i++) + if (t == pairs[i].start) + return pairs + i; + return NULL; +} + bool tokenSkipOverPairFull (tokenInfo *token, void *data) { int start = token->type; int end = token->klass->typeForUndefined; - unsigned int i; - for (i = 0; i < token->klass->pairCount; i++) - if (start == token->klass->pairs[i].start) - end = token->klass->pairs[i].end; + struct tokenTypePair *endp = tokenTypeIsStarterOfPairs (start, + token->klass->pairs, + token->klass->pairCount); + if (endp) + end = endp->end; if (end == token->klass->typeForUndefined) return false; @@ -230,6 +241,36 @@ bool tokenSkipToTypesFull (tokenInfo *token, const tokenType ts[], size_t count, return tokenIsEOF (token)? false: true; } +bool tokenSkipToTypeOverPairs (tokenInfo *token, tokenType t) +{ + return tokenSkipToTypeOverPairsFull (token, t, NULL); +} + +bool tokenSkipToTypeOverPairsFull (tokenInfo *token, tokenType t, void *data) +{ + + return tokenSkipToTypesOverPairsFull (token, &t, 1, data); +} + +bool tokenSkipToTypesOverPairs (tokenInfo *token, const tokenType ts[], size_t count) +{ + return tokenSkipToTypesOverPairsFull (token, ts, count, NULL); +} + +bool tokenSkipToTypesOverPairsFull (tokenInfo *token, const tokenType ts[], size_t count, void *data) +{ + while (! (tokenIsEOF (token))) + { + if (tokenTypeIsMember (token->type, ts, count)) + return true; + tokenSkipOverPairFull (token, data); + if (tokenIsEOF (token)) + return false; + tokenReadFull (token, data); + } + return false; +} + void initTagEntryFromToken (tagEntryInfo *e, tokenInfo *const token, int kindIndex, int scopeIndex) { diff --git a/main/tokeninfo.h b/main/tokeninfo.h index 04ba9dcf4f..0da11e2245 100644 --- a/main/tokeninfo.h +++ b/main/tokeninfo.h @@ -104,6 +104,10 @@ bool tokenSkipOverPairFull (tokenInfo *token, void *data); bool tokenSkipToTypes (tokenInfo *token, const tokenType ts[], size_t count); bool tokenSkipToTypesFull (tokenInfo *token, const tokenType ts[], size_t count, void *data); +bool tokenSkipToTypeOverPairs (tokenInfo *token, tokenType t); +bool tokenSkipToTypeOverPairsFull (tokenInfo *token, tokenType t, void *data); +bool tokenSkipToTypesOverPairs (tokenInfo *token, const tokenType ts[], size_t count); +bool tokenSkipToTypesOverPairsFull (tokenInfo *token, const tokenType ts[], size_t count, void *data); /* Making a tag from a token */ void initTagEntryFromToken (tagEntryInfo *e, tokenInfo *const token, int kindIndex, int scopeIndex); From 39170f80f2cbfe81d52353ab4a499896d1769342 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 19 Dec 2020 18:36:36 +0900 Subject: [PATCH 05/44] tokeninfo: provide the way to activate/deactivate a type pair Signed-off-by: Masatake YAMATO --- main/tokeninfo.c | 8 +++++++- main/tokeninfo.h | 9 +++++++++ parsers/ldscript.c | 2 +- parsers/r.c | 6 +++--- parsers/tcl.c | 4 ++-- 5 files changed, 22 insertions(+), 7 deletions(-) diff --git a/main/tokeninfo.c b/main/tokeninfo.c index 6a29a1ea64..b516ce23b9 100644 --- a/main/tokeninfo.c +++ b/main/tokeninfo.c @@ -10,6 +10,7 @@ #include "general.h" #include "tokeninfo.h" +#include "debug.h" #include "entry.h" #include "read.h" #include "routines.h" @@ -183,12 +184,17 @@ bool tokenSkipOverPair (tokenInfo *token) return tokenSkipOverPairFull(token, NULL); } +static bool isTokenTypePairActive (struct tokenTypePair *pair) +{ + return ((pair->active == NULL) || (*pair->active))? true: false; +} + static struct tokenTypePair *tokenTypeIsStarterOfPairs (tokenType t, struct tokenTypePair pairs [], size_t count) { for (size_t i = 0; i < count; i++) - if (t == pairs[i].start) + if (isTokenTypePairActive (pairs +i) && (t == pairs[i].start)) return pairs + i; return NULL; } diff --git a/main/tokeninfo.h b/main/tokeninfo.h index 0da11e2245..e31536c304 100644 --- a/main/tokeninfo.h +++ b/main/tokeninfo.h @@ -33,6 +33,15 @@ typedef struct sTokenInfo { struct tokenTypePair { tokenType start; tokenType end; + + /* If the field is NULL or the value pointed by the field is true, + * tokenSkipOverPair and its variants regard the pair as an active + * pair; they will skip over the pair. + * + * The value pointed by the field is false, they regard the pair + * as an inactive pair; they will not skip over the pair. + */ + bool *active; }; #define TOKEN(X) ((tokenInfo *)X) diff --git a/parsers/ldscript.c b/parsers/ldscript.c index c7da533feb..2475e70f42 100644 --- a/parsers/ldscript.c +++ b/parsers/ldscript.c @@ -131,7 +131,7 @@ typedef struct sLdScriptToken { #define LDSCRIPT(TOKEN) ((ldScriptToken *)TOKEN) static struct tokenTypePair ldScriptTypePairs [] = { - { '{', '}' }, + { '{', '}', NULL }, }; static struct tokenInfoClass ldScriptTokenInfoClass = { diff --git a/parsers/r.c b/parsers/r.c index eb9c25848b..cfb7a8242b 100644 --- a/parsers/r.c +++ b/parsers/r.c @@ -194,9 +194,9 @@ static const char *tokenTypeStr(enum RTokenType e); #endif static struct tokenTypePair typePairs [] = { - { '{', '}' }, - { '[', ']' }, - { '(', ')' }, + { '{', '}', NULL }, + { '[', ']', NULL }, + { '(', ')', NULL }, }; typedef struct sRToken { diff --git a/parsers/tcl.c b/parsers/tcl.c index 249486806d..2cf6c220e6 100644 --- a/parsers/tcl.c +++ b/parsers/tcl.c @@ -97,8 +97,8 @@ typedef struct sTclToken { #define TCL_PSTATE(TOKEN) (TCL(TOKEN)->pstate) static struct tokenTypePair typePairs [] = { - { '{', '}' }, - { '[', ']' }, + { '{', '}', NULL }, + { '[', ']', NULL }, }; From 8fcebabe8f966e6cc24c1e6bdf4badcc98aece27 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Mon, 18 Nov 2019 02:36:16 +0900 Subject: [PATCH 06/44] Vala: new parser --- main/parsers_p.h | 1 + parsers/vala.c | 506 +++++++++++++++++++++++++++++ source.mak | 1 + win32/ctags_vs2013.vcxproj | 1 + win32/ctags_vs2013.vcxproj.filters | 3 + 5 files changed, 512 insertions(+) create mode 100644 parsers/vala.c diff --git a/main/parsers_p.h b/main/parsers_p.h index 8036a2f9af..7efa0ef320 100644 --- a/main/parsers_p.h +++ b/main/parsers_p.h @@ -184,6 +184,7 @@ VerilogParser, \ SystemVerilogParser, \ VhdlParser, \ + ValaParser, \ VimParser, \ WindResParser, \ YACCParser, \ diff --git a/parsers/vala.c b/parsers/vala.c new file mode 100644 index 0000000000..4797f4529f --- /dev/null +++ b/parsers/vala.c @@ -0,0 +1,506 @@ +/* +* Copyright (c) 2019, +* +* This source code is released for free distribution under the terms of the +* GNU General Public License version 2 or (at your option) any later version. +* +* This module contains functions for parsing and scanning Vaka source files. +*/ + +/* +* INCLUDE FILES +*/ +#include "general.h" /* must always come first */ + +#include "tokeninfo.h" +#include "parse.h" +#include "read.h" +#include "vstring.h" +#include "keyword.h" +#include "entry.h" + +#include + +/* +* MACROS +*/ + +#define tokenEqType(TKN,T) ((TKN)->type == T) + + +/* +* DATA DEFINITIONS +*/ + +typedef enum { + K_UNDEFINED = -1, + K_CLASS, + K_FIELD, + K_METHOD, + K_PROP, +} valaKind; + +static kindDefinition ValaKinds [] = { + { true, 'c', "class", "classes"}, + { true, 'f', "field", "fields"}, + { true, 'm', "method", "methods"}, + { true, 'p', "property", "properties"}, +}; + +enum eKeywordId +{ + KEYWORD_CLASS, + KEYWORD_PUBLIC, + KEYWORD_STRING, + KEYWORD_VOID, +}; + +typedef int keywordId; /* to allow KEYWORD_NONE */ + +static const keywordTable ValaKeywordTable [] = { + { "class", KEYWORD_CLASS }, + { "public", KEYWORD_PUBLIC }, + { "string", KEYWORD_STRING }, + { "void", KEYWORD_VOID }, +}; + +enum ValaTokenType { + /* 0..255 are the byte's value */ + TOKEN_EOF = 256, + TOKEN_UNDEFINED, + TOKEN_KEYWORD, + TOKEN_IDENTIFIER, + TOKEN_EOL, + TOKEN_STRING, +}; + + +/* +* FUNCTION PROTOTYPES +*/ + +static void readToken (tokenInfo *const token, void *data); + + +/* +* DATA DEFINITIONS +*/ + +static struct tokenTypePair typePairs [] = { + { '{', '}', NULL }, + { '[', ']', NULL }, + { '(', ')', NULL }, +}; + +static struct tokenInfoClass valaTokenInfoClass = { + .nPreAlloc = 4, + .typeForUndefined = TOKEN_UNDEFINED, + .keywordNone = KEYWORD_NONE, + .typeForKeyword = TOKEN_KEYWORD, + .typeForEOF = TOKEN_EOF, + .extraSpace = 0, + .pairs = typePairs, + .pairCount = ARRAY_SIZE (typePairs), + .init = NULL, + .read = readToken, + .clear = NULL, + .copy = NULL, +}; + + +/* +* FUNCTION DEFINITIONS +*/ + +static bool tokenIsEmpty (tokenInfo *token) +{ + return vStringIsEmpty (token->string); +} + +static keywordId resolveKeyword (vString *string) +{ + char *s = vStringValue (string); + static langType lang = LANG_AUTO; + + if (lang == LANG_AUTO) + lang = getInputLanguage (); + + return lookupKeyword (s, lang); +} + +static void readString (tokenInfo *token) +{ + int c; + while (1) + { + c = getcFromInputFile (); + switch (c) + { + case EOF: + return; + case '"': + tokenPutc (token, c); + return; + default: + tokenPutc (token, c); + break; + } + } +} + +static void readIdentifier (tokenInfo *token) +{ + + while (1) + { + int c = getcFromInputFile (); + if (c == EOF) + return; + else if ((!tokenIsEmpty (token)) && + (isalnum (c) || c == '_')) + tokenPutc (token, c); + else if (isalpha (c) || c == '_') + tokenPutc (token, c); + else + { + ungetcToInputFile (c); + break; + } + } +} + +static void readToken (tokenInfo *const token, void *data) +{ + int c; + bool semi_terminaotr = false; + + token->type = TOKEN_UNDEFINED; + token->keyword = KEYWORD_NONE; + vStringClear (token->string); + + getNextChar: + /* Skip whitespaces */ + do + { + c = getcFromInputFile (); + } + while (c == ' ' || c== '\t' || c == '\f' || c == '\n'); + + if (c == '/') + { + int c0 = getcFromInputFile (); + + if (c0 == '/') + { + /* line comment */ + while ((c0 = getcFromInputFile ())) + { + if (c0 == EOF) + { + token->type = TOKEN_EOF; + return; + } + else if (c0 == '\n') + goto getNextChar; + } + + } + else if (c0 == '*') + { + /* block comment */ + int c1; + while ((c1 = getcFromInputFile ())) + { + if (c1 == EOF) + { + token->type = TOKEN_EOF; + return; + } + else if (c1 == '*') + { + int c2; + lookingForEndOfBlockComment: + c2 = getcFromInputFile (); + if (c2 == EOF) + { + token->type = TOKEN_EOF; + return; + } + else if (c2 == '/') + goto getNextChar; + else if (c2 == '*') + goto lookingForEndOfBlockComment; + } + } + } + else + ungetcToInputFile (c0); + } + + switch (c) + { + case EOF: + token->type = TOKEN_EOF; + break; + case '"': + token->type = TOKEN_STRING; + tokenPutc (token, c); + readString (token); + break; + case '@': + token->type = TOKEN_IDENTIFIER; + tokenPutc (token, c); + readIdentifier (token); + break; + case ',': + case '}': + case ']': + case ')': + case ';': + semi_terminaotr = true; + case '{': + case '[': + case '(': + token->type = c; + tokenPutc (token, c); + break; + default: + if (isalpha (c) || c == '_') + { + tokenPutc (token, c); + readIdentifier (token); + + token->keyword = resolveKeyword (token->string); + if (token->keyword == KEYWORD_NONE) + token->type = TOKEN_IDENTIFIER; + else + token->type = TOKEN_KEYWORD; + break; + } + else + { + token->type = c; + vStringPut (token->string, c); + break; + } + } + + if (data) + { + vString *collector = data; + if (vStringIsEmpty (collector)) + vStringCat (collector, token->string); + else + { + if (!semi_terminaotr + && !strchr ("{[(", vStringLast(collector))) + vStringPut(collector, ' '); + vStringCat (collector, token->string); + } + } +} + +static tokenInfo *newValaToken (void) +{ + return newToken (&valaTokenInfoClass); +} + +static void parseStatement (tokenInfo *const token) +{ + tokenInfo *lastToken = newValaToken (); + bool foundSignature = false; + + do + { + tokenCopy (lastToken, token); + tokenRead (token); + if (tokenEqType (token, '(')) + { + vString *signature = vStringNewInit ("("); + int corkIndex = makeSimpleTag (lastToken->string, K_METHOD); + foundSignature = tokenSkipOverPairFull (token, signature); + if (foundSignature) + { + tagEntryInfo *e = getEntryInCorkQueue (corkIndex); + e->extensionFields.signature = vStringDeleteUnwrap (signature); + } + else + vStringDelete (signature); + break; + } + } + while (!tokenIsEOF (token)); + + /* Skip the body of method */ + if (foundSignature) + { + if (tokenSkipToType (token, '{')) + tokenSkipOverPair (token); + } + tokenDelete (lastToken); +} + +static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended) +{ + bool nextTokeIsIdentifier = false; + tokenInfo *token = newValaToken (); + if (extended) + *extended = false; + + do + { + tokenRead (token); + if (tokenIsTypeVal (token, '.')) + { + tokenPutc (resultToken, '.'); + if (extended) + *extended = true; + } + else if (tokenIsType (token, IDENTIFIER)) + { + if (tokenLast (resultToken) == '.') + tokenCat (resultToken, token->string); + else + { + tokenUnread (token); + nextTokeIsIdentifier = true; + break; + } + } + else + { + if (!tokenIsEOF (token)) + tokenUnread (token); + nextTokeIsIdentifier = false; + break; + } + } + while (1); + + tokenDelete (token); + return nextTokeIsIdentifier; +} + +static void parseClassBody (tokenInfo *const token, int classCorkIndex) +{ + bool isPublic; + tokenInfo *typerefToken = newValaToken (); + tokenInfo *nameToken = newValaToken (); + + do + { + tokenRead (token); + if (tokenEqType (token, '}')) + break; + + isPublic = tokenIsKeyword(token, PUBLIC)? true: false; + + if (isPublic) + tokenRead (token); + + if (tokenIsType (token, IDENTIFIER) + || tokenIsType (token, KEYWORD)) + tokenCopy (typerefToken, token); + else + break; /* Unexpected sequence to token */ + + bool typerefIsClass; + if (!readIdentifierExtended (typerefToken, &typerefIsClass)) + goto out; + + tokenRead (token); + if (tokenIsType (token, IDENTIFIER)) + tokenCopy (nameToken, token); + + tokenRead (token); + int kind; + if (tokenEqType (token, ';')) + kind = K_FIELD; + else if (tokenEqType (token, '{')) + kind = K_PROP; + else + break; /* Unexpected sequence of token */ + + int memberCorkIndex = makeSimpleTag (nameToken->string, kind); + tagEntryInfo *entry = getEntryInCorkQueue (memberCorkIndex); + + /* Fill access field. */ + entry->extensionFields.access = isPublic? eStrdup ("public"): NULL; + /* Fill typeref field. */ + entry->extensionFields.typeRef [0] = eStrdup ( + typerefIsClass? + /* '.' is included in typeref name. Can I expect it as a class? + */ + "class" + :tokenIsType (typerefToken, KEYWORD)? + /* "typename" is choice in C++ parser. However, "builtin" may be + * better. See #862. This should be fixed in ctags-6.0.0. */ + "typename" + : + /* Till we implement symbol table, we cannot resolve this. + * ctags-7.0.0. */ + "unknown"); + entry->extensionFields.typeRef [1] = vStringStrdup(typerefToken->string); + + /* Fill scope field. */ + entry->extensionFields.scopeIndex = classCorkIndex; + + if (kind == K_PROP) + tokenSkipOverPair (token); + } while (!tokenIsEOF (token)); + + out: + tokenDelete (typerefToken); + tokenDelete (nameToken); +} + +static void parseClass (tokenInfo *const token) +{ + tokenRead (token); + if (!tokenIsType (token, IDENTIFIER)) + return; /* Unexpected sequence of token */ + + int classCorkIndex = makeSimpleTag (token->string, K_CLASS); + + /* Skip the class definition. */ + tokenRead (token); + if (!tokenSkipToType (token, '{')) + return; /* Unexpected sequence of token */ + + parseClassBody (token, classCorkIndex); +} + +static void findValaTags (void) +{ + tokenInfo *const token = newValaToken (); + do + { + tokenRead (token); + if (tokenIsKeyword(token, CLASS)) + parseClass (token); + else if (tokenIsType (token, IDENTIFIER) + || tokenIsType (token, KEYWORD)) + parseStatement (token); + } + while (!tokenIsEOF (token)); + + tokenDelete (token); + flashTokenBacklog (&valaTokenInfoClass); +} + +extern parserDefinition* ValaParser (void) +{ + static const char *const extensions [] = { "vala", NULL }; + + parserDefinition* def = parserNew ("Vala"); + def->kindTable = ValaKinds; + def->kindCount = ARRAY_SIZE (ValaKinds); + def->extensions = extensions; + def->keywordTable = ValaKeywordTable; + def->keywordCount = ARRAY_SIZE (ValaKeywordTable); + def->useCork = true; + def->requestAutomaticFQTag = true; + + def->parser = findValaTags; + return def; +} diff --git a/source.mak b/source.mak index 2266f84e19..fd834c28e3 100644 --- a/source.mak +++ b/source.mak @@ -414,6 +414,7 @@ PARSER_SRCS = \ parsers/ttcn.c \ parsers/txt2tags.c \ parsers/typescript.c \ + parsers/vala.c \ parsers/vera.c \ parsers/verilog.c \ parsers/vhdl.c \ diff --git a/win32/ctags_vs2013.vcxproj b/win32/ctags_vs2013.vcxproj index 8e2fb01d6b..7df42e62c4 100644 --- a/win32/ctags_vs2013.vcxproj +++ b/win32/ctags_vs2013.vcxproj @@ -367,6 +367,7 @@ + diff --git a/win32/ctags_vs2013.vcxproj.filters b/win32/ctags_vs2013.vcxproj.filters index 3a327be697..794fc55df3 100644 --- a/win32/ctags_vs2013.vcxproj.filters +++ b/win32/ctags_vs2013.vcxproj.filters @@ -624,6 +624,9 @@ Source Files\parsers + + Source Files\parsers + Source Files\parsers From 57cc17cd3515c2b2d01cba936fc418b3fb49d94b Mon Sep 17 00:00:00 2001 From: Alberto Fanjul Date: Sat, 7 Dec 2019 07:28:19 +0100 Subject: [PATCH 07/44] Vala: improve the parser --- .../parser-genie.r/simple.genie.b/args.ctags | 2 + .../simple.genie.b/expected.tags | 1 + Units/parser-genie.r/simple.genie.b/input.gs | 2 + Units/parser-vala.r/class.vala.d/args.ctags | 2 + .../parser-vala.r/class.vala.d/expected.tags | 10 + Units/parser-vala.r/class.vala.d/input.vala | 38 +++ .../parser-vala.r/comments.vala.d/args.ctags | 2 + .../comments.vala.d/expected.tags | 6 + .../parser-vala.r/comments.vala.d/input.vala | 11 + .../parser-vala.r/functions.vala.d/args.ctags | 2 + .../functions.vala.d/expected.tags | 2 + .../parser-vala.r/functions.vala.d/input.vala | 10 + .../namespace.vala.d/expected.tags | 17 ++ .../parser-vala.r/namespace.vala.d/input.vala | 55 ++++ Units/parser-vala.r/simple.vala.d/args.ctags | 2 + .../parser-vala.r/simple.vala.d/expected.tags | 1 + Units/parser-vala.r/simple.vala.d/input.vala | 6 + main/parsers_p.h | 2 +- parsers/vala.c | 275 ++++++++++++++++-- 19 files changed, 415 insertions(+), 31 deletions(-) create mode 100644 Units/parser-genie.r/simple.genie.b/args.ctags create mode 100644 Units/parser-genie.r/simple.genie.b/expected.tags create mode 100644 Units/parser-genie.r/simple.genie.b/input.gs create mode 100644 Units/parser-vala.r/class.vala.d/args.ctags create mode 100644 Units/parser-vala.r/class.vala.d/expected.tags create mode 100644 Units/parser-vala.r/class.vala.d/input.vala create mode 100644 Units/parser-vala.r/comments.vala.d/args.ctags create mode 100644 Units/parser-vala.r/comments.vala.d/expected.tags create mode 100644 Units/parser-vala.r/comments.vala.d/input.vala create mode 100644 Units/parser-vala.r/functions.vala.d/args.ctags create mode 100644 Units/parser-vala.r/functions.vala.d/expected.tags create mode 100644 Units/parser-vala.r/functions.vala.d/input.vala create mode 100644 Units/parser-vala.r/namespace.vala.d/expected.tags create mode 100644 Units/parser-vala.r/namespace.vala.d/input.vala create mode 100644 Units/parser-vala.r/simple.vala.d/args.ctags create mode 100644 Units/parser-vala.r/simple.vala.d/expected.tags create mode 100644 Units/parser-vala.r/simple.vala.d/input.vala diff --git a/Units/parser-genie.r/simple.genie.b/args.ctags b/Units/parser-genie.r/simple.genie.b/args.ctags new file mode 100644 index 0000000000..3bba6778c9 --- /dev/null +++ b/Units/parser-genie.r/simple.genie.b/args.ctags @@ -0,0 +1,2 @@ +--sort=no +--fields=+neKl diff --git a/Units/parser-genie.r/simple.genie.b/expected.tags b/Units/parser-genie.r/simple.genie.b/expected.tags new file mode 100644 index 0000000000..ab049f81b4 --- /dev/null +++ b/Units/parser-genie.r/simple.genie.b/expected.tags @@ -0,0 +1 @@ +main input.gs 1;" method line:1 language:Genie diff --git a/Units/parser-genie.r/simple.genie.b/input.gs b/Units/parser-genie.r/simple.genie.b/input.gs new file mode 100644 index 0000000000..a758ec928b --- /dev/null +++ b/Units/parser-genie.r/simple.genie.b/input.gs @@ -0,0 +1,2 @@ +init + print "Hello World" diff --git a/Units/parser-vala.r/class.vala.d/args.ctags b/Units/parser-vala.r/class.vala.d/args.ctags new file mode 100644 index 0000000000..3bba6778c9 --- /dev/null +++ b/Units/parser-vala.r/class.vala.d/args.ctags @@ -0,0 +1,2 @@ +--sort=no +--fields=+neKl diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags new file mode 100644 index 0000000000..3da11114d4 --- /dev/null +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -0,0 +1,10 @@ +main input.vala /^void main(string[] args) {$/;" method line:8 language:Vala +Address input.vala /^class Address {$/;" class line:15 language:Vala +country input.vala /^ string country;$/;" field line:16 language:Vala class:Address typeref:typename:string +city input.vala /^ string city;$/;" field line:17 language:Vala class:Address typeref:typename:string +street input.vala /^ string street;$/;" field line:18 language:Vala class:Address typeref:typename:string +building input.vala /^ int building;$/;" field line:19 language:Vala class:Address typeref:typename:int +floor input.vala /^ int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int +Person input.vala /^class Person {$/;" class line:23 language:Vala +address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address +name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala new file mode 100644 index 0000000000..e9ff415f91 --- /dev/null +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -0,0 +1,38 @@ +/* + * vala HelloWorld + * + * $ valac input.vala + * $ ./input + * Hello John, you're 21 years old + */ +void main(string[] args) { + var p = new Person(); + p.name = "John"; + p.age = 21; + print("Hello %s, you're %d years old\n", p.name, p.age); +} + +class Address { + string country; + string city; + string street; + int building; + int floor; +} + +class Person { + public Address address {get; set;} + public string name {get; set;} + private int d_age; + + public int age { + get { return d_age;} + set { + if (value > 0) { + d_age = value; + } else { + d_age = 0; + } + } + } +} diff --git a/Units/parser-vala.r/comments.vala.d/args.ctags b/Units/parser-vala.r/comments.vala.d/args.ctags new file mode 100644 index 0000000000..3bba6778c9 --- /dev/null +++ b/Units/parser-vala.r/comments.vala.d/args.ctags @@ -0,0 +1,2 @@ +--sort=no +--fields=+neKl diff --git a/Units/parser-vala.r/comments.vala.d/expected.tags b/Units/parser-vala.r/comments.vala.d/expected.tags new file mode 100644 index 0000000000..55e8edace3 --- /dev/null +++ b/Units/parser-vala.r/comments.vala.d/expected.tags @@ -0,0 +1,6 @@ +f1 input.vala /^void f1 () {$/;" method line:1 language:Vala +f2 input.vala /^void f2 () {print ("hello");} \/\/ void g3 () { print ("hello");}$/;" method line:7 language:Vala +f3 input.vala /^void f3 () {print ("hello");} void g4 () { print ("hello");}$/;" method line:8 language:Vala +g4 input.vala /^void f3 () {print ("hello");} void g4 () { print ("hello");}$/;" method line:8 language:Vala +f4 input.vala /^void f4 () {print ("hello"); \/\/ void g5 () { print ("hello");}$/;" method line:9 language:Vala +g7 input.vala /^} void g7 () { print ("hello");} \/\/ void g8 () {} ; void f5 () { print ("hello");} # void g/;" method line:11 language:Vala diff --git a/Units/parser-vala.r/comments.vala.d/input.vala b/Units/parser-vala.r/comments.vala.d/input.vala new file mode 100644 index 0000000000..ed4cfe902a --- /dev/null +++ b/Units/parser-vala.r/comments.vala.d/input.vala @@ -0,0 +1,11 @@ +void f1 () { + print ("hello"); +} +// void g0 () { print ("hello");} + // void g1 () { print ("hello");} + +void f2 () {print ("hello");} // void g3 () { print ("hello");} +void f3 () {print ("hello");} void g4 () { print ("hello");} +void f4 () {print ("hello"); // void g5 () { print ("hello");} +// void g6 () { print ("hello");} +} void g7 () { print ("hello");} // void g8 () {} ; void f5 () { print ("hello");} # void g9 () {} diff --git a/Units/parser-vala.r/functions.vala.d/args.ctags b/Units/parser-vala.r/functions.vala.d/args.ctags new file mode 100644 index 0000000000..0e201d551b --- /dev/null +++ b/Units/parser-vala.r/functions.vala.d/args.ctags @@ -0,0 +1,2 @@ +--sort=no +--fields=+neKl{signature} diff --git a/Units/parser-vala.r/functions.vala.d/expected.tags b/Units/parser-vala.r/functions.vala.d/expected.tags new file mode 100644 index 0000000000..7321862626 --- /dev/null +++ b/Units/parser-vala.r/functions.vala.d/expected.tags @@ -0,0 +1,2 @@ +main input.vala /^void main(string[] args) {$/;" method line:4 language:Vala signature:(string [] args) +sum input.vala /^int sum(int sum1, int sum2) {$/;" method line:8 language:Vala signature:(int sum1, int sum2) diff --git a/Units/parser-vala.r/functions.vala.d/input.vala b/Units/parser-vala.r/functions.vala.d/input.vala new file mode 100644 index 0000000000..3466ab552a --- /dev/null +++ b/Units/parser-vala.r/functions.vala.d/input.vala @@ -0,0 +1,10 @@ +/* + * vala sum + */ +void main(string[] args) { + print("Sum is: %d\n", sum(1,2)); +} + +int sum(int sum1, int sum2) { + return sum1 + sum2; +} diff --git a/Units/parser-vala.r/namespace.vala.d/expected.tags b/Units/parser-vala.r/namespace.vala.d/expected.tags new file mode 100644 index 0000000000..e1039b1e0c --- /dev/null +++ b/Units/parser-vala.r/namespace.vala.d/expected.tags @@ -0,0 +1,17 @@ +Address input.vala /^ class Address {$/;" c namespace:Data +Contact input.vala /^ class Contact {$/;" c namespace:Data.Private +Data input.vala /^namespace Data {$/;" n +Person input.vala /^class Person {$/;" c +Private input.vala /^ namespace Private {$/;" n namespace:Data +address input.vala /^ public Data.Address address {get; set;}$/;" p class:Person typeref:class:Data.Address +building input.vala /^ public int building;$/;" f class:Data.Address typeref:typename:int +city input.vala /^ public string city;$/;" f class:Data.Address typeref:typename:string +country input.vala /^ public string country;$/;" f class:Data.Address typeref:typename:string +d_street input.vala /^ public string d_street;$/;" f class:Data.Address typeref:typename:string +email input.vala /^ public string email;$/;" f class:Data.Private.Contact typeref:typename:string +floor input.vala /^ public int floor;$/;" f class:Data.Address typeref:typename:int +id input.vala /^ public string id;$/;" f class:Data.Private.Contact typeref:typename:string +main input.vala /^void main(string[] args) {$/;" m +name input.vala /^ public string name {get; set;}$/;" p class:Person typeref:typename:string +phone input.vala /^ public string phone;$/;" f class:Data.Private.Contact typeref:typename:string +street input.vala /^ public string street {$/;" p class:Data.Address typeref:typename:string diff --git a/Units/parser-vala.r/namespace.vala.d/input.vala b/Units/parser-vala.r/namespace.vala.d/input.vala new file mode 100644 index 0000000000..46efe6ffa5 --- /dev/null +++ b/Units/parser-vala.r/namespace.vala.d/input.vala @@ -0,0 +1,55 @@ +using Data; + +void main(string[] args) { + var p = new Person(); + var a = new Address(); + a.street = "Oxford Street"; + p.address = a; + p.name = "John"; + p.age = 21; + print("Hello %s, you're %d years old\nliving in %s\n", p.name, p.age, p.address.street); +} + +namespace Data { + class Address { + public string country; + public string city; + public string d_street; + public int building; + public int floor; + + public string street { + owned get { + return d_street; + } + set { + d_street = value; + } + } + } + + namespace Private { + class Contact { + public string email; + public string phone; + public string id; + } + } +} + +class Person { + public Data.Address address {get; set;} + public string name {get; set;} + private int d_age; + + public int age { + get { return d_age;} + set { + if (value > 0) { + d_age = value; + } else { + d_age = 0; + } + } + } +} diff --git a/Units/parser-vala.r/simple.vala.d/args.ctags b/Units/parser-vala.r/simple.vala.d/args.ctags new file mode 100644 index 0000000000..3bba6778c9 --- /dev/null +++ b/Units/parser-vala.r/simple.vala.d/args.ctags @@ -0,0 +1,2 @@ +--sort=no +--fields=+neKl diff --git a/Units/parser-vala.r/simple.vala.d/expected.tags b/Units/parser-vala.r/simple.vala.d/expected.tags new file mode 100644 index 0000000000..000700e9ac --- /dev/null +++ b/Units/parser-vala.r/simple.vala.d/expected.tags @@ -0,0 +1 @@ +main input.vala /^void main(string[] args) {$/;" method line:4 language:Vala diff --git a/Units/parser-vala.r/simple.vala.d/input.vala b/Units/parser-vala.r/simple.vala.d/input.vala new file mode 100644 index 0000000000..0f4c815972 --- /dev/null +++ b/Units/parser-vala.r/simple.vala.d/input.vala @@ -0,0 +1,6 @@ +/* + * vala HelloWorld + */ +void main(string[] args) { + print("Hello, World\n"); +} diff --git a/main/parsers_p.h b/main/parsers_p.h index 7efa0ef320..b7edba6319 100644 --- a/main/parsers_p.h +++ b/main/parsers_p.h @@ -183,8 +183,8 @@ VeraParser, \ VerilogParser, \ SystemVerilogParser, \ - VhdlParser, \ ValaParser, \ + VhdlParser, \ VimParser, \ WindResParser, \ YACCParser, \ diff --git a/parsers/vala.c b/parsers/vala.c index 4797f4529f..e7bac8bd4d 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -1,10 +1,11 @@ /* -* Copyright (c) 2019, +* Copyright (c) 2019, Masatake Yamato +* Copyright (c) 2019, Alberto Fanjul * * This source code is released for free distribution under the terms of the * GNU General Public License version 2 or (at your option) any later version. * -* This module contains functions for parsing and scanning Vaka source files. +* This module contains functions for parsing and scanning Vala source files. */ /* @@ -35,33 +36,194 @@ typedef enum { K_UNDEFINED = -1, K_CLASS, + K_STRUCT, + K_INTERFACE, + K_ENUM, + K_ENUMVALUE, + K_ERRORDOMAIN, + K_ERRORCODE, + K_DELEGATE, + K_SIGNAL, K_FIELD, K_METHOD, K_PROP, + K_LOCAL, + K_NAMESPACE, + COUNT_KIND } valaKind; static kindDefinition ValaKinds [] = { - { true, 'c', "class", "classes"}, - { true, 'f', "field", "fields"}, - { true, 'm', "method", "methods"}, - { true, 'p', "property", "properties"}, + { true, 'c', "class", "classes" }, + { true, 's', "struct", "structures" }, + { true, 'i', "interface", "interfaces" }, + { true, 'e', "enum", "enumerations" }, + { true, 'v', "enumvalue", "enumeration Values" }, + { true, 'E', "errordomain", "error domains" }, + { true, 'r', "errorcode", "error codes" }, + { true, 'd', "delegate", "delegates" }, + { true, 'S', "signal", "signals" }, + { true, 'f', "field", "fields" }, + { true, 'm', "method", "methods" }, + { true, 'p', "property", "properties" }, + { false, 'l', "local", "local variables" }, + { true, 'n', "namespace", "namespace" }, }; enum eKeywordId { - KEYWORD_CLASS, - KEYWORD_PUBLIC, KEYWORD_STRING, + KEYWORD_INT, + KEYWORD_DOUBLE, + KEYWORD_FLOAT, + KEYWORD_BOOL, KEYWORD_VOID, + KEYWORD_TYPE, + KEYWORD_ABSTRACT, + KEYWORD_AS, + KEYWORD_ASYNC, + KEYWORD_BASE, + KEYWORD_BREAK, + KEYWORD_CASE, + KEYWORD_CATCH, + KEYWORD_CLASS, + KEYWORD_CONST, + KEYWORD_CONSTRUCT, + KEYWORD_CONTINUE, + KEYWORD_DEFAULT, + KEYWORD_DELEGATE, + KEYWORD_DELETE, + KEYWORD_DO, + KEYWORD_DYNAMIC, + KEYWORD_ELSE, + KEYWORD_ENSURES, + KEYWORD_ENUM, + KEYWORD_ERRORDOMAIN, + KEYWORD_EXTERN, + KEYWORD_FALSE, + KEYWORD_FINALLY, + KEYWORD_FOR, + KEYWORD_FOREACH, + KEYWORD_GET, + KEYWORD_GLOBAL, + KEYWORD_IF, + KEYWORD_IN, + KEYWORD_INLINE, + KEYWORD_INTERFACE, + KEYWORD_INTERNAL, + KEYWORD_IS, + KEYWORD_LOCK, + KEYWORD_NAMESPACE, + KEYWORD_NEW, + KEYWORD_NULL, + KEYWORD_OUT, + KEYWORD_OVERRIDE, + KEYWORD_OWNED, + KEYWORD_PRIVATE, + KEYWORD_PROTECTED, + KEYWORD_PUBLIC, + KEYWORD_REF, + KEYWORD_REQUIRES, + KEYWORD_RETURN, + KEYWORD_SET, + KEYWORD_SIGNAL, + KEYWORD_SIZEOF, + KEYWORD_STATIC, + KEYWORD_STRUCT, + KEYWORD_SWITCH, + KEYWORD_THIS, + KEYWORD_THROW, + KEYWORD_THROWS, + KEYWORD_TRUE, + KEYWORD_TRY, + KEYWORD_TYPEOF, + KEYWORD_UNOWNED, + KEYWORD_USING, + KEYWORD_VALUE, + KEYWORD_VAR, + KEYWORD_VIRTUAL, + KEYWORD_WEAK, + KEYWORD_WHILE, + KEYWORD_YIELD, + }; typedef int keywordId; /* to allow KEYWORD_NONE */ static const keywordTable ValaKeywordTable [] = { - { "class", KEYWORD_CLASS }, - { "public", KEYWORD_PUBLIC }, { "string", KEYWORD_STRING }, + { "int", KEYWORD_INT }, + { "double", KEYWORD_DOUBLE }, + { "float", KEYWORD_FLOAT }, + { "bool", KEYWORD_BOOL }, + { "void", KEYWORD_VOID }, + { "Type", KEYWORD_TYPE }, + { "abstract", KEYWORD_ABSTRACT }, + { "as", KEYWORD_AS }, + { "async", KEYWORD_ASYNC }, + { "base", KEYWORD_BASE }, + { "break", KEYWORD_BREAK }, + { "case", KEYWORD_CASE }, + { "catch", KEYWORD_CATCH }, + { "class", KEYWORD_CLASS }, + { "const", KEYWORD_CONST }, + { "construct", KEYWORD_CONSTRUCT }, + { "continue", KEYWORD_CONTINUE }, + { "default", KEYWORD_DEFAULT }, + { "delegate", KEYWORD_DELEGATE }, + { "delete", KEYWORD_DELETE }, + { "do", KEYWORD_DO }, + { "dynamic", KEYWORD_DYNAMIC }, + { "else", KEYWORD_ELSE }, + { "ensures", KEYWORD_ENSURES }, + { "enum", KEYWORD_ENUM }, + { "errordomain", KEYWORD_ERRORDOMAIN }, + { "extern", KEYWORD_EXTERN }, + { "false", KEYWORD_FALSE }, + { "finally", KEYWORD_FINALLY }, + { "for", KEYWORD_FOR }, + { "foreach", KEYWORD_FOREACH }, + { "get", KEYWORD_GET }, + { "global", KEYWORD_GLOBAL }, + { "if", KEYWORD_IF }, + { "in", KEYWORD_IN }, + { "inline", KEYWORD_INLINE }, + { "interface", KEYWORD_INTERFACE }, + { "internal", KEYWORD_INTERNAL }, + { "is", KEYWORD_IS }, + { "lock", KEYWORD_LOCK }, + { "namespace", KEYWORD_NAMESPACE }, + { "new", KEYWORD_NEW }, + { "null", KEYWORD_NULL }, + { "out", KEYWORD_OUT }, + { "override", KEYWORD_OVERRIDE }, + { "owned", KEYWORD_OWNED }, + { "private", KEYWORD_PRIVATE }, + { "protected", KEYWORD_PROTECTED }, + { "public", KEYWORD_PUBLIC }, + { "ref", KEYWORD_REF }, + { "requires", KEYWORD_REQUIRES }, + { "return", KEYWORD_RETURN }, + { "set", KEYWORD_SET }, + { "signal", KEYWORD_SIGNAL }, + { "sizeof", KEYWORD_SIZEOF }, + { "static", KEYWORD_STATIC }, + { "struct", KEYWORD_STRUCT }, + { "switch", KEYWORD_SWITCH }, + { "this", KEYWORD_THIS }, + { "throw", KEYWORD_THROW }, + { "throws", KEYWORD_THROWS }, + { "true", KEYWORD_TRUE }, + { "try", KEYWORD_TRY }, + { "typeof", KEYWORD_TYPEOF }, + { "unowned", KEYWORD_UNOWNED }, + { "using", KEYWORD_USING }, + { "value", KEYWORD_VALUE }, + { "var", KEYWORD_VAR }, + { "virtual", KEYWORD_VIRTUAL }, + { "weak", KEYWORD_WEAK }, + { "while", KEYWORD_WHILE }, + { "yield", KEYWORD_YIELD }, }; enum ValaTokenType { @@ -80,16 +242,21 @@ enum ValaTokenType { */ static void readToken (tokenInfo *const token, void *data); +static void parseNamespace (tokenInfo *const token, int corkIndex); +static void parseClass (tokenInfo *const token, int corkIndex); +static void parseStatement (tokenInfo *const token, int corkIndex); /* * DATA DEFINITIONS */ +static bool trianglePairState = true; static struct tokenTypePair typePairs [] = { { '{', '}', NULL }, { '[', ']', NULL }, { '(', ')', NULL }, + { '<', '>', &trianglePairState }, }; static struct tokenInfoClass valaTokenInfoClass = { @@ -172,7 +339,7 @@ static void readIdentifier (tokenInfo *token) static void readToken (tokenInfo *const token, void *data) { int c; - bool semi_terminaotr = false; + bool semi_terminator = false; token->type = TOKEN_UNDEFINED; token->keyword = KEYWORD_NONE; @@ -256,8 +423,10 @@ static void readToken (tokenInfo *const token, void *data) case '}': case ']': case ')': + case '<': + case '>': case ';': - semi_terminaotr = true; + semi_terminator = true; case '{': case '[': case '(': @@ -292,7 +461,7 @@ static void readToken (tokenInfo *const token, void *data) vStringCat (collector, token->string); else { - if (!semi_terminaotr + if (!semi_terminator && !strchr ("{[(", vStringLast(collector))) vStringPut(collector, ' '); vStringCat (collector, token->string); @@ -305,7 +474,7 @@ static tokenInfo *newValaToken (void) return newToken (&valaTokenInfoClass); } -static void parseStatement (tokenInfo *const token) +static void parseStatement (tokenInfo *const token, int corkIndex) { tokenInfo *lastToken = newValaToken (); bool foundSignature = false; @@ -316,16 +485,20 @@ static void parseStatement (tokenInfo *const token) tokenRead (token); if (tokenEqType (token, '(')) { - vString *signature = vStringNewInit ("("); - int corkIndex = makeSimpleTag (lastToken->string, K_METHOD); - foundSignature = tokenSkipOverPairFull (token, signature); - if (foundSignature) - { - tagEntryInfo *e = getEntryInCorkQueue (corkIndex); - e->extensionFields.signature = vStringDeleteUnwrap (signature); - } - else - vStringDelete (signature); + if (tokenIsType (lastToken, KEYWORD)) { + tokenSkipOverPair (token); + } else { + vString *signature = vStringNewInit ("("); + int corkIndex = makeSimpleTag (lastToken->string, K_METHOD); + foundSignature = tokenSkipOverPairFull (token, signature); + if (foundSignature) + { + tagEntryInfo *e = getEntryInCorkQueue (corkIndex); + e->extensionFields.signature = vStringDeleteUnwrap (signature); + } + else + vStringDelete (signature); + } break; } } @@ -340,6 +513,32 @@ static void parseStatement (tokenInfo *const token) tokenDelete (lastToken); } +static void recurseValaTags (tokenInfo *token, int corkIndex) +{ + if (tokenIsKeyword(token, NAMESPACE)) + parseNamespace (token, corkIndex); + if (tokenIsKeyword(token, CLASS)) + parseClass (token, corkIndex); + else if (tokenIsType (token, IDENTIFIER)) + parseStatement (token, corkIndex); +} + +static void parseNamespaceBody (tokenInfo *const token, int corkIndex) +{ + do + { + tokenRead (token); + if (tokenEqType (token, '}')) + break; + + recurseValaTags (token, corkIndex); + + if (tokenEqType (token, '{')) + tokenSkipOverPair (token); + + } while (!tokenIsEOF (token)); +} + static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended) { bool nextTokeIsIdentifier = false; @@ -454,13 +653,33 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) tokenDelete (nameToken); } -static void parseClass (tokenInfo *const token) +static void parseNamespace (tokenInfo *const token, int corkIndex) +{ + + tokenRead (token); + if (!tokenIsType (token, IDENTIFIER)) + return; /* Unexpected sequence of token */ + + int namespaceCorkIndex = makeSimpleTag (token->string, K_NAMESPACE); + tagEntryInfo *entry = getEntryInCorkQueue (namespaceCorkIndex); + entry->extensionFields.scopeIndex = corkIndex; + + tokenRead (token); + if (!tokenSkipToType (token, '{')) + return; /* Unexpected sequence of token */ + + parseNamespaceBody (token, namespaceCorkIndex); +} + +static void parseClass (tokenInfo *const token, int corkIndex) { tokenRead (token); if (!tokenIsType (token, IDENTIFIER)) return; /* Unexpected sequence of token */ int classCorkIndex = makeSimpleTag (token->string, K_CLASS); + tagEntryInfo *entry = getEntryInCorkQueue (classCorkIndex); + entry->extensionFields.scopeIndex = corkIndex; /* Skip the class definition. */ tokenRead (token); @@ -476,11 +695,7 @@ static void findValaTags (void) do { tokenRead (token); - if (tokenIsKeyword(token, CLASS)) - parseClass (token); - else if (tokenIsType (token, IDENTIFIER) - || tokenIsType (token, KEYWORD)) - parseStatement (token); + recurseValaTags (token, CORK_NIL); } while (!tokenIsEOF (token)); From 6db5339548d65e64b4244edc1709c1da05191e9d Mon Sep 17 00:00:00 2001 From: Reuben Thomas Date: Thu, 8 Oct 2020 13:52:48 +0100 Subject: [PATCH 08/44] Vala: fix some minor nits MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix a misleading comment. Fix incorrect spacing of close brace. Remove unnecessary conversion to bool. Add an “else” before a mutually-exclusive “if”. --- parsers/vala.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/parsers/vala.c b/parsers/vala.c index e7bac8bd4d..7123626ed4 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -498,7 +498,7 @@ static void parseStatement (tokenInfo *const token, int corkIndex) } else vStringDelete (signature); - } + } break; } } @@ -517,7 +517,7 @@ static void recurseValaTags (tokenInfo *token, int corkIndex) { if (tokenIsKeyword(token, NAMESPACE)) parseNamespace (token, corkIndex); - if (tokenIsKeyword(token, CLASS)) + else if (tokenIsKeyword(token, CLASS)) parseClass (token, corkIndex); else if (tokenIsType (token, IDENTIFIER)) parseStatement (token, corkIndex); @@ -592,7 +592,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) if (tokenEqType (token, '}')) break; - isPublic = tokenIsKeyword(token, PUBLIC)? true: false; + isPublic = tokenIsKeyword(token, PUBLIC); if (isPublic) tokenRead (token); @@ -681,7 +681,7 @@ static void parseClass (tokenInfo *const token, int corkIndex) tagEntryInfo *entry = getEntryInCorkQueue (classCorkIndex); entry->extensionFields.scopeIndex = corkIndex; - /* Skip the class definition. */ + /* Parse the class definition. */ tokenRead (token); if (!tokenSkipToType (token, '{')) return; /* Unexpected sequence of token */ From 159c7c5ef6789068746687e695a3ec2ec59e9ace Mon Sep 17 00:00:00 2001 From: Reuben Thomas Date: Thu, 8 Oct 2020 13:59:18 +0100 Subject: [PATCH 09/44] Vala: ignore attributes Attributes, in matched square brackets, should be ignored, as otherwise they upset parsing. Add a test. --- Units/parser-vala.r/attributes.vala.d/args.ctags | 2 ++ Units/parser-vala.r/attributes.vala.d/expected.tags | 1 + Units/parser-vala.r/attributes.vala.d/input.vala | 2 ++ parsers/vala.c | 5 ++++- 4 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 Units/parser-vala.r/attributes.vala.d/args.ctags create mode 100644 Units/parser-vala.r/attributes.vala.d/expected.tags create mode 100644 Units/parser-vala.r/attributes.vala.d/input.vala diff --git a/Units/parser-vala.r/attributes.vala.d/args.ctags b/Units/parser-vala.r/attributes.vala.d/args.ctags new file mode 100644 index 0000000000..3bba6778c9 --- /dev/null +++ b/Units/parser-vala.r/attributes.vala.d/args.ctags @@ -0,0 +1,2 @@ +--sort=no +--fields=+neKl diff --git a/Units/parser-vala.r/attributes.vala.d/expected.tags b/Units/parser-vala.r/attributes.vala.d/expected.tags new file mode 100644 index 0000000000..b7a553ef7d --- /dev/null +++ b/Units/parser-vala.r/attributes.vala.d/expected.tags @@ -0,0 +1 @@ +Delegate input.vala /^public delegate bool Delegate ();$/;" method line:2 language:Vala diff --git a/Units/parser-vala.r/attributes.vala.d/input.vala b/Units/parser-vala.r/attributes.vala.d/input.vala new file mode 100644 index 0000000000..6d7033e53c --- /dev/null +++ b/Units/parser-vala.r/attributes.vala.d/input.vala @@ -0,0 +1,2 @@ +[CCode (has_target="false")] +public delegate bool Delegate (); diff --git a/parsers/vala.c b/parsers/vala.c index 7123626ed4..016e3bc0be 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -515,7 +515,10 @@ static void parseStatement (tokenInfo *const token, int corkIndex) static void recurseValaTags (tokenInfo *token, int corkIndex) { - if (tokenIsKeyword(token, NAMESPACE)) + /* Skip attributes */ + if (tokenEqType (token, '[')) + tokenSkipOverPair (token); + else if (tokenIsKeyword(token, NAMESPACE)) parseNamespace (token, corkIndex); else if (tokenIsKeyword(token, CLASS)) parseClass (token, corkIndex); From ca39bd840eb58521c3101e6585514f90990b149f Mon Sep 17 00:00:00 2001 From: Reuben Thomas Date: Sun, 11 Oct 2020 22:32:08 +0100 Subject: [PATCH 10/44] Vala: support interfaces, argument lists of methods, methods, more keywords --- Units/parser-vala.r/class.vala.d/args.ctags | 2 +- .../parser-vala.r/class.vala.d/expected.tags | 4 +- .../namespace.vala.d/expected.tags | 2 + parsers/vala.c | 44 ++++++++++++++++--- 4 files changed, 43 insertions(+), 9 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/args.ctags b/Units/parser-vala.r/class.vala.d/args.ctags index 3bba6778c9..0e201d551b 100644 --- a/Units/parser-vala.r/class.vala.d/args.ctags +++ b/Units/parser-vala.r/class.vala.d/args.ctags @@ -1,2 +1,2 @@ --sort=no ---fields=+neKl +--fields=+neKl{signature} diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index 3da11114d4..f8d027fa29 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -1,4 +1,4 @@ -main input.vala /^void main(string[] args) {$/;" method line:8 language:Vala +main input.vala /^void main(string[] args) {$/;" method line:8 language:Vala signature:(string [] args) Address input.vala /^class Address {$/;" class line:15 language:Vala country input.vala /^ string country;$/;" field line:16 language:Vala class:Address typeref:typename:string city input.vala /^ string city;$/;" field line:17 language:Vala class:Address typeref:typename:string @@ -8,3 +8,5 @@ floor input.vala /^ int floor;$/;" field line:20 language:Vala class:Address t Person input.vala /^class Person {$/;" class line:23 language:Vala address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string +d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int +age input.vala /^ public int age {$/;" property line:28 language:Vala class:Person typeref:typename:int diff --git a/Units/parser-vala.r/namespace.vala.d/expected.tags b/Units/parser-vala.r/namespace.vala.d/expected.tags index e1039b1e0c..b772afc626 100644 --- a/Units/parser-vala.r/namespace.vala.d/expected.tags +++ b/Units/parser-vala.r/namespace.vala.d/expected.tags @@ -4,9 +4,11 @@ Data input.vala /^namespace Data {$/;" n Person input.vala /^class Person {$/;" c Private input.vala /^ namespace Private {$/;" n namespace:Data address input.vala /^ public Data.Address address {get; set;}$/;" p class:Person typeref:class:Data.Address +age input.vala /^ public int age {$/;" p class:Person typeref:typename:int building input.vala /^ public int building;$/;" f class:Data.Address typeref:typename:int city input.vala /^ public string city;$/;" f class:Data.Address typeref:typename:string country input.vala /^ public string country;$/;" f class:Data.Address typeref:typename:string +d_age input.vala /^ private int d_age;$/;" f class:Person typeref:typename:int d_street input.vala /^ public string d_street;$/;" f class:Data.Address typeref:typename:string email input.vala /^ public string email;$/;" f class:Data.Private.Contact typeref:typename:string floor input.vala /^ public int floor;$/;" f class:Data.Address typeref:typename:int diff --git a/parsers/vala.c b/parsers/vala.c index 016e3bc0be..81510df5db 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -243,6 +243,7 @@ enum ValaTokenType { static void readToken (tokenInfo *const token, void *data); static void parseNamespace (tokenInfo *const token, int corkIndex); +static void parseInterface (tokenInfo *const token, int corkIndex); static void parseClass (tokenInfo *const token, int corkIndex); static void parseStatement (tokenInfo *const token, int corkIndex); @@ -518,8 +519,10 @@ static void recurseValaTags (tokenInfo *token, int corkIndex) /* Skip attributes */ if (tokenEqType (token, '[')) tokenSkipOverPair (token); - else if (tokenIsKeyword(token, NAMESPACE)) + if (tokenIsKeyword(token, NAMESPACE)) parseNamespace (token, corkIndex); + if (tokenIsKeyword(token, INTERFACE)) + parseInterface (token, corkIndex); else if (tokenIsKeyword(token, CLASS)) parseClass (token, corkIndex); else if (tokenIsType (token, IDENTIFIER)) @@ -544,7 +547,7 @@ static void parseNamespaceBody (tokenInfo *const token, int corkIndex) static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended) { - bool nextTokeIsIdentifier = false; + bool nextTokenIsIdentifier = false; tokenInfo *token = newValaToken (); if (extended) *extended = false; @@ -558,6 +561,8 @@ static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended if (extended) *extended = true; } + else if (tokenIsType (token, KEYWORD)) + ; /* Skip keywords */ else if (tokenIsType (token, IDENTIFIER)) { if (tokenLast (resultToken) == '.') @@ -565,7 +570,7 @@ static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended else { tokenUnread (token); - nextTokeIsIdentifier = true; + nextTokenIsIdentifier = true; break; } } @@ -573,14 +578,14 @@ static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended { if (!tokenIsEOF (token)) tokenUnread (token); - nextTokeIsIdentifier = false; + nextTokenIsIdentifier = false; break; } } while (1); tokenDelete (token); - return nextTokeIsIdentifier; + return nextTokenIsIdentifier; } static void parseClassBody (tokenInfo *const token, int classCorkIndex) @@ -597,7 +602,8 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) isPublic = tokenIsKeyword(token, PUBLIC); - if (isPublic) + if (isPublic || tokenIsKeyword (token, PROTECTED) || + tokenIsKeyword (token, PRIVATE) || tokenIsKeyword (token, INTERNAL)) tokenRead (token); if (tokenIsType (token, IDENTIFIER) @@ -614,7 +620,13 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) if (tokenIsType (token, IDENTIFIER)) tokenCopy (nameToken, token); + /* Argument list for a method */ tokenRead (token); + if (tokenEqType (token, '(')) { + tokenSkipOverPair (token); + tokenRead (token); + } + int kind; if (tokenEqType (token, ';')) kind = K_FIELD; @@ -627,7 +639,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) tagEntryInfo *entry = getEntryInCorkQueue (memberCorkIndex); /* Fill access field. */ - entry->extensionFields.access = isPublic? eStrdup ("public"): NULL; + entry->extensionFields.access = isPublic ? eStrdup ("public") : NULL; /* Fill typeref field. */ entry->extensionFields.typeRef [0] = eStrdup ( typerefIsClass? @@ -674,6 +686,24 @@ static void parseNamespace (tokenInfo *const token, int corkIndex) parseNamespaceBody (token, namespaceCorkIndex); } +static void parseInterface (tokenInfo *const token, int corkIndex) +{ + + tokenRead (token); + if (!tokenIsType (token, IDENTIFIER)) + return; /* Unexpected sequence of token */ + + int interfaceCorkIndex = makeSimpleTag (token->string, K_INTERFACE); + tagEntryInfo *entry = getEntryInCorkQueue (interfaceCorkIndex); + entry->extensionFields.scopeIndex = corkIndex; + + tokenRead (token); + if (!tokenSkipToType (token, '{')) + return; /* Unexpected sequence of token */ + + parseClassBody (token, interfaceCorkIndex); /* Should we have a custom parser? */ +} + static void parseClass (tokenInfo *const token, int corkIndex) { tokenRead (token); From 9532fe53edcff949e9465afcb51651bf54938c36 Mon Sep 17 00:00:00 2001 From: Reuben Thomas Date: Sun, 11 Oct 2020 23:41:54 +0100 Subject: [PATCH 11/44] Vala: more parser improvements --- Units/parser-vala.r/class.vala.d/expected.tags | 10 +++++----- Units/parser-vala.r/class.vala.d/input.vala | 10 +++++----- parsers/vala.c | 13 ++++++++++--- 3 files changed, 20 insertions(+), 13 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index f8d027fa29..6f170c84cc 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -1,10 +1,10 @@ main input.vala /^void main(string[] args) {$/;" method line:8 language:Vala signature:(string [] args) -Address input.vala /^class Address {$/;" class line:15 language:Vala +Address input.vala /^public class Address {$/;" class line:15 language:Vala country input.vala /^ string country;$/;" field line:16 language:Vala class:Address typeref:typename:string -city input.vala /^ string city;$/;" field line:17 language:Vala class:Address typeref:typename:string -street input.vala /^ string street;$/;" field line:18 language:Vala class:Address typeref:typename:string -building input.vala /^ int building;$/;" field line:19 language:Vala class:Address typeref:typename:int -floor input.vala /^ int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int +city input.vala /^ public string city;$/;" field line:17 language:Vala class:Address typeref:typename:string +street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string +building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int +floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int Person input.vala /^class Person {$/;" class line:23 language:Vala address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index e9ff415f91..b51908a1d2 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -12,12 +12,12 @@ void main(string[] args) { print("Hello %s, you're %d years old\n", p.name, p.age); } -class Address { +public class Address { string country; - string city; - string street; - int building; - int floor; + public string city; + protected string street; + internal int building; + private int floor; } class Person { diff --git a/parsers/vala.c b/parsers/vala.c index 81510df5db..feeda145a9 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -503,7 +503,7 @@ static void parseStatement (tokenInfo *const token, int corkIndex) break; } } - while (!tokenIsEOF (token)); + while (!tokenEqType (token, ';') && !tokenIsEOF (token)); /* Skip the body of method */ if (foundSignature) @@ -519,9 +519,9 @@ static void recurseValaTags (tokenInfo *token, int corkIndex) /* Skip attributes */ if (tokenEqType (token, '[')) tokenSkipOverPair (token); - if (tokenIsKeyword(token, NAMESPACE)) + else if (tokenIsKeyword(token, NAMESPACE)) parseNamespace (token, corkIndex); - if (tokenIsKeyword(token, INTERFACE)) + else if (tokenIsKeyword(token, INTERFACE)) parseInterface (token, corkIndex); else if (tokenIsKeyword(token, CLASS)) parseClass (token, corkIndex); @@ -563,6 +563,13 @@ static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended } else if (tokenIsType (token, KEYWORD)) ; /* Skip keywords */ + else if (tokenIsTypeVal (token, '?')) + ; /* Skip nullable */ + else if (tokenIsTypeVal (token, '*')) + ; /* Skip pointer or indirection */ + else if (tokenIsTypeVal (token, '<')) + /* Skip over generic type parameter. */ + tokenSkipOverPair (token); else if (tokenIsType (token, IDENTIFIER)) { if (tokenLast (resultToken) == '.') From 4333cc2934bb283160b8918c726907a3eb22d8e7 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 01:56:50 +0900 Subject: [PATCH 12/44] Vala: update the COPYRIGHT notice Signed-off-by: Masatake YAMATO --- parsers/vala.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/parsers/vala.c b/parsers/vala.c index feeda145a9..1ee36fc635 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -1,6 +1,7 @@ /* -* Copyright (c) 2019, Masatake Yamato * Copyright (c) 2019, Alberto Fanjul +* Copyright (c) 2020, Masatake Yamato +* Copyright (c) 2020, Red Hat, Inc. * * This source code is released for free distribution under the terms of the * GNU General Public License version 2 or (at your option) any later version. From 94a9dedc33fea7a4b3acdfb30549b3fefaa8c672 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 01:57:48 +0900 Subject: [PATCH 13/44] Vala: add a URL for the language reference Signed-off-by: Masatake YAMATO --- parsers/vala.c | 1 + 1 file changed, 1 insertion(+) diff --git a/parsers/vala.c b/parsers/vala.c index 1ee36fc635..d38268ba75 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -7,6 +7,7 @@ * GNU General Public License version 2 or (at your option) any later version. * * This module contains functions for parsing and scanning Vala source files. +* https://www.vala-project.org/doc/vala/ */ /* From 34d9133a81b3ea9fafbc82fe47fcac6a2d8baef4 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 02:06:50 +0900 Subject: [PATCH 14/44] Vala: rename parameters Signed-off-by: Masatake YAMATO --- parsers/vala.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/parsers/vala.c b/parsers/vala.c index d38268ba75..2e311c3ad2 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -477,7 +477,7 @@ static tokenInfo *newValaToken (void) return newToken (&valaTokenInfoClass); } -static void parseStatement (tokenInfo *const token, int corkIndex) +static void parseStatement (tokenInfo *const token, int parentIndex) { tokenInfo *lastToken = newValaToken (); bool foundSignature = false; @@ -516,22 +516,22 @@ static void parseStatement (tokenInfo *const token, int corkIndex) tokenDelete (lastToken); } -static void recurseValaTags (tokenInfo *token, int corkIndex) +static void recurseValaTags (tokenInfo *token, int parentIndex) { /* Skip attributes */ if (tokenEqType (token, '[')) tokenSkipOverPair (token); else if (tokenIsKeyword(token, NAMESPACE)) - parseNamespace (token, corkIndex); + parseNamespace (token, parentIndex); else if (tokenIsKeyword(token, INTERFACE)) - parseInterface (token, corkIndex); + parseInterface (token, parentIndex); else if (tokenIsKeyword(token, CLASS)) - parseClass (token, corkIndex); + parseClass (token, parentIndex); else if (tokenIsType (token, IDENTIFIER)) - parseStatement (token, corkIndex); + parseStatement (token, parentIndex); } -static void parseNamespaceBody (tokenInfo *const token, int corkIndex) +static void parseNamespaceBody (tokenInfo *const token, int parentIndex) { do { @@ -539,7 +539,7 @@ static void parseNamespaceBody (tokenInfo *const token, int corkIndex) if (tokenEqType (token, '}')) break; - recurseValaTags (token, corkIndex); + recurseValaTags (token, parentIndex); if (tokenEqType (token, '{')) tokenSkipOverPair (token); @@ -677,7 +677,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) tokenDelete (nameToken); } -static void parseNamespace (tokenInfo *const token, int corkIndex) +static void parseNamespace (tokenInfo *const token, int parentIndex) { tokenRead (token); @@ -686,7 +686,7 @@ static void parseNamespace (tokenInfo *const token, int corkIndex) int namespaceCorkIndex = makeSimpleTag (token->string, K_NAMESPACE); tagEntryInfo *entry = getEntryInCorkQueue (namespaceCorkIndex); - entry->extensionFields.scopeIndex = corkIndex; + entry->extensionFields.scopeIndex = parentIndex; tokenRead (token); if (!tokenSkipToType (token, '{')) @@ -695,7 +695,7 @@ static void parseNamespace (tokenInfo *const token, int corkIndex) parseNamespaceBody (token, namespaceCorkIndex); } -static void parseInterface (tokenInfo *const token, int corkIndex) +static void parseInterface (tokenInfo *const token, int parentIndex) { tokenRead (token); @@ -704,7 +704,7 @@ static void parseInterface (tokenInfo *const token, int corkIndex) int interfaceCorkIndex = makeSimpleTag (token->string, K_INTERFACE); tagEntryInfo *entry = getEntryInCorkQueue (interfaceCorkIndex); - entry->extensionFields.scopeIndex = corkIndex; + entry->extensionFields.scopeIndex = parentIndex; tokenRead (token); if (!tokenSkipToType (token, '{')) @@ -713,7 +713,7 @@ static void parseInterface (tokenInfo *const token, int corkIndex) parseClassBody (token, interfaceCorkIndex); /* Should we have a custom parser? */ } -static void parseClass (tokenInfo *const token, int corkIndex) +static void parseClass (tokenInfo *const token, int parentIndex) { tokenRead (token); if (!tokenIsType (token, IDENTIFIER)) @@ -721,7 +721,7 @@ static void parseClass (tokenInfo *const token, int corkIndex) int classCorkIndex = makeSimpleTag (token->string, K_CLASS); tagEntryInfo *entry = getEntryInCorkQueue (classCorkIndex); - entry->extensionFields.scopeIndex = corkIndex; + entry->extensionFields.scopeIndex = parentIndex; /* Parse the class definition. */ tokenRead (token); From 716996e7489ffabff75ff07ba99826aa505b7d91 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 02:11:18 +0900 Subject: [PATCH 15/44] Vala,cosmetic: fix style of if/else Signed-off-by: Masatake YAMATO --- parsers/vala.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/parsers/vala.c b/parsers/vala.c index 2e311c3ad2..44d2a28329 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -488,9 +488,10 @@ static void parseStatement (tokenInfo *const token, int parentIndex) tokenRead (token); if (tokenEqType (token, '(')) { - if (tokenIsType (lastToken, KEYWORD)) { + if (tokenIsType (lastToken, KEYWORD)) tokenSkipOverPair (token); - } else { + else + { vString *signature = vStringNewInit ("("); int corkIndex = makeSimpleTag (lastToken->string, K_METHOD); foundSignature = tokenSkipOverPairFull (token, signature); From 581bfc4d8cc57cab891b84abcecbf1b7bc836c91 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 02:46:30 +0900 Subject: [PATCH 16/44] Vala: record the line number correctly Signed-off-by: Masatake YAMATO --- parsers/vala.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/parsers/vala.c b/parsers/vala.c index 44d2a28329..a8ade54aaa 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -368,6 +368,8 @@ static void readToken (tokenInfo *const token, void *data) if (c0 == EOF) { token->type = TOKEN_EOF; + token->lineNumber = getInputLineNumber (); + token->filePosition = getInputFilePosition (); return; } else if (c0 == '\n') @@ -384,6 +386,8 @@ static void readToken (tokenInfo *const token, void *data) if (c1 == EOF) { token->type = TOKEN_EOF; + token->lineNumber = getInputLineNumber (); + token->filePosition = getInputFilePosition (); return; } else if (c1 == '*') @@ -394,6 +398,8 @@ static void readToken (tokenInfo *const token, void *data) if (c2 == EOF) { token->type = TOKEN_EOF; + token->lineNumber = getInputLineNumber (); + token->filePosition = getInputFilePosition (); return; } else if (c2 == '/') @@ -407,6 +413,8 @@ static void readToken (tokenInfo *const token, void *data) ungetcToInputFile (c0); } + token->lineNumber = getInputLineNumber (); + token->filePosition = getInputFilePosition (); switch (c) { case EOF: From 381e83061a1696ac58fd298b5160fbcd32404e66 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 02:16:56 +0900 Subject: [PATCH 17/44] Vala: rearrange the way to add fields Signed-off-by: Masatake YAMATO --- parsers/vala.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/parsers/vala.c b/parsers/vala.c index a8ade54aaa..0b91d9da2b 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -500,16 +500,17 @@ static void parseStatement (tokenInfo *const token, int parentIndex) tokenSkipOverPair (token); else { - vString *signature = vStringNewInit ("("); int corkIndex = makeSimpleTag (lastToken->string, K_METHOD); - foundSignature = tokenSkipOverPairFull (token, signature); - if (foundSignature) + tagEntryInfo *e = getEntryInCorkQueue (corkIndex); + if (e) { - tagEntryInfo *e = getEntryInCorkQueue (corkIndex); - e->extensionFields.signature = vStringDeleteUnwrap (signature); + vString *signature = vStringNewInit ("("); + foundSignature = tokenSkipOverPairFull (token, signature); + if (foundSignature) + e->extensionFields.signature = vStringDeleteUnwrap (signature); + else + vStringDelete (signature); } - else - vStringDelete (signature); } break; } From a4340099892315f73951affb6d36c1f8a875e70f Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 02:20:45 +0900 Subject: [PATCH 18/44] Vala: fill end: field of method kind tags Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/attributes.vala.d/expected.tags | 2 +- Units/parser-vala.r/class.vala.d/expected.tags | 2 +- Units/parser-vala.r/comments.vala.d/expected.tags | 12 ++++++------ Units/parser-vala.r/functions.vala.d/expected.tags | 4 ++-- Units/parser-vala.r/simple.vala.d/expected.tags | 2 +- parsers/vala.c | 7 ++++++- 6 files changed, 17 insertions(+), 12 deletions(-) diff --git a/Units/parser-vala.r/attributes.vala.d/expected.tags b/Units/parser-vala.r/attributes.vala.d/expected.tags index b7a553ef7d..e266837743 100644 --- a/Units/parser-vala.r/attributes.vala.d/expected.tags +++ b/Units/parser-vala.r/attributes.vala.d/expected.tags @@ -1 +1 @@ -Delegate input.vala /^public delegate bool Delegate ();$/;" method line:2 language:Vala +Delegate input.vala /^public delegate bool Delegate ();$/;" method line:2 language:Vala end:2 diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index 6f170c84cc..6c0a1d136f 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -1,4 +1,4 @@ -main input.vala /^void main(string[] args) {$/;" method line:8 language:Vala signature:(string [] args) +main input.vala /^void main(string[] args) {$/;" method line:8 language:Vala signature:(string [] args) end:13 Address input.vala /^public class Address {$/;" class line:15 language:Vala country input.vala /^ string country;$/;" field line:16 language:Vala class:Address typeref:typename:string city input.vala /^ public string city;$/;" field line:17 language:Vala class:Address typeref:typename:string diff --git a/Units/parser-vala.r/comments.vala.d/expected.tags b/Units/parser-vala.r/comments.vala.d/expected.tags index 55e8edace3..3eafc8aa3b 100644 --- a/Units/parser-vala.r/comments.vala.d/expected.tags +++ b/Units/parser-vala.r/comments.vala.d/expected.tags @@ -1,6 +1,6 @@ -f1 input.vala /^void f1 () {$/;" method line:1 language:Vala -f2 input.vala /^void f2 () {print ("hello");} \/\/ void g3 () { print ("hello");}$/;" method line:7 language:Vala -f3 input.vala /^void f3 () {print ("hello");} void g4 () { print ("hello");}$/;" method line:8 language:Vala -g4 input.vala /^void f3 () {print ("hello");} void g4 () { print ("hello");}$/;" method line:8 language:Vala -f4 input.vala /^void f4 () {print ("hello"); \/\/ void g5 () { print ("hello");}$/;" method line:9 language:Vala -g7 input.vala /^} void g7 () { print ("hello");} \/\/ void g8 () {} ; void f5 () { print ("hello");} # void g/;" method line:11 language:Vala +f1 input.vala /^void f1 () {$/;" method line:1 language:Vala end:3 +f2 input.vala /^void f2 () {print ("hello");} \/\/ void g3 () { print ("hello");}$/;" method line:7 language:Vala end:7 +f3 input.vala /^void f3 () {print ("hello");} void g4 () { print ("hello");}$/;" method line:8 language:Vala end:8 +g4 input.vala /^void f3 () {print ("hello");} void g4 () { print ("hello");}$/;" method line:8 language:Vala end:8 +f4 input.vala /^void f4 () {print ("hello"); \/\/ void g5 () { print ("hello");}$/;" method line:9 language:Vala end:11 +g7 input.vala /^} void g7 () { print ("hello");} \/\/ void g8 () {} ; void f5 () { print ("hello");} # void g/;" method line:11 language:Vala end:11 diff --git a/Units/parser-vala.r/functions.vala.d/expected.tags b/Units/parser-vala.r/functions.vala.d/expected.tags index 7321862626..439cd9aa3b 100644 --- a/Units/parser-vala.r/functions.vala.d/expected.tags +++ b/Units/parser-vala.r/functions.vala.d/expected.tags @@ -1,2 +1,2 @@ -main input.vala /^void main(string[] args) {$/;" method line:4 language:Vala signature:(string [] args) -sum input.vala /^int sum(int sum1, int sum2) {$/;" method line:8 language:Vala signature:(int sum1, int sum2) +main input.vala /^void main(string[] args) {$/;" method line:4 language:Vala signature:(string [] args) end:6 +sum input.vala /^int sum(int sum1, int sum2) {$/;" method line:8 language:Vala signature:(int sum1, int sum2) end:10 diff --git a/Units/parser-vala.r/simple.vala.d/expected.tags b/Units/parser-vala.r/simple.vala.d/expected.tags index 000700e9ac..bc5e950745 100644 --- a/Units/parser-vala.r/simple.vala.d/expected.tags +++ b/Units/parser-vala.r/simple.vala.d/expected.tags @@ -1 +1 @@ -main input.vala /^void main(string[] args) {$/;" method line:4 language:Vala +main input.vala /^void main(string[] args) {$/;" method line:4 language:Vala end:6 diff --git a/parsers/vala.c b/parsers/vala.c index 0b91d9da2b..19219409a1 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -489,6 +489,7 @@ static void parseStatement (tokenInfo *const token, int parentIndex) { tokenInfo *lastToken = newValaToken (); bool foundSignature = false; + tagEntryInfo *e = NULL; do { @@ -501,7 +502,7 @@ static void parseStatement (tokenInfo *const token, int parentIndex) else { int corkIndex = makeSimpleTag (lastToken->string, K_METHOD); - tagEntryInfo *e = getEntryInCorkQueue (corkIndex); + e = getEntryInCorkQueue (corkIndex); if (e) { vString *signature = vStringNewInit ("("); @@ -523,6 +524,10 @@ static void parseStatement (tokenInfo *const token, int parentIndex) if (tokenSkipToType (token, '{')) tokenSkipOverPair (token); } + + if (e) + e->extensionFields.endLine = token->lineNumber; + tokenDelete (lastToken); } From 675cea8de54fdc77f0b916ca244a2f7316fbe9fa Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 03:26:25 +0900 Subject: [PATCH 19/44] Vala: use makeSimpleTagFromToken Signed-off-by: Masatake YAMATO --- parsers/vala.c | 19 +++++-------------- 1 file changed, 5 insertions(+), 14 deletions(-) diff --git a/parsers/vala.c b/parsers/vala.c index 19219409a1..e4230da159 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -501,7 +501,7 @@ static void parseStatement (tokenInfo *const token, int parentIndex) tokenSkipOverPair (token); else { - int corkIndex = makeSimpleTag (lastToken->string, K_METHOD); + int corkIndex = makeSimpleTagFromToken (lastToken, K_METHOD, parentIndex); e = getEntryInCorkQueue (corkIndex); if (e) { @@ -659,7 +659,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) else break; /* Unexpected sequence of token */ - int memberCorkIndex = makeSimpleTag (nameToken->string, kind); + int memberCorkIndex = makeSimpleTagFromToken (nameToken, kind, classCorkIndex); tagEntryInfo *entry = getEntryInCorkQueue (memberCorkIndex); /* Fill access field. */ @@ -680,9 +680,6 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) "unknown"); entry->extensionFields.typeRef [1] = vStringStrdup(typerefToken->string); - /* Fill scope field. */ - entry->extensionFields.scopeIndex = classCorkIndex; - if (kind == K_PROP) tokenSkipOverPair (token); } while (!tokenIsEOF (token)); @@ -699,9 +696,7 @@ static void parseNamespace (tokenInfo *const token, int parentIndex) if (!tokenIsType (token, IDENTIFIER)) return; /* Unexpected sequence of token */ - int namespaceCorkIndex = makeSimpleTag (token->string, K_NAMESPACE); - tagEntryInfo *entry = getEntryInCorkQueue (namespaceCorkIndex); - entry->extensionFields.scopeIndex = parentIndex; + int namespaceCorkIndex = makeSimpleTagFromToken (token, K_NAMESPACE, parentIndex); tokenRead (token); if (!tokenSkipToType (token, '{')) @@ -717,9 +712,7 @@ static void parseInterface (tokenInfo *const token, int parentIndex) if (!tokenIsType (token, IDENTIFIER)) return; /* Unexpected sequence of token */ - int interfaceCorkIndex = makeSimpleTag (token->string, K_INTERFACE); - tagEntryInfo *entry = getEntryInCorkQueue (interfaceCorkIndex); - entry->extensionFields.scopeIndex = parentIndex; + int interfaceCorkIndex = makeSimpleTagFromToken (token, K_INTERFACE, parentIndex); tokenRead (token); if (!tokenSkipToType (token, '{')) @@ -734,9 +727,7 @@ static void parseClass (tokenInfo *const token, int parentIndex) if (!tokenIsType (token, IDENTIFIER)) return; /* Unexpected sequence of token */ - int classCorkIndex = makeSimpleTag (token->string, K_CLASS); - tagEntryInfo *entry = getEntryInCorkQueue (classCorkIndex); - entry->extensionFields.scopeIndex = parentIndex; + int classCorkIndex = makeSimpleTagFromToken (token, K_CLASS, parentIndex); /* Parse the class definition. */ tokenRead (token); From 40d8f317bf6cd6d12da423ac7a9e160bb6ecbbc2 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 03:42:33 +0900 Subject: [PATCH 20/44] Vala: fill end: field for more kinds Signed-off-by: Masatake YAMATO --- .../parser-vala.r/class.vala.d/expected.tags | 22 +++++++++---------- parsers/vala.c | 10 +++++++++ 2 files changed, 21 insertions(+), 11 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index 6c0a1d136f..1317f59eef 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -1,12 +1,12 @@ main input.vala /^void main(string[] args) {$/;" method line:8 language:Vala signature:(string [] args) end:13 -Address input.vala /^public class Address {$/;" class line:15 language:Vala -country input.vala /^ string country;$/;" field line:16 language:Vala class:Address typeref:typename:string -city input.vala /^ public string city;$/;" field line:17 language:Vala class:Address typeref:typename:string -street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string -building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int -floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int -Person input.vala /^class Person {$/;" class line:23 language:Vala -address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address -name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string -d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int -age input.vala /^ public int age {$/;" property line:28 language:Vala class:Person typeref:typename:int +Address input.vala /^public class Address {$/;" class line:15 language:Vala end:21 +country input.vala /^ string country;$/;" field line:16 language:Vala class:Address typeref:typename:string end:16 +city input.vala /^ public string city;$/;" field line:17 language:Vala class:Address typeref:typename:string end:17 +street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string end:18 +building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int end:19 +floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int end:20 +Person input.vala /^class Person {$/;" class line:23 language:Vala end:38 +address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address end:24 +name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string end:25 +d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int end:26 +age input.vala /^ public int age {$/;" property line:28 language:Vala class:Person typeref:typename:int end:37 diff --git a/parsers/vala.c b/parsers/vala.c index e4230da159..11eab13751 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -682,6 +682,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) if (kind == K_PROP) tokenSkipOverPair (token); + entry->extensionFields.endLine = token->lineNumber; } while (!tokenIsEOF (token)); out: @@ -703,6 +704,9 @@ static void parseNamespace (tokenInfo *const token, int parentIndex) return; /* Unexpected sequence of token */ parseNamespaceBody (token, namespaceCorkIndex); + tagEntryInfo *e = getEntryInCorkQueue (namespaceCorkIndex); + if (e) + e->extensionFields.endLine = token->lineNumber; } static void parseInterface (tokenInfo *const token, int parentIndex) @@ -719,6 +723,9 @@ static void parseInterface (tokenInfo *const token, int parentIndex) return; /* Unexpected sequence of token */ parseClassBody (token, interfaceCorkIndex); /* Should we have a custom parser? */ + tagEntryInfo *e = getEntryInCorkQueue (interfaceCorkIndex); + if (e) + e->extensionFields.endLine = token->lineNumber; } static void parseClass (tokenInfo *const token, int parentIndex) @@ -735,6 +742,9 @@ static void parseClass (tokenInfo *const token, int parentIndex) return; /* Unexpected sequence of token */ parseClassBody (token, classCorkIndex); + tagEntryInfo *e = getEntryInCorkQueue (classCorkIndex); + if (e) + e->extensionFields.endLine = token->lineNumber; } static void findValaTags (void) From f2cdb69f5ab4bb2911e5738c3d80a76d6425f3d2 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 03:44:19 +0900 Subject: [PATCH 21/44] Units,Vala: add --sort=no to namespace.vala Signed-off-by: Masatake YAMATO --- .../parser-vala.r/namespace.vala.d/args.ctags | 1 + .../namespace.vala.d/expected.tags | 26 +++++++++---------- 2 files changed, 14 insertions(+), 13 deletions(-) create mode 100644 Units/parser-vala.r/namespace.vala.d/args.ctags diff --git a/Units/parser-vala.r/namespace.vala.d/args.ctags b/Units/parser-vala.r/namespace.vala.d/args.ctags new file mode 100644 index 0000000000..5ee5f79f70 --- /dev/null +++ b/Units/parser-vala.r/namespace.vala.d/args.ctags @@ -0,0 +1 @@ +--sort=no diff --git a/Units/parser-vala.r/namespace.vala.d/expected.tags b/Units/parser-vala.r/namespace.vala.d/expected.tags index b772afc626..89d3eff1ea 100644 --- a/Units/parser-vala.r/namespace.vala.d/expected.tags +++ b/Units/parser-vala.r/namespace.vala.d/expected.tags @@ -1,19 +1,19 @@ -Address input.vala /^ class Address {$/;" c namespace:Data -Contact input.vala /^ class Contact {$/;" c namespace:Data.Private +main input.vala /^void main(string[] args) {$/;" m Data input.vala /^namespace Data {$/;" n -Person input.vala /^class Person {$/;" c -Private input.vala /^ namespace Private {$/;" n namespace:Data -address input.vala /^ public Data.Address address {get; set;}$/;" p class:Person typeref:class:Data.Address -age input.vala /^ public int age {$/;" p class:Person typeref:typename:int -building input.vala /^ public int building;$/;" f class:Data.Address typeref:typename:int -city input.vala /^ public string city;$/;" f class:Data.Address typeref:typename:string +Address input.vala /^ class Address {$/;" c namespace:Data country input.vala /^ public string country;$/;" f class:Data.Address typeref:typename:string -d_age input.vala /^ private int d_age;$/;" f class:Person typeref:typename:int +city input.vala /^ public string city;$/;" f class:Data.Address typeref:typename:string d_street input.vala /^ public string d_street;$/;" f class:Data.Address typeref:typename:string -email input.vala /^ public string email;$/;" f class:Data.Private.Contact typeref:typename:string +building input.vala /^ public int building;$/;" f class:Data.Address typeref:typename:int floor input.vala /^ public int floor;$/;" f class:Data.Address typeref:typename:int +street input.vala /^ public string street {$/;" p class:Data.Address typeref:typename:string +Private input.vala /^ namespace Private {$/;" n namespace:Data +Contact input.vala /^ class Contact {$/;" c namespace:Data.Private +email input.vala /^ public string email;$/;" f class:Data.Private.Contact typeref:typename:string +phone input.vala /^ public string phone;$/;" f class:Data.Private.Contact typeref:typename:string id input.vala /^ public string id;$/;" f class:Data.Private.Contact typeref:typename:string -main input.vala /^void main(string[] args) {$/;" m +Person input.vala /^class Person {$/;" c +address input.vala /^ public Data.Address address {get; set;}$/;" p class:Person typeref:class:Data.Address name input.vala /^ public string name {get; set;}$/;" p class:Person typeref:typename:string -phone input.vala /^ public string phone;$/;" f class:Data.Private.Contact typeref:typename:string -street input.vala /^ public string street {$/;" p class:Data.Address typeref:typename:string +d_age input.vala /^ private int d_age;$/;" f class:Person typeref:typename:int +age input.vala /^ public int age {$/;" p class:Person typeref:typename:int From 67517123d3f93db40a60a8e4504304a6165324e0 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 03:49:58 +0900 Subject: [PATCH 22/44] Units,Vala: extend namespace.vala to test end: fields Signed-off-by: Masatake YAMATO --- .../parser-vala.r/namespace.vala.d/args.ctags | 1 + .../namespace.vala.d/expected.tags | 38 +++++++++---------- 2 files changed, 20 insertions(+), 19 deletions(-) diff --git a/Units/parser-vala.r/namespace.vala.d/args.ctags b/Units/parser-vala.r/namespace.vala.d/args.ctags index 5ee5f79f70..a60a455e15 100644 --- a/Units/parser-vala.r/namespace.vala.d/args.ctags +++ b/Units/parser-vala.r/namespace.vala.d/args.ctags @@ -1 +1,2 @@ --sort=no +--fields=+e diff --git a/Units/parser-vala.r/namespace.vala.d/expected.tags b/Units/parser-vala.r/namespace.vala.d/expected.tags index 89d3eff1ea..72360621fe 100644 --- a/Units/parser-vala.r/namespace.vala.d/expected.tags +++ b/Units/parser-vala.r/namespace.vala.d/expected.tags @@ -1,19 +1,19 @@ -main input.vala /^void main(string[] args) {$/;" m -Data input.vala /^namespace Data {$/;" n -Address input.vala /^ class Address {$/;" c namespace:Data -country input.vala /^ public string country;$/;" f class:Data.Address typeref:typename:string -city input.vala /^ public string city;$/;" f class:Data.Address typeref:typename:string -d_street input.vala /^ public string d_street;$/;" f class:Data.Address typeref:typename:string -building input.vala /^ public int building;$/;" f class:Data.Address typeref:typename:int -floor input.vala /^ public int floor;$/;" f class:Data.Address typeref:typename:int -street input.vala /^ public string street {$/;" p class:Data.Address typeref:typename:string -Private input.vala /^ namespace Private {$/;" n namespace:Data -Contact input.vala /^ class Contact {$/;" c namespace:Data.Private -email input.vala /^ public string email;$/;" f class:Data.Private.Contact typeref:typename:string -phone input.vala /^ public string phone;$/;" f class:Data.Private.Contact typeref:typename:string -id input.vala /^ public string id;$/;" f class:Data.Private.Contact typeref:typename:string -Person input.vala /^class Person {$/;" c -address input.vala /^ public Data.Address address {get; set;}$/;" p class:Person typeref:class:Data.Address -name input.vala /^ public string name {get; set;}$/;" p class:Person typeref:typename:string -d_age input.vala /^ private int d_age;$/;" f class:Person typeref:typename:int -age input.vala /^ public int age {$/;" p class:Person typeref:typename:int +main input.vala /^void main(string[] args) {$/;" m end:11 +Data input.vala /^namespace Data {$/;" n end:38 +Address input.vala /^ class Address {$/;" c namespace:Data end:29 +country input.vala /^ public string country;$/;" f class:Data.Address typeref:typename:string end:15 +city input.vala /^ public string city;$/;" f class:Data.Address typeref:typename:string end:16 +d_street input.vala /^ public string d_street;$/;" f class:Data.Address typeref:typename:string end:17 +building input.vala /^ public int building;$/;" f class:Data.Address typeref:typename:int end:18 +floor input.vala /^ public int floor;$/;" f class:Data.Address typeref:typename:int end:19 +street input.vala /^ public string street {$/;" p class:Data.Address typeref:typename:string end:28 +Private input.vala /^ namespace Private {$/;" n namespace:Data end:37 +Contact input.vala /^ class Contact {$/;" c namespace:Data.Private end:36 +email input.vala /^ public string email;$/;" f class:Data.Private.Contact typeref:typename:string end:33 +phone input.vala /^ public string phone;$/;" f class:Data.Private.Contact typeref:typename:string end:34 +id input.vala /^ public string id;$/;" f class:Data.Private.Contact typeref:typename:string end:35 +Person input.vala /^class Person {$/;" c end:55 +address input.vala /^ public Data.Address address {get; set;}$/;" p class:Person typeref:class:Data.Address end:41 +name input.vala /^ public string name {get; set;}$/;" p class:Person typeref:typename:string end:42 +d_age input.vala /^ private int d_age;$/;" f class:Person typeref:typename:int end:43 +age input.vala /^ public int age {$/;" p class:Person typeref:typename:int end:54 From 0726e68f48c38c52971ff65dc0fb4c0824e83a87 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 04:10:42 +0900 Subject: [PATCH 23/44] Vala: consider other than public when filling access: fields Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/class.vala.d/args.ctags | 2 +- .../parser-vala.r/class.vala.d/expected.tags | 16 ++++++------ .../parser-vala.r/namespace.vala.d/args.ctags | 2 +- .../namespace.vala.d/expected.tags | 26 +++++++++---------- parsers/vala.c | 18 +++++++++---- 5 files changed, 36 insertions(+), 28 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/args.ctags b/Units/parser-vala.r/class.vala.d/args.ctags index 0e201d551b..2c02d04a86 100644 --- a/Units/parser-vala.r/class.vala.d/args.ctags +++ b/Units/parser-vala.r/class.vala.d/args.ctags @@ -1,2 +1,2 @@ --sort=no ---fields=+neKl{signature} +--fields=+neKl{signature}{access} diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index 1317f59eef..df8763026b 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -1,12 +1,12 @@ main input.vala /^void main(string[] args) {$/;" method line:8 language:Vala signature:(string [] args) end:13 Address input.vala /^public class Address {$/;" class line:15 language:Vala end:21 country input.vala /^ string country;$/;" field line:16 language:Vala class:Address typeref:typename:string end:16 -city input.vala /^ public string city;$/;" field line:17 language:Vala class:Address typeref:typename:string end:17 -street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string end:18 -building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int end:19 -floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int end:20 +city input.vala /^ public string city;$/;" field line:17 language:Vala class:Address typeref:typename:string access:public end:17 +street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string access:protected end:18 +building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int access:internal end:19 +floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int access:private end:20 Person input.vala /^class Person {$/;" class line:23 language:Vala end:38 -address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address end:24 -name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string end:25 -d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int end:26 -age input.vala /^ public int age {$/;" property line:28 language:Vala class:Person typeref:typename:int end:37 +address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address access:public end:24 +name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string access:public end:25 +d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int access:private end:26 +age input.vala /^ public int age {$/;" property line:28 language:Vala class:Person typeref:typename:int access:public end:37 diff --git a/Units/parser-vala.r/namespace.vala.d/args.ctags b/Units/parser-vala.r/namespace.vala.d/args.ctags index a60a455e15..3a2f45774d 100644 --- a/Units/parser-vala.r/namespace.vala.d/args.ctags +++ b/Units/parser-vala.r/namespace.vala.d/args.ctags @@ -1,2 +1,2 @@ --sort=no ---fields=+e +--fields=+ea diff --git a/Units/parser-vala.r/namespace.vala.d/expected.tags b/Units/parser-vala.r/namespace.vala.d/expected.tags index 72360621fe..68a7d290e0 100644 --- a/Units/parser-vala.r/namespace.vala.d/expected.tags +++ b/Units/parser-vala.r/namespace.vala.d/expected.tags @@ -1,19 +1,19 @@ main input.vala /^void main(string[] args) {$/;" m end:11 Data input.vala /^namespace Data {$/;" n end:38 Address input.vala /^ class Address {$/;" c namespace:Data end:29 -country input.vala /^ public string country;$/;" f class:Data.Address typeref:typename:string end:15 -city input.vala /^ public string city;$/;" f class:Data.Address typeref:typename:string end:16 -d_street input.vala /^ public string d_street;$/;" f class:Data.Address typeref:typename:string end:17 -building input.vala /^ public int building;$/;" f class:Data.Address typeref:typename:int end:18 -floor input.vala /^ public int floor;$/;" f class:Data.Address typeref:typename:int end:19 -street input.vala /^ public string street {$/;" p class:Data.Address typeref:typename:string end:28 +country input.vala /^ public string country;$/;" f class:Data.Address typeref:typename:string access:public end:15 +city input.vala /^ public string city;$/;" f class:Data.Address typeref:typename:string access:public end:16 +d_street input.vala /^ public string d_street;$/;" f class:Data.Address typeref:typename:string access:public end:17 +building input.vala /^ public int building;$/;" f class:Data.Address typeref:typename:int access:public end:18 +floor input.vala /^ public int floor;$/;" f class:Data.Address typeref:typename:int access:public end:19 +street input.vala /^ public string street {$/;" p class:Data.Address typeref:typename:string access:public end:28 Private input.vala /^ namespace Private {$/;" n namespace:Data end:37 Contact input.vala /^ class Contact {$/;" c namespace:Data.Private end:36 -email input.vala /^ public string email;$/;" f class:Data.Private.Contact typeref:typename:string end:33 -phone input.vala /^ public string phone;$/;" f class:Data.Private.Contact typeref:typename:string end:34 -id input.vala /^ public string id;$/;" f class:Data.Private.Contact typeref:typename:string end:35 +email input.vala /^ public string email;$/;" f class:Data.Private.Contact typeref:typename:string access:public end:33 +phone input.vala /^ public string phone;$/;" f class:Data.Private.Contact typeref:typename:string access:public end:34 +id input.vala /^ public string id;$/;" f class:Data.Private.Contact typeref:typename:string access:public end:35 Person input.vala /^class Person {$/;" c end:55 -address input.vala /^ public Data.Address address {get; set;}$/;" p class:Person typeref:class:Data.Address end:41 -name input.vala /^ public string name {get; set;}$/;" p class:Person typeref:typename:string end:42 -d_age input.vala /^ private int d_age;$/;" f class:Person typeref:typename:int end:43 -age input.vala /^ public int age {$/;" p class:Person typeref:typename:int end:54 +address input.vala /^ public Data.Address address {get; set;}$/;" p class:Person typeref:class:Data.Address access:public end:41 +name input.vala /^ public string name {get; set;}$/;" p class:Person typeref:typename:string access:public end:42 +d_age input.vala /^ private int d_age;$/;" f class:Person typeref:typename:int access:private end:43 +age input.vala /^ public int age {$/;" p class:Person typeref:typename:int access:public end:54 diff --git a/parsers/vala.c b/parsers/vala.c index 11eab13751..730979264c 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -614,7 +614,7 @@ static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended static void parseClassBody (tokenInfo *const token, int classCorkIndex) { - bool isPublic; + char *visiblity = NULL; tokenInfo *typerefToken = newValaToken (); tokenInfo *nameToken = newValaToken (); @@ -624,17 +624,22 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) if (tokenEqType (token, '}')) break; - isPublic = tokenIsKeyword(token, PUBLIC); - - if (isPublic || tokenIsKeyword (token, PROTECTED) || + if (tokenIsKeyword(token, PUBLIC) || tokenIsKeyword (token, PROTECTED) || tokenIsKeyword (token, PRIVATE) || tokenIsKeyword (token, INTERNAL)) + { + visiblity = eStrdup (tokenString (token)); tokenRead (token); + } if (tokenIsType (token, IDENTIFIER) || tokenIsType (token, KEYWORD)) tokenCopy (typerefToken, token); else + { + if (visiblity) + eFree (visiblity); break; /* Unexpected sequence to token */ + } bool typerefIsClass; if (!readIdentifierExtended (typerefToken, &typerefIsClass)) @@ -663,7 +668,8 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) tagEntryInfo *entry = getEntryInCorkQueue (memberCorkIndex); /* Fill access field. */ - entry->extensionFields.access = isPublic ? eStrdup ("public") : NULL; + entry->extensionFields.access = visiblity; + visiblity = NULL; /* Fill typeref field. */ entry->extensionFields.typeRef [0] = eStrdup ( typerefIsClass? @@ -686,6 +692,8 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) } while (!tokenIsEOF (token)); out: + if (visiblity) + eFree (visiblity); tokenDelete (typerefToken); tokenDelete (nameToken); } From fb3cd6b1b36f6d19d3c957dc022499bbba06a510 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 05:10:25 +0900 Subject: [PATCH 24/44] Vala: fill inherits: field of class kind entries Signed-off-by: Masatake YAMATO --- .../inheritance-list.d/args.ctags | 2 ++ .../inheritance-list.d/expected.tags | 5 +++ .../inheritance-list.d/input.vala | 10 ++++++ parsers/vala.c | 35 +++++++++++++++++++ 4 files changed, 52 insertions(+) create mode 100644 Units/parser-vala.r/inheritance-list.d/args.ctags create mode 100644 Units/parser-vala.r/inheritance-list.d/expected.tags create mode 100644 Units/parser-vala.r/inheritance-list.d/input.vala diff --git a/Units/parser-vala.r/inheritance-list.d/args.ctags b/Units/parser-vala.r/inheritance-list.d/args.ctags new file mode 100644 index 0000000000..cace191508 --- /dev/null +++ b/Units/parser-vala.r/inheritance-list.d/args.ctags @@ -0,0 +1,2 @@ +--sort=no +--fields=+i diff --git a/Units/parser-vala.r/inheritance-list.d/expected.tags b/Units/parser-vala.r/inheritance-list.d/expected.tags new file mode 100644 index 0000000000..c8441163ad --- /dev/null +++ b/Units/parser-vala.r/inheritance-list.d/expected.tags @@ -0,0 +1,5 @@ +AXc input.vala /^public class AXc {$/;" c +a input.vala /^ int a;$/;" f class:AXc typeref:typename:int +BXi input.vala /^public interface BXi {$/;" i +MyObject input.vala /^public class MyObject: AXc, BXi {$/;" c inherits:AXc,BXi +c input.vala /^ int c;$/;" f class:MyObject typeref:typename:int diff --git a/Units/parser-vala.r/inheritance-list.d/input.vala b/Units/parser-vala.r/inheritance-list.d/input.vala new file mode 100644 index 0000000000..82d68b211a --- /dev/null +++ b/Units/parser-vala.r/inheritance-list.d/input.vala @@ -0,0 +1,10 @@ +public class AXc { + int a; +} + +public interface BXi { +} + +public class MyObject: AXc, BXi { + int c; +} diff --git a/parsers/vala.c b/parsers/vala.c index 730979264c..871a12a840 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -736,6 +736,38 @@ static void parseInterface (tokenInfo *const token, int parentIndex) e->extensionFields.endLine = token->lineNumber; } +static void parseInheritanceList (tokenInfo *const token, int classIndex) +{ + vString *list = vStringNew (); + + do + { + tokenRead (token); + if (!tokenIsType (token, IDENTIFIER)) + break; /* Unexpected sequence of token */ + readIdentifierExtended (token, NULL); + vStringCat (list, token->string); + + tokenRead (token); + if (tokenIsTypeVal (token, ',')) + vStringPut (list, ','); + else if (tokenIsTypeVal (token, '{')) + { + tagEntryInfo *e = getEntryInCorkQueue (classIndex); + if (e) + { + e->extensionFields.inheritance = vStringDeleteUnwrap (list); + list = NULL; + } + break; + } + else + break; /* Unexpected sequence of token or EOF */ + } while (1); + + vStringDelete (list); /* NULL is acceptable */ +} + static void parseClass (tokenInfo *const token, int parentIndex) { tokenRead (token); @@ -746,6 +778,9 @@ static void parseClass (tokenInfo *const token, int parentIndex) /* Parse the class definition. */ tokenRead (token); + if (tokenIsTypeVal (token, ':')) + parseInheritanceList (token, classCorkIndex); + if (!tokenSkipToType (token, '{')) return; /* Unexpected sequence of token */ From c312e801015e814440e4de862b32ebb837930a55 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 05:23:05 +0900 Subject: [PATCH 25/44] Vala: accept qualified names as class names Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/qnamed-class.d/args.ctags | 1 + Units/parser-vala.r/qnamed-class.d/expected.tags | 3 +++ Units/parser-vala.r/qnamed-class.d/input.vala | 6 ++++++ parsers/vala.c | 1 + 4 files changed, 11 insertions(+) create mode 100644 Units/parser-vala.r/qnamed-class.d/args.ctags create mode 100644 Units/parser-vala.r/qnamed-class.d/expected.tags create mode 100644 Units/parser-vala.r/qnamed-class.d/input.vala diff --git a/Units/parser-vala.r/qnamed-class.d/args.ctags b/Units/parser-vala.r/qnamed-class.d/args.ctags new file mode 100644 index 0000000000..5ee5f79f70 --- /dev/null +++ b/Units/parser-vala.r/qnamed-class.d/args.ctags @@ -0,0 +1 @@ +--sort=no diff --git a/Units/parser-vala.r/qnamed-class.d/expected.tags b/Units/parser-vala.r/qnamed-class.d/expected.tags new file mode 100644 index 0000000000..1010841659 --- /dev/null +++ b/Units/parser-vala.r/qnamed-class.d/expected.tags @@ -0,0 +1,3 @@ +X input.vala /^namespace X {$/;" n +X.MyObject input.vala /^public class X.MyObject {$/;" c +a input.vala /^ int a;$/;" f class:X.MyObject typeref:typename:int diff --git a/Units/parser-vala.r/qnamed-class.d/input.vala b/Units/parser-vala.r/qnamed-class.d/input.vala new file mode 100644 index 0000000000..09db8f1a96 --- /dev/null +++ b/Units/parser-vala.r/qnamed-class.d/input.vala @@ -0,0 +1,6 @@ +namespace X { +} + +public class X.MyObject { + int a; +} diff --git a/parsers/vala.c b/parsers/vala.c index 871a12a840..0dff09cf3c 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -773,6 +773,7 @@ static void parseClass (tokenInfo *const token, int parentIndex) tokenRead (token); if (!tokenIsType (token, IDENTIFIER)) return; /* Unexpected sequence of token */ + readIdentifierExtended (token, NULL); int classCorkIndex = makeSimpleTagFromToken (token, K_CLASS, parentIndex); From dd6181cf33eed2523c784c6bdb15ebecda236522 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 24 Oct 2020 06:53:32 +0900 Subject: [PATCH 26/44] Vala: use tokenIsTypeVal instead of tokenEqTye Signed-off-by: Masatake YAMATO --- parsers/vala.c | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/parsers/vala.c b/parsers/vala.c index 0dff09cf3c..e7e1bb0f85 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -28,7 +28,6 @@ * MACROS */ -#define tokenEqType(TKN,T) ((TKN)->type == T) /* @@ -495,7 +494,7 @@ static void parseStatement (tokenInfo *const token, int parentIndex) { tokenCopy (lastToken, token); tokenRead (token); - if (tokenEqType (token, '(')) + if (tokenIsTypeVal (token, '(')) { if (tokenIsType (lastToken, KEYWORD)) tokenSkipOverPair (token); @@ -516,7 +515,7 @@ static void parseStatement (tokenInfo *const token, int parentIndex) break; } } - while (!tokenEqType (token, ';') && !tokenIsEOF (token)); + while (!tokenIsTypeVal (token, ';') && !tokenIsEOF (token)); /* Skip the body of method */ if (foundSignature) @@ -534,7 +533,7 @@ static void parseStatement (tokenInfo *const token, int parentIndex) static void recurseValaTags (tokenInfo *token, int parentIndex) { /* Skip attributes */ - if (tokenEqType (token, '[')) + if (tokenIsTypeVal (token, '[')) tokenSkipOverPair (token); else if (tokenIsKeyword(token, NAMESPACE)) parseNamespace (token, parentIndex); @@ -551,12 +550,12 @@ static void parseNamespaceBody (tokenInfo *const token, int parentIndex) do { tokenRead (token); - if (tokenEqType (token, '}')) + if (tokenIsTypeVal (token, '}')) break; recurseValaTags (token, parentIndex); - if (tokenEqType (token, '{')) + if (tokenIsTypeVal (token, '{')) tokenSkipOverPair (token); } while (!tokenIsEOF (token)); @@ -621,7 +620,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) do { tokenRead (token); - if (tokenEqType (token, '}')) + if (tokenIsTypeVal (token, '}')) break; if (tokenIsKeyword(token, PUBLIC) || tokenIsKeyword (token, PROTECTED) || @@ -651,15 +650,15 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) /* Argument list for a method */ tokenRead (token); - if (tokenEqType (token, '(')) { + if (tokenIsTypeVal (token, '(')) { tokenSkipOverPair (token); tokenRead (token); } int kind; - if (tokenEqType (token, ';')) + if (tokenIsTypeVal (token, ';')) kind = K_FIELD; - else if (tokenEqType (token, '{')) + else if (tokenIsTypeVal (token, '{')) kind = K_PROP; else break; /* Unexpected sequence of token */ From a033dbfbe663e800f86e1d6305949635c053f700 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 19 Dec 2020 16:08:07 +0900 Subject: [PATCH 27/44] Vala: define built-in types as keywords Signed-off-by: Masatake YAMATO --- parsers/vala.c | 62 +++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 51 insertions(+), 11 deletions(-) diff --git a/parsers/vala.c b/parsers/vala.c index e7e1bb0f85..a4ede0debd 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -72,11 +72,7 @@ static kindDefinition ValaKinds [] = { enum eKeywordId { - KEYWORD_STRING, - KEYWORD_INT, - KEYWORD_DOUBLE, - KEYWORD_FLOAT, - KEYWORD_BOOL, + KEYWORD_BUILTIN_TYPE, KEYWORD_VOID, KEYWORD_TYPE, KEYWORD_ABSTRACT, @@ -150,13 +146,51 @@ enum eKeywordId typedef int keywordId; /* to allow KEYWORD_NONE */ -static const keywordTable ValaKeywordTable [] = { - { "string", KEYWORD_STRING }, - { "int", KEYWORD_INT }, - { "double", KEYWORD_DOUBLE }, - { "float", KEYWORD_FLOAT }, - { "bool", KEYWORD_BOOL }, +static struct keywordGroup valaBuiltInKeywordGroup = { + .value = KEYWORD_BUILTIN_TYPE, + .addingUnlessExisting = false, + .keywords = { + /* type: + * value-type: + * fundamental-struct-type: + * integral-type: */ + "char", + "uchar", + "short", + "ushort", + "int", + "uint", + "long", + "ulong", + "size_t", + "ssize_t", + "int8", + "uint8", + "int16", + "uint16", + "int32", + "uint32", + "int64", + "uint64", + "unichar", + /* type: + * value-type: + * fundamental-struct-type: + * floating-point-type: */ + "float", + "double", + /* type: + * value-type: + * fundamental-struct-type: */ + "bool", + /* type: + * reference-type: */ + "string", + NULL + }, +}; +static const keywordTable ValaKeywordTable [] = { { "void", KEYWORD_VOID }, { "Type", KEYWORD_TYPE }, { "abstract", KEYWORD_ABSTRACT }, @@ -804,6 +838,11 @@ static void findValaTags (void) flashTokenBacklog (&valaTokenInfoClass); } +static void initialize (const langType language) +{ + addKeywordGroup (&valaBuiltInKeywordGroup, language); +} + extern parserDefinition* ValaParser (void) { static const char *const extensions [] = { "vala", NULL }; @@ -817,6 +856,7 @@ extern parserDefinition* ValaParser (void) def->useCork = true; def->requestAutomaticFQTag = true; + def->initialize = initialize, def->parser = findValaTags; return def; } From 719e5ab96d53210ba1b74fa514abdaf855d30686 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sat, 19 Dec 2020 19:00:13 +0900 Subject: [PATCH 28/44] Vala: tag enum and enum values Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/enum.vala.d/args.ctags | 1 + Units/parser-vala.r/enum.vala.d/expected.tags | 19 ++++++ Units/parser-vala.r/enum.vala.d/input.vala | 58 +++++++++++++++++++ parsers/vala.c | 43 ++++++++++++++ 4 files changed, 121 insertions(+) create mode 100644 Units/parser-vala.r/enum.vala.d/args.ctags create mode 100644 Units/parser-vala.r/enum.vala.d/expected.tags create mode 100644 Units/parser-vala.r/enum.vala.d/input.vala diff --git a/Units/parser-vala.r/enum.vala.d/args.ctags b/Units/parser-vala.r/enum.vala.d/args.ctags new file mode 100644 index 0000000000..5ee5f79f70 --- /dev/null +++ b/Units/parser-vala.r/enum.vala.d/args.ctags @@ -0,0 +1 @@ +--sort=no diff --git a/Units/parser-vala.r/enum.vala.d/expected.tags b/Units/parser-vala.r/enum.vala.d/expected.tags new file mode 100644 index 0000000000..7298d74458 --- /dev/null +++ b/Units/parser-vala.r/enum.vala.d/expected.tags @@ -0,0 +1,19 @@ +Skk input.vala /^namespace Skk {$/;" n +ModifierType input.vala /^ public enum ModifierType {$/;" e namespace:Skk +NONE input.vala /^ NONE = 0,$/;" v enum:Skk.ModifierType +SHIFT_MASK input.vala /^ SHIFT_MASK = 1 << 0,$/;" v enum:Skk.ModifierType +LOCK_MASK input.vala /^ LOCK_MASK = 1 << 1,$/;" v enum:Skk.ModifierType +CONTROL_MASK input.vala /^ CONTROL_MASK = 1 << 2,$/;" v enum:Skk.ModifierType +MOD1_MASK input.vala /^ MOD1_MASK = 1 << 3,$/;" v enum:Skk.ModifierType +MOD2_MASK input.vala /^ MOD2_MASK = 1 << 4,$/;" v enum:Skk.ModifierType +MOD3_MASK input.vala /^ MOD3_MASK = 1 << 5,$/;" v enum:Skk.ModifierType +MOD4_MASK input.vala /^ MOD4_MASK = 1 << 6,$/;" v enum:Skk.ModifierType +MOD5_MASK input.vala /^ MOD5_MASK = 1 << 7,$/;" v enum:Skk.ModifierType +LSHIFT_MASK input.vala /^ LSHIFT_MASK = 1 << 22,$/;" v enum:Skk.ModifierType +RSHIFT_MASK input.vala /^ RSHIFT_MASK = 1 << 23,$/;" v enum:Skk.ModifierType +USLEEP_MASK input.vala /^ USLEEP_MASK = 1 << 24,$/;" v enum:Skk.ModifierType +SUPER_MASK input.vala /^ SUPER_MASK = 1 << 26,$/;" v enum:Skk.ModifierType +HYPER_MASK input.vala /^ HYPER_MASK = 1 << 27,$/;" v enum:Skk.ModifierType +META_MASK input.vala /^ META_MASK = 1 << 28,$/;" v enum:Skk.ModifierType +RELEASE_MASK input.vala /^ RELEASE_MASK = 1 << 30$/;" v enum:Skk.ModifierType +KeyEvent input.vala /^ public class KeyEvent : Object {$/;" c namespace:Skk diff --git a/Units/parser-vala.r/enum.vala.d/input.vala b/Units/parser-vala.r/enum.vala.d/input.vala new file mode 100644 index 0000000000..019b04eb8b --- /dev/null +++ b/Units/parser-vala.r/enum.vala.d/input.vala @@ -0,0 +1,58 @@ +/* Taken from https://github.com/ueno/libskk + * (libskk/libskk/key-event.vala) + * errordomain is removed because ctags is not ready to parse it. + */ + +/* + * Copyright (C) 2011-2018 Daiki Ueno + * Copyright (C) 2011-2018 Red Hat, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +using Gee; + +namespace Skk { + /** + * A set of bit-flags to indicate the state of modifier keys. + */ + [Flags] + public enum ModifierType { + NONE = 0, + SHIFT_MASK = 1 << 0, + LOCK_MASK = 1 << 1, + CONTROL_MASK = 1 << 2, + MOD1_MASK = 1 << 3, + MOD2_MASK = 1 << 4, + MOD3_MASK = 1 << 5, + MOD4_MASK = 1 << 6, + MOD5_MASK = 1 << 7, + + // dummy modifiers for NICOLA + LSHIFT_MASK = 1 << 22, + RSHIFT_MASK = 1 << 23, + USLEEP_MASK = 1 << 24, + + SUPER_MASK = 1 << 26, + HYPER_MASK = 1 << 27, + META_MASK = 1 << 28, + RELEASE_MASK = 1 << 30 + } + + /** + * Object representing a key event. + */ + public class KeyEvent : Object { + /* ... */ + } +} diff --git a/parsers/vala.c b/parsers/vala.c index a4ede0debd..93f6acc284 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -281,6 +281,7 @@ static void parseNamespace (tokenInfo *const token, int corkIndex); static void parseInterface (tokenInfo *const token, int corkIndex); static void parseClass (tokenInfo *const token, int corkIndex); static void parseStatement (tokenInfo *const token, int corkIndex); +static void parseEnum (tokenInfo *const token, int corkIndex); /* @@ -564,6 +565,46 @@ static void parseStatement (tokenInfo *const token, int parentIndex) tokenDelete (lastToken); } +static void parseEnumBody (tokenInfo *const token, int corkIndex) +{ + bool s = tokenTypePairSetState (&valaTokenInfoClass, '<', false); + while (!tokenIsEOF (token)) + { + tokenRead (token); + if (tokenIsType (token, IDENTIFIER)) + { + makeSimpleTagFromToken (token, K_ENUMVALUE, corkIndex); + tokenType endMakers [] = {',', '}'}; + if (tokenSkipToTypesOverPairs (token, endMakers, ARRAY_SIZE(endMakers))) + { + if (tokenIsTypeVal (token, '}')) + break; + } + else + break; + } + } + tokenTypePairSetState (&valaTokenInfoClass, '<', s); +} + +static void parseEnum (tokenInfo *const token, int corkIndex) +{ + tokenRead (token); + if (!tokenIsType (token, IDENTIFIER)) + return; /* Unexpected sequence of token */ + + int enumCorkIndex = makeSimpleTagFromToken (token, K_ENUM, corkIndex); + + tokenRead (token); + if (!tokenSkipToType (token, '{')) + return; /* Unexpected sequence of token */ + parseEnumBody (token, enumCorkIndex); + + tagEntryInfo *e = getEntryInCorkQueue (enumCorkIndex); + if (e) + e->extensionFields.endLine = token->lineNumber; +} + static void recurseValaTags (tokenInfo *token, int parentIndex) { /* Skip attributes */ @@ -575,6 +616,8 @@ static void recurseValaTags (tokenInfo *token, int parentIndex) parseInterface (token, parentIndex); else if (tokenIsKeyword(token, CLASS)) parseClass (token, parentIndex); + else if (tokenIsKeyword(token, ENUM)) + parseEnum (token, parentIndex); else if (tokenIsType (token, IDENTIFIER)) parseStatement (token, parentIndex); } From 98155c8d021061de26f9a754aec97225b871ee04 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 20 Dec 2020 03:29:15 +0900 Subject: [PATCH 29/44] Vala: tag errordomain and errorcode Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/enum.vala.d/expected.tags | 3 +++ Units/parser-vala.r/enum.vala.d/input.vala | 6 +++++- parsers/vala.c | 16 +++++++++------- 3 files changed, 17 insertions(+), 8 deletions(-) diff --git a/Units/parser-vala.r/enum.vala.d/expected.tags b/Units/parser-vala.r/enum.vala.d/expected.tags index 7298d74458..0ea73be07d 100644 --- a/Units/parser-vala.r/enum.vala.d/expected.tags +++ b/Units/parser-vala.r/enum.vala.d/expected.tags @@ -1,4 +1,7 @@ Skk input.vala /^namespace Skk {$/;" n +KeyEventFormatError input.vala /^ public errordomain KeyEventFormatError {$/;" E namespace:Skk +PARSE_FAILED input.vala /^ PARSE_FAILED,$/;" r errordomain:Skk.KeyEventFormatError +KEYSYM_NOT_FOUND input.vala /^ KEYSYM_NOT_FOUND$/;" r errordomain:Skk.KeyEventFormatError ModifierType input.vala /^ public enum ModifierType {$/;" e namespace:Skk NONE input.vala /^ NONE = 0,$/;" v enum:Skk.ModifierType SHIFT_MASK input.vala /^ SHIFT_MASK = 1 << 0,$/;" v enum:Skk.ModifierType diff --git a/Units/parser-vala.r/enum.vala.d/input.vala b/Units/parser-vala.r/enum.vala.d/input.vala index 019b04eb8b..399985a685 100644 --- a/Units/parser-vala.r/enum.vala.d/input.vala +++ b/Units/parser-vala.r/enum.vala.d/input.vala @@ -1,6 +1,5 @@ /* Taken from https://github.com/ueno/libskk * (libskk/libskk/key-event.vala) - * errordomain is removed because ctags is not ready to parse it. */ /* @@ -23,6 +22,11 @@ using Gee; namespace Skk { + public errordomain KeyEventFormatError { + PARSE_FAILED, + KEYSYM_NOT_FOUND + } + /** * A set of bit-flags to indicate the state of modifier keys. */ diff --git a/parsers/vala.c b/parsers/vala.c index 93f6acc284..3337ddc7ca 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -281,7 +281,7 @@ static void parseNamespace (tokenInfo *const token, int corkIndex); static void parseInterface (tokenInfo *const token, int corkIndex); static void parseClass (tokenInfo *const token, int corkIndex); static void parseStatement (tokenInfo *const token, int corkIndex); -static void parseEnum (tokenInfo *const token, int corkIndex); +static void parseEnum (tokenInfo *const token, int kindIndex, int elementKindIndex, int corkIndex); /* @@ -565,7 +565,7 @@ static void parseStatement (tokenInfo *const token, int parentIndex) tokenDelete (lastToken); } -static void parseEnumBody (tokenInfo *const token, int corkIndex) +static void parseEnumBody (tokenInfo *const token, int kindIndex, int corkIndex) { bool s = tokenTypePairSetState (&valaTokenInfoClass, '<', false); while (!tokenIsEOF (token)) @@ -573,7 +573,7 @@ static void parseEnumBody (tokenInfo *const token, int corkIndex) tokenRead (token); if (tokenIsType (token, IDENTIFIER)) { - makeSimpleTagFromToken (token, K_ENUMVALUE, corkIndex); + makeSimpleTagFromToken (token, kindIndex, corkIndex); tokenType endMakers [] = {',', '}'}; if (tokenSkipToTypesOverPairs (token, endMakers, ARRAY_SIZE(endMakers))) { @@ -587,18 +587,18 @@ static void parseEnumBody (tokenInfo *const token, int corkIndex) tokenTypePairSetState (&valaTokenInfoClass, '<', s); } -static void parseEnum (tokenInfo *const token, int corkIndex) +static void parseEnum (tokenInfo *const token, int kindIndex, int elementKindIndex, int corkIndex) { tokenRead (token); if (!tokenIsType (token, IDENTIFIER)) return; /* Unexpected sequence of token */ - int enumCorkIndex = makeSimpleTagFromToken (token, K_ENUM, corkIndex); + int enumCorkIndex = makeSimpleTagFromToken (token, kindIndex, corkIndex); tokenRead (token); if (!tokenSkipToType (token, '{')) return; /* Unexpected sequence of token */ - parseEnumBody (token, enumCorkIndex); + parseEnumBody (token, elementKindIndex, enumCorkIndex); tagEntryInfo *e = getEntryInCorkQueue (enumCorkIndex); if (e) @@ -617,7 +617,9 @@ static void recurseValaTags (tokenInfo *token, int parentIndex) else if (tokenIsKeyword(token, CLASS)) parseClass (token, parentIndex); else if (tokenIsKeyword(token, ENUM)) - parseEnum (token, parentIndex); + parseEnum (token, K_ENUM, K_ENUMVALUE, parentIndex); + else if (tokenIsKeyword(token, ERRORDOMAIN)) + parseEnum (token, K_ERRORDOMAIN, K_ERRORCODE, parentIndex); else if (tokenIsType (token, IDENTIFIER)) parseStatement (token, parentIndex); } From 1eda73a6d7c17663e4d15f04678d35ee2fa6c8d4 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 20 Dec 2020 23:03:44 +0900 Subject: [PATCH 30/44] Vala: tag structs Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/value-types.d/args.ctags | 1 + Units/parser-vala.r/value-types.d/expected.tags | 4 ++++ Units/parser-vala.r/value-types.d/input.vala | 8 ++++++++ parsers/vala.c | 10 ++++++---- 4 files changed, 19 insertions(+), 4 deletions(-) create mode 100644 Units/parser-vala.r/value-types.d/args.ctags create mode 100644 Units/parser-vala.r/value-types.d/expected.tags create mode 100644 Units/parser-vala.r/value-types.d/input.vala diff --git a/Units/parser-vala.r/value-types.d/args.ctags b/Units/parser-vala.r/value-types.d/args.ctags new file mode 100644 index 0000000000..5ee5f79f70 --- /dev/null +++ b/Units/parser-vala.r/value-types.d/args.ctags @@ -0,0 +1 @@ +--sort=no diff --git a/Units/parser-vala.r/value-types.d/expected.tags b/Units/parser-vala.r/value-types.d/expected.tags new file mode 100644 index 0000000000..8a4c402219 --- /dev/null +++ b/Units/parser-vala.r/value-types.d/expected.tags @@ -0,0 +1,4 @@ +Vector input.vala /^struct Vector {$/;" s +x input.vala /^ public double x;$/;" f struct:Vector typeref:typename:double +y input.vala /^ public double y;$/;" f struct:Vector typeref:typename:double +z input.vala /^ public double z;$/;" f struct:Vector typeref:typename:double diff --git a/Units/parser-vala.r/value-types.d/input.vala b/Units/parser-vala.r/value-types.d/input.vala new file mode 100644 index 0000000000..9bd9688262 --- /dev/null +++ b/Units/parser-vala.r/value-types.d/input.vala @@ -0,0 +1,8 @@ +// Taken from https://naaando.gitbooks.io/the-vala-tutorial/content/en/3-basics/3.1-data-types/value-types.html + +/* defining a struct */ +struct Vector { + public double x; + public double y; + public double z; +} diff --git a/parsers/vala.c b/parsers/vala.c index 3337ddc7ca..601659273b 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -279,7 +279,7 @@ enum ValaTokenType { static void readToken (tokenInfo *const token, void *data); static void parseNamespace (tokenInfo *const token, int corkIndex); static void parseInterface (tokenInfo *const token, int corkIndex); -static void parseClass (tokenInfo *const token, int corkIndex); +static void parseClass (tokenInfo *const token, int kindIndex, int corkIndex); static void parseStatement (tokenInfo *const token, int corkIndex); static void parseEnum (tokenInfo *const token, int kindIndex, int elementKindIndex, int corkIndex); @@ -615,11 +615,13 @@ static void recurseValaTags (tokenInfo *token, int parentIndex) else if (tokenIsKeyword(token, INTERFACE)) parseInterface (token, parentIndex); else if (tokenIsKeyword(token, CLASS)) - parseClass (token, parentIndex); + parseClass (token, K_CLASS, parentIndex); else if (tokenIsKeyword(token, ENUM)) parseEnum (token, K_ENUM, K_ENUMVALUE, parentIndex); else if (tokenIsKeyword(token, ERRORDOMAIN)) parseEnum (token, K_ERRORDOMAIN, K_ERRORCODE, parentIndex); + else if (tokenIsKeyword (token, STRUCT)) + parseClass (token, K_STRUCT, parentIndex); else if (tokenIsType (token, IDENTIFIER)) parseStatement (token, parentIndex); } @@ -846,14 +848,14 @@ static void parseInheritanceList (tokenInfo *const token, int classIndex) vStringDelete (list); /* NULL is acceptable */ } -static void parseClass (tokenInfo *const token, int parentIndex) +static void parseClass (tokenInfo *const token, int kindIndex, int parentIndex) { tokenRead (token); if (!tokenIsType (token, IDENTIFIER)) return; /* Unexpected sequence of token */ readIdentifierExtended (token, NULL); - int classCorkIndex = makeSimpleTagFromToken (token, K_CLASS, parentIndex); + int classCorkIndex = makeSimpleTagFromToken (token, kindIndex, parentIndex); /* Parse the class definition. */ tokenRead (token); From 89ae0e9a33314ece08cb034af5c23c4e9c71a255 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Mon, 21 Dec 2020 00:24:04 +0900 Subject: [PATCH 31/44] Vala: tag fields having initializer Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/qnamed-class.d/expected.tags | 3 +++ Units/parser-vala.r/qnamed-class.d/input.vala | 3 +++ parsers/vala.c | 16 +++++++++++++--- 3 files changed, 19 insertions(+), 3 deletions(-) diff --git a/Units/parser-vala.r/qnamed-class.d/expected.tags b/Units/parser-vala.r/qnamed-class.d/expected.tags index 1010841659..2f4d3b28c3 100644 --- a/Units/parser-vala.r/qnamed-class.d/expected.tags +++ b/Units/parser-vala.r/qnamed-class.d/expected.tags @@ -1,3 +1,6 @@ X input.vala /^namespace X {$/;" n X.MyObject input.vala /^public class X.MyObject {$/;" c a input.vala /^ int a;$/;" f class:X.MyObject typeref:typename:int +b input.vala /^ int b = 1;$/;" f class:X.MyObject typeref:typename:int +c input.vala /^ int c = 2;$/;" f class:X.MyObject typeref:typename:int +d input.vala /^ int d;$/;" f class:X.MyObject typeref:typename:int diff --git a/Units/parser-vala.r/qnamed-class.d/input.vala b/Units/parser-vala.r/qnamed-class.d/input.vala index 09db8f1a96..95db054dfe 100644 --- a/Units/parser-vala.r/qnamed-class.d/input.vala +++ b/Units/parser-vala.r/qnamed-class.d/input.vala @@ -3,4 +3,7 @@ namespace X { public class X.MyObject { int a; + int b = 1; + int c = 2; + int d; } diff --git a/parsers/vala.c b/parsers/vala.c index 601659273b..4abdae6651 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -567,7 +567,8 @@ static void parseStatement (tokenInfo *const token, int parentIndex) static void parseEnumBody (tokenInfo *const token, int kindIndex, int corkIndex) { - bool s = tokenTypePairSetState (&valaTokenInfoClass, '<', false); + bool s = trianglePairState; + trianglePairState = false; while (!tokenIsEOF (token)) { tokenRead (token); @@ -584,7 +585,7 @@ static void parseEnumBody (tokenInfo *const token, int kindIndex, int corkIndex) break; } } - tokenTypePairSetState (&valaTokenInfoClass, '<', s); + trianglePairState = s; } static void parseEnum (tokenInfo *const token, int kindIndex, int elementKindIndex, int corkIndex) @@ -737,8 +738,17 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) } int kind; - if (tokenIsTypeVal (token, ';')) + if (tokenIsTypeVal (token, ';') + || tokenIsTypeVal (token, '=')) + { kind = K_FIELD; + if (tokenIsTypeVal (token, '=')) + { + bool s = trianglePairState; + tokenSkipToTypeOverPairs (token, ';'); + trianglePairState = s; + } + } else if (tokenIsTypeVal (token, '{')) kind = K_PROP; else From 3d83ef84bc75be727498b82337ed4b5efe6d5570 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Wed, 23 Dec 2020 12:47:44 +0900 Subject: [PATCH 32/44] Vala: accept an enumvalue with ending ',}' Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/enum.vala.d/expected.tags | 3 +++ Units/parser-vala.r/enum.vala.d/input.vala | 5 +++++ parsers/vala.c | 10 ++++++++++ 3 files changed, 18 insertions(+) diff --git a/Units/parser-vala.r/enum.vala.d/expected.tags b/Units/parser-vala.r/enum.vala.d/expected.tags index 0ea73be07d..a67e6124a9 100644 --- a/Units/parser-vala.r/enum.vala.d/expected.tags +++ b/Units/parser-vala.r/enum.vala.d/expected.tags @@ -19,4 +19,7 @@ SUPER_MASK input.vala /^ SUPER_MASK = 1 << 26,$/;" v enum:Skk.ModifierTyp HYPER_MASK input.vala /^ HYPER_MASK = 1 << 27,$/;" v enum:Skk.ModifierType META_MASK input.vala /^ META_MASK = 1 << 28,$/;" v enum:Skk.ModifierType RELEASE_MASK input.vala /^ RELEASE_MASK = 1 << 30$/;" v enum:Skk.ModifierType +ModifierType2 input.vala /^ public enum ModifierType2 {$/;" e namespace:Skk +ULTRA_MASK input.vala /^ ULTRA_MASK = 1 << 20,$/;" v enum:Skk.ModifierType2 +MIRACLE_MASK input.vala /^ MIRACLE_MASK = 1 << 21, \/\/ valac accept this.$/;" v enum:Skk.ModifierType2 KeyEvent input.vala /^ public class KeyEvent : Object {$/;" c namespace:Skk diff --git a/Units/parser-vala.r/enum.vala.d/input.vala b/Units/parser-vala.r/enum.vala.d/input.vala index 399985a685..64a21c3e34 100644 --- a/Units/parser-vala.r/enum.vala.d/input.vala +++ b/Units/parser-vala.r/enum.vala.d/input.vala @@ -53,6 +53,11 @@ namespace Skk { RELEASE_MASK = 1 << 30 } + public enum ModifierType2 { + ULTRA_MASK = 1 << 20, + MIRACLE_MASK = 1 << 21, // valac accept this. + } + /** * Object representing a key event. */ diff --git a/parsers/vala.c b/parsers/vala.c index 4abdae6651..d797e25e70 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -578,6 +578,16 @@ static void parseEnumBody (tokenInfo *const token, int kindIndex, int corkIndex) tokenType endMakers [] = {',', '}'}; if (tokenSkipToTypesOverPairs (token, endMakers, ARRAY_SIZE(endMakers))) { + if (tokenIsTypeVal (token, ',')) + { + tokenRead (token); + if (!tokenIsTypeVal (token, '}')) + { + tokenUnread (token); + continue; + } + } + if (tokenIsTypeVal (token, '}')) break; } From c74720c28316604a15106356b61c402510508e2d Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Wed, 23 Dec 2020 12:51:49 +0900 Subject: [PATCH 33/44] Vala: tag methods defined as parts of an enum Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/enum.vala.d/expected.tags | 5 +++++ Units/parser-vala.r/enum.vala.d/input.vala | 11 +++++++++++ parsers/vala.c | 16 +++++++++++++++- 3 files changed, 31 insertions(+), 1 deletion(-) diff --git a/Units/parser-vala.r/enum.vala.d/expected.tags b/Units/parser-vala.r/enum.vala.d/expected.tags index a67e6124a9..213e9a006c 100644 --- a/Units/parser-vala.r/enum.vala.d/expected.tags +++ b/Units/parser-vala.r/enum.vala.d/expected.tags @@ -22,4 +22,9 @@ RELEASE_MASK input.vala /^ RELEASE_MASK = 1 << 30$/;" v enum:Skk.Modifier ModifierType2 input.vala /^ public enum ModifierType2 {$/;" e namespace:Skk ULTRA_MASK input.vala /^ ULTRA_MASK = 1 << 20,$/;" v enum:Skk.ModifierType2 MIRACLE_MASK input.vala /^ MIRACLE_MASK = 1 << 21, \/\/ valac accept this.$/;" v enum:Skk.ModifierType2 +ModifierType3 input.vala /^ public enum ModifierType3 {$/;" e namespace:Skk +A_MASK input.vala /^ A_MASK = 1 << 29,$/;" v enum:Skk.ModifierType3 +B_MASK input.vala /^ B_MASK = 1 << 31;$/;" v enum:Skk.ModifierType3 +to_string0 input.vala /^ string to_string0() {$/;" m enum:Skk.ModifierType3 +to_string1 input.vala /^ string to_string1() {$/;" m enum:Skk.ModifierType3 KeyEvent input.vala /^ public class KeyEvent : Object {$/;" c namespace:Skk diff --git a/Units/parser-vala.r/enum.vala.d/input.vala b/Units/parser-vala.r/enum.vala.d/input.vala index 64a21c3e34..4d99cdd185 100644 --- a/Units/parser-vala.r/enum.vala.d/input.vala +++ b/Units/parser-vala.r/enum.vala.d/input.vala @@ -58,6 +58,17 @@ namespace Skk { MIRACLE_MASK = 1 << 21, // valac accept this. } + public enum ModifierType3 { + A_MASK = 1 << 29, + B_MASK = 1 << 31; + string to_string0() { + return ""; + } + string to_string1() { + return ""; + } + } + /** * Object representing a key event. */ diff --git a/parsers/vala.c b/parsers/vala.c index d797e25e70..068883c570 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -282,6 +282,7 @@ static void parseInterface (tokenInfo *const token, int corkIndex); static void parseClass (tokenInfo *const token, int kindIndex, int corkIndex); static void parseStatement (tokenInfo *const token, int corkIndex); static void parseEnum (tokenInfo *const token, int kindIndex, int elementKindIndex, int corkIndex); +static void recurseValaTags (tokenInfo *token, int parentIndex); /* @@ -575,7 +576,7 @@ static void parseEnumBody (tokenInfo *const token, int kindIndex, int corkIndex) if (tokenIsType (token, IDENTIFIER)) { makeSimpleTagFromToken (token, kindIndex, corkIndex); - tokenType endMakers [] = {',', '}'}; + tokenType endMakers [] = {',', ';', '}'}; if (tokenSkipToTypesOverPairs (token, endMakers, ARRAY_SIZE(endMakers))) { if (tokenIsTypeVal (token, ',')) @@ -590,6 +591,19 @@ static void parseEnumBody (tokenInfo *const token, int kindIndex, int corkIndex) if (tokenIsTypeVal (token, '}')) break; + else if (tokenIsTypeVal (token, ';')) + { + bool t = trianglePairState; + do + { + tokenRead (token); + if (tokenIsTypeVal (token, '}')) + break; + recurseValaTags (token, corkIndex); + } while (!tokenIsEOF (token)); + trianglePairState = t; + break; + } } else break; From 8e16ea913a23240f26cc931dbd2a514a1a870f02 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 06:06:58 +0900 Subject: [PATCH 34/44] Vala: handle "static" keyword in class definitions Signed-off-by: Masatake YAMATO --- .../stdout-expected.txt | 1 + Tmain/list-fields.d/stdout-expected.txt | 1 + .../parser-vala.r/class.vala.d/expected.tags | 5 +++-- Units/parser-vala.r/class.vala.d/input.vala | 2 ++ parsers/vala.c | 21 +++++++++++++++++++ 5 files changed, 28 insertions(+), 2 deletions(-) diff --git a/Tmain/list-fields-with-prefix.d/stdout-expected.txt b/Tmain/list-fields-with-prefix.d/stdout-expected.txt index 898a490932..8fd19ed4db 100644 --- a/Tmain/list-fields-with-prefix.d/stdout-expected.txt +++ b/Tmain/list-fields-with-prefix.d/stdout-expected.txt @@ -44,4 +44,5 @@ x UCTAGSxpath no NONE s-- no -- xpath for - UCTAGStarget yes Thrift s-- no -- the target language specified at "namespace" - UCTAGSthrows yes Thrift s-- no -- throws list of function - UCTAGSarchitecture yes VHDL s-- no -- architecture designing the entity +- UCTAGSproperties yes Vala s-- no -- properties (static) - UCTAGSparameter no Verilog --b no -- parameter whose value can be overridden. diff --git a/Tmain/list-fields.d/stdout-expected.txt b/Tmain/list-fields.d/stdout-expected.txt index d05ad961de..5da66406d4 100644 --- a/Tmain/list-fields.d/stdout-expected.txt +++ b/Tmain/list-fields.d/stdout-expected.txt @@ -62,6 +62,7 @@ z kind no NONE s-- no r- [tags output] prepend "kind:" to k/ (or K/) field outpu - target yes Thrift s-- no -- the target language specified at "namespace" - throws yes Thrift s-- no -- throws list of function - architecture yes VHDL s-- no -- architecture designing the entity +- properties yes Vala s-- no -- properties (static) - parameter no Verilog --b no -- parameter whose value can be overridden. # Foo input.java /^abstract public class Foo extends Bar$/ diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index df8763026b..d16cce4c3a 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -5,8 +5,9 @@ city input.vala /^ public string city;$/;" field line:17 language:Vala class:A street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string access:protected end:18 building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int access:internal end:19 floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int access:private end:20 -Person input.vala /^class Person {$/;" class line:23 language:Vala end:38 +Person input.vala /^class Person {$/;" class line:23 language:Vala end:40 address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address access:public end:24 name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string access:public end:25 d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int access:private end:26 -age input.vala /^ public int age {$/;" property line:28 language:Vala class:Person typeref:typename:int access:public end:37 +population input.vala /^ static int population;$/;" field line:28 language:Vala class:Person typeref:typename:int end:28 properties:static +age input.vala /^ public int age {$/;" property line:30 language:Vala class:Person typeref:typename:int access:public end:39 diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index b51908a1d2..45353b379f 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -25,6 +25,8 @@ class Person { public string name {get; set;} private int d_age; + static int population; + public int age { get { return d_age;} set { diff --git a/parsers/vala.c b/parsers/vala.c index 068883c570..2361b069ee 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -271,6 +271,15 @@ enum ValaTokenType { TOKEN_STRING, }; +typedef enum { + F_PROPERTIES, +} valaField; + +static fieldDefinition ValaFields[] = { + { .name = "properties", + .description = "properties (static)", + .enabled = true }, +}; /* * FUNCTION PROTOTYPES @@ -725,6 +734,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) do { + bool seen_static = false; tokenRead (token); if (tokenIsTypeVal (token, '}')) break; @@ -736,6 +746,12 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) tokenRead (token); } + if (tokenIsKeyword(token, STATIC)) + { + seen_static = true; + tokenRead (token); + } + if (tokenIsType (token, IDENTIFIER) || tokenIsType (token, KEYWORD)) tokenCopy (typerefToken, token); @@ -799,6 +815,9 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) * ctags-7.0.0. */ "unknown"); entry->extensionFields.typeRef [1] = vStringStrdup(typerefToken->string); + /* Fill prototypes field. */ + if (seen_static) + attachParserField(entry, ValaFields[F_PROPERTIES].ftype, "static"); if (kind == K_PROP) tokenSkipOverPair (token); @@ -934,6 +953,8 @@ extern parserDefinition* ValaParser (void) def->extensions = extensions; def->keywordTable = ValaKeywordTable; def->keywordCount = ARRAY_SIZE (ValaKeywordTable); + def->fieldTable = ValaFields; + def->fieldCount = ARRAY_SIZE (ValaFields); def->useCork = true; def->requestAutomaticFQTag = true; From 968fa7ccc68b0fcb15e143797ba6fd1ca84317da Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 06:16:27 +0900 Subject: [PATCH 35/44] Vala: skip construct keyword Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/construct.d/args.ctags | 1 + Units/parser-vala.r/construct.d/expected.tags | 2 ++ Units/parser-vala.r/construct.d/input.vala | 7 +++++++ parsers/vala.c | 10 ++++++++++ 4 files changed, 20 insertions(+) create mode 100644 Units/parser-vala.r/construct.d/args.ctags create mode 100644 Units/parser-vala.r/construct.d/expected.tags create mode 100644 Units/parser-vala.r/construct.d/input.vala diff --git a/Units/parser-vala.r/construct.d/args.ctags b/Units/parser-vala.r/construct.d/args.ctags new file mode 100644 index 0000000000..5ee5f79f70 --- /dev/null +++ b/Units/parser-vala.r/construct.d/args.ctags @@ -0,0 +1 @@ +--sort=no diff --git a/Units/parser-vala.r/construct.d/expected.tags b/Units/parser-vala.r/construct.d/expected.tags new file mode 100644 index 0000000000..8cf463b109 --- /dev/null +++ b/Units/parser-vala.r/construct.d/expected.tags @@ -0,0 +1,2 @@ +Abc input.vala /^class Abc : Object {$/;" c +main input.vala /^void main(string[] args) {}$/;" m diff --git a/Units/parser-vala.r/construct.d/input.vala b/Units/parser-vala.r/construct.d/input.vala new file mode 100644 index 0000000000..16b2c60637 --- /dev/null +++ b/Units/parser-vala.r/construct.d/input.vala @@ -0,0 +1,7 @@ +using GLib; + +class Abc : Object { + construct {} +} + +void main(string[] args) {} diff --git a/parsers/vala.c b/parsers/vala.c index 2361b069ee..64d4090b5c 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -751,6 +751,16 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) seen_static = true; tokenRead (token); } + else if (tokenIsKeyword(token, CONSTRUCT)) + { + tokenRead (token); + if (tokenIsTypeVal (token, '{')) + { + /* TODO: we can make an anonymous tag for the constructor. */ + tokenSkipOverPair (token); + continue; + } + } if (tokenIsType (token, IDENTIFIER) || tokenIsType (token, KEYWORD)) From 46f6b90bebe0ed4d2cfbcea75e6386b3a28ae16b Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 07:36:50 +0900 Subject: [PATCH 36/44] Vala: extract methods Signed-off-by: Masatake YAMATO --- .../parser-vala.r/class.vala.d/expected.tags | 3 +- Units/parser-vala.r/class.vala.d/input.vala | 3 ++ parsers/vala.c | 47 ++++++++++++++----- 3 files changed, 40 insertions(+), 13 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index d16cce4c3a..6d60dc2991 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -5,9 +5,10 @@ city input.vala /^ public string city;$/;" field line:17 language:Vala class:A street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string access:protected end:18 building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int access:internal end:19 floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int access:private end:20 -Person input.vala /^class Person {$/;" class line:23 language:Vala end:40 +Person input.vala /^class Person {$/;" class line:23 language:Vala end:43 address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address access:public end:24 name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string access:public end:25 d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int access:private end:26 population input.vala /^ static int population;$/;" field line:28 language:Vala class:Person typeref:typename:int end:28 properties:static age input.vala /^ public int age {$/;" property line:30 language:Vala class:Person typeref:typename:int access:public end:39 +getLastAge input.vala /^ int getLastAge (int n) throws GLib.Error { return d_age - n; }$/;" method line:41 language:Vala class:Person typeref:typename:int signature:(int n) end:41 diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index 45353b379f..a8a1a4c8bc 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -37,4 +37,7 @@ class Person { } } } + + int getLastAge (int n) throws GLib.Error { return d_age - n; } + } diff --git a/parsers/vala.c b/parsers/vala.c index 64d4090b5c..a3ac7e7707 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -289,7 +289,7 @@ static void readToken (tokenInfo *const token, void *data); static void parseNamespace (tokenInfo *const token, int corkIndex); static void parseInterface (tokenInfo *const token, int corkIndex); static void parseClass (tokenInfo *const token, int kindIndex, int corkIndex); -static void parseStatement (tokenInfo *const token, int corkIndex); +static int parseStatement (tokenInfo *const token, int corkIndex); static void parseEnum (tokenInfo *const token, int kindIndex, int elementKindIndex, int corkIndex); static void recurseValaTags (tokenInfo *token, int parentIndex); @@ -529,11 +529,12 @@ static tokenInfo *newValaToken (void) return newToken (&valaTokenInfoClass); } -static void parseStatement (tokenInfo *const token, int parentIndex) +static int parseStatement (tokenInfo *const token, int parentIndex) { tokenInfo *lastToken = newValaToken (); bool foundSignature = false; tagEntryInfo *e = NULL; + int corkIndex = CORK_NIL; do { @@ -545,7 +546,7 @@ static void parseStatement (tokenInfo *const token, int parentIndex) tokenSkipOverPair (token); else { - int corkIndex = makeSimpleTagFromToken (lastToken, K_METHOD, parentIndex); + corkIndex = makeSimpleTagFromToken (lastToken, K_METHOD, parentIndex); e = getEntryInCorkQueue (corkIndex); if (e) { @@ -573,6 +574,8 @@ static void parseStatement (tokenInfo *const token, int parentIndex) e->extensionFields.endLine = token->lineNumber; tokenDelete (lastToken); + + return corkIndex; } static void parseEnumBody (tokenInfo *const token, int kindIndex, int corkIndex) @@ -776,19 +779,36 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) if (!readIdentifierExtended (typerefToken, &typerefIsClass)) goto out; + bool nameFound = false; tokenRead (token); if (tokenIsType (token, IDENTIFIER)) + { tokenCopy (nameToken, token); + nameFound = true; + } - /* Argument list for a method */ + int kind = KIND_GHOST_INDEX; + int methodIndex = CORK_NIL; tokenRead (token); - if (tokenIsTypeVal (token, '(')) { - tokenSkipOverPair (token); - tokenRead (token); + if (tokenIsTypeVal (token, '(')) + { + if (nameFound) + { + /* Method */ + tokenUnread(token); + tokenCopy (token, nameToken); + methodIndex = parseStatement (token, classCorkIndex); + tagEntryInfo *e = getEntryInCorkQueue (methodIndex); + if (e && e->kindIndex == K_METHOD) + kind = e->kindIndex; + } + else + { + tokenSkipOverPair (token); + tokenRead (token); + } } - - int kind; - if (tokenIsTypeVal (token, ';') + else if (tokenIsTypeVal (token, ';') || tokenIsTypeVal (token, '=')) { kind = K_FIELD; @@ -804,7 +824,9 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) else break; /* Unexpected sequence of token */ - int memberCorkIndex = makeSimpleTagFromToken (nameToken, kind, classCorkIndex); + int memberCorkIndex = methodIndex == CORK_NIL + ? makeSimpleTagFromToken (nameToken, kind, classCorkIndex) + : methodIndex; tagEntryInfo *entry = getEntryInCorkQueue (memberCorkIndex); /* Fill access field. */ @@ -831,7 +853,8 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) if (kind == K_PROP) tokenSkipOverPair (token); - entry->extensionFields.endLine = token->lineNumber; + if (kind != K_METHOD) + entry->extensionFields.endLine = token->lineNumber; } while (!tokenIsEOF (token)); out: From 09ca9631eb9bde1ad582b6f202ed7c95ab48b4fc Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 07:47:39 +0900 Subject: [PATCH 37/44] Vala: skip array markers Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/class.vala.d/expected.tags | 3 ++- Units/parser-vala.r/class.vala.d/input.vala | 1 + parsers/vala.c | 3 +++ 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index 6d60dc2991..e06c39589e 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -5,10 +5,11 @@ city input.vala /^ public string city;$/;" field line:17 language:Vala class:A street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string access:protected end:18 building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int access:internal end:19 floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int access:private end:20 -Person input.vala /^class Person {$/;" class line:23 language:Vala end:43 +Person input.vala /^class Person {$/;" class line:23 language:Vala end:44 address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address access:public end:24 name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string access:public end:25 d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int access:private end:26 population input.vala /^ static int population;$/;" field line:28 language:Vala class:Person typeref:typename:int end:28 properties:static age input.vala /^ public int age {$/;" property line:30 language:Vala class:Person typeref:typename:int access:public end:39 getLastAge input.vala /^ int getLastAge (int n) throws GLib.Error { return d_age - n; }$/;" method line:41 language:Vala class:Person typeref:typename:int signature:(int n) end:41 +table input.vala /^ string [] table = {"a", "b"};$/;" field line:43 language:Vala class:Person typeref:typename:string end:43 diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index a8a1a4c8bc..4013dcdd91 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -40,4 +40,5 @@ class Person { int getLastAge (int n) throws GLib.Error { return d_age - n; } + string [] table = {"a", "b"}; } diff --git a/parsers/vala.c b/parsers/vala.c index a3ac7e7707..feb98ff9a2 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -704,6 +704,9 @@ static bool readIdentifierExtended (tokenInfo *const resultToken, bool *extended else if (tokenIsTypeVal (token, '<')) /* Skip over generic type parameter. */ tokenSkipOverPair (token); + else if (tokenIsTypeVal (token, '[')) + /* Skip over array. */ + tokenSkipOverPair (token); else if (tokenIsType (token, IDENTIFIER)) { if (tokenLast (resultToken) == '.') From 7a1c04ce1b4bd3565ba4d5866ff56221e64eea90 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 07:56:07 +0900 Subject: [PATCH 38/44] Vala: skip const keyword Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/class.vala.d/expected.tags | 3 ++- Units/parser-vala.r/class.vala.d/input.vala | 1 + parsers/vala.c | 5 +++++ 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index e06c39589e..99d243dff6 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -5,7 +5,7 @@ city input.vala /^ public string city;$/;" field line:17 language:Vala class:A street input.vala /^ protected string street;$/;" field line:18 language:Vala class:Address typeref:typename:string access:protected end:18 building input.vala /^ internal int building;$/;" field line:19 language:Vala class:Address typeref:typename:int access:internal end:19 floor input.vala /^ private int floor;$/;" field line:20 language:Vala class:Address typeref:typename:int access:private end:20 -Person input.vala /^class Person {$/;" class line:23 language:Vala end:44 +Person input.vala /^class Person {$/;" class line:23 language:Vala end:45 address input.vala /^ public Address address {get; set;}$/;" property line:24 language:Vala class:Person typeref:unknown:Address access:public end:24 name input.vala /^ public string name {get; set;}$/;" property line:25 language:Vala class:Person typeref:typename:string access:public end:25 d_age input.vala /^ private int d_age;$/;" field line:26 language:Vala class:Person typeref:typename:int access:private end:26 @@ -13,3 +13,4 @@ population input.vala /^ static int population;$/;" field line:28 language:Val age input.vala /^ public int age {$/;" property line:30 language:Vala class:Person typeref:typename:int access:public end:39 getLastAge input.vala /^ int getLastAge (int n) throws GLib.Error { return d_age - n; }$/;" method line:41 language:Vala class:Person typeref:typename:int signature:(int n) end:41 table input.vala /^ string [] table = {"a", "b"};$/;" field line:43 language:Vala class:Person typeref:typename:string end:43 +ctable input.vala /^ const string [] ctable = {"a", "b"};$/;" field line:44 language:Vala class:Person typeref:typename:string end:44 diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index 4013dcdd91..7a80707d0f 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -41,4 +41,5 @@ class Person { int getLastAge (int n) throws GLib.Error { return d_age - n; } string [] table = {"a", "b"}; + const string [] ctable = {"a", "b"}; } diff --git a/parsers/vala.c b/parsers/vala.c index feb98ff9a2..9addb21aa3 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -767,6 +767,11 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) continue; } } + else if (tokenIsKeyword(token, CONST)) + { + /* TODO: we can record "const" to "properties:" field. */ + tokenRead (token); + } if (tokenIsType (token, IDENTIFIER) || tokenIsType (token, KEYWORD)) From 1d6ab3394043c06202c9b1a80baee6e2613a3236 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 08:31:20 +0900 Subject: [PATCH 39/44] Vala: extract constructors as method Signed-off-by: Masatake YAMATO --- .../parser-vala.r/class.vala.d/expected.tags | 3 + Units/parser-vala.r/class.vala.d/input.vala | 7 +++ parsers/vala.c | 58 +++++++++++++------ 3 files changed, 49 insertions(+), 19 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index 99d243dff6..9f30d49d31 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -14,3 +14,6 @@ age input.vala /^ public int age {$/;" property line:30 language:Vala class:Pe getLastAge input.vala /^ int getLastAge (int n) throws GLib.Error { return d_age - n; }$/;" method line:41 language:Vala class:Person typeref:typename:int signature:(int n) end:41 table input.vala /^ string [] table = {"a", "b"};$/;" field line:43 language:Vala class:Person typeref:typename:string end:43 ctable input.vala /^ const string [] ctable = {"a", "b"};$/;" field line:44 language:Vala class:Person typeref:typename:string end:44 +Car input.vala /^public class Car {$/;" class line:47 language:Vala end:52 +n_seat input.vala /^ public int n_seat;$/;" field line:48 language:Vala class:Car typeref:typename:int access:public end:48 +Car input.vala /^ public Car () {$/;" method line:49 language:Vala class:Car access:public signature:() end:51 diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index 7a80707d0f..cf173b82ee 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -43,3 +43,10 @@ class Person { string [] table = {"a", "b"}; const string [] ctable = {"a", "b"}; } + +public class Car { + public int n_seat; + public Car () { + n_seat = 0; + } +} diff --git a/parsers/vala.c b/parsers/vala.c index 9addb21aa3..2704b466d0 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -737,6 +737,13 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) char *visiblity = NULL; tokenInfo *typerefToken = newValaToken (); tokenInfo *nameToken = newValaToken (); + const char *className = NULL; + + { + tagEntryInfo *e = getEntryInCorkQueue (classCorkIndex); + if (e) + className = e->name; + } do { @@ -784,8 +791,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) } bool typerefIsClass; - if (!readIdentifierExtended (typerefToken, &typerefIsClass)) - goto out; + readIdentifierExtended (typerefToken, &typerefIsClass); bool nameFound = false; tokenRead (token); @@ -793,11 +799,12 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) { tokenCopy (nameToken, token); nameFound = true; + tokenRead (token); } int kind = KIND_GHOST_INDEX; int methodIndex = CORK_NIL; - tokenRead (token); + bool is_name_constructor = false; if (tokenIsTypeVal (token, '(')) { if (nameFound) @@ -810,6 +817,17 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) if (e && e->kindIndex == K_METHOD) kind = e->kindIndex; } + else if (strcmp (vStringValue (typerefToken->string), className) == 0) + { + /* Constructor */ + tokenUnread(token); + tokenCopy (token, typerefToken); + is_name_constructor = true; + methodIndex = parseStatement (token, classCorkIndex); + tagEntryInfo *e = getEntryInCorkQueue (methodIndex); + if (e && e->kindIndex == K_METHOD) + kind = e->kindIndex; + } else { tokenSkipOverPair (token); @@ -840,21 +858,24 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) /* Fill access field. */ entry->extensionFields.access = visiblity; visiblity = NULL; - /* Fill typeref field. */ - entry->extensionFields.typeRef [0] = eStrdup ( - typerefIsClass? - /* '.' is included in typeref name. Can I expect it as a class? - */ - "class" - :tokenIsType (typerefToken, KEYWORD)? - /* "typename" is choice in C++ parser. However, "builtin" may be - * better. See #862. This should be fixed in ctags-6.0.0. */ - "typename" - : - /* Till we implement symbol table, we cannot resolve this. - * ctags-7.0.0. */ - "unknown"); - entry->extensionFields.typeRef [1] = vStringStrdup(typerefToken->string); + if (!is_name_constructor) + { + /* Fill typeref field. */ + entry->extensionFields.typeRef [0] = eStrdup ( + typerefIsClass? + /* '.' is included in typeref name. Can I expect it as a class? + */ + "class" + :tokenIsType (typerefToken, KEYWORD)? + /* "typename" is choice in C++ parser. However, "builtin" may be + * better. See #862. This should be fixed in ctags-6.0.0. */ + "typename" + : + /* Till we implement symbol table, we cannot resolve this. + * ctags-7.0.0. */ + "unknown"); + entry->extensionFields.typeRef [1] = vStringStrdup(typerefToken->string); + } /* Fill prototypes field. */ if (seen_static) attachParserField(entry, ValaFields[F_PROPERTIES].ftype, "static"); @@ -865,7 +886,6 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) entry->extensionFields.endLine = token->lineNumber; } while (!tokenIsEOF (token)); - out: if (visiblity) eFree (visiblity); tokenDelete (typerefToken); From 483df07f90c0ed72c32ffd0d2d28d12c7785e0eb Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 08:44:20 +0900 Subject: [PATCH 40/44] Vala: skip the combinations of const and static Signed-off-by: Masatake YAMATO --- .../parser-vala.r/class.vala.d/expected.tags | 3 ++- Units/parser-vala.r/class.vala.d/input.vala | 1 + parsers/vala.c | 24 ++++++++++++------- 3 files changed, 18 insertions(+), 10 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index 9f30d49d31..742c24907d 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -14,6 +14,7 @@ age input.vala /^ public int age {$/;" property line:30 language:Vala class:Pe getLastAge input.vala /^ int getLastAge (int n) throws GLib.Error { return d_age - n; }$/;" method line:41 language:Vala class:Person typeref:typename:int signature:(int n) end:41 table input.vala /^ string [] table = {"a", "b"};$/;" field line:43 language:Vala class:Person typeref:typename:string end:43 ctable input.vala /^ const string [] ctable = {"a", "b"};$/;" field line:44 language:Vala class:Person typeref:typename:string end:44 -Car input.vala /^public class Car {$/;" class line:47 language:Vala end:52 +Car input.vala /^public class Car {$/;" class line:47 language:Vala end:53 n_seat input.vala /^ public int n_seat;$/;" field line:48 language:Vala class:Car typeref:typename:int access:public end:48 Car input.vala /^ public Car () {$/;" method line:49 language:Vala class:Car access:public signature:() end:51 +sctable input.vala /^ static const string [] sctable = {"a", "b"};$/;" field line:52 language:Vala class:Car typeref:typename:string end:52 properties:static diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index cf173b82ee..3c26e85959 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -49,4 +49,5 @@ public class Car { public Car () { n_seat = 0; } + static const string [] sctable = {"a", "b"}; } diff --git a/parsers/vala.c b/parsers/vala.c index 2704b466d0..bdbfc9f1f8 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -759,12 +759,23 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) tokenRead (token); } - if (tokenIsKeyword(token, STATIC)) + while (true) { - seen_static = true; - tokenRead (token); + if (tokenIsKeyword(token, STATIC)) + { + seen_static = true; + tokenRead (token); + } + else if (tokenIsKeyword(token, CONST)) + { + /* TODO: we can record "const" to "properties:" field. */ + tokenRead (token); + } + else + break; } - else if (tokenIsKeyword(token, CONSTRUCT)) + + if (tokenIsKeyword(token, CONSTRUCT)) { tokenRead (token); if (tokenIsTypeVal (token, '{')) @@ -774,11 +785,6 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) continue; } } - else if (tokenIsKeyword(token, CONST)) - { - /* TODO: we can record "const" to "properties:" field. */ - tokenRead (token); - } if (tokenIsType (token, IDENTIFIER) || tokenIsType (token, KEYWORD)) From fdce7ff8cac7f18a20f35ecc6de6cf0b0c5a9002 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 08:47:37 +0900 Subject: [PATCH 41/44] Vala: skip "new" keyword Signed-off-by: Masatake YAMATO --- Units/parser-vala.r/class.vala.d/expected.tags | 3 ++- Units/parser-vala.r/class.vala.d/input.vala | 5 +++++ parsers/vala.c | 3 ++- 3 files changed, 9 insertions(+), 2 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index 742c24907d..a8be363c2b 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -14,7 +14,8 @@ age input.vala /^ public int age {$/;" property line:30 language:Vala class:Pe getLastAge input.vala /^ int getLastAge (int n) throws GLib.Error { return d_age - n; }$/;" method line:41 language:Vala class:Person typeref:typename:int signature:(int n) end:41 table input.vala /^ string [] table = {"a", "b"};$/;" field line:43 language:Vala class:Person typeref:typename:string end:43 ctable input.vala /^ const string [] ctable = {"a", "b"};$/;" field line:44 language:Vala class:Person typeref:typename:string end:44 -Car input.vala /^public class Car {$/;" class line:47 language:Vala end:53 +Car input.vala /^public class Car {$/;" class line:47 language:Vala end:58 n_seat input.vala /^ public int n_seat;$/;" field line:48 language:Vala class:Car typeref:typename:int access:public end:48 Car input.vala /^ public Car () {$/;" method line:49 language:Vala class:Car access:public signature:() end:51 sctable input.vala /^ static const string [] sctable = {"a", "b"};$/;" field line:52 language:Vala class:Car typeref:typename:string end:52 properties:static +@get input.vala /^ public new string? @get (string key) {$/;" method line:54 language:Vala class:Car typeref:typename:string access:public signature:(string key) end:56 diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index 3c26e85959..8c9685e662 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -50,4 +50,9 @@ public class Car { n_seat = 0; } static const string [] sctable = {"a", "b"}; + + public new string? @get (string key) { + return null; + } + } diff --git a/parsers/vala.c b/parsers/vala.c index bdbfc9f1f8..8013126d0c 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -766,7 +766,8 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) seen_static = true; tokenRead (token); } - else if (tokenIsKeyword(token, CONST)) + else if (tokenIsKeyword(token, CONST) + || tokenIsKeyword(token, NEW)) { /* TODO: we can record "const" to "properties:" field. */ tokenRead (token); From 041961cbfea47b5da4423532b60cdaabb27eeffb Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 09:14:41 +0900 Subject: [PATCH 42/44] Vala: extract signals Signed-off-by: Masatake YAMATO --- .../parser-vala.r/class.vala.d/expected.tags | 4 +++- Units/parser-vala.r/class.vala.d/input.vala | 2 ++ parsers/vala.c | 19 +++++++++++++++++-- 3 files changed, 22 insertions(+), 3 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index a8be363c2b..a320aa1e5d 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -14,8 +14,10 @@ age input.vala /^ public int age {$/;" property line:30 language:Vala class:Pe getLastAge input.vala /^ int getLastAge (int n) throws GLib.Error { return d_age - n; }$/;" method line:41 language:Vala class:Person typeref:typename:int signature:(int n) end:41 table input.vala /^ string [] table = {"a", "b"};$/;" field line:43 language:Vala class:Person typeref:typename:string end:43 ctable input.vala /^ const string [] ctable = {"a", "b"};$/;" field line:44 language:Vala class:Person typeref:typename:string end:44 -Car input.vala /^public class Car {$/;" class line:47 language:Vala end:58 +Car input.vala /^public class Car {$/;" class line:47 language:Vala end:60 n_seat input.vala /^ public int n_seat;$/;" field line:48 language:Vala class:Car typeref:typename:int access:public end:48 Car input.vala /^ public Car () {$/;" method line:49 language:Vala class:Car access:public signature:() end:51 sctable input.vala /^ static const string [] sctable = {"a", "b"};$/;" field line:52 language:Vala class:Car typeref:typename:string end:52 properties:static @get input.vala /^ public new string? @get (string key) {$/;" method line:54 language:Vala class:Car typeref:typename:string access:public signature:(string key) end:56 +value_changed input.vala /^ public signal void value_changed (string name, Variant value);$/;" signal line:58 language:Vala class:Car typeref:typename:void access:public signature:(string name, Variant value) end:58 +addSeat input.vala /^ int addSeat (int n) { return n_seat + n; }$/;" method line:59 language:Vala class:Car typeref:typename:int signature:(int n) end:59 diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index 8c9685e662..d5ba5821c8 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -55,4 +55,6 @@ public class Car { return null; } + public signal void value_changed (string name, Variant value); + int addSeat (int n) { return n_seat + n; } } diff --git a/parsers/vala.c b/parsers/vala.c index 8013126d0c..f6aacabd14 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -566,7 +566,12 @@ static int parseStatement (tokenInfo *const token, int parentIndex) /* Skip the body of method */ if (foundSignature) { - if (tokenSkipToType (token, '{')) + while (! (tokenIsTypeVal (token, '{') + || tokenIsTypeVal (token, ';') + || tokenIsEOF (token))) + tokenRead (token); + + if (tokenIsTypeVal (token, '{')) tokenSkipOverPair (token); } @@ -747,6 +752,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) do { + bool seen_signal = false; bool seen_static = false; tokenRead (token); if (tokenIsTypeVal (token, '}')) @@ -766,6 +772,11 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) seen_static = true; tokenRead (token); } + else if (tokenIsKeyword(token, SIGNAL)) + { + seen_signal = true; + tokenRead (token); + } else if (tokenIsKeyword(token, CONST) || tokenIsKeyword(token, NEW)) { @@ -822,7 +833,11 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) methodIndex = parseStatement (token, classCorkIndex); tagEntryInfo *e = getEntryInCorkQueue (methodIndex); if (e && e->kindIndex == K_METHOD) + { + if (seen_signal) + e->kindIndex = K_SIGNAL; kind = e->kindIndex; + } } else if (strcmp (vStringValue (typerefToken->string), className) == 0) { @@ -889,7 +904,7 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) if (kind == K_PROP) tokenSkipOverPair (token); - if (kind != K_METHOD) + if (kind != K_METHOD && kind != K_SIGNAL) entry->extensionFields.endLine = token->lineNumber; } while (!tokenIsEOF (token)); From b3426b1e3247b9b1d7e7e303d269fd606e81e8a3 Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 09:38:08 +0900 Subject: [PATCH 43/44] Vala: let recurseValaTags return whether it handles something or not Signed-off-by: Masatake YAMATO --- parsers/vala.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/parsers/vala.c b/parsers/vala.c index f6aacabd14..c6c4c52771 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -291,7 +291,7 @@ static void parseInterface (tokenInfo *const token, int corkIndex); static void parseClass (tokenInfo *const token, int kindIndex, int corkIndex); static int parseStatement (tokenInfo *const token, int corkIndex); static void parseEnum (tokenInfo *const token, int kindIndex, int elementKindIndex, int corkIndex); -static void recurseValaTags (tokenInfo *token, int parentIndex); +static bool recurseValaTags (tokenInfo *token, int parentIndex); /* @@ -647,8 +647,9 @@ static void parseEnum (tokenInfo *const token, int kindIndex, int elementKindInd e->extensionFields.endLine = token->lineNumber; } -static void recurseValaTags (tokenInfo *token, int parentIndex) +static bool recurseValaTags (tokenInfo *token, int parentIndex) { + bool r = true; /* Skip attributes */ if (tokenIsTypeVal (token, '[')) tokenSkipOverPair (token); @@ -666,6 +667,10 @@ static void recurseValaTags (tokenInfo *token, int parentIndex) parseClass (token, K_STRUCT, parentIndex); else if (tokenIsType (token, IDENTIFIER)) parseStatement (token, parentIndex); + else + r = false; + + return r; } static void parseNamespaceBody (tokenInfo *const token, int parentIndex) From bb54fdb695e278972236cbaff12ae41bc19d538b Mon Sep 17 00:00:00 2001 From: Masatake YAMATO Date: Sun, 10 Dec 2023 09:39:14 +0900 Subject: [PATCH 44/44] Vala: handle nested classes Signed-off-by: Masatake YAMATO --- .../parser-vala.r/class.vala.d/expected.tags | 5 ++++- Units/parser-vala.r/class.vala.d/input.vala | 6 +++++ parsers/vala.c | 22 ++++++++++++++----- 3 files changed, 26 insertions(+), 7 deletions(-) diff --git a/Units/parser-vala.r/class.vala.d/expected.tags b/Units/parser-vala.r/class.vala.d/expected.tags index a320aa1e5d..edfe138fcf 100644 --- a/Units/parser-vala.r/class.vala.d/expected.tags +++ b/Units/parser-vala.r/class.vala.d/expected.tags @@ -14,10 +14,13 @@ age input.vala /^ public int age {$/;" property line:30 language:Vala class:Pe getLastAge input.vala /^ int getLastAge (int n) throws GLib.Error { return d_age - n; }$/;" method line:41 language:Vala class:Person typeref:typename:int signature:(int n) end:41 table input.vala /^ string [] table = {"a", "b"};$/;" field line:43 language:Vala class:Person typeref:typename:string end:43 ctable input.vala /^ const string [] ctable = {"a", "b"};$/;" field line:44 language:Vala class:Person typeref:typename:string end:44 -Car input.vala /^public class Car {$/;" class line:47 language:Vala end:60 +Car input.vala /^public class Car {$/;" class line:47 language:Vala end:66 n_seat input.vala /^ public int n_seat;$/;" field line:48 language:Vala class:Car typeref:typename:int access:public end:48 Car input.vala /^ public Car () {$/;" method line:49 language:Vala class:Car access:public signature:() end:51 sctable input.vala /^ static const string [] sctable = {"a", "b"};$/;" field line:52 language:Vala class:Car typeref:typename:string end:52 properties:static @get input.vala /^ public new string? @get (string key) {$/;" method line:54 language:Vala class:Car typeref:typename:string access:public signature:(string key) end:56 value_changed input.vala /^ public signal void value_changed (string name, Variant value);$/;" signal line:58 language:Vala class:Car typeref:typename:void access:public signature:(string name, Variant value) end:58 addSeat input.vala /^ int addSeat (int n) { return n_seat + n; }$/;" method line:59 language:Vala class:Car typeref:typename:int signature:(int n) end:59 +Seat input.vala /^ public class Seat {$/;" class line:61 language:Vala class:Car end:63 +x input.vala /^ int x;$/;" field line:62 language:Vala class:Car.Seat typeref:typename:int end:62 +more input.vala /^ public int more;$/;" field line:65 language:Vala class:Car typeref:typename:int access:public end:65 diff --git a/Units/parser-vala.r/class.vala.d/input.vala b/Units/parser-vala.r/class.vala.d/input.vala index d5ba5821c8..20cec09893 100644 --- a/Units/parser-vala.r/class.vala.d/input.vala +++ b/Units/parser-vala.r/class.vala.d/input.vala @@ -57,4 +57,10 @@ public class Car { public signal void value_changed (string name, Variant value); int addSeat (int n) { return n_seat + n; } + + public class Seat { + int x; + } + + public int more; } diff --git a/parsers/vala.c b/parsers/vala.c index c6c4c52771..1bc4ae5981 100644 --- a/parsers/vala.c +++ b/parsers/vala.c @@ -667,6 +667,15 @@ static bool recurseValaTags (tokenInfo *token, int parentIndex) parseClass (token, K_STRUCT, parentIndex); else if (tokenIsType (token, IDENTIFIER)) parseStatement (token, parentIndex); + else if (tokenIsKeyword(token, CONSTRUCT)) + { + tokenRead (token); + if (tokenIsTypeVal (token, '{')) + { + /* TODO: we can make an anonymous tag for the constructor. */ + tokenSkipOverPair (token); + } + } else r = false; @@ -792,15 +801,16 @@ static void parseClassBody (tokenInfo *const token, int classCorkIndex) break; } - if (tokenIsKeyword(token, CONSTRUCT)) + if (tokenIsKeyword(token, CLASS) + || tokenIsKeyword(token, CONSTRUCT)) { - tokenRead (token); - if (tokenIsTypeVal (token, '{')) + recurseValaTags (token, classCorkIndex); + if (visiblity) { - /* TODO: we can make an anonymous tag for the constructor. */ - tokenSkipOverPair (token); - continue; + eFree (visiblity); + visiblity = NULL; } + continue; } if (tokenIsType (token, IDENTIFIER)