Commits May 2022

commits@lists.geany.org

1 participants
49 discussions

[geany/geany] 2ed895: Add ADA ctags parser
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: Jiří Techet <techet(a)gmail.com> Date: Fri, 13 May 2022 00:39:12 UTC Commit: 2ed8955886b142a44e6bb69dc30f75d4bd02063b https://github.com/geany/geany/commit/2ed8955886b142a44e6bb69dc30f75d4bd020… Log Message: ----------- Add ADA ctags parser Modified Paths: -------------- ctags/Makefile.am ctags/parsers/ada.c meson.build src/filetypes.c src/tagmanager/tm_parser.c src/tagmanager/tm_parser.h src/tagmanager/tm_parsers.h tests/ctags/Makefile.am tests/ctags/ada-adb.adb tests/ctags/ada-adb.adb.tags tests/ctags/ada-ads.ads tests/ctags/ada-ads.ads.tags tests/ctags/ada-expression-function-generic.adb tests/ctags/ada-expression-function-generic.adb.tags tests/ctags/ada-expression-function.adb tests/ctags/ada-expression-function.adb.tags tests/ctags/ada-overriding.ads tests/ctags/ada-overriding.ads.tags tests/ctags/ada-package-generic.ads tests/ctags/ada-package-generic.ads.tags tests/ctags/ada-task.adb tests/ctags/ada-task.adb.tags tests/meson.build Modified: ctags/Makefile.am 1 lines changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -45,6 +45,7 @@ parsers = \ parsers/cpreprocessor.h \ parsers/abaqus.c \ parsers/abc.c \ + parsers/ada.c \ parsers/asciidoc.c \ parsers/asm.c \ parsers/basic.c \ Modified: ctags/parsers/ada.c 2395 lines changed, 2395 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,2395 @@ +/* File: Ada.c + * Description: Enables extended Ada parsing support in Exuberant Ctags + * Version: 0.6 + * Date: October 26, 2006 + * Author: A. Aaron Cornelius (ADotAaronDotCorneliusAtgmailDotcom) + * License: GPL-2 + * + * Installation: + * You must have the Exuberant Ctags source to install this parser. Once you + * have the source, place this file into the directory with the rest of the + * ctags source. After ada.c is in the correct directory you need to make the + * following changes so that the ada parser is included when you compile and + * install ctags: + * + * to file source.mak add the line + * ada.c \ + * + * after + * SOURCES = \ + * + * then add the line + * ada.$(OBJECT) \ + * + * after + * OBJECTS = \ + * + * to file parsers.h add the line + * AdaParser, \ + * + * after + * #define PARSER_LIST \ + * + * Then compile and install ctags as normal (usually: './configure', './make', + * './make install'). + * + * Changelog: + * + * 11/02/2006 - Completed implementation of file scope info and qualified tags + * information gathering. + * 11/02/2006 - Added recognition of private flag in a token for file scope + * checking purposes. + * 10/27/2006 - Added full package scope name when --extra=+q is set. + * 10/27/2006 - Fixed file scope setting, and added check to verify that tags + * with file scope should be included in the tag file. + * 10/26/2006 - Fixed error which caused infinite loop when parsing some + * files. + * 0.5 - Bugfixes + * 10/20/2006 - Cleaned up freeAdaTokenList. + * 10/20/2006 - Fixed error in freeAdaToken that caused the child token lists + * to become corrupted when "separate" tokens were deleted. + * 0.4 - Third Revision - 09/25/2006 + * 09/25/2006 - Fixed error in newAdaToken which could cause an error on some + * systems when a separate token (which is temporary) gets + * created. + * 09/25/2006 - Change matchFilePos initialization in the findAdaTags + * function. + * 0.3 - Second Revision + * 06/02/2006 - Added missing EOF checks to prevent infinite loops in the case + * of an incomplete Ada (or non-Ada) file being parsed. + * 06/02/2006 - Added Copyright notice. + * 0.2 - First Revision + * 05/26/2006 - Fixed an error where tagging the proper scope of something + * declared in an anonymous block or anonymous loop was not + * working properly. + * 05/26/2006 - Fixed an error capturing the name of a 'separate' tag. + * 05/26/2006 - Fixed the cmp() function so that it finds matches correctly. + * 05/26/2006 - Fixed some spelling errors. + * 05/26/2006 - Added explicit skipping of use and with clauses. + * 0.1 - Initial Release + * + * Future Changes: + * TODO: Add inheritance information? + * TODO: Add signature gathering? + * + * Copyright (C) 2006 A. Aaron Cornelius + * + * 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 2 + * 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, + * USA. + * + */ + +#include "general.h" /* always include first */ + +#include <string.h> /* to declare strxxx() functions */ +#include <ctype.h> /* to define isxxx() macros */ + +#include "parse.h" /* always include */ +#include "read.h" /* to define file readLineFromInputFile() */ +#include "entry.h" /* for the tag entry manipulation */ +#include "routines.h" /* for generic malloc/realloc/free routines */ +#include "debug.h" /* for Assert */ +#include "xtag.h" + + +static bool eof_reached; + +typedef enum eAdaParseMode +{ + ADA_ROOT, + ADA_DECLARATIONS, + ADA_CODE, + ADA_EXCEPTIONS, + ADA_GENERIC +} adaParseMode; + +typedef enum eAdaKinds +{ + ADA_KIND_UNDEFINED = KIND_GHOST_INDEX, /* for default/initialization values */ + ADA_KIND_PACKAGE_SPEC, + ADA_KIND_PACKAGE, + ADA_KIND_TYPE_SPEC, + ADA_KIND_TYPE, + ADA_KIND_SUBTYPE_SPEC, + ADA_KIND_SUBTYPE, + ADA_KIND_RECORD_COMPONENT, + ADA_KIND_ENUM_LITERAL, + ADA_KIND_VARIABLE_SPEC, + ADA_KIND_VARIABLE, + ADA_KIND_FORMAL, + ADA_KIND_CONSTANT, + ADA_KIND_EXCEPTION, + ADA_KIND_SUBPROGRAM_SPEC, + ADA_KIND_SUBPROGRAM, + ADA_KIND_TASK_SPEC, + ADA_KIND_TASK, + ADA_KIND_PROTECTED_SPEC, + ADA_KIND_PROTECTED, + ADA_KIND_ENTRY_SPEC, + ADA_KIND_ENTRY, + ADA_KIND_LABEL, + ADA_KIND_IDENTIFIER, + ADA_KIND_AUTOMATIC_VARIABLE, + ADA_KIND_ANONYMOUS, /* for non-identified loops and blocks */ + ADA_KIND_COUNT /* must be last */ +} adaKind; + +typedef enum { + ADA_PACKAGE_SUBUNIT, +} adaPackageRole; + +static roleDefinition AdaPackageRoles [] = { + { true, "subunit", + "package name referenced in separate()" }, +}; + +static kindDefinition AdaKinds[] = +{ + { true, 'P', "packspec", "package specifications" }, + { true, 'p', "package", "packages", + .referenceOnly = false, ATTACH_ROLES(AdaPackageRoles) }, + { false, 'T', "typespec", "type specifications" }, + { true, 't', "type", "types" }, + { false, 'U', "subspec", "subtype specifications" }, + { true, 'u', "subtype", "subtypes" }, + { true, 'c', "component", "record type components" }, + { true, 'l', "literal", "enum type literals" }, + { false, 'V', "varspec", "variable specifications" }, + { true, 'v', "variable", "variables" }, + { true, 'f', "formal", "generic formal parameters" }, + { true, 'n', "constant", "constants" }, + { true, 'x', "exception", "user defined exceptions" }, + { true, 'R', "subprogspec", "subprogram specifications" }, + { true, 'r', "subprogram", "subprograms" }, + { true, 'K', "taskspec", "task specifications" }, + { true, 'k', "task", "tasks" }, + { true, 'O', "protectspec", "protected data specifications" }, + { true, 'o', "protected", "protected data" }, + { false, 'E', "entryspec", "task/protected data entry specifications" }, + { true, 'e', "entry", "task/protected data entries" }, + { true, 'b', "label", "labels" }, + { true, 'i', "identifier", "loop/declare identifiers"}, + { false, 'a', "autovar", "automatic variables" }, + { false, 'y', "anon", "loops and blocks with no identifier" }, +}; + +typedef struct sAdaTokenList +{ + int numTokens; + struct sAdaTokenInfo *head; + struct sAdaTokenInfo *tail; +} adaTokenList; + +typedef struct sAdaTokenInfo +{ + adaKind kind; + bool isSpec; + bool isPrivate; + char *name; + tagEntryInfo tag; + struct sAdaTokenInfo *parent; + struct sAdaTokenInfo *prev; + struct sAdaTokenInfo *next; + adaTokenList children; +} adaTokenInfo; + +typedef enum eAdaKeywords +{ + ADA_KEYWORD_ACCEPT, + ADA_KEYWORD_BEGIN, + ADA_KEYWORD_BODY, + ADA_KEYWORD_CASE, + ADA_KEYWORD_CONSTANT, + ADA_KEYWORD_DECLARE, + ADA_KEYWORD_DO, + ADA_KEYWORD_ELSE, + ADA_KEYWORD_ELSIF, + ADA_KEYWORD_END, + ADA_KEYWORD_ENTRY, + ADA_KEYWORD_EXCEPTION, + ADA_KEYWORD_FOR, + ADA_KEYWORD_FUNCTION, + ADA_KEYWORD_GENERIC, + ADA_KEYWORD_IF, + ADA_KEYWORD_IN, + ADA_KEYWORD_IS, + ADA_KEYWORD_LOOP, + ADA_KEYWORD_NEW, + ADA_KEYWORD_NOT, + ADA_KEYWORD_OR, + ADA_KEYWORD_OVERRIDING, /* Ada 2005 */ + ADA_KEYWORD_PACKAGE, + ADA_KEYWORD_PRAGMA, + ADA_KEYWORD_PRIVATE, + ADA_KEYWORD_PROCEDURE, + ADA_KEYWORD_PROTECTED, + ADA_KEYWORD_RECORD, + ADA_KEYWORD_RENAMES, + ADA_KEYWORD_SELECT, + ADA_KEYWORD_SEPARATE, + ADA_KEYWORD_SUBTYPE, + ADA_KEYWORD_TASK, + ADA_KEYWORD_THEN, + ADA_KEYWORD_TYPE, + ADA_KEYWORD_UNTIL, + ADA_KEYWORD_USE, + ADA_KEYWORD_WHEN, + ADA_KEYWORD_WHILE, + ADA_KEYWORD_WITH +} adaKeyword; + +static const char *AdaKeywords[] = +{ + "accept", + "begin", + "body", + "case", + "constant", + "declare", + "do", + "else", + "elsif", + "end", + "entry", + "exception", + "for", + "function", + "generic", + "if", + "in", + "is", + "loop", + "new", + "not", + "or", + "overriding", + "package", + "pragma", + "private", + "procedure", + "protected", + "record", + "renames", + "select", + "separate", + "subtype", + "task", + "then", + "type", + "until", + "use", + "when", + "while", + "with" +}; + + +/* variables for managing the input string, position as well as input line + * number and position */ +static const char *line; +static int lineLen; +static int pos; +static unsigned long matchLineNum; +static MIOPos matchFilePos; + +/* utility functions */ +static void makeSpec (adaKind *kind); + +/* prototypes of functions for manipulating the Ada tokens */ +static adaTokenInfo *newAdaToken (const char *name, int len, + adaKind kind, bool isSpec, + adaTokenInfo *parent); +static adaTokenInfo *newAdaTokenFull (const char *name, int len, + adaKind kind, int role, bool isSpec, + adaTokenInfo *parent); +static void freeAdaToken (adaTokenList *list, adaTokenInfo *token); +static void appendAdaToken (adaTokenInfo *parent, adaTokenInfo *token); + +/* token list processing function prototypes */ +static void initAdaTokenList (adaTokenList *list); +static void freeAdaTokenList (adaTokenList *list); +static void appendAdaTokenList (adaTokenInfo *parent, adaTokenList *children); + +/* prototypes of functions for moving through the DEFINED text */ +static void readNewLine (void); +static void movePos (int amount); +static bool cmp (const char *buf, int len, const char *match); +static bool adaCmp (const char *match); +static bool adaKeywordCmp (adaKeyword keyword); +static void skipUntilWhiteSpace (void); +static void skipWhiteSpace (void); +static void skipComments (void); +static void skipCommentsAndStringLiteral (void); +static void skipPast (const char *past); +static void skipPastKeyword (adaKeyword keyword); +static void skipPastWord (void); + +typedef bool (* skipCompFn) (void *data); +static void skipPastLambda (skipCompFn cmpfn, void *data); + +struct cmpKeywordOrWordDataElt +{ + enum eltType + { + ELT_KEYWORD, + ELT_WORD, + } type; + union + { + adaKeyword keyword; + const char* word; + } u; +}; +static struct cmpKeywordOrWordDataElt *skipPastKeywordOrWord (struct cmpKeywordOrWordDataElt * elt, + int count); + +/* prototypes of functions for parsing the high-level Ada constructs */ +static adaTokenInfo *adaParseBlock (adaTokenInfo *parent, adaKind kind); +static adaTokenInfo *adaParseSubprogram (adaTokenInfo *parent, adaKind kind); +static adaTokenInfo *adaParseType (adaTokenInfo *parent, adaKind kind); +static adaTokenInfo *adaParseVariables (adaTokenInfo *parent, adaKind kind); +static adaTokenInfo *adaParseLoopVar (adaTokenInfo *parent); +static adaTokenInfo *adaParse (adaParseMode mode, adaTokenInfo *parent); + +/* prototypes of the functions used by ctags */ +static void storeAdaTags (adaTokenInfo *token, const char *parentScope); +static void findAdaTags (void); + +static void makeSpec (adaKind *kind) +{ + switch (*kind) + { + case ADA_KIND_PACKAGE: + *kind = ADA_KIND_PACKAGE_SPEC; + break; + + case ADA_KIND_TYPE: + *kind = ADA_KIND_TYPE_SPEC; + break; + + case ADA_KIND_SUBTYPE: + *kind = ADA_KIND_SUBTYPE_SPEC; + break; + + case ADA_KIND_VARIABLE: + *kind = ADA_KIND_VARIABLE_SPEC; + break; + + case ADA_KIND_SUBPROGRAM: + *kind = ADA_KIND_SUBPROGRAM_SPEC; + break; + + case ADA_KIND_TASK: + *kind = ADA_KIND_TASK_SPEC; + break; + + case ADA_KIND_PROTECTED: + *kind = ADA_KIND_PROTECTED_SPEC; + break; + + case ADA_KIND_ENTRY: + *kind = ADA_KIND_ENTRY_SPEC; + break; + + default: + *kind = ADA_KIND_UNDEFINED; + break; + } +} + +static adaTokenInfo *newAdaTokenFull (const char *name, int len, adaKind kind, int role, + bool isSpec, adaTokenInfo *parent) +{ + char *tmpName = NULL; + adaTokenInfo *token = xMalloc (1, adaTokenInfo); + + token->name = NULL; + + if (name != NULL && len != 0) + { + tmpName = xMalloc (len + 1, char); + strncpy (tmpName, name, len); + tmpName[len] = '\0'; + } + + /* init the tag */ + initTagEntry (&token->tag, tmpName, ADA_KIND_UNDEFINED); + + token->kind = kind; + token->isSpec = isSpec; + token->isPrivate = false; + + /* set the token data */ + token->name = tmpName; + token->parent = parent; + + /* Now set the file scope for this tag. A tag has file scope if its direct + * parent is a package/subprogram/protected/task spec, or if it it's parent + * is UNDEFINED (a 'root' token), and if this is not in a 'private' section + * of that spec. */ + if ((parent != NULL) && (parent->isPrivate == false) && + ((parent->kind == ADA_KIND_UNDEFINED) || + (parent->kind == ADA_KIND_PACKAGE && isRoleAssigned(&parent->tag, ADA_PACKAGE_SUBUNIT)) || + ((parent->isSpec == true) && ((parent->kind == ADA_KIND_PACKAGE) || + (parent->kind == ADA_KIND_SUBPROGRAM) || + (parent->kind == ADA_KIND_PROTECTED) || + (parent->kind == ADA_KIND_TASK))))) + { + token->tag.isFileScope = false; + } + else + { + markTagExtraBit (&token->tag, XTAG_FILE_SCOPE); + token->tag.isFileScope = true; + } + + /* add the kind info - unless this is a SEPARATE kind, in which case keep + * them blank because they get filled in later. */ + if (kind > ADA_KIND_UNDEFINED) + { + token->tag.kindIndex = kind; + if (role != ROLE_DEFINITION_INDEX) + assignRole(&token->tag, role); + } + else + { + token->tag.kindIndex = KIND_GHOST_INDEX; + } + + /* setup the parent and children pointers */ + initAdaTokenList (&token->children); + appendAdaToken (parent, token); + + return token; +} + +static adaTokenInfo *newAdaToken (const char *name, int len, adaKind kind, + bool isSpec, adaTokenInfo *parent) +{ + return newAdaTokenFull (name, len, kind, ROLE_DEFINITION_INDEX, isSpec, parent); +} + +static void freeAdaToken (adaTokenList *list, adaTokenInfo *token) +{ + if (token != NULL) + { + if (token->name != NULL) + { + eFree ((void *) token->name); + token->name = NULL; + } + + /* before we delete this token, clean up it's children */ + freeAdaTokenList (&token->children); + + /* move the next token in the list to this token's spot */ + if (token->prev != NULL) + { + token->prev->next = token->next; + } + else if (list != NULL) + { + /* Token to remove is head in list as 'token->prev == NULL' */ + Assert (token->prev == NULL); + list->head = token->next; + } + + /* move the previous token in the list to this token's spot */ + if (token->next != NULL) + { + token->next->prev = token->prev; + } + else if (list != NULL) + { + /* Token to remove is tail of list as 'token->next == NULL') */ + Assert (token->next == NULL); + list->tail = token->prev; + } + + /* decrement the list count */ + if (list != NULL) + { + list->numTokens--; + } + + /* now that this node has had everything hanging off of it rearranged, + * delete this node */ + eFree (token); + } +} + +static void appendAdaToken (adaTokenInfo *parent, adaTokenInfo *token) +{ + /* if the parent or newChild is NULL there is nothing to be done */ + if (parent != NULL && token != NULL) + { + /* we just need to add this to the list and set a parent pointer */ + parent->children.numTokens++; + token->parent = parent; + token->prev = parent->children.tail; + token->next = NULL; + + if (parent->children.tail != NULL) + { + parent->children.tail->next = token; + } + + /* the token that was just added always becomes the last token int the + * list */ + parent->children.tail = token; + + if (parent->children.head == NULL) + { + parent->children.head = token; + } + } +} + +static void initAdaTokenList (adaTokenList *list) +{ + if (list != NULL) + { + list->numTokens = 0; + list->head = NULL; + list->tail = NULL; + } +} + +static void freeAdaTokenList (adaTokenList *list) +{ + if (list != NULL) + { + while (list->head != NULL) + { + freeAdaToken (list, list->head); + } + } +} + +static void appendAdaTokenList (adaTokenInfo *parent, adaTokenList *children) +{ + adaTokenInfo *tmp = NULL; + + if (parent != NULL && children != NULL) + { + while (children->head != NULL) + { + tmp = children->head->next; + appendAdaToken (parent, children->head); + + /* we just need to worry about setting the head pointer properly during + * the list iteration. The node's pointers will get set properly by the + * appendAdaToken () function */ + children->head = tmp; + } + + /* now that we have added all nodes from the children list to the parent + * node, zero out the children list */ + initAdaTokenList (children); + } +} + +static void readNewLine (void) +{ + while (true) + { + line = (const char *) readLineFromInputFile (); + pos = 0; + + if (line == NULL) + { + lineLen = 0; + eof_reached = true; + return; + } + + lineLen = strlen (line); + + if (lineLen > 0) + { + return; + } + } +} + +static void movePos (int amount) +{ + pos += amount; + if (!eof_reached && pos >= lineLen) + { + readNewLine (); + } +} + +/* a macro for checking for comments... This isn't the same as the check in + * cmp () because comments don't have to have whitespace or separation-type + * characters following the "--" */ +#define isAdaComment(buf, pos, len) \ + (((pos) == 0 || (!isalnum ((buf)[(pos) - 1]) && (buf)[(pos) - 1] != '_')) && \ + (pos) < (len) && \ + strncasecmp (&(buf)[(pos)], "--", strlen ("--")) == 0) +#define isAdaStringLiteral(buf, pos, len) \ + (((pos) < (len)) && ((buf)[(pos)] == '"')) +#define isAdaCharLiteral(buf, pos, len) \ + (((pos) < (len - 2)) && ((buf)[(pos)] == '\'') \ + && ((buf)[(pos + 2)] == '\'')) + + +static bool cmp (const char *buf, int len, const char *match) +{ + bool status = false; + int matchLen; + + /* if we are trying to match nothing, that is always true */ + if (match == NULL) + { + return true; + } + + /* first check to see if the buffer is empty, if it is, return false */ + if (buf == NULL) + { + return status; + } + + matchLen = strlen (match); + + /* A match only happens the number of chars in the matching string match, + * and whitespace follows... Which means we also must check to see if the + * end of the line is after the matching string. Also check for some + * separation characters such as (, ), :, or ; */ + if ((strncasecmp (buf, match, matchLen) == 0) && + (matchLen == len || + (matchLen < len && + (isspace (buf[matchLen]) || buf[matchLen] == '(' || + buf[matchLen] == ')' || buf[matchLen] == ':' || + buf[matchLen] == ';')))) + { + status = true; + } + + return status; +} + +static bool adaCmp (const char *match) +{ + bool status = false; + + /* first check to see if line is empty */ + if (line == NULL) + { + eof_reached = true; + return status; + } + + status = cmp (&line[pos], lineLen - pos, match); + + /* if we match, increment the position pointer */ + if (status == true && match != NULL) + { + matchLineNum = getInputLineNumber (); + matchFilePos = getInputFilePosition (); + + movePos ((strlen (match))); + } + + return status; +} + +/* just a version of adaCmp that is a bit more optimized for keywords */ +static bool adaKeywordCmp (adaKeyword keyword) +{ + bool status = false; + + /* first check to see if line is empty, if it is */ + if (line == NULL) + { + eof_reached = true; + return status; + } + + status = cmp (&line[pos], lineLen - pos, AdaKeywords[keyword]); + + /* if we match, increment the position pointer */ + if (status == true) + { + matchLineNum = getInputLineNumber (); + matchFilePos = getInputFilePosition (); + + movePos ((strlen (AdaKeywords[keyword]))); + } + + return status; +} + +static void skipUntilWhiteSpace (void) +{ + /* first check for a comment line, because this would cause the isspace + * check to be true immediately */ + skipComments (); + + while (!eof_reached && !isspace (line[pos])) + { + /* don't use movePos () because if we read in a new line with this function + * we need to stop */ + pos++; + + /* the newline counts as whitespace so read in the newline and return + * immediately */ + if (pos >= lineLen) + { + line = (const char *) readLineFromInputFile (); + pos = 0; + + if (line == NULL) + { + lineLen = 0; + eof_reached = true; + return; + } + + lineLen = strlen (line); + + return; + } + + /* now check for comments here */ + skipComments (); + } +} + +static void skipWhiteSpace (void) +{ + /* first check for a comment line, because this would cause the isspace + * check to fail immediately */ + skipComments (); + + while (!eof_reached && isspace (line[pos])) + { + movePos (1); + + /* now check for comments here */ + skipComments (); + } +} + +static void skipComments (void) +{ + while (!eof_reached && isAdaComment (line, pos, lineLen)) + { + readNewLine (); + } +} + +/* Return true if skipped over a string literal (or char literal). + * Return false if no string literal (nor char literal) is found. */ +static bool skipStringLiteral (void) +{ + if (!eof_reached && isAdaStringLiteral (line, pos, lineLen)) + { + do { + movePos (1); + } while (!eof_reached && !isAdaStringLiteral (line, pos, lineLen)); + + /* Go to the next char of " */ + movePos (1); + + return true; + } + else if (!eof_reached && isAdaCharLiteral (line, pos, lineLen)) + { + movePos (3); + return true; + } + return false; +} + +static void skipCommentsAndStringLiteral (void) +{ + while (true) + { + skipComments (); + if (!skipStringLiteral ()) + break; + } +} + +static void skipPast (const char *past) +{ + /* first check for a comment line, because this would cause the isspace + * check to fail immediately */ + skipCommentsAndStringLiteral (); + + /* now look for the keyword */ + while (!eof_reached && !adaCmp (past)) + { + movePos (1); + + /* now check for comments here */ + skipCommentsAndStringLiteral (); + } +} + +static void skipPastKeyword (adaKeyword keyword) +{ + /* first check for a comment line, because this would cause the isspace + * check to fail immediately */ + skipComments (); + + /* now look for the keyword */ + while (!eof_reached && !adaKeywordCmp (keyword)) + { + movePos (1); + + /* now check for comments here */ + skipComments (); + } +} + +static void skipPastWord (void) +{ + /* first check for a comment line, because this would cause the isspace + * check to fail immediately */ + skipComments (); + + /* now increment until we hit a non-word character... Specifically, + * whitespace, '(', ')', ':', and ';' */ + while (!eof_reached && !isspace (line[pos]) && + line[pos] != '(' && line[pos] != ')' && line[pos] != ':' && + line[pos] != ';') + { + /* don't use movePos () because if we read in a new line with this function + * we need to stop */ + pos++; + + /* the newline counts as whitespace so read in the newline and return + * immediately */ + if (pos >= lineLen) + { + line = (const char *) readLineFromInputFile (); + pos = 0; + + if (line == NULL) + { + lineLen = 0; + eof_reached = true; + return; + } + + lineLen = strlen (line); + + return; + } + + /* now check for comments here */ + skipComments (); + } +} + +static void skipPastLambda (skipCompFn cmpfn, void *data) +{ + /* first check for a comment line, because this would cause the isspace + * check to fail immediately */ + skipCommentsAndStringLiteral (); + + /* now call the predicate */ + while (!eof_reached && !cmpfn (data)) + { + movePos (1); + + /* now check for comments here */ + skipCommentsAndStringLiteral (); + } +} + +struct cmpKeywordOrWordData +{ + struct cmpKeywordOrWordDataElt *found; + int count; + struct cmpKeywordOrWordDataElt *elt; +}; + +static bool cmpKeywordOrWord (void *data) +{ + struct cmpKeywordOrWordData *cmdData = data; + + cmdData->found = NULL; + for (int i = 0; i < cmdData->count; i++) + { + if (cmdData->elt[i].type == ELT_KEYWORD) + { + if (adaKeywordCmp (cmdData->elt[i].u.keyword)) + { + cmdData->found = cmdData->elt + i; + return true; + } + } + else if (cmdData->elt[i].type == ELT_WORD) + { + if (adaCmp (cmdData->elt[i].u.word)) + { + cmdData->found = cmdData->elt + i; + return true; + } + } + else + AssertNotReached (); + } + return false; +} + +static struct cmpKeywordOrWordDataElt *skipPastKeywordOrWord (struct cmpKeywordOrWordDataElt * elt, + int count) +{ + struct cmpKeywordOrWordData data = { + .found = NULL, + .count = count, + .elt = elt + }; + skipPastLambda (cmpKeywordOrWord, &data); + return data.found; +} + +static adaTokenInfo *adaParseBlock (adaTokenInfo *parent, adaKind kind) +{ + int i; + adaTokenInfo *token; + bool isSpec = true; + + skipWhiteSpace (); + + /* if the next word is body, this is not a package spec */ + if (adaKeywordCmp (ADA_KEYWORD_BODY)) + { + isSpec = false; + } + /* if the next word is "type" then this has to be a task or protected spec */ + else if (adaKeywordCmp (ADA_KEYWORD_TYPE) && + (kind != ADA_KIND_PROTECTED && kind != ADA_KIND_TASK)) + { + /* if this failed to validate then we should just fail */ + return NULL; + } + skipWhiteSpace (); + + /* we are at the start of what should be the tag now... But we have to get + * it's length. So loop until we hit whitespace, init the counter to 1 + * since we know that the current position is not whitespace */ + for (i = 1; (pos + i) < lineLen && !isspace (line[pos + i]) && + line[pos + i] != '(' && line[pos + i] != ';'; i++); + + /* we have reached the tag of the package, so create the tag */ + token = newAdaToken (&line[pos], i, kind, isSpec, parent); + + movePos (i); + skipWhiteSpace (); + + /* task and protected types are allowed to have discriminants */ + if (!eof_reached && line[pos] == '(') + { + while (!eof_reached && line[pos] != ')') + { + movePos (1); + adaParseVariables (token, ADA_KIND_AUTOMATIC_VARIABLE); + } + movePos (1); + } + + /* we must parse until we hit the "is" string to reach the end of + * this package declaration, or a "renames" keyword */ + while (token != NULL) + { + skipWhiteSpace (); + + if (adaKeywordCmp (ADA_KEYWORD_IS)) + { + skipWhiteSpace (); + + if (adaKeywordCmp (ADA_KEYWORD_SEPARATE)) + { + /* if the next word is the keyword "separate", don't create the tag + * since it will be defined elsewhere */ + freeAdaToken (&parent->children, token); + token = NULL; + + /* move past the ";" ending this declaration */ + skipPast (";"); + } + else if (adaKeywordCmp (ADA_KEYWORD_NEW)) + { + struct cmpKeywordOrWordDataElt *elt; + + elt = skipPastKeywordOrWord ((struct cmpKeywordOrWordDataElt []) {{ + .type = ELT_KEYWORD, + .u.keyword = ADA_KEYWORD_WITH, + }, { + .type = ELT_WORD, + .u.word = ";", + } + }, 2); + + if (elt && elt->type == ELT_KEYWORD) + adaParse (ADA_DECLARATIONS, token); + } + else + { + adaParse (ADA_DECLARATIONS, token); + } + + break; + } + else if (adaKeywordCmp (ADA_KEYWORD_RENAMES)) + { + skipPast (";"); + break; + } + else if (adaCmp (";")) + { + token->isSpec = true; + break; + } + else + { + /* nothing found, move to the next word */ + skipUntilWhiteSpace (); + } + + if (eof_reached) + { + freeAdaToken (&parent->children, token); + token = NULL; + } + } + + return token; +} + +static adaTokenInfo *adaParseSubprogram (adaTokenInfo *parent, adaKind kind) +{ + int i; + adaTokenInfo *token; + adaTokenInfo *tmpToken = NULL; + + skipWhiteSpace (); + + /* we are at the start of what should be the tag now... But we have to get + * it's length. So loop until we hit whitespace or the beginning of the + * parameter list. Init the counter to 1 * since we know that the current + * position is not whitespace */ + for (i = 1; (pos + i) < lineLen && !isspace (line[pos + i]) && + line[pos + i] != '(' && line[pos + i] != ';'; i++); + + /* we have reached the tag of the subprogram, so create the tag... Init the + * isSpec flag to false and we will adjust it when we see if there is an + * "is", "do" or a ";" following the tag */ + token = newAdaToken (&line[pos], i, kind, false, parent); + + /* move the line position */ + movePos (i); + skipWhiteSpace (); + + /* if we find a '(' grab any parameters */ + if (!eof_reached && line[pos] == '(' && token != NULL) + { + while (!eof_reached && line[pos] != ')') + { + movePos (1); + tmpToken = adaParseVariables (token, ADA_KIND_AUTOMATIC_VARIABLE); + } + movePos (1); + + /* check to see if anything was received... If this is an entry this may + * have a 'discriminant' and not have any parameters in the first + * parenthesis pair, so check again if this was the case*/ + if (kind == ADA_KIND_ENTRY && tmpToken == NULL) + { + /* skip any existing whitespace and see if there is a second parenthesis + * pair */ + skipWhiteSpace (); + + if (!eof_reached && line[pos] == '(') + { + while (!eof_reached && line[pos] != ')') + { + movePos (1); + adaParseVariables (token, ADA_KIND_AUTOMATIC_VARIABLE); + } + movePos (1); + } + } + } + + /* loop infinitely until we hit a "is", "do" or ";", this will skip over + * the returns keyword, returned-type for functions as well as any one of a + * myriad of keyword qualifiers */ + while (!eof_reached && token != NULL) + { + skipWhiteSpace (); + + if (adaKeywordCmp (ADA_KEYWORD_IS)) + { + skipWhiteSpace (); + + if (adaKeywordCmp (ADA_KEYWORD_SEPARATE)) + { + /* if the next word is the keyword "separate", don't create the tag + * since it will be defined elsewhere */ + freeAdaToken (&parent->children, token); + token = NULL; + + /* move past the ";" ending this declaration */ + skipPast (";"); + } + else if (adaKeywordCmp (ADA_KEYWORD_NEW)) + { + /* if this is a "new" something then no need to parse */ + skipPast (";"); + } + else if (line[pos] == '(') + { + /* '(' is the starter of an expression function. */ + skipPast (";"); + } + else + { + adaParse (ADA_DECLARATIONS, token); + } + + break; + } + else if (adaKeywordCmp (ADA_KEYWORD_RENAMES)) + { + skipPast (";"); + break; + } + else if (adaKeywordCmp (ADA_KEYWORD_DO)) + { + /* do is the keyword for the beginning of a task entry */ + adaParse (ADA_CODE, token); + break; + } + else if (adaCmp (";")) + { + /* this is just a spec then, so set the flag in the token */ + token->isSpec = true; + break; + } + else + { + /* nothing found, move to the next word */ + movePos (1); /* make sure to advance even if we aren't actually on a word */ + skipPastWord (); + } + } + + return token; +} + +static adaTokenInfo *adaParseType (adaTokenInfo *parent, adaKind kind) +{ + int i; + adaTokenInfo *token = NULL; + + skipWhiteSpace (); + + /* get the name of the type */ + for (i = 1; (pos + i) < lineLen && !isspace (line[pos + i]) && + line[pos + i] != '(' && line[pos + i] != ';'; i++); + + token = newAdaToken (&line[pos], i, kind, false, parent); + + movePos (i); + skipWhiteSpace (); + + if (!eof_reached && line[pos] == '(') + { + /* in this case there is a discriminant to this type, gather the + * variables */ + while (!eof_reached && line[pos] != ')') + { + movePos (1); + adaParseVariables (token, ADA_KIND_AUTOMATIC_VARIABLE); + } + movePos (1); + skipWhiteSpace (); + } + + /* check to see what is next, if it is not "is" then just skip to the end of + * the statement and register this as a 'spec' */ + if (adaKeywordCmp (ADA_KEYWORD_IS)) + { + skipWhiteSpace (); + /* check to see if this may be a record or an enumeration */ + if (!eof_reached && line[pos] == '(') + { + movePos (1); + adaParseVariables (token, ADA_KIND_ENUM_LITERAL); + } + else + { + /* Parsing following form here. + * + * A. type foo is record ...; + * B. type foo is new bar with record ...; + * C. type foo is new bar; + */ + if (adaKeywordCmp (ADA_KEYWORD_NEW)) + { + /* B and C */ + struct cmpKeywordOrWordDataElt *elt; + elt = skipPastKeywordOrWord ((struct cmpKeywordOrWordDataElt []) {{ + .type = ELT_KEYWORD, + .u.keyword = ADA_KEYWORD_WITH, + }, { + .type = ELT_WORD, + .u.word = ";", + } + }, 2); + if (elt && elt->type == ELT_WORD) + { + /* C */ + return token; + } + + /* B */ + skipWhiteSpace (); + } + if (adaKeywordCmp (ADA_KEYWORD_RECORD)) + { + /* A and B */ + /* until we hit "end record" we need to gather type variables */ + while (!eof_reached) + { + skipWhiteSpace (); + + if (adaKeywordCmp (ADA_KEYWORD_END)) + { + skipWhiteSpace (); + if (adaKeywordCmp (ADA_KEYWORD_RECORD)) + { + break; + } + skipPast (";"); + } + /* handle variant types */ + else if (adaKeywordCmp (ADA_KEYWORD_CASE)) + { + skipPastKeyword (ADA_KEYWORD_IS); + } + else if (adaKeywordCmp (ADA_KEYWORD_WHEN)) + { + skipPast ("=>"); + } + else + { + adaParseVariables (token, ADA_KIND_RECORD_COMPONENT); + skipPast (";"); + } + } + } + } + } + else + { + token->isSpec = true; + } + + skipPast (";"); + + return token; +} + +static adaTokenInfo *adaParseVariables (adaTokenInfo *parent, adaKind kind) +{ + /* variables for keeping track of tags */ + int varEndPos = -1; + int tokenStart = -1; + adaTokenInfo *token = NULL; + + /* buffer management variables */ + int i = 0; + int bufPos = 0; + int bufLen = 0; + char *buf = NULL; + + /* file and line position variables */ + unsigned long int lineNum; + int filePosIndex = 0; + int filePosSize = 32; + MIOPos *filePos = xMalloc (filePosSize, MIOPos); + + /* skip any preliminary whitespace or comments */ + skipWhiteSpace (); + skipComments (); + + /* before we start reading input save the current line number and file + * position, so we can reconstruct the correct line & file position for any + * tags we create */ + lineNum = getInputLineNumber (); + filePos[filePosIndex] = getInputFilePosition (); + + /* setup local buffer... Since we may have to read a few lines to verify + * that this is a proper variable declaration, and still make a token for + * each variable, add one to the allocated string to account for a '\0' */ + bufLen = lineLen - pos; + buf = xMalloc (bufLen + 1, char); + memcpy ((void *) buf, (void *) &line[pos], bufLen); + + /* don't increase bufLen to include the NULL char so that strlen (buf) and + * bufLen match */ + buf[bufLen] = '\0'; + + while (!eof_reached) + { + /* make sure that we don't count anything in a comment as being valid to + * parse */ + if (isAdaComment (buf, bufPos, bufLen)) + { + /* move bufPos to the end of this 'line' so a new line of input is + * read */ + bufPos = bufLen - 1; + + /* if tokenStart is not -2 then we may be trying to track the type + * of this variable declaration, so set tokenStart to -1 so that the + * tracking can start over */ + if (tokenStart != -2) + { + tokenStart = -1; + } + } + /* we have to keep track of any () pairs that may be in the variable + * declarations. And then quit if we hit a ';' the real end ')', or also + * a variable initialization... Once we hit := then we have hit the end of + * the variable declaration */ + else if (buf[bufPos] == '(') + { + i++; + } + else if (buf[bufPos] == ')') + { + if (i == 0) + { + break; + } + else + { + i--; + } + } + else if (buf[bufPos] == ';' || + ((bufPos + 1) < bufLen && + (strncasecmp (&buf[bufPos], ":=", strlen (":=")) == 0 || + strncasecmp (&buf[bufPos], "=>", strlen ("=>")) == 0))) + { + break; + } + /* if we found the : keep track of where we found it */ + else if (buf[bufPos] == ':' && + (bufPos + 1 >= bufLen || buf[bufPos + 1] != '=')) + { + varEndPos = bufPos; + } + /* if we have the position of the ':' find out what the next word is, + * because if it "constant" or "exception" then we must tag this slightly + * differently, But only check this for normal variables */ + else if (kind == ADA_KIND_VARIABLE && varEndPos != -1 && + !isspace (buf[bufPos]) && tokenStart == -1) + { + tokenStart = bufPos; + } + else if (kind == ADA_KIND_VARIABLE && varEndPos != -1 && tokenStart >= 0 && + ((bufPos + 1) >= bufLen || isspace (buf[bufPos + 1]) || + buf[bufPos + 1] == ';')) + { + if (cmp (&buf[tokenStart], bufLen - tokenStart, + AdaKeywords[ADA_KEYWORD_CONSTANT]) == true) + { + kind = ADA_KIND_CONSTANT; + } + else if (cmp (&buf[tokenStart], bufLen - tokenStart, + AdaKeywords[ADA_KEYWORD_EXCEPTION]) == true) + { + kind = ADA_KIND_EXCEPTION; + } + + /* set tokenStart to -2 to prevent any more words from being checked */ + tokenStart = -2; + } + + bufPos++; + + /* if we just incremented beyond the length of the current buffer, we need + * to read in a new line */ + if (!eof_reached && bufPos >= bufLen) + { + readNewLine (); + + /* store the new file position for the start of this line */ + filePosIndex++; + while (filePosIndex >= filePosSize) + { + filePosSize *= 2; + filePos = xRealloc (filePos, filePosSize, MIOPos); + } + filePos[filePosIndex] = getInputFilePosition (); + + /* increment bufLen and bufPos now so that they jump past the NULL + * character in the buffer */ + bufLen++; + bufPos++; + + /* allocate space and store this into our buffer */ + bufLen += lineLen; + buf = xRealloc (buf, bufLen + 1, char); + memcpy ((void *) &buf[bufPos], (void *) line, lineLen); + buf[bufLen] = '\0'; + } + } + + /* There is a special case if we are gathering enumeration values and we hit + * a ')', that is allowed so we need to move varEndPos to where the ')' is */ + if (kind == ADA_KIND_ENUM_LITERAL && buf[bufPos] == ')' && varEndPos == -1) + { + varEndPos = bufPos; + } + + /* so we found a : or ;... If it is a : go back through the buffer and + * create a token for each word skipping over all whitespace and commas + * until the : is hit*/ + if (varEndPos != -1) + { + /* there should be no whitespace at the beginning, so tokenStart is + * initialized to 0 */ + tokenStart = 0; + + /* before we start set the filePosIndex back to 0 so we can go through the + * file position table as the read line number increases */ + filePosIndex = 0; + + for (i = 0; i < varEndPos; i++) + { + /* skip comments which are '--' unless we are in a word */ + if (isAdaComment (buf, i, varEndPos)) + { + /* move i past the '\0' that we put at the end of each line stored in + * buf */ + for ( ; i < varEndPos && buf[i] != '\0'; i++); + } + else if (tokenStart != -1 && (isspace (buf[i]) || buf[i] == ',' || + buf[i] == '\0')) + { + /* only store the word if it is not an in/out keyword */ + if (!cmp (&buf[tokenStart], varEndPos, "in") && + !cmp (&buf[tokenStart], varEndPos, "out")) + { + token = newAdaToken (&buf[tokenStart], i - tokenStart, + kind, false, parent); + + /* now set the proper line and file position counts for this + * new token */ + token->tag.lineNumber = lineNum + filePosIndex; + token->tag.filePosition = filePos[filePosIndex]; + } + tokenStart = -1; + } + else if (tokenStart == -1 && !(isspace (buf[i]) || buf[i] == ',' || + buf[i] == '\0')) + { + /* only set the tokenStart for non-newline characters */ + tokenStart = i; + } + + /* after we are finished with this line, move the file position */ + if (buf[i] == '\0') + { + filePosIndex++; + } + } + + /* if token start was 'started' then we should store the last token */ + if (tokenStart != -1) + { + token = newAdaToken (&buf[tokenStart], i - tokenStart, + kind, false, parent); + + /* now set the proper line and file position counts for this + * new token */ + token->tag.lineNumber = lineNum + filePosIndex; + token->tag.filePosition = filePos[filePosIndex]; + } + } + + /* now get the pos variable to point to the correct place in line where we + * left off in our temp buf, and free our temporary buffer. This is a + * little different than most buf position moves. It gets the distance from + * the current buf position to the end of the buffer, which is also the + * distance from where pos should be wrt the end of the variable + * definition */ + movePos ((lineLen - (bufLen - bufPos)) - pos); + eFree ((void *) buf); + eFree ((void *) filePos); + + return token; +} + +static adaTokenInfo *adaParseLoopVar (adaTokenInfo *parent) +{ + int i; + adaTokenInfo *token = NULL; + + skipWhiteSpace (); + for (i = 1; (pos + i) < lineLen && !isspace (line[pos + i]); i++); + token = newAdaToken (&line[pos], i, ADA_KIND_AUTOMATIC_VARIABLE, false, + parent); + movePos (i); + + /* now skip to the end of the loop declaration */ + skipPastKeyword (ADA_KEYWORD_LOOP); + + return token; +} + +static adaTokenInfo *adaParse (adaParseMode mode, adaTokenInfo *parent) +{ + int i; + adaTokenInfo genericParamsRoot; + adaTokenInfo *token = NULL; + + initAdaTokenList (&genericParamsRoot.children); + + /* if we hit the end of the file, line will be NULL and our skip and match + * functions will hit this jump buffer with eof_reached */ + while (!eof_reached) + { + /* find the next place to start */ + skipWhiteSpace (); + + /* check some universal things to check for first */ + if (eof_reached) + { + break; + } + else if (isAdaComment (line, pos, lineLen)) + { + readNewLine (); + continue; + } + else if (adaKeywordCmp (ADA_KEYWORD_PRAGMA) || + ((mode != ADA_GENERIC) && adaKeywordCmp (ADA_KEYWORD_WITH)) || + adaKeywordCmp (ADA_KEYWORD_USE)) + { + /* set the token to NULL so we accidentally don't pick up something + * from earlier + * Do not skip lines having 'with' when 'mode == ADA_GENERIC' + * this to intercept 'formal subprograms' of a generic declaration. + * see: ARM 12.1(22) */ + skipPast (";"); + continue; + } + + /* check for tags based on our current mode */ + switch (mode) + { + case ADA_ROOT: + if (adaKeywordCmp (ADA_KEYWORD_PACKAGE)) + { + token = adaParseBlock (parent, ADA_KIND_PACKAGE); + } + else if (adaKeywordCmp (ADA_KEYWORD_PROCEDURE) || + adaKeywordCmp (ADA_KEYWORD_FUNCTION)) + { + token = adaParseSubprogram (parent, ADA_KIND_SUBPROGRAM); + } + else if (adaKeywordCmp (ADA_KEYWORD_TASK)) + { + token = adaParseBlock (parent, ADA_KIND_TASK); + } + else if (adaKeywordCmp (ADA_KEYWORD_PROTECTED)) + { + token = adaParseBlock (parent, ADA_KIND_PROTECTED); + } + else if (adaKeywordCmp (ADA_KEYWORD_GENERIC)) + { + /* if we have hit a generic declaration, go to the generic section + * and collect the formal parameters */ + mode = ADA_GENERIC; + break; + } + else if (adaKeywordCmp (ADA_KEYWORD_SEPARATE)) + { + /* skip any possible whitespace */ + skipWhiteSpace (); + + /* skip over the "(" until we hit the tag */ + if (!eof_reached && line[pos] == '(') + { + movePos (1); + skipWhiteSpace (); + + /* get length of tag */ + for (i = 1; (pos + i) < lineLen && line[pos + i] != ')' && + !isspace (line[pos + i]); i++); + + /* the original comment before we introduced reference tags: + * ----------------------------------------------------------------- + * if this is a separate declaration, all it really does is create + * a false high level token for everything in this file to belong + * to... But we don't know what kind it is, so we declare it as + * ADA_KIND_SEPARATE, which will cause it not to be placed in + * the tag file, and the item in this file will be printed as + * separate:<name> instead of package:<name> or whatever the + * parent kind really is (assuming the ctags option will be on + * for printing such info to the tag file) + * ----------------------------------------------------------------- + * Now we have reference tags. So we can use ADA_KIND_PACKAGE as kind. + */ + token = newAdaTokenFull (&line[pos], i, ADA_KIND_PACKAGE, ADA_PACKAGE_SUBUNIT, + false, parent); + + /* since this is a false top-level token, set parent to be + * token */ + parent = token; + token = NULL; + + /* skip past the ')' */ + skipPast (")"); + } + else + { + /* move to the end of this statement */ + skipPast (";"); + } + } + else + { + /* otherwise, nothing was found so just skip until the end of this + * unknown statement... It's most likely just a use or with + * clause. Also set token to NULL so we don't attempt anything + * incorrect */ + token = NULL; + skipPast (";"); + } + + /* check to see if we succeeded in creating our token */ + if (token != NULL) + { + /* if any generic params have been gathered, attach them to + * token */ + appendAdaTokenList (token, &genericParamsRoot.children); + } + + break; + + case ADA_GENERIC: + /* if we are processing a generic block, make up some temp children + * which we will later attach to the root of the real + * procedure/package/whatever the formal parameters are for */ + if (adaKeywordCmp (ADA_KEYWORD_PACKAGE)) + { + token = adaParseBlock (parent, ADA_KIND_PACKAGE); + + /* The above 'adaParseBlock' has read the end of a 'generic package declaration', + * reset the mode back to the original mode. + * see: ARM 12.1(24) */ + Assert (parent); + mode = (parent->parent)? ADA_DECLARATIONS: ADA_ROOT; + } + else if (adaKeywordCmp (ADA_KEYWORD_PROCEDURE) || + adaKeywordCmp (ADA_KEYWORD_FUNCTION)) + { + token = adaParseSubprogram (parent, ADA_KIND_SUBPROGRAM); + + /* The above 'adaParseBlock' as read the end of a 'generic function/procedure declaration', + * reset the mode back to the original mode. + * see: ARM 12.1(21/22) */ + Assert (parent); + mode = (parent->parent)? ADA_DECLARATIONS: ADA_ROOT; + } + else if (adaKeywordCmp (ADA_KEYWORD_TASK)) + { + token = adaParseBlock (parent, ADA_KIND_TASK); + } + else if (adaKeywordCmp (ADA_KEYWORD_PROTECTED)) + { + token = adaParseBlock (parent, ADA_KIND_PROTECTED); + } + else if (adaKeywordCmp (ADA_KEYWORD_TYPE)) + { + skipWhiteSpace (); + + /* get length of tag */ + for (i = 1; (pos + i) < lineLen && !isspace (line[pos + i]) && + line[pos + i] != '(' && line[pos + i] != ';'; i++); + + appendAdaToken (&genericParamsRoot, + newAdaToken (&line[pos], i, ADA_KIND_FORMAL, false, + NULL)); + + /* skip to the end of this formal type declaration */ + skipPast (";"); + } + else if (adaKeywordCmp (ADA_KEYWORD_WITH)) + { + skipWhiteSpace (); + /* skip over the function/procedure keyword, it doesn't matter for + * now */ + skipUntilWhiteSpace (); + skipWhiteSpace (); + + /* get length of tag */ + for (i = 1; (pos + i) < lineLen && !isspace (line[pos + i]) && + line[pos + i] != '(' && line[pos + i] != ';'; i++); + + appendAdaToken (&genericParamsRoot, + newAdaToken (&line[pos], i, ADA_KIND_FORMAL, false, + NULL)); + + /* increment the position */ + movePos (i); + + /* now gather the parameters to this subprogram */ + if (!eof_reached && line[pos] == '(') + { + while (!eof_reached && line[pos] != ')') + { + movePos (1); + adaParseVariables (genericParamsRoot.children.tail, + ADA_KIND_AUTOMATIC_VARIABLE); + } + movePos (1); + } + + /* skip to the end of this formal type declaration */ + skipPast (";"); + } + else + { + /* otherwise, nothing was found so just skip until the end of this + * unknown statement... It's most likely just a use or with + * clause. Also set token to NULL so we don't attempt anything + * incorrect */ + token = NULL; + skipPast (";"); + } + + /* check to see if we succeeded in creating our token */ + if (token != NULL) + { + /* if any generic params have been gathered, attach them to + * token. */ + appendAdaTokenList (token, &genericParamsRoot.children); + } + + break; + + case ADA_DECLARATIONS: + if (adaKeywordCmp (ADA_KEYWORD_PACKAGE)) + { + token = adaParseBlock (parent, ADA_KIND_PACKAGE); + } + else if (adaKeywordCmp (ADA_KEYWORD_PROCEDURE) || + adaKeywordCmp (ADA_KEYWORD_FUNCTION)) + { + token = adaParseSubprogram (parent, ADA_KIND_SUBPROGRAM); + } + else if (adaKeywordCmp (ADA_KEYWORD_TASK)) + { + token = adaParseBlock (parent, ADA_KIND_TASK); + } + else if (adaKeywordCmp (ADA_KEYWORD_PROTECTED)) + { + token = adaParseBlock (parent, ADA_KIND_PROTECTED); + } + else if (adaKeywordCmp (ADA_KEYWORD_GENERIC)) + { + /* if we have hit a generic declaration, go to the generic section + * and collect the formal parameters */ + mode = ADA_GENERIC; + break; + } + else if (adaKeywordCmp (ADA_KEYWORD_TYPE)) + { + token = adaParseType (parent, ADA_KIND_TYPE); + } + else if (adaKeywordCmp (ADA_KEYWORD_SUBTYPE)) + { + token = adaParseType (parent, ADA_KIND_SUBTYPE); + } + else if (adaKeywordCmp (ADA_KEYWORD_BEGIN)) + { + mode = ADA_CODE; + break; + } + else if (adaKeywordCmp (ADA_KEYWORD_FOR)) + { + /* if we hit a "for" statement it is defining implementation details + * for a specific type/variable/subprogram/etc... So we should just + * skip it, so skip the tag, then we need to see if there is a + * 'record' keyword... If there is we must skip past the + * 'end record;' statement. First skip past the tag */ + skipPastKeyword (ADA_KEYWORD_USE); + skipWhiteSpace (); + + if (adaKeywordCmp (ADA_KEYWORD_RECORD)) + { + /* now skip to the next "record" keyword, which should be the end + * of this use statement */ + skipPastKeyword (ADA_KEYWORD_RECORD); + } + + /* lastly, skip past the end ";" */ + skipPast (";"); + } + else if (adaKeywordCmp (ADA_KEYWORD_END)) + { + /* if we have hit an end then we must see if the next word matches + * the parent token's name. If it does we hit the end of whatever + * sort of block construct we were processing and we must + * return */ + skipWhiteSpace (); + if (adaCmp (parent->name)) + { + skipPast (";"); + + /* return the token */ + freeAdaTokenList (&genericParamsRoot.children); + return token; + } + else + { + /* set the token to NULL so we accidentally don't pick up something + * from earlier */ + token = NULL; + skipPast (";"); + } + } + else if (adaKeywordCmp (ADA_KEYWORD_ENTRY)) + { + token = adaParseSubprogram (parent, ADA_KIND_ENTRY); + } + else if (adaKeywordCmp (ADA_KEYWORD_PRIVATE)) + { + /* if this is a private declaration then we need to set the global + * file spec flag and then skip whitespace to get to the next bit of + * code to parse. */ + if (parent != NULL) + { + parent->isPrivate = true; + } + + skipWhiteSpace (); + } + else if (adaKeywordCmp (ADA_KEYWORD_OVERRIDING) + || adaKeywordCmp (ADA_KEYWORD_NOT)) + { + /* Do nothing, just ignore these keywords. */ + ; + } + else + { + /* if nothing else matched this is probably a variable, constant + * or exception declaration */ + token = adaParseVariables (parent, ADA_KIND_VARIABLE); + skipPast (";"); + } + + /* check to see if we succeeded in creating our token */ + if (token != NULL) + { + /* if this is one of the root-type tokens... Do some extra + * processing */ + if (token->kind == ADA_KIND_PACKAGE || + token->kind == ADA_KIND_SUBPROGRAM || + token->kind == ADA_KIND_TASK || + token->kind == ADA_KIND_PROTECTED) + { + /* if any generic params have been gathered, attach them to + * token */ + appendAdaTokenList (token, &genericParamsRoot.children); + } + } + break; + + case ADA_CODE: + if (adaKeywordCmp (ADA_KEYWORD_DECLARE)) + { + /* if we are starting a declare block here, and not down at the + * identifier definition then make an anonymous token to track the + * data in this block */ + token = newAdaToken (NULL, 0, ADA_KIND_ANONYMOUS, false, parent); + + /* save the correct starting line */ + token->tag.lineNumber = matchLineNum; + token->tag.filePosition = matchFilePos; + + adaParse (ADA_DECLARATIONS, token); + } + else if (adaKeywordCmp (ADA_KEYWORD_BEGIN)) + { + /* if we are starting a code block here, and not down at the + * identifier definition then make an anonymous token to track the + * data in this block, if this was part of a proper LABEL: + * declare/begin/end block then the parent would already be a label + * and this begin statement would have been found while in the + * ADA_DECLARATIONS parsing section */ + token = newAdaToken (NULL, 0, ADA_KIND_ANONYMOUS, false, parent); + + /* save the correct starting line */ + token->tag.lineNumber = matchLineNum; + token->tag.filePosition = matchFilePos; + + adaParse (ADA_CODE, token); + } + else if (adaKeywordCmp (ADA_KEYWORD_EXCEPTION)) + { + mode = ADA_EXCEPTIONS; + break; + } + else if (adaKeywordCmp (ADA_KEYWORD_END)) + { + /* if we have hit an end then we must see if the next word matches + * the parent token's name. If it does we hit the end of whatever + * sort of block construct we were processing and we must + * return */ + skipWhiteSpace (); + if (adaCmp (parent->name)) + { + skipPast (";"); + + /* return the token */ + freeAdaTokenList (&genericParamsRoot.children); + return token; + } + else if (adaKeywordCmp (ADA_KEYWORD_LOOP)) + { + /* a loop with an identifier has this syntax: + * "end loop <ident>;" */ + skipWhiteSpace (); + + /* now check for the parent loop's name */ + if (adaCmp (parent->name)) + { + skipPast (";"); + + /* return the token */ + freeAdaTokenList (&genericParamsRoot.children); + return token; + } + } + else + { + /* otherwise, nothing was found so just skip until the end of + * this statement */ + skipPast (";"); + } + } + else if (adaKeywordCmp (ADA_KEYWORD_ACCEPT)) + { + adaParseSubprogram (parent, ADA_KIND_ENTRY); + } + else if (adaKeywordCmp (ADA_KEYWORD_FOR)) + { + /* if this is a for loop, then we may need to pick up the + * automatic loop iterator, But... The loop variable is only + * available within the loop itself so make an anonymous label + * parent for this loop var to be parsed in */ + token = newAdaToken (AdaKeywords[ADA_KEYWORD_LOOP], + strlen (AdaKeywords[ADA_KEYWORD_LOOP]), + ADA_KIND_ANONYMOUS, false, parent); + adaParseLoopVar (token); + adaParse (ADA_CODE, token); + } + else if (adaKeywordCmp (ADA_KEYWORD_WHILE)) + { + token = newAdaToken (AdaKeywords[ADA_KEYWORD_LOOP], + strlen (AdaKeywords[ADA_KEYWORD_LOOP]), + ADA_KIND_ANONYMOUS, false, parent); + + /* skip past the while loop declaration and parse the loop body */ + skipPastKeyword (ADA_KEYWORD_LOOP); + skipWhiteSpace (); + adaParse (ADA_CODE, token); + } + else if (adaKeywordCmp (ADA_KEYWORD_LOOP)) + { + token = newAdaToken (AdaKeywords[ADA_KEYWORD_LOOP], + strlen (AdaKeywords[ADA_KEYWORD_LOOP]), + ADA_KIND_ANONYMOUS, false, parent); + + /* save the correct starting line */ + token->tag.lineNumber = matchLineNum; + token->tag.filePosition = matchFilePos; + + /* parse the loop body */ + skipWhiteSpace (); + adaParse (ADA_CODE, token); + } + else if (line != NULL && + strncasecmp (&line[pos], "<<", strlen ("<<")) == 0) + { + movePos (strlen ("<<")); + + /* if the first chars are <<, find the ending >> and if we do that + * then store the label tag, start i at strlen of "<<" plus 1 + * because we don't want to move the real pos until we know for + * sure this is a label */ + for (i = 1; (pos + i) < lineLen && + strncasecmp (&line[pos + i], ">>", strlen (">>")) != 0; + i++); + + /* if we didn't increment to the end of the line, a match was + * found, if we didn't just fall through */ + if ((pos + i) < lineLen) + { + newAdaToken (&line[pos], i, ADA_KIND_LABEL, false, parent); + skipPast (">>"); + } + } + /* we need to check for a few special case keywords that might cause + * the simple ; ending statement checks to fail, first the simple + * one word keywords and then the start <stuff> end statements */ + else if (adaKeywordCmp (ADA_KEYWORD_SELECT) || + adaKeywordCmp (ADA_KEYWORD_OR) || + adaKeywordCmp (ADA_KEYWORD_ELSE)) + { + skipWhiteSpace (); + } + else if (adaKeywordCmp (ADA_KEYWORD_IF) || + adaKeywordCmp (ADA_KEYWORD_ELSIF)) + { + skipPastKeyword (ADA_KEYWORD_THEN); + } + else if (adaKeywordCmp (ADA_KEYWORD_CASE)) + { + skipPastKeyword (ADA_KEYWORD_IS); + } + else if (adaKeywordCmp (ADA_KEYWORD_WHEN)) + { + skipPast ("=>"); + } + else + { + int i_end; + /* set token to NULL so we don't accidentally not find an identifier, + * But then fall through to the != NULL check */ + token = NULL; + + /* there is a possibility that this may be a loop or block + * identifier, so check for a <random_word>[ ]?: statement */ + for (i = 1; (pos + i) < lineLen; i++) + if(!(isalnum (line[pos + i]) || line[pos + i] == '_')) + break; + i_end = i; /* Records the end of identifier. */ + + /* Skip whitespaces between the identifier and ':' */ + for (; (pos + i) < lineLen; i++) + if (!isspace((unsigned char)(line[pos + i]))) + break; + + if ((pos + i) < lineLen + && (line[pos + i] == ':') + && ( + ((pos + i + 1) == lineLen) + || (line[pos + i + 1] != '=') + )) + token = newAdaToken (&line[pos], i_end, ADA_KIND_IDENTIFIER, false, + parent); + + /* if we created a token, we found an identifier. Now check for a + * declare or begin statement to see if we need to start parsing + * the following code like a root-style token would */ + if (token != NULL) + { + /* if something was found, reset the position variable and try to + * find the next item */ + movePos (i + 1); + skipWhiteSpace (); + + if (adaKeywordCmp (ADA_KEYWORD_DECLARE)) + { + adaParse (ADA_DECLARATIONS, token); + } + else if (adaKeywordCmp (ADA_KEYWORD_BEGIN)) + { + adaParse (ADA_CODE, token); + } + else if (adaKeywordCmp (ADA_KEYWORD_FOR)) + { + /* just grab the automatic loop variable, and then parse the + * loop (it may have something to tag which will be a 'child' + * of the loop) */ + adaParseLoopVar (token); + adaParse (ADA_CODE, token); + } + else if (adaKeywordCmp (ADA_KEYWORD_WHILE)) + { + /* skip to the loop keyword */ + skipPastKeyword (ADA_KEYWORD_LOOP); + skipWhiteSpace (); + + /* parse the loop (it may have something to tag which will be + * a 'child' of the loop) */ + adaParse (ADA_CODE, token); + } + else if (adaKeywordCmp (ADA_KEYWORD_LOOP)) + { + skipWhiteSpace (); + + /* parse the loop (it may have something to tag which will be + * a 'child' of the loop) */ + adaParse (ADA_CODE, token); + } + else + { + /* otherwise, nothing was found so this is not a valid + * identifier, delete it */ + freeAdaToken (&parent->children, token); + token = NULL; + } + } + else + { + /* since nothing was found, simply skip to the end of this + * statement */ + skipPast (";"); + } + } + /* else... No keyword tag fields found, look for others such as + * loop and declare identifiers labels or just skip over this + * line */ + + break; + + case ADA_EXCEPTIONS: + if (adaKeywordCmp (ADA_KEYWORD_PRAGMA)) + { + skipPast (";"); + } + else if (adaKeywordCmp (ADA_KEYWORD_WHEN)) + { + skipWhiteSpace (); + token = adaParseVariables (parent, ADA_KIND_AUTOMATIC_VARIABLE); + } + else if (adaKeywordCmp (ADA_KEYWORD_END)) + { + /* if we have hit an end then we must see if the next word matches + * the parent token's name. If it does we hit the end of whatever + * sort of block construct we were processing and we must + * return */ + skipWhiteSpace (); + if (adaCmp (parent->name)) + { + skipPast (";"); + + /* return the token */ + freeAdaTokenList (&genericParamsRoot.children); + return token; + } + else + { + /* otherwise, nothing was found so just skip until the end of + * this statement */ + skipPast (";"); + } + } + else + { + /* otherwise, nothing was found so just skip until the end of + * this statement */ + skipPast (";"); + } + + break; + + default: + Assert (0); + } + } + + freeAdaTokenList (&genericParamsRoot.children); + return token; +} + +static void storeAdaTags (adaTokenInfo *token, const char *parentScope) +{ + char *currentScope = NULL; + adaTokenInfo *tmp = NULL; + + Assert (token); + + /* do a spec transition if necessary */ + if (token->isSpec == true) + { + makeSpec (&token->kind); + + if (token->kind != ADA_KIND_UNDEFINED) + { + token->tag.kindIndex = token->kind; + } + } + + /* fill in the scope data */ + if (token->parent != NULL) + { + if (token->parent->kind != ADA_KIND_UNDEFINED) + { + token->tag.extensionFields.scopeKindIndex = token->parent->kind; + token->tag.extensionFields.scopeName = token->parent->name; + } + } + + /* one check before we try to make a tag... If this is an anonymous + * declare block then it's name is empty. Give it one */ + if (token->kind == ADA_KIND_ANONYMOUS && token->name == NULL) + { + token->name = (char *) AdaKeywords[ADA_KEYWORD_DECLARE]; + token->tag.name = AdaKeywords[ADA_KEYWORD_DECLARE]; + } + + /* Now 'make' tags that have their options set, But only make anonymous + * tags if they have children tags. Also, don't make this tag if the file + * scope flag is not set and this tag is a file scope tag. */ + if ((token->kind > ADA_KIND_UNDEFINED) && (token->kind < ADA_KIND_COUNT) && + (AdaKinds[token->kind].enabled == true) && + (token->name != NULL) && + ((token->kind == ADA_KIND_ANONYMOUS && token->children.head != NULL) || + token->kind != ADA_KIND_ANONYMOUS) && + ((isXtagEnabled (XTAG_FILE_SCOPE) == true) || + ((isXtagEnabled (XTAG_FILE_SCOPE) == false) && + (token->tag.isFileScope == false)))) + { + makeTagEntry (&token->tag); + + /* before making the tag, if the --extra=+q flag is set we should create + * an extra entry which is the full parent.tag name. But only do this if + * the parentScope flag is not NULL, and this token is not of a limited + * scope type such as a record component, enum literal, label, etc. */ + if ((isXtagEnabled (XTAG_QUALIFIED_TAGS) == true) && + (token->kind != ADA_KIND_RECORD_COMPONENT) && + (token->kind != ADA_KIND_ENUM_LITERAL) && + (token->kind != ADA_KIND_FORMAL) && + (token->kind != ADA_KIND_LABEL) && + (token->kind != ADA_KIND_IDENTIFIER) && + (token->kind != ADA_KIND_AUTOMATIC_VARIABLE) && + (token->kind != ADA_KIND_ANONYMOUS)) + { + if (parentScope != NULL) + { + /* first create our new scope which is the parent scope + '.' + the + * current tag name. */ + size_t parentScope_len = strlen (parentScope); + size_t name_len = strlen (token->name); + currentScope = xMalloc (parentScope_len + name_len + 2, char); + memcpy (currentScope, parentScope, parentScope_len); + currentScope[parentScope_len] = '.'; + memcpy (&currentScope[parentScope_len + 1], token->name, name_len); + currentScope[parentScope_len + 1 + name_len] = '\0'; + + token->tag.name = currentScope; + markTagExtraBit (&token->tag, XTAG_QUALIFIED_TAGS); + makeTagEntry (&token->tag); + } + else + { + /* if the parent scope is null then the current token does not have + * a parent tag to prepend onto the current scope. Therefore, just + * setup the current scope as a copy of the current tag name, but make + * no extra entry. */ + currentScope = token->name; + } + } + } + + /* now make the child tags */ + tmp = token->children.head; + while (tmp != NULL) + { + storeAdaTags (tmp, currentScope); + tmp = tmp->next; + } + + /* we have to clear out the declare name here or else it may cause issues + * when we try to process it's children, and when we try to free the token + * data */ + if (token->kind == ADA_KIND_ANONYMOUS && + strncasecmp (token->name, AdaKeywords[ADA_KEYWORD_DECLARE], + strlen (AdaKeywords[ADA_KEYWORD_DECLARE])) == 0) + { + token->name = NULL; + token->tag.name = NULL; + } + + if ((currentScope != NULL) && (currentScope != token->name)) + { + eFree ((void *) currentScope); + } +} + +/* main parse function */ +static void findAdaTags (void) +{ + adaTokenInfo root; + adaTokenInfo *tmp; + + /* init all global data now */ + eof_reached = false; + line = NULL; + pos = 0; + matchLineNum = 0; + + /* cannot just set matchFilePos to 0 because the fpos_t is not a simple + * integer on all systems. */ + matchFilePos = getInputFilePosition (); + + /* init the root tag */ + root.kind = ADA_KIND_UNDEFINED; + root.isSpec = false; + root.name = NULL; + root.parent = NULL; + root.isPrivate = false; + initAdaTokenList (&root.children); + + /* read in the first line */ + readNewLine (); + if (eof_reached) + goto out; + + /* tokenize entire file */ + while (!eof_reached && adaParse (ADA_ROOT, &root) != NULL); + + /* store tags */ + tmp = root.children.head; + while (tmp != NULL) + { + storeAdaTags (tmp, NULL); + tmp = tmp->next; + } + + out: + /* clean up tokens */ + freeAdaTokenList (&root.children); +} + +/* parser definition function */ +extern parserDefinition* AdaParser (void) +{ + static const char *const extensions[] = { "adb", "ads", "Ada", "ada", NULL }; + parserDefinition* def = parserNew ("Ada"); + def->kindTable = AdaKinds; + def->kindCount = ADA_KIND_COUNT; + def->extensions = extensions; + def->parser = findAdaTags; + return def; +} Modified: meson.build 1 lines changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -589,6 +589,7 @@ ctags = static_library('ctags', 'ctags/main/xtag_p.h', 'ctags/parsers/abaqus.c', 'ctags/parsers/abc.c', + 'ctags/parsers/ada.c', 'ctags/parsers/asciidoc.c', 'ctags/parsers/asm.c', 'ctags/parsers/basic.c', Modified: src/filetypes.c 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -176,7 +176,7 @@ static void init_builtin_filetypes(void) FT_INIT( YAML, NONE, "YAML", NULL, FILE, MISC ); FT_INIT( CMAKE, NONE, "CMake", NULL, SOURCE_FILE, SCRIPT ); FT_INIT( NSIS, NSIS, "NSIS", NULL, SOURCE_FILE, SCRIPT ); - FT_INIT( ADA, NONE, "Ada", NULL, SOURCE_FILE, COMPILED ); + FT_INIT( ADA, ADA, "Ada", NULL, SOURCE_FILE, COMPILED ); FT_INIT( FORTH, NONE, "Forth", NULL, SOURCE_FILE, SCRIPT ); FT_INIT( ASCIIDOC, ASCIIDOC, "Asciidoc", NULL, SOURCE_FILE, MARKUP ); FT_INIT( ABAQUS, ABAQUS, "Abaqus", NULL, SOURCE_FILE, SCRIPT ); Modified: src/tagmanager/tm_parser.c 40 lines changed, 39 insertions(+), 1 deletions(-) =================================================================== @@ -1031,6 +1031,43 @@ static TMParserMapGroup group_TYPESCRIPT[] = { {_("Other"), TM_ICON_MEMBER, tm_tag_member_t | tm_tag_enumerator_t}, }; +static TMParserMapEntry map_ADA[] = { + {'P', tm_tag_package_t}, // packspec + {'p', tm_tag_package_t}, // package + {'T', tm_tag_typedef_t}, // typespec + {'t', tm_tag_typedef_t}, // type + {'U', tm_tag_undef_t}, // subspec + {'u', tm_tag_typedef_t}, // subtype + {'c', tm_tag_member_t}, // component + {'l', tm_tag_enumerator_t}, // literal + {'V', tm_tag_undef_t}, // varspec + {'v', tm_tag_variable_t}, // variable + {'f', tm_tag_undef_t}, // formal + {'n', tm_tag_macro_t}, // constant + {'x', tm_tag_undef_t}, // exception + {'R', tm_tag_prototype_t}, // subprogspec + {'r', tm_tag_function_t}, // subprogram + {'K', tm_tag_prototype_t}, // taskspec + {'k', tm_tag_method_t}, // task + {'O', tm_tag_undef_t}, // protectspec + {'o', tm_tag_undef_t}, // protected + {'E', tm_tag_undef_t}, // entryspec + {'e', tm_tag_undef_t}, // entry + {'b', tm_tag_undef_t}, // label + {'i', tm_tag_undef_t}, // identifier + {'a', tm_tag_undef_t}, // autovar + {'y', tm_tag_undef_t}, // anon +}; +static TMParserMapGroup group_ADA[] = { + {_("Packages"), TM_ICON_NAMESPACE, tm_tag_package_t}, + {_("Types"), TM_ICON_STRUCT, tm_tag_typedef_t}, + {_("Functions"), TM_ICON_METHOD, tm_tag_function_t | tm_tag_prototype_t}, + {_("Tasks"), TM_ICON_METHOD, tm_tag_method_t}, + {_("Variables"), TM_ICON_VAR, tm_tag_variable_t}, + {_("Constants"), TM_ICON_MACRO, tm_tag_macro_t}, + {_("Other"), TM_ICON_MEMBER, tm_tag_member_t | tm_tag_enumerator_t}, +}; + typedef struct { TMParserMapEntry *entries; @@ -1075,7 +1112,7 @@ static TMParserMap parser_map[] = { MAP_ENTRY(HAXE), MAP_ENTRY(REST), MAP_ENTRY(HTML), - MAP_ENTRY(UNUSED1), + MAP_ENTRY(ADA), MAP_ENTRY(CUDA), MAP_ENTRY(MATLAB), MAP_ENTRY(VALA), @@ -1613,6 +1650,7 @@ gboolean tm_parser_has_full_scope(TMParserType lang) /* These make use of the scope, but don't include nested hierarchy * (either as a parser limitation or a language semantic) */ + case TM_PARSER_ADA: case TM_PARSER_ASCIIDOC: case TM_PARSER_CLOJURE: case TM_PARSER_CONF: Modified: src/tagmanager/tm_parser.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -89,7 +89,7 @@ enum TM_PARSER_HAXE, TM_PARSER_REST, TM_PARSER_HTML, - TM_PARSER_UNUSED1, /* dummy entry, replace with some new parser */ + TM_PARSER_ADA, TM_PARSER_CUDA, TM_PARSER_MATLAB, TM_PARSER_VALA, Modified: src/tagmanager/tm_parsers.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -45,7 +45,7 @@ HaxeParser,\ RstParser, \ HtmlParser, \ - LiterateHaskellParser, /* dummy entry, replace with some new parser */ \ + AdaParser, \ CUDAParser, \ MatLabParser, \ ValaParser, \ Modified: tests/ctags/Makefile.am 7 lines changed, 7 insertions(+), 0 deletions(-) =================================================================== @@ -19,6 +19,13 @@ test_sources = \ actionscript/method-attributes.as \ actionscript/packages.as \ actionscript/sampler.as \ + ada-adb.adb \ + ada-ads.ads \ + ada-expression-function.adb \ + ada-expression-function-generic.adb \ + ada-overriding.ads \ + ada-package-generic.ads \ + ada-task.adb \ angle_bracket.cpp \ anonymous_functions.php \ arraylist.js \ Modified: tests/ctags/ada-adb.adb 64 lines changed, 64 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,64 @@ +-- Taken from altivec of GNAT examples (http://www.adacore.com/developers/code-samples/gnat-examples/) +-- ==================================================================================================== +-- This example shows how to create and manipulate vectors by the mean of high +-- level views. + +with GNAT.Altivec; use GNAT.Altivec; +with GNAT.Altivec.Conversions; use GNAT.Altivec.Conversions; +with GNAT.Altivec.Vector_Operations; use GNAT.Altivec.Vector_Operations; +with GNAT.Altivec.Vector_Types; use GNAT.Altivec.Vector_Types; +with GNAT.Altivec.Vector_Views; use GNAT.Altivec.Vector_Views; + +with GNAT.IO; use GNAT.IO; + +procedure Altivec is + + View_A : constant VUI_View := (Values => (1, 2, 3, 4)); + Vector_A : constant vector_unsigned_int := To_Vector (View_A); + + View_B : constant VUI_View := (Values => (1, 1, 1, 1)); + Vector_B : constant vector_unsigned_int := To_Vector (View_B); + + Vector_C : vector_unsigned_int; + View_C : VUI_View; + +begin + Vector_C := vec_add (Vector_A, Vector_B); + -- C = A + B + + View_C := To_View (Vector_C); + + for I in View_C.Values'Range loop + Put_Line (unsigned_int'Image (View_C.Values (I))); + end loop; + +end Altivec; + +procedure Greet is + type Days is (Monday, Tuesday, Wednesday, + Thursday, Friday, + Saturday, Sunday); + + -- Declaration of a subtype + subtype Weekend_Days is + Days range Saturday .. Sunday; + -- ^ Constraint of the subtype + + M : Days := Sunday; + + S : Weekend_Days := M; + -- No error here, Days and Weekend_Days + -- are of the same type. +begin + for I in Days loop + case I is + -- Just like a type, a subtype can + -- be used as a range + when Weekend_Days => + Put_Line ("Week end!"); + when others => + Put_Line ("Hello on " + & Days'Image (I)); + end case; + end loop; +end Greet; \ No newline at end of file Modified: tests/ctags/ada-adb.adb.tags 20 lines changed, 20 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,20 @@ +# format=tagmanager +Altivec�16�0 +Days�4096�Greet�0 +Friday�4�Days�0 +Greet�16�0 +M�16384�Greet�0 +Monday�4�Days�0 +S�16384�Greet�0 +Saturday�4�Days�0 +Sunday�4�Days�0 +Thursday�4�Days�0 +Tuesday�4�Days�0 +Vector_A�65536�Altivec�0 +Vector_B�65536�Altivec�0 +Vector_C�16384�Altivec�0 +View_A�65536�Altivec�0 +View_B�65536�Altivec�0 +View_C�16384�Altivec�0 +Wednesday�4�Days�0 +Weekend_Days�4096�Greet�0 Modified: tests/ctags/ada-ads.ads 50 lines changed, 50 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,50 @@ +-- Object-oriented generalized stack. This illustrates the use of a +-- controlled type, which is one that has construction and destructions. +-- It also shows how to create two related types in the same package so +-- that they can share private declarations. This sort of thing is +-- accomplished in Java or C++ using nested classes, or using friend +-- declarations in C++. +-- +with Ada.Finalization; use Ada.Finalization; + +package GenStack is + -- This is the stack type. + type Stack is new Controlled with private; + + -- This is the base type for nodes. Client packages must derive their + -- nodes from StackData. Since it comes from Controlled, the user can + -- override the Initialize, Adjust, and Finalize methods as needed. + type StackData is new Controlled with null record; + + -- Initialization operations. + procedure Initialize(S: in out Stack); + procedure Adjust(S: in out Stack); + procedure Finalize(S: in out Stack); + + -- Stack operations. + procedure Push(S: in out Stack; D: StackData'class); + procedure Pop(S: in out Stack; D: in out StackData'class); + procedure Top(S: Stack; Data: in out StackData'class); + function Empty(S: Stack) return Boolean; + + private + -- Pointer to the node type. + type Node; + type Node_Ptr is access Node; + + -- Here is the generalized stack itself. We would just make it the + -- pointer itself, but it needs to be a record so it can be in a with. + type Stack is new Controlled with record + Head: Node_Ptr; + end record; + + -- Now, we need a pointer to the data part. + type Data_Ptr is access StackData'Class; + + -- This is the node type. + type Node is record + Data: Data_Ptr; + Next: Node_Ptr; + end record; + +end GenStack; Modified: tests/ctags/ada-ads.ads.tags 17 lines changed, 17 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,17 @@ +# format=tagmanager +Adjust�1024�GenStack�0 +Data�64�Node�0 +Data_Ptr�4096�GenStack�0 +Empty�1024�GenStack�0 +Finalize�1024�GenStack�0 +GenStack�512�0 +Head�64�Stack�0 +Initialize�1024�GenStack�0 +Next�64�Node�0 +Node�4096�GenStack�0 +Node_Ptr�4096�GenStack�0 +Pop�1024�GenStack�0 +Push�1024�GenStack�0 +Stack�4096�GenStack�0 +StackData�4096�GenStack�0 +Top�1024�GenStack�0 Modified: tests/ctags/ada-expression-function-generic.adb 18 lines changed, 18 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,18 @@ +procedure My_Package is + + generic + type Unsigned_Type is range <>; + package Generic_Integer_Images is + function Digit_To_Character (X : Unsigned_Type) return Character; + end Generic_Integer_Images; + + package body Generic_Integer_Images is + function Digit_To_Character (X : Unsigned_Type) return Character is + (Character'Val (0)); + end Generic_Integer_Images; + + type Signed_Address is range + -2**(Standard'Address_Size - 1) .. 2**(Standard'Address_Size - 1) - 1; +begin + null; +end My_Package; Modified: tests/ctags/ada-expression-function-generic.adb.tags 6 lines changed, 6 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,6 @@ +# format=tagmanager +Digit_To_Character�16�Generic_Integer_Images�0 +Digit_To_Character�1024�Generic_Integer_Images�0 +Generic_Integer_Images�512�My_Package�0 +My_Package�16�0 +Signed_Address�4096�My_Package�0 Modified: tests/ctags/ada-expression-function.adb 38 lines changed, 38 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,38 @@ +with Ada.Text_IO; + +procedure Test is + + My_Type : Boolean := True; + + procedure Tagged_Procedure is + function Boolean_As_String return String is + (case My_Type is + when True => "True Value", + when False => "False Value"); + + function Another_Boolean_As_String return String is + (case My_Type is when True => "; function dummy0 return String is (", + when False => "; function dummy1 return String is ("); + procedure p0 is + begin + Ada.Text_IO.put ("-0"); + end p0; + function Yet_Boolean_As_String return String is + (case My_Type is + when True => "1", + when False => "0"); + procedure p1 is + begin + Ada.Text_IO.put ("-1"); + end p1; + begin + null; + end Tagged_Procedure; + + procedure Not_Tagged_Procedure is + begin + null; + end Not_Tagged_Procedure; +begin + null; +end Test; Modified: tests/ctags/ada-expression-function.adb.tags 10 lines changed, 10 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,10 @@ +# format=tagmanager +Another_Boolean_As_String�16�Tagged_Procedure�0 +Boolean_As_String�16�Tagged_Procedure�0 +My_Type�16384�Test�0 +Not_Tagged_Procedure�16�Test�0 +Tagged_Procedure�16�Test�0 +Test�16�0 +Yet_Boolean_As_String�16�Tagged_Procedure�0 +p0�16�Tagged_Procedure�0 +p1�16�Tagged_Procedure�0 Modified: tests/ctags/ada-overriding.ads 42 lines changed, 42 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,42 @@ +-- Taken from #2382 submitted by @JulienPivard +-- @summary +-- Implémentation par une tâche. +-- @description +-- Implémentation par une tache de la classe synchronisé. +-- @group Version tâche +-- +-- package Carte_P.Tasche_P +package Input + with + Pure => False, + Preelaborate => False, + Elaborate_Body => True, + Spark_Mode => Off +is + + --------------------------------------------------------------------------- + task type Tasche_T is new Carte_T with + -- Implémentation par une tâche de l'interface Carte_T. + + ----------------------------------- + overriding + entry Coucou; + -- Implémentation par un accept. + + ----------------------------------- + -- overriding + -- entry Inutile; + -- Implémentation par un accept. + -- @param This + -- La carte. + end Tasche_T; + --------------------------------------------------------------------------- + + overriding + procedure Inutile + (This : in out Tasche_T); + -- Implémentation par une procédure. + -- @param This + -- La carte. + +end Carte_P.Tasche_P; Modified: tests/ctags/ada-overriding.ads.tags 4 lines changed, 4 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,4 @@ +# format=tagmanager +Input�512�0 +Inutile�1024�Input�0 +Tasche_T�1024�Input�0 Modified: tests/ctags/ada-package-generic.ads 16 lines changed, 16 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,16 @@ +-- Taken from #2925 submitted by @koenmeersman +package My_Package is + + generic + type Num is digits <>; + package Conversions is + function From_Big_Real (Arg : Integer) return Num; + end Conversions; + + type Missing_Tag is record + Num : Integer; + end record; + + type Primary_Color is (Red, Green, Blue); + +end My_Package; Modified: tests/ctags/ada-package-generic.ads.tags 10 lines changed, 10 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,10 @@ +# format=tagmanager +Blue�4�Primary_Color�0 +Conversions�512�My_Package�0 +From_Big_Real�1024�Conversions�0 +Green�4�Primary_Color�0 +Missing_Tag�4096�My_Package�0 +My_Package�512�0 +Num�64�Missing_Tag�0 +Primary_Color�4096�My_Package�0 +Red�4�Primary_Color�0 Modified: tests/ctags/ada-task.adb 19 lines changed, 19 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,19 @@ +with Ada.Text_IO; use Ada.Text_IO; + +procedure Show_Simple_Tasks is + task T; + task T2; + + task body T is + begin + Put_Line ("In task T"); + end T; + + task body T2 is + begin + Put_Line ("In task T2"); + end T2; + +begin + Put_Line ("In main"); +end Show_Simple_Tasks; Modified: tests/ctags/ada-task.adb.tags 6 lines changed, 6 insertions(+), 0 deletions(-) =================================================================== @@ -0,0 +1,6 @@ +# format=tagmanager +Show_Simple_Tasks�16�0 +T�128�Show_Simple_Tasks�0 +T�1024�Show_Simple_Tasks�0 +T2�128�Show_Simple_Tasks�0 +T2�1024�Show_Simple_Tasks�0 Modified: tests/meson.build 7 lines changed, 7 insertions(+), 0 deletions(-) =================================================================== @@ -18,6 +18,13 @@ ctags_tests = files([ 'ctags/actionscript/method-attributes.as.tags', 'ctags/actionscript/packages.as.tags', 'ctags/actionscript/sampler.as.tags', + 'ctags/ada-adb.adb.tags', + 'ctags/ada-ads.ads.tags', + 'ctags/ada-expression-function.adb.tags', + 'ctags/ada-expression-function-generic.adb.tags', + 'ctags/ada-overriding.ads.tags', + 'ctags/ada-package-generic.ads.tags', + 'ctags/ada-task.adb.tags', 'ctags/angle_bracket.cpp.tags', 'ctags/anonymous_functions.php.tags', 'ctags/arraylist.js.tags', -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 13a58c: Fix anonymous tag renaming for Fortran structures
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: Jiří Techet <techet(a)gmail.com> Date: Mon, 11 Apr 2022 15:05:35 UTC Commit: 13a58c2b2e58d4a3157e93a7f2bd0d006b884cdf https://github.com/geany/geany/commit/13a58c2b2e58d4a3157e93a7f2bd0d006b884… Log Message: ----------- Fix anonymous tag renaming for Fortran structures See comment in the added code. Modified Paths: -------------- src/tagmanager/tm_ctags.c Modified: src/tagmanager/tm_ctags.c 16 lines changed, 16 insertions(+), 0 deletions(-) =================================================================== @@ -257,6 +257,7 @@ static void rename_anon_tags(TMSourceFile *source_file) gchar *orig_name, *new_name = NULL; guint j; guint new_name_len, orig_name_len; + gboolean inside_nesting = FALSE; guint scope_len = tag->scope ? strlen(tag->scope) : 0; gchar kind = tag->kind_letter; @@ -332,6 +333,21 @@ static void rename_anon_tags(TMSourceFile *source_file) guint nested_scope_len = nested_tag->scope ? strlen(nested_tag->scope) : 0; gchar *pos; + /* In Fortran, we can create variables of anonymous structures: + * structure var1, var2 + * integer a + * end structure + * and the parser first generates tags for var1 and var2 which + * are on the same scope as the structure itself. So first + * we need to skip past the tags on the same scope and only + * afterwards we get the nested tags. + * */ + if ((source_file->lang == TM_PARSER_F77 || source_file->lang == TM_PARSER_FORTRAN) && + !inside_nesting && nested_scope_len == scope_len) + continue; + + inside_nesting = TRUE; + /* Terminate if outside of tag scope, see above */ if (nested_scope_len <= scope_len) break; -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 272706: Merge pull request #3160 from techee/fortran_sync
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: GitHub <noreply(a)github.com> Date: Fri, 13 May 2022 00:27:02 UTC Commit: 272706848bbf388d17cbbc60a25497f5c2833b1b https://github.com/geany/geany/commit/272706848bbf388d17cbbc60a25497f5c2833… Log Message: ----------- Merge pull request #3160 from techee/fortran_sync Use the upstream Fortran parser Modified Paths: -------------- ctags/Makefile.am ctags/parsers/fortran.c meson.build src/filetypes.c src/tagmanager/tm_ctags.c src/tagmanager/tm_parser.c src/tagmanager/tm_parser.h src/tagmanager/tm_parsers.h tests/ctags/bug565813.f90.tags tests/ctags/bug670433.f90.tags tests/ctags/bug726712.f90.tags tests/ctags/enum.f90.tags tests/ctags/forall_module.f90.tags tests/ctags/fortran_associate.f90.tags tests/ctags/members.f90.tags tests/ctags/numlib.f90.tags tests/ctags/procedure_pointer_module.f90.tags tests/ctags/qualified_types.f90 tests/ctags/square_parens.f90.tags tests/ctags/stdcall.f.tags tests/ctags/structure.f.tags Modified: ctags/Makefile.am 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -59,7 +59,7 @@ parsers = \ parsers/geany_docbook.c \ parsers/erlang.c \ parsers/flex.c \ - parsers/geany_fortran.c \ + parsers/fortran.c \ parsers/gdscript.c \ parsers/go.c \ parsers/haskell.c \ Modified: ctags/parsers/fortran.c 738 lines changed, 538 insertions(+), 200 deletions(-) =================================================================== @@ -16,10 +16,8 @@ #include <string.h> #include <limits.h> #include <ctype.h> /* to define tolower () */ -#include <setjmp.h> #include "debug.h" -#include "mio.h" #include "entry.h" #include "keyword.h" #include "options.h" @@ -42,11 +40,6 @@ /* * DATA DECLARATIONS */ - -typedef enum eException { - ExceptionNone, ExceptionEOF, ExceptionFixedFormat, ExceptionLoop -} exception_t; - /* Used to designate type of line read in fixed source form. */ typedef enum eFortranLineType { @@ -62,6 +55,7 @@ typedef enum eFortranLineType { /* Used to specify type of keyword. */ enum eKeywordId { + KEYWORD_abstract, KEYWORD_allocatable, KEYWORD_assignment, KEYWORD_associate, @@ -71,12 +65,14 @@ enum eKeywordId { KEYWORD_byte, KEYWORD_cexternal, KEYWORD_cglobal, + KEYWORD_class, KEYWORD_character, KEYWORD_codimension, KEYWORD_common, KEYWORD_complex, KEYWORD_contains, KEYWORD_data, + KEYWORD_deferred, KEYWORD_dimension, KEYWORD_dllexport, KEYWORD_dllimport, @@ -90,11 +86,14 @@ enum eKeywordId { KEYWORD_equivalence, KEYWORD_extends, KEYWORD_external, + KEYWORD_final, KEYWORD_forall, KEYWORD_format, KEYWORD_function, + KEYWORD_generic, KEYWORD_if, KEYWORD_implicit, + KEYWORD_import, KEYWORD_include, KEYWORD_inline, KEYWORD_integer, @@ -107,17 +106,21 @@ enum eKeywordId { KEYWORD_map, KEYWORD_module, KEYWORD_namelist, + KEYWORD_non_overridable, + KEYWORD_nopass, KEYWORD_operator, KEYWORD_optional, KEYWORD_parameter, KEYWORD_pascal, + KEYWORD_pass, KEYWORD_pexternal, KEYWORD_pglobal, KEYWORD_pointer, KEYWORD_precision, KEYWORD_private, KEYWORD_procedure, KEYWORD_program, + KEYWORD_protected, KEYWORD_public, KEYWORD_pure, KEYWORD_real, @@ -129,6 +132,7 @@ enum eKeywordId { KEYWORD_static, KEYWORD_stdcall, KEYWORD_structure, + KEYWORD_submodule, KEYWORD_subroutine, KEYWORD_target, KEYWORD_then, @@ -145,6 +149,7 @@ typedef int keywordId; /* to allow KEYWORD_NONE */ typedef enum eTokenType { TOKEN_UNDEFINED, + TOKEN_EOF, TOKEN_COMMA, TOKEN_DOUBLE_COLON, TOKEN_IDENTIFIER, @@ -154,39 +159,55 @@ typedef enum eTokenType { TOKEN_OPERATOR, TOKEN_PAREN_CLOSE, TOKEN_PAREN_OPEN, - TOKEN_SQUARE_CLOSE, TOKEN_SQUARE_OPEN, + TOKEN_SQUARE_CLOSE, TOKEN_PERCENT, TOKEN_STATEMENT_END, - TOKEN_STRING + TOKEN_STRING, + TOKEN_COLON, } tokenType; typedef enum eTagType { TAG_UNDEFINED = -1, TAG_BLOCK_DATA, TAG_COMMON_BLOCK, TAG_ENTRY_POINT, + TAG_ENUM, TAG_FUNCTION, TAG_INTERFACE, TAG_COMPONENT, TAG_LABEL, TAG_LOCAL, TAG_MODULE, + TAG_METHOD, TAG_NAMELIST, + TAG_ENUMERATOR, TAG_PROGRAM, + TAG_PROTOTYPE, TAG_SUBROUTINE, TAG_DERIVED_TYPE, TAG_VARIABLE, - TAG_ENUM, - TAG_ENUMERATOR, + TAG_SUBMODULE, TAG_COUNT /* must be last */ } tagType; +typedef enum eImplementation { + IMP_DEFAULT, + IMP_ABSTRACT, + IMP_DEFERRED, + IMP_NON_OVERRIDABLE, + IMP_COUNT +} impType; + typedef struct sTokenInfo { tokenType type; keywordId keyword; tagType tag; vString* string; + vString* parentType; + vString* signature; + impType implementation; + bool isMethod; struct sTokenInfo *secondary; unsigned long lineNumber; MIOPos filePosition; @@ -198,37 +219,36 @@ typedef struct sTokenInfo { */ static langType Lang_fortran; -static langType Lang_f77; -static jmp_buf Exception; -static int Ungetc = '\0'; -static unsigned int Column = 0; -static bool FreeSourceForm = false; +static int Ungetc; +static unsigned int Column; +static bool FreeSourceForm; +static bool FreeSourceFormFound = false; static bool ParsingString; -static tokenInfo *Parent = NULL; -static bool NewLine = true; -static unsigned int contextual_fake_count = 0; /* indexed by tagType */ -static kindDefinition FortranKinds [TAG_COUNT] = { +static kindDefinition FortranKinds [] = { { true, 'b', "blockData", "block data"}, { true, 'c', "common", "common blocks"}, { true, 'e', "entry", "entry points"}, + { true, 'E', "enum", "enumerations"}, { true, 'f', "function", "functions"}, { true, 'i', "interface", "interface contents, generic names, and operators"}, { true, 'k', "component", "type and structure components"}, { true, 'l', "label", "labels"}, { false, 'L', "local", "local, common block, and namelist variables"}, { true, 'm', "module", "modules"}, + { true, 'M', "method", "type bound procedures"}, { true, 'n', "namelist", "namelists"}, + { true, 'N', "enumerator", "enumeration values"}, { true, 'p', "program", "programs"}, + { false, 'P', "prototype", "subprogram prototypes"}, { true, 's', "subroutine", "subroutines"}, { true, 't', "type", "derived types and structures"}, { true, 'v', "variable", "program (global) and module variables"}, - { true, 'E', "enum", "enumerations"}, - { true, 'N', "enumerator", "enumeration values"}, + { true, 'S', "submodule", "submodules"}, }; -/* For efinitions of Fortran 77 with extensions: +/* For definitions of Fortran 77 with extensions: * http://www.fortran.com/fortran/F77_std/rjcnf0001.html * http://scienide.uwaterloo.ca/MIPSpro7/007-2362-004/sgi_html/index.html * @@ -238,6 +258,7 @@ static kindDefinition FortranKinds [TAG_COUNT] = { static const keywordTable FortranKeywordTable [] = { /* keyword keyword ID */ + { "abstract", KEYWORD_abstract }, { "allocatable", KEYWORD_allocatable }, { "assignment", KEYWORD_assignment }, { "associate", KEYWORD_associate }, @@ -247,12 +268,14 @@ static const keywordTable FortranKeywordTable [] = { { "byte", KEYWORD_byte }, { "cexternal", KEYWORD_cexternal }, { "cglobal", KEYWORD_cglobal }, + { "class", KEYWORD_class }, { "character", KEYWORD_character }, { "codimension", KEYWORD_codimension }, { "common", KEYWORD_common }, { "complex", KEYWORD_complex }, { "contains", KEYWORD_contains }, { "data", KEYWORD_data }, + { "deferred", KEYWORD_deferred }, { "dimension", KEYWORD_dimension }, { "dll_export", KEYWORD_dllexport }, { "dll_import", KEYWORD_dllimport }, @@ -266,11 +289,14 @@ static const keywordTable FortranKeywordTable [] = { { "equivalence", KEYWORD_equivalence }, { "extends", KEYWORD_extends }, { "external", KEYWORD_external }, + { "final", KEYWORD_final }, { "forall", KEYWORD_forall }, { "format", KEYWORD_format }, { "function", KEYWORD_function }, + { "generic", KEYWORD_generic }, { "if", KEYWORD_if }, { "implicit", KEYWORD_implicit }, + { "import", KEYWORD_import }, { "include", KEYWORD_include }, { "inline", KEYWORD_inline }, { "integer", KEYWORD_integer }, @@ -283,17 +309,21 @@ static const keywordTable FortranKeywordTable [] = { { "map", KEYWORD_map }, { "module", KEYWORD_module }, { "namelist", KEYWORD_namelist }, + { "non_overridable", KEYWORD_non_overridable }, + { "nopass", KEYWORD_nopass }, { "operator", KEYWORD_operator }, { "optional", KEYWORD_optional }, { "parameter", KEYWORD_parameter }, { "pascal", KEYWORD_pascal }, + { "pass", KEYWORD_pass }, { "pexternal", KEYWORD_pexternal }, { "pglobal", KEYWORD_pglobal }, { "pointer", KEYWORD_pointer }, { "precision", KEYWORD_precision }, { "private", KEYWORD_private }, { "procedure", KEYWORD_procedure }, { "program", KEYWORD_program }, + { "protected", KEYWORD_protected }, { "public", KEYWORD_public }, { "pure", KEYWORD_pure }, { "real", KEYWORD_real }, @@ -305,6 +335,7 @@ static const keywordTable FortranKeywordTable [] = { { "static", KEYWORD_static }, { "stdcall", KEYWORD_stdcall }, { "structure", KEYWORD_structure }, + { "submodule", KEYWORD_submodule }, { "subroutine", KEYWORD_subroutine }, { "target", KEYWORD_target }, { "then", KEYWORD_then }, @@ -330,8 +361,7 @@ static struct { static void parseStructureStmt (tokenInfo *const token); static void parseUnionStmt (tokenInfo *const token); static void parseDerivedTypeDef (tokenInfo *const token); -static void parseFunctionSubprogram (tokenInfo *const token); -static void parseSubroutineSubprogram (tokenInfo *const token); +static void parseSubprogram (tokenInfo *const token); /* * FUNCTION DEFINITIONS @@ -354,6 +384,7 @@ static void ancestorPush (tokenInfo *const token) } Ancestors.list [Ancestors.count] = *token; Ancestors.list [Ancestors.count].string = vStringNewCopy (token->string); + Ancestors.list [Ancestors.count].signature = token->signature? vStringNewCopy (token->signature): NULL; Ancestors.count++; } @@ -362,13 +393,16 @@ static void ancestorPop (void) Assert (Ancestors.count > 0); --Ancestors.count; vStringDelete (Ancestors.list [Ancestors.count].string); + vStringDelete (Ancestors.list [Ancestors.count].signature); Ancestors.list [Ancestors.count].type = TOKEN_UNDEFINED; Ancestors.list [Ancestors.count].keyword = KEYWORD_NONE; Ancestors.list [Ancestors.count].secondary = NULL; Ancestors.list [Ancestors.count].tag = TAG_UNDEFINED; Ancestors.list [Ancestors.count].string = NULL; Ancestors.list [Ancestors.count].lineNumber = 0L; + Ancestors.list [Ancestors.count].implementation = IMP_DEFAULT; + Ancestors.list [Ancestors.count].isMethod = false; } static const tokenInfo* ancestorScope (void) @@ -419,7 +453,6 @@ static bool insideInterface (void) /* * Tag generation functions */ - static tokenInfo *newToken (void) { tokenInfo *const token = xMalloc (1, tokenInfo); @@ -429,30 +462,38 @@ static tokenInfo *newToken (void) token->tag = TAG_UNDEFINED; token->string = vStringNew (); token->secondary = NULL; + token->parentType = NULL; + token->signature = NULL; + token->implementation = IMP_DEFAULT; + token->isMethod = false; token->lineNumber = getInputLineNumber (); token->filePosition = getInputFilePosition (); token->anonymous = false; return token; } -static tokenInfo *newTokenFrom (tokenInfo *const token) +static tokenInfo *newTokenFromFull (tokenInfo *const token, bool copyStr) { - tokenInfo *result = newToken (); + tokenInfo *result = xMalloc (1, tokenInfo); *result = *token; - result->string = vStringNewCopy (token->string); + result->string = copyStr? vStringNewCopy (token->string): vStringNew(); token->secondary = NULL; + token->parentType = NULL; + token->signature = NULL; return result; } -static tokenInfo *newAnonTokenFrom (tokenInfo *const token, const char *type) +static tokenInfo *newTokenFrom (tokenInfo *const token) { - char buffer[64]; - tokenInfo *result = newTokenFrom (token); + return newTokenFromFull (token, true); +} + +static tokenInfo *newAnonTokenFrom (tokenInfo *const token, unsigned int uTagKind) +{ + tokenInfo *result = newTokenFromFull (token, false); result->anonymous = true; - sprintf (buffer, "%s#%u", type, contextual_fake_count++); - vStringClear (result->string); - vStringCatS (result->string, buffer); + anonGenerate (result->string, "__anon", uTagKind); return result; } @@ -461,6 +502,8 @@ static void deleteToken (tokenInfo *const token) if (token != NULL) { vStringDelete (token->string); + vStringDelete (token->parentType); + vStringDelete (token->signature); deleteToken (token->secondary); token->secondary = NULL; eFree (token); @@ -475,13 +518,23 @@ static bool isFileScope (const tagType type) static bool includeTag (const tagType type) { bool include; - Assert (type > TAG_UNDEFINED && type < TAG_COUNT); + Assert (type != TAG_UNDEFINED); include = FortranKinds [(int) type].enabled; if (include && isFileScope (type)) include = isXtagEnabled(XTAG_FILE_SCOPE); return include; } +static const char *implementationString (const impType imp) +{ + static const char *const names [] ={ + "?", "abstract", "deferred", "non_overridable" + }; + Assert (ARRAY_SIZE (names) == IMP_COUNT); + Assert ((int) imp < IMP_COUNT); + return names [(int) imp]; +} + static void makeFortranTag (tokenInfo *const token, tagType tag) { token->tag = tag; @@ -501,7 +554,9 @@ static void makeFortranTag (tokenInfo *const token, tagType tag) e.lineNumber = token->lineNumber; e.filePosition = token->filePosition; e.isFileScope = isFileScope (token->tag); - e.truncateLineAfterTag = (bool) (token->tag != TAG_LABEL); + if (e.isFileScope) + markTagExtraBit (&e, XTAG_FILE_SCOPE); + e.truncateLineAfterTag = (bool) (token->tag != TAG_LABEL); if (ancestorCount () > 0) { @@ -512,8 +567,20 @@ static void makeFortranTag (tokenInfo *const token, tagType tag) e.extensionFields.scopeName = vStringValue (scope->string); } } - if (! insideInterface () /*|| includeTag (TAG_INTERFACE)*/) - makeTagEntry (&e); + if (token->parentType != NULL && + vStringLength (token->parentType) > 0 && + (token->tag == TAG_DERIVED_TYPE || (token->tag == TAG_SUBMODULE))) + e.extensionFields.inheritance = vStringValue (token->parentType); + if (token->implementation != IMP_DEFAULT) + e.extensionFields.implementation = + implementationString (token->implementation); + if (token->signature && + vStringLength (token->signature) > 0 && + (token->tag == TAG_FUNCTION || + token->tag == TAG_SUBROUTINE || + token->tag == TAG_PROTOTYPE)) + e.extensionFields.signature = vStringValue (token->signature); + makeTagEntry (&e); } } @@ -543,10 +610,11 @@ static void makeLabelTag (vString *const label) static lineType getLineType (void) { - vString *label = vStringNew (); + static vString *label = NULL; int column = 0; lineType type = LTYPE_UNDETERMINED; + label = vStringNewOrClear (label); do /* read in first 6 "margin" characters */ { int c = getcFromInputFile (); @@ -608,7 +676,6 @@ static lineType getLineType (void) if (vStringLength (label) > 0) makeLabelTag (label); - vStringDelete (label); return type; } @@ -646,7 +713,7 @@ static int getFixedFormChar (void) { const int c2 = getcFromInputFile (); if (c2 == '\n') - longjmp (Exception, (int) ExceptionFixedFormat); + FreeSourceFormFound = true; else ungetcToInputFile (c2); } @@ -658,8 +725,9 @@ static int getFixedFormChar (void) { case LTYPE_UNDETERMINED: case LTYPE_INVALID: - longjmp (Exception, (int) ExceptionFixedFormat); - break; + FreeSourceFormFound = true; + if (! FreeSourceForm) + return EOF; case LTYPE_SHORT: break; case LTYPE_COMMENT: skipLine (); break; @@ -679,7 +747,7 @@ static int getFixedFormChar (void) Column = 6; break; } - /* fall through */ + /* fall through to next case */ case LTYPE_CONTINUATION: Column = 5; do @@ -711,23 +779,24 @@ static int skipToNextLine (void) return c; } -static int getFreeFormChar (bool inComment) +static int getFreeFormChar (void) { + static bool newline = true; bool advanceLine = false; int c = getcFromInputFile (); /* If the last nonblank, non-comment character of a FORTRAN 90 * free-format text line is an ampersand then the next non-comment * line is a continuation line. */ - if (! inComment && c == '&') + if (c == '&') { do c = getcFromInputFile (); while (isspace (c) && c != '\n'); if (c == '\n') { - NewLine = true; + newline = true; advanceLine = true; } else if (c == '!') @@ -738,24 +807,24 @@ static int getFreeFormChar (bool inComment) c = '&'; } } - else if (NewLine && (c == '!' || c == '#')) + else if (newline && (c == '!' || c == '#')) advanceLine = true; while (advanceLine) { while (isspace (c)) c = getcFromInputFile (); - if (c == '!' || (NewLine && c == '#')) + if (c == '!' || (newline && c == '#')) { c = skipToNextLine (); - NewLine = true; + newline = true; continue; } if (c == '&') c = getcFromInputFile (); else advanceLine = false; } - NewLine = (bool) (c == '\n'); + newline = (bool) (c == '\n'); return c; } @@ -769,7 +838,7 @@ static int getChar (void) Ungetc = '\0'; } else if (FreeSourceForm) - c = getFreeFormChar (false); + c = getFreeFormChar (); else c = getFixedFormChar (); return c; @@ -813,23 +882,20 @@ static vString *parseInteger (int c) static vString *parseNumeric (int c) { - vString *string = vStringNew (); - vString *integer = parseInteger (c); - vStringCopy (string, integer); - vStringDelete (integer); + vString *string = parseInteger (c); c = getChar (); if (c == '.') { - integer = parseInteger ('\0'); + vString *integer = parseInteger ('\0'); vStringPut (string, c); vStringCat (string, integer); vStringDelete (integer); c = getChar (); } if (tolower (c) == 'e') { - integer = parseInteger ('\0'); + vString *integer = parseInteger ('\0'); vStringPut (string, c); vStringCat (string, integer); vStringDelete (integer); @@ -855,10 +921,8 @@ static void parseString (vString *const string, const int delimiter) { verbose ("%s: unterminated character string at line %lu\n", getInputFileName (), inputLineNumber); - if (c == EOF) - longjmp (Exception, (int) ExceptionEOF); - else if (! FreeSourceForm) - longjmp (Exception, (int) ExceptionFixedFormat); + if (c != EOF && ! FreeSourceForm) + FreeSourceFormFound = true; } ParsingString = false; } @@ -906,27 +970,10 @@ static void checkForLabel (void) ungetChar (c); } -/* Analyzes the identifier contained in a statement described by the - * statement structure and adjusts the structure according the significance - * of the identifier. - */ -static keywordId analyzeToken (vString *const name, langType language) -{ - static vString *keyword = NULL; - keywordId id; - - if (keyword == NULL) - keyword = vStringNew (); - vStringCopyToLower (keyword, name); - id = (keywordId) lookupKeyword (vStringValue (keyword), language); - - return id; -} - static void readIdentifier (tokenInfo *const token, const int c) { parseIdentifier (token->string, c); - token->keyword = analyzeToken (token->string, Lang_fortran); + token->keyword = lookupCaseKeyword (vStringValue (token->string), Lang_fortran); if (! isKeyword (token, KEYWORD_NONE)) token->type = TOKEN_KEYWORD; else @@ -935,7 +982,7 @@ static void readIdentifier (tokenInfo *const token, const int c) if (strncmp (vStringValue (token->string), "end", 3) == 0) { vString *const sub = vStringNewInit (vStringValue (token->string) + 3); - const keywordId kw = analyzeToken (sub, Lang_fortran); + const keywordId kw = lookupCaseKeyword (vStringValue (sub), Lang_fortran); vStringDelete (sub); if (kw != KEYWORD_NONE) { @@ -957,7 +1004,13 @@ static void readToken (tokenInfo *const token) token->tag = TAG_UNDEFINED; token->keyword = KEYWORD_NONE; token->secondary = NULL; + token->implementation = IMP_DEFAULT; vStringClear (token->string); + vStringDelete (token->parentType); + vStringDelete (token->signature); + token->parentType = NULL; + token->isMethod = false; + token->signature = NULL; getNextChar: c = getChar (); @@ -967,7 +1020,7 @@ static void readToken (tokenInfo *const token) switch (c) { - case EOF: longjmp (Exception, (int) ExceptionEOF); break; + case EOF: token->type = TOKEN_EOF; break; case ' ': goto getNextChar; case '\t': goto getNextChar; case ',': token->type = TOKEN_COMMA; break; @@ -999,15 +1052,15 @@ static void readToken (tokenInfo *const token) if (FreeSourceForm) { do - c = getFreeFormChar (true); + c = getChar (); while (c != '\n' && c != EOF); } else { skipLine (); Column = 0; } - /* fall through */ + /* fall through to newline case */ case '\n': token->type = TOKEN_STATEMENT_END; if (FreeSourceForm) @@ -1046,7 +1099,7 @@ static void readToken (tokenInfo *const token) else { ungetChar (c); - token->type = TOKEN_UNDEFINED; + token->type = TOKEN_COLON; } break; @@ -1082,7 +1135,8 @@ static void readSubToken (tokenInfo *const token) static void skipToToken (tokenInfo *const token, tokenType type) { while (! isType (token, type) && ! isType (token, TOKEN_STATEMENT_END) && - !(token->secondary != NULL && isType (token->secondary, TOKEN_STATEMENT_END))) + !(token->secondary != NULL && isType (token->secondary, TOKEN_STATEMENT_END)) && + ! isType (token, TOKEN_EOF)) readToken (token); } @@ -1105,7 +1159,11 @@ static void skipToNextStatement (tokenInfo *const token) /* skip over paired tokens, managing nested pairs and stopping at statement end * or right after closing token, whatever comes first. */ -static void skipOverPair (tokenInfo *const token, tokenType topen, tokenType tclose) +static void skipOverPairsFull (tokenInfo *const token, + tokenType topen, + tokenType tclose, + void (* token_cb) (tokenInfo *const, void *), + void *user_data) { int level = 0; do { @@ -1115,18 +1173,38 @@ static void skipOverPair (tokenInfo *const token, tokenType topen, tokenType tcl ++level; else if (isType (token, tclose)) --level; + else if (token_cb) + token_cb (token, user_data); readToken (token); - } while (level > 0); + } while (level > 0 && !isType (token, TOKEN_EOF)); +} + +static void skipOverParensFull (tokenInfo *const token, + void (* token_cb) (tokenInfo *const, void *), + void *user_data) +{ + skipOverPairsFull (token, TOKEN_PAREN_OPEN, + TOKEN_PAREN_CLOSE, + token_cb, user_data); +} + +static void skipOverSquaresFull (tokenInfo *const token, + void (* token_cb) (tokenInfo *const, void *), + void *user_data) +{ + skipOverPairsFull (token, TOKEN_SQUARE_OPEN, + TOKEN_SQUARE_CLOSE, + token_cb, user_data); } static void skipOverParens (tokenInfo *const token) { - skipOverPair (token, TOKEN_PAREN_OPEN, TOKEN_PAREN_CLOSE); + skipOverParensFull (token, NULL, NULL); } static void skipOverSquares (tokenInfo *const token) { - skipOverPair (token, TOKEN_SQUARE_OPEN, TOKEN_SQUARE_CLOSE); + skipOverSquaresFull (token, NULL, NULL); } static bool isTypeSpec (tokenInfo *const token) @@ -1144,6 +1222,9 @@ static bool isTypeSpec (tokenInfo *const token) case KEYWORD_record: case KEYWORD_type: case KEYWORD_procedure: + case KEYWORD_final: + case KEYWORD_generic: + case KEYWORD_class: case KEYWORD_enumerator: result = true; break; @@ -1223,6 +1304,7 @@ static void parseTypeSpec (tokenInfo *const token) case KEYWORD_logical: case KEYWORD_real: case KEYWORD_procedure: + case KEYWORD_class: readToken (token); parseKindSelector (token); break; @@ -1255,6 +1337,8 @@ static void parseTypeSpec (tokenInfo *const token) parseDerivedTypeDef (token); break; + case KEYWORD_final: + case KEYWORD_generic: case KEYWORD_enumerator: readToken (token); break; @@ -1276,6 +1360,53 @@ static bool skipStatementIfKeyword (tokenInfo *const token, keywordId keyword) return result; } +/* parse extends qualifier, leaving token at first token following close + * parenthesis. + */ + +static void attachParentType (tokenInfo *const token, vString* parentType) +{ + if (token->parentType) + vStringDelete (token->parentType); + token->parentType = parentType; +} + +static void makeParentType (tokenInfo *const token, void *userData) +{ + attachParentType ((tokenInfo *const)userData, + vStringNewCopy (token->string)); +} + +static void parseExtendsQualifier (tokenInfo *const token, + tokenInfo *const qualifierToken) +{ + skipOverParensFull (token, makeParentType, qualifierToken); +} + +static void parseAbstractQualifier (tokenInfo *const token, + tokenInfo *const qualifierToken) +{ + Assert (isKeyword (token, KEYWORD_abstract)); + qualifierToken->implementation = IMP_ABSTRACT; + readToken (token); +} + +static void parseDeferredQualifier (tokenInfo *const token, + tokenInfo *const qualifierToken) +{ + Assert (isKeyword (token, KEYWORD_deferred)); + qualifierToken->implementation = IMP_DEFERRED; + readToken (token); +} + +static void parseNonOverridableQualifier (tokenInfo *const token, + tokenInfo *const qualifierToken) +{ + Assert (isKeyword (token, KEYWORD_non_overridable)); + qualifierToken->implementation = IMP_NON_OVERRIDABLE; + readToken (token); +} + /* parse a list of qualifying specifiers, leaving `token' at first token * following list. Examples of such specifiers are: * [[, attr-spec] ::] @@ -1286,21 +1417,28 @@ static bool skipStatementIfKeyword (tokenInfo *const token, keywordId keyword) * or access-spec (is PUBLIC or PRIVATE) * or ALLOCATABLE * or DIMENSION ( array-spec ) + * or EXTENDS ( extends-spec ) * or EXTERNAL * or INTENT ( intent-spec ) * or INTRINSIC * or OPTIONAL * or POINTER * or SAVE * or TARGET + * or PASS + * or NOPASS + * or DEFERRED + * or NON_OVERRIDABLE + * or ABSTRACT * * component-attr-spec * is POINTER * or DIMENSION ( component-array-spec ) - * or EXTENDS ( type name ) */ -static void parseQualifierSpecList (tokenInfo *const token) +static tokenInfo *parseQualifierSpecList (tokenInfo *const token) { + tokenInfo *qualifierToken = newToken (); + do { readToken (token); /* should be an attr-spec */ @@ -1315,54 +1453,91 @@ static void parseQualifierSpecList (tokenInfo *const token) case KEYWORD_optional: case KEYWORD_private: case KEYWORD_pointer: + case KEYWORD_protected: case KEYWORD_public: case KEYWORD_save: case KEYWORD_target: + case KEYWORD_nopass: readToken (token); break; - case KEYWORD_codimension: + case KEYWORD_dimension: + case KEYWORD_intent: + case KEYWORD_bind: readToken (token); - skipOverSquares (token); + skipOverParens (token); break; - case KEYWORD_dimension: case KEYWORD_extends: - case KEYWORD_intent: readToken (token); - skipOverParens (token); + parseExtendsQualifier (token, qualifierToken); + break; + + case KEYWORD_pass: + readToken (token); + if (isType (token, TOKEN_PAREN_OPEN)) + skipOverParens (token); + break; + + case KEYWORD_abstract: + parseAbstractQualifier (token, qualifierToken); + break; + + case KEYWORD_deferred: + parseDeferredQualifier (token, qualifierToken); + break; + + case KEYWORD_non_overridable: + parseNonOverridableQualifier (token, qualifierToken); + break; + + case KEYWORD_codimension: + readToken (token); + skipOverSquares (token); break; default: skipToToken (token, TOKEN_STATEMENT_END); break; } } while (isType (token, TOKEN_COMMA)); if (! isType (token, TOKEN_DOUBLE_COLON)) skipToToken (token, TOKEN_STATEMENT_END); + + return qualifierToken; } -static tagType variableTagType (void) +static tagType variableTagType (tokenInfo *const st) { tagType result = TAG_VARIABLE; if (ancestorCount () > 0) { const tokenInfo* const parent = ancestorTop (); switch (parent->tag) { + case TAG_SUBMODULE: /* Fall through */ case TAG_MODULE: result = TAG_VARIABLE; break; - case TAG_DERIVED_TYPE: result = TAG_COMPONENT; break; + case TAG_DERIVED_TYPE: + if (st && st->isMethod) + result = TAG_METHOD; + else + result = TAG_COMPONENT; + break; case TAG_FUNCTION: result = TAG_LOCAL; break; case TAG_SUBROUTINE: result = TAG_LOCAL; break; + case TAG_PROTOTYPE: result = TAG_LOCAL; break; case TAG_ENUM: result = TAG_ENUMERATOR; break; default: result = TAG_VARIABLE; break; } } return result; } -static void parseEntityDecl (tokenInfo *const token) +static void parseEntityDecl (tokenInfo *const token, + tokenInfo *const st) { Assert (isType (token, TOKEN_IDENTIFIER)); - makeFortranTag (token, variableTagType ()); + if (st && st->implementation != IMP_DEFAULT) + token->implementation = st->implementation; + makeFortranTag (token, variableTagType (st)); readToken (token); /* we check for both '()' and '[]' * coarray syntax permits variable(), variable[], or variable()[] @@ -1391,7 +1566,8 @@ static void parseEntityDecl (tokenInfo *const token) strcmp (vStringValue (token->string), "=>") == 0) { while (! isType (token, TOKEN_COMMA) && - ! isType (token, TOKEN_STATEMENT_END)) + ! isType (token, TOKEN_STATEMENT_END) && + ! isType (token, TOKEN_EOF)) { readToken (token); /* another coarray check, for () and [] */ @@ -1405,7 +1581,8 @@ static void parseEntityDecl (tokenInfo *const token) /* token left at either comma or statement end */ } -static void parseEntityDeclList (tokenInfo *const token) +static void parseEntityDeclList (tokenInfo *const token, + tokenInfo *const st) { if (isType (token, TOKEN_PERCENT)) skipToNextStatement (token); @@ -1417,7 +1594,7 @@ static void parseEntityDeclList (tokenInfo *const token) /* compilers accept keywords as identifiers */ if (isType (token, TOKEN_KEYWORD)) token->type = TOKEN_IDENTIFIER; - parseEntityDecl (token); + parseEntityDecl (token, st); if (isType (token, TOKEN_COMMA)) readToken (token); else if (isType (token, TOKEN_STATEMENT_END)) @@ -1438,10 +1615,13 @@ static void parseTypeDeclarationStmt (tokenInfo *const token) if (!isType (token, TOKEN_STATEMENT_END)) /* if not end of derived type... */ { if (isType (token, TOKEN_COMMA)) - parseQualifierSpecList (token); + { + tokenInfo* qualifierToken = parseQualifierSpecList (token); + deleteToken (qualifierToken); + } if (isType (token, TOKEN_DOUBLE_COLON)) readToken (token); - parseEntityDeclList (token); + parseEntityDeclList (token, NULL); } if (isType (token, TOKEN_STATEMENT_END)) skipToNextStatement (token); @@ -1486,7 +1666,8 @@ static void parseCommonNamelistStmt (tokenInfo *const token, tagType type) skipOverParens (token); /* skip explicit-shape-spec-list */ if (isType (token, TOKEN_COMMA)) readToken (token); - } while (! isType (token, TOKEN_STATEMENT_END)); + } while (! isType (token, TOKEN_STATEMENT_END) && + ! isType (token, TOKEN_EOF)); skipToNextStatement (token); } @@ -1506,7 +1687,8 @@ static void parseMap (tokenInfo *const token) { Assert (isKeyword (token, KEYWORD_map)); skipToNextStatement (token); - while (! isKeyword (token, KEYWORD_end)) + while (! isKeyword (token, KEYWORD_end) && + ! isType (token, TOKEN_EOF)) parseFieldDefinition (token); readSubToken (token); /* should be at KEYWORD_map token */ @@ -1515,16 +1697,16 @@ static void parseMap (tokenInfo *const token) /* UNION * MAP - * [field-definition] [field-definition] ... + * [field-definition] [field-definition] ... * END MAP * MAP - * [field-definition] [field-definition] ... + * [field-definition] [field-definition] ... * END MAP * [MAP * [field-definition] - * [field-definition] ... + * [field-definition] ... * END MAP] ... - * END UNION + * END UNION * * * * Typed data declarations (variables or arrays) in structure declarations @@ -1539,7 +1721,7 @@ static void parseMap (tokenInfo *const token) * share a common location within the containing structure. When initializing * the fields within a UNION, the final initialization value assigned * overlays any value previously assigned to a field definition that shares - * that field. + * that field. */ static void parseUnionStmt (tokenInfo *const token) { @@ -1561,11 +1743,11 @@ static void parseUnionStmt (tokenInfo *const token) * structure-name * identifies the structure in a subsequent RECORD statement. * Substructures can be established within a structure by means of either - * a nested STRUCTURE declaration or a RECORD statement. + * a nested STRUCTURE declaration or a RECORD statement. * * field-names * (for substructure declarations only) one or more names having the - * structure of the substructure being defined. + * structure of the substructure being defined. * * field-definition * can be one or more of the following: @@ -1580,7 +1762,7 @@ static void parseUnionStmt (tokenInfo *const token) * statements. The syntax of a UNION declaration is described below. * * PARAMETER statements, which do not affect the form of the - * structure. + * structure. */ static void parseStructureStmt (tokenInfo *const token) { @@ -1600,7 +1782,7 @@ static void parseStructureStmt (tokenInfo *const token) } if (name == NULL) { /* fake out anonymous structure */ - name = newAnonTokenFrom (token, "Structure"); + name = newAnonTokenFrom (token, TAG_COMPONENT); name->type = TOKEN_IDENTIFIER; name->tag = TAG_DERIVED_TYPE; } @@ -1614,7 +1796,8 @@ static void parseStructureStmt (tokenInfo *const token) } skipToNextStatement (token); ancestorPush (name); - while (! isKeyword (token, KEYWORD_end)) + while (! isKeyword (token, KEYWORD_end) && + ! isType (token, TOKEN_EOF)) parseFieldDefinition (token); readSubToken (token); /* secondary token should be KEYWORD_structure token */ @@ -1662,13 +1845,13 @@ static bool parseSpecificationStmt (tokenInfo *const token) case KEYWORD_data: case KEYWORD_dimension: case KEYWORD_equivalence: - case KEYWORD_extends: case KEYWORD_external: case KEYWORD_intent: case KEYWORD_intrinsic: case KEYWORD_optional: case KEYWORD_pointer: case KEYWORD_private: + case KEYWORD_protected: case KEYWORD_public: case KEYWORD_save: case KEYWORD_target: @@ -1682,6 +1865,32 @@ static bool parseSpecificationStmt (tokenInfo *const token) return result; } +/* Type bound generic procedure is: + * GENERIC [, access-spec ] :: generic-spec => binding-name1 [, binding-name2]... + * access-spec: PUBLIC or PRIVATE + * generic-spec: 1. generic name; 2. OPERATOR(op); 3. ASSIGNMENT(=) + * binding-name: type bound procedure + */ +static void parseGenericMethod (tokenInfo *const token) +{ + if (isKeyword (token, KEYWORD_assignment) || + isKeyword (token, KEYWORD_operator)) + { + readToken (token); + if (isType (token, TOKEN_PAREN_OPEN)) + readToken (token); + if (isType (token, TOKEN_OPERATOR)) + makeFortranTag (token, TAG_METHOD); + } + else + { + if (isType (token, TOKEN_KEYWORD)) + token->type = TOKEN_IDENTIFIER; + makeFortranTag (token, TAG_METHOD); + } + skipToNextStatement (token); +} + /* component-def-stmt is * type-spec [[, component-attr-spec-list] ::] component-decl-list * @@ -1690,13 +1899,32 @@ static bool parseSpecificationStmt (tokenInfo *const token) */ static void parseComponentDefStmt (tokenInfo *const token) { + tokenInfo* st = newToken (); + tokenInfo* qt = NULL; + bool isGeneric = false; + Assert (isTypeSpec (token)); + if (isKeyword (token, KEYWORD_procedure) || + isKeyword (token, KEYWORD_final) || + isKeyword (token, KEYWORD_generic)) + st->isMethod = true; + if (isKeyword (token, KEYWORD_generic)) + isGeneric = true; parseTypeSpec (token); if (isType (token, TOKEN_COMMA)) - parseQualifierSpecList (token); + { + qt = parseQualifierSpecList (token); + if (qt->implementation != IMP_DEFAULT) + st->implementation = qt->implementation; + deleteToken (qt); + } if (isType (token, TOKEN_DOUBLE_COLON)) readToken (token); - parseEntityDeclList (token); + if (isGeneric) + parseGenericMethod (token); + else + parseEntityDeclList (token, st); + deleteToken (st); } /* derived-type-def is @@ -1708,23 +1936,34 @@ static void parseComponentDefStmt (tokenInfo *const token) */ static void parseDerivedTypeDef (tokenInfo *const token) { + tokenInfo *qualifierToken = NULL; + if (isType (token, TOKEN_COMMA)) - parseQualifierSpecList (token); + qualifierToken = parseQualifierSpecList (token); if (isType (token, TOKEN_DOUBLE_COLON)) readToken (token); if (isType (token, TOKEN_IDENTIFIER) || isType (token, TOKEN_KEYWORD)) { token->type = TOKEN_IDENTIFIER; + if (qualifierToken) + { + if (qualifierToken->parentType) + token->parentType = vStringNewCopy (qualifierToken->parentType); + if (qualifierToken->implementation != IMP_DEFAULT) + token->implementation = qualifierToken->implementation; + } makeFortranTag (token, TAG_DERIVED_TYPE); } + deleteToken (qualifierToken); ancestorPush (token); skipToNextStatement (token); if (isKeyword (token, KEYWORD_private) || isKeyword (token, KEYWORD_sequence)) { skipToNextStatement (token); } - while (! isKeyword (token, KEYWORD_end)) + while (! isKeyword (token, KEYWORD_end) && + ! isType (token, TOKEN_EOF)) { if (isTypeSpec (token)) parseComponentDefStmt (token); @@ -1765,7 +2004,7 @@ static void parseInterfaceBlock (tokenInfo *const token) Assert (isKeyword (token, KEYWORD_interface)); readToken (token); if (isKeyword (token, KEYWORD_assignment) || - isKeyword (token, KEYWORD_operator)) + isKeyword (token, KEYWORD_operator)) { readToken (token); if (isType (token, TOKEN_PAREN_OPEN)) @@ -1780,18 +2019,19 @@ static void parseInterfaceBlock (tokenInfo *const token) } if (name == NULL) { - name = newAnonTokenFrom (token, "Interface"); + name = newAnonTokenFrom (token, TAG_INTERFACE); name->type = TOKEN_IDENTIFIER; name->tag = TAG_INTERFACE; } makeFortranTag (name, TAG_INTERFACE); ancestorPush (name); - while (! isKeyword (token, KEYWORD_end)) + while (! isKeyword (token, KEYWORD_end) && + ! isType (token, TOKEN_EOF)) { switch (token->keyword) { - case KEYWORD_function: parseFunctionSubprogram (token); break; - case KEYWORD_subroutine: parseSubroutineSubprogram (token); break; + case KEYWORD_function: + case KEYWORD_subroutine: parseSubprogram (token); break; default: if (isSubprogramPrefix (token)) @@ -1839,14 +2079,15 @@ static void parseEnumBlock (tokenInfo *const token) } if (name == NULL) { - name = newAnonTokenFrom (token, "Enum"); + name = newAnonTokenFrom (token, TAG_ENUM); name->type = TOKEN_IDENTIFIER; name->tag = TAG_ENUM; } makeFortranTag (name, TAG_ENUM); skipToNextStatement (token); ancestorPush (name); - while (! isKeyword (token, KEYWORD_end)) + while (! isKeyword (token, KEYWORD_end) && + ! isType(token, TOKEN_EOF)) { if (isTypeSpec (token)) parseTypeDeclarationStmt (token); @@ -1939,12 +2180,21 @@ static bool parseDeclarationConstruct (tokenInfo *const token) bool result = true; switch (token->keyword) { - case KEYWORD_entry: parseEntryStmt (token); break; - case KEYWORD_interface: parseInterfaceBlock (token); break; + case KEYWORD_entry: parseEntryStmt (token); break; + case KEYWORD_interface: parseInterfaceBlock (token); break; case KEYWORD_enum: parseEnumBlock (token); break; case KEYWORD_stdcall: readToken (token); break; /* derived type handled by parseTypeDeclarationStmt(); */ + case KEYWORD_abstract: + readToken (token); + if (isKeyword (token, KEYWORD_interface)) + parseInterfaceBlock (token); + else + skipToNextStatement (token); + result = true; + break; + case KEYWORD_automatic: readToken (token); if (isTypeSpec (token)) @@ -2006,6 +2256,8 @@ static bool parseSpecificationPart (tokenInfo *const token) bool result = false; while (skipStatementIfKeyword (token, KEYWORD_use)) result = true; + while (skipStatementIfKeyword (token, KEYWORD_import)) + result = true; while (parseImplicitPartStmt (token)) result = true; while (parseDeclarationConstruct (token)) @@ -2031,7 +2283,8 @@ static void parseBlockData (tokenInfo *const token) ancestorPush (token); skipToNextStatement (token); parseSpecificationPart (token); - while (! isKeyword (token, KEYWORD_end)) + while (! isKeyword (token, KEYWORD_end) && + ! isType (token, TOKEN_EOF)) skipToNextStatement (token); readSubToken (token); /* secondary token should be KEYWORD_NONE or KEYWORD_block token */ @@ -2057,9 +2310,9 @@ static void parseInternalSubprogramPart (tokenInfo *const token) { switch (token->keyword) { - case KEYWORD_function: parseFunctionSubprogram (token); break; - case KEYWORD_subroutine: parseSubroutineSubprogram (token); break; - case KEYWORD_end: done = true; break; + case KEYWORD_function: + case KEYWORD_subroutine: parseSubprogram (token); break; + case KEYWORD_end: done = true; break; default: if (isSubprogramPrefix (token)) @@ -2070,7 +2323,57 @@ static void parseInternalSubprogramPart (tokenInfo *const token) readToken (token); break; } - } while (! done); + } while (! done && ! isType (token, TOKEN_EOF)); +} + +/* submodule is + * submodule-stmt (is SUBMODULE ( parent-identifier ) submodule-name) + * [specification-part] + * [module-subprogram-part] + * end-submodule-stmt (is END [SUBMODULE [submodule-name]]) + * + * parent-identifier is + * ancestor_module_name [ : parent_submodule_name ]* + * + * ------------------------------------------------------------------ + * XL Fortran for AIX, V15.1.3 + * Language Reference + * Program units and procedures + * https://www.ibm.com/support/knowledgecenter/en/SSGH4D_15.1.3/com.ibm.xlf151… + * ------------------------------------------------------------------- + */ +static vString *parserParentIdentifierOfSubmoduleStatement (tokenInfo *const token) +{ + vString *parentId; + + if (!isType (token, TOKEN_PAREN_OPEN)) + return NULL; + + parentId = vStringNew(); + + while (1) + { + readToken (token); + if (isType (token, TOKEN_IDENTIFIER)) + vStringCat (parentId, token->string); + else if (isType (token, TOKEN_COLON)) + vStringPut (parentId, ':'); + else if (isType (token, TOKEN_PAREN_CLOSE)) + break; + else + { + /* Unexpected token (including EOF) */ + vStringClear (parentId); + break; + } + } + + if (vStringLength (parentId) == 0) + { + vStringDelete (parentId); + parentId = NULL; + } + return parentId; } /* module is @@ -2088,26 +2391,52 @@ static void parseInternalSubprogramPart (tokenInfo *const token) * is function-subprogram * or subroutine-subprogram */ -static void parseModule (tokenInfo *const token) +static void parseModule (tokenInfo *const token, bool isSubmodule) { - Assert (isKeyword (token, KEYWORD_module)); + vString *parentIdentifier = NULL; + + Assert (((!isSubmodule) && isKeyword (token, KEYWORD_module)) + || (isSubmodule && isKeyword (token, KEYWORD_submodule))); + + + if (isSubmodule) + { + readToken (token); + parentIdentifier = parserParentIdentifierOfSubmoduleStatement (token); + if (parentIdentifier == NULL) + { + /* Unexpected syntax */ + skipToNextStatement (token); + return; + } + } + readToken (token); if (isType (token, TOKEN_IDENTIFIER) || isType (token, TOKEN_KEYWORD)) { token->type = TOKEN_IDENTIFIER; - makeFortranTag (token, TAG_MODULE); + if (isSubmodule) + { + attachParentType (token, parentIdentifier); + parentIdentifier = NULL; + } + makeFortranTag (token, isSubmodule? TAG_SUBMODULE: TAG_MODULE); } ancestorPush (token); skipToNextStatement (token); parseSpecificationPart (token); if (isKeyword (token, KEYWORD_contains)) parseInternalSubprogramPart (token); - while (! isKeyword (token, KEYWORD_end)) + while (! isKeyword (token, KEYWORD_end) && + ! isType (token, TOKEN_EOF)) skipToNextStatement (token); readSubToken (token); /* secondary token should be KEYWORD_NONE or KEYWORD_module token */ skipToNextStatement (token); ancestorPop (); + + if (parentIdentifier) + vStringDelete (parentIdentifier); } /* execution-part @@ -2126,7 +2455,7 @@ static bool parseExecutionPart (tokenInfo *const token) { bool result = false; bool done = false; - while (! done) + while (! done && ! isType (token, TOKEN_EOF)) { switch (token->keyword) { @@ -2157,7 +2486,8 @@ static bool parseExecutionPart (tokenInfo *const token) isSecondaryKeyword (token, KEYWORD_select) || isSecondaryKeyword (token, KEYWORD_where) || isSecondaryKeyword (token, KEYWORD_forall) || - isSecondaryKeyword (token, KEYWORD_associate)) + isSecondaryKeyword (token, KEYWORD_associate) || + isSecondaryKeyword (token, KEYWORD_block)) { skipToNextStatement (token); result = true; @@ -2170,18 +2500,47 @@ static bool parseExecutionPart (tokenInfo *const token) return result; } -static void parseSubprogram (tokenInfo *const token, const tagType tag) +static void makeSignature (tokenInfo *const token, void* signature) +{ + if (isType (token, TOKEN_IDENTIFIER) || isType (token, TOKEN_KEYWORD)) + vStringCat ((vString *)signature, token->string); + else if (isType (token, TOKEN_COMMA)) + vStringCatS ((vString *)signature, ", "); +} + +static vString* parseSignature (tokenInfo *const token) +{ + vString* signature = vStringNew (); + + readToken (token); + if (isType (token, TOKEN_PAREN_OPEN)) + { + vStringPut (signature, '('); + skipOverParensFull (token, makeSignature, signature); + vStringPut (signature, ')'); + } + return signature; +} + +static void parseSubprogramFull (tokenInfo *const token, const tagType tag) { Assert (isKeyword (token, KEYWORD_program) || isKeyword (token, KEYWORD_function) || isKeyword (token, KEYWORD_subroutine)); readToken (token); if (isType (token, TOKEN_IDENTIFIER) || isType (token, TOKEN_KEYWORD)) { + tokenInfo* name = newTokenFrom (token); token->type = TOKEN_IDENTIFIER; - makeFortranTag (token, tag); + if (tag == TAG_SUBROUTINE || + tag == TAG_PROTOTYPE) + name->signature = parseSignature (token); + makeFortranTag (name, tag); + ancestorPush (name); + deleteToken (name); } - ancestorPush (token); + else + ancestorPush (token); skipToNextStatement (token); parseSpecificationPart (token); parseExecutionPart (token); @@ -2196,6 +2555,21 @@ static void parseSubprogram (tokenInfo *const token, const tagType tag) ancestorPop (); } +static tagType subprogramTagType (tokenInfo *const token) +{ + tagType result = TAG_UNDEFINED; + + if (insideInterface ()) + result = TAG_PROTOTYPE; + else if (isKeyword (token, KEYWORD_subroutine)) + result = TAG_SUBROUTINE; + else if (isKeyword (token, KEYWORD_function)) + result = TAG_FUNCTION; + + Assert (result != TAG_UNDEFINED); + + return result; +} /* function-subprogram is * function-stmt (is [prefix] FUNCTION function-name etc.) @@ -2208,21 +2582,16 @@ static void parseSubprogram (tokenInfo *const token, const tagType tag) * is type-spec [RECURSIVE] * or [RECURSIVE] type-spec */ -static void parseFunctionSubprogram (tokenInfo *const token) -{ - parseSubprogram (token, TAG_FUNCTION); -} - /* subroutine-subprogram is * subroutine-stmt (is [RECURSIVE] SUBROUTINE subroutine-name etc.) * [specification-part] * [execution-part] * [internal-subprogram-part] * end-subroutine-stmt (is END [SUBROUTINE [function-name]]) */ -static void parseSubroutineSubprogram (tokenInfo *const token) +static void parseSubprogram (tokenInfo *const token) { - parseSubprogram (token, TAG_SUBROUTINE); + parseSubprogramFull (token, subprogramTagType (token)); } /* main-program is @@ -2234,7 +2603,7 @@ static void parseSubroutineSubprogram (tokenInfo *const token) */ static void parseMainProgram (tokenInfo *const token) { - parseSubprogram (token, TAG_PROGRAM); + parseSubprogramFull (token, TAG_PROGRAM); } /* program-unit @@ -2254,10 +2623,11 @@ static void parseProgramUnit (tokenInfo *const token) { case KEYWORD_block: parseBlockData (token); break; case KEYWORD_end: skipToNextStatement (token); break; - case KEYWORD_function: parseFunctionSubprogram (token); break; - case KEYWORD_module: parseModule (token); break; + case KEYWORD_function: + case KEYWORD_subroutine: parseSubprogram (token); break; + case KEYWORD_submodule: parseModule (token, true); break; + case KEYWORD_module: parseModule (token, false); break; case KEYWORD_program: parseMainProgram (token); break; - case KEYWORD_subroutine: parseSubroutineSubprogram (token); break; default: if (isSubprogramPrefix (token)) @@ -2271,88 +2641,56 @@ static void parseProgramUnit (tokenInfo *const token) } break; } - } while (true); + } while (! isType (token, TOKEN_EOF)); } static rescanReason findFortranTags (const unsigned int passCount) { tokenInfo *token; - exception_t exception; rescanReason rescan; Assert (passCount < 3); - Parent = newToken (); token = newToken (); + FreeSourceForm = (bool) (passCount > 1); - contextual_fake_count = 0; Column = 0; - NewLine = true; - exception = (exception_t) setjmp (Exception); - if (exception == ExceptionEOF) - rescan = RESCAN_NONE; - else if (exception == ExceptionFixedFormat && ! FreeSourceForm) + parseProgramUnit (token); + if (FreeSourceFormFound && ! FreeSourceForm) { verbose ("%s: not fixed source form; retry as free source form\n", getInputFileName ()); rescan = RESCAN_FAILED; } else { - parseProgramUnit (token); rescan = RESCAN_NONE; } ancestorClear (); deleteToken (token); - deleteToken (Parent); return rescan; } -static void initializeFortran (const langType language) +static void initialize (const langType language) { Lang_fortran = language; } -static void initializeF77 (const langType language) -{ - Lang_f77 = language; -} - extern parserDefinition* FortranParser (void) { static const char *const extensions [] = { - "f90", "f95", "f03", + "f", "for", "ftn", "f77", "f90", "f95", "f03", "f08", "f15", #ifndef CASE_INSENSITIVE_FILENAMES - "F90", "F95", "F03", + "F", "FOR", "FTN", "F77", "F90", "F95", "F03", "F08", "F15", #endif - NULL + NULL }; parserDefinition* def = parserNew ("Fortran"); - def->kindTable = FortranKinds; - def->kindCount = ARRAY_SIZE (FortranKinds); - def->extensions = extensions; - def->parser2 = findFortranTags; - def->initialize = initializeFortran; - def->keywordTable = FortranKeywordTable; - def->keywordCount = ARRAY_SIZE (FortranKeywordTable); - return def; -} - -extern parserDefinition* F77Parser (void) -{ - static const char *const extensions [] = { - "f", "for", "ftn", "f77", -#ifndef CASE_INSENSITIVE_FILENAMES - "F", "FOR", "FTN", "F77", -#endif - NULL - }; - parserDefinition* def = parserNew ("F77"); - def->kindTable = FortranKinds; + def->kindTable = FortranKinds; def->kindCount = ARRAY_SIZE (FortranKinds); def->extensions = extensions; def->parser2 = findFortranTags; - def->initialize = initializeF77; + def->initialize = initialize; def->keywordTable = FortranKeywordTable; def->keywordCount = ARRAY_SIZE (FortranKeywordTable); return def; Modified: meson.build 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -631,10 +631,10 @@ ctags = static_library('ctags', 'ctags/parsers/diff.c', 'ctags/parsers/erlang.c', 'ctags/parsers/flex.c', + 'ctags/parsers/fortran.c', 'ctags/parsers/gdscript.c', 'ctags/parsers/geany_c.c', 'ctags/parsers/geany_docbook.c', - 'ctags/parsers/geany_fortran.c', 'ctags/parsers/geany_lcpp.c', 'ctags/parsers/geany_lcpp.h', 'ctags/parsers/geany_matlab.c', Modified: src/filetypes.c 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -136,7 +136,7 @@ static void init_builtin_filetypes(void) FT_INIT( ASM, ASM, "ASM", "Assembler", SOURCE_FILE, COMPILED ); FT_INIT( BASIC, FREEBASIC, "FreeBasic", NULL, SOURCE_FILE, COMPILED ); FT_INIT( FORTRAN, FORTRAN, "Fortran", "Fortran (F90)", SOURCE_FILE, COMPILED ); - FT_INIT( F77, F77, "F77", "Fortran (F77)", SOURCE_FILE, COMPILED ); + FT_INIT( F77, FORTRAN, "F77", "Fortran (F77)", SOURCE_FILE, COMPILED ); FT_INIT( GLSL, C, "GLSL", NULL, SOURCE_FILE, COMPILED ); FT_INIT( CAML, NONE, "CAML", "(O)Caml", SOURCE_FILE, COMPILED ); FT_INIT( PERL, PERL, "Perl", NULL, SOURCE_FILE, SCRIPT ); Modified: src/tagmanager/tm_ctags.c 16 lines changed, 16 insertions(+), 0 deletions(-) =================================================================== @@ -257,6 +257,7 @@ static void rename_anon_tags(TMSourceFile *source_file) gchar *orig_name, *new_name = NULL; guint j; guint new_name_len, orig_name_len; + gboolean inside_nesting = FALSE; guint scope_len = tag->scope ? strlen(tag->scope) : 0; gchar kind = tag->kind_letter; @@ -332,6 +333,21 @@ static void rename_anon_tags(TMSourceFile *source_file) guint nested_scope_len = nested_tag->scope ? strlen(nested_tag->scope) : 0; gchar *pos; + /* In Fortran, we can create variables of anonymous structures: + * structure var1, var2 + * integer a + * end structure + * and the parser first generates tags for var1 and var2 which + * are on the same scope as the structure itself. So first + * we need to skip past the tags on the same scope and only + * afterwards we get the nested tags. + * */ + if (source_file->lang == TM_PARSER_FORTRAN && + !inside_nesting && nested_scope_len == scope_len) + continue; + + inside_nesting = TRUE; + /* Terminate if outside of tag scope, see above */ if (nested_scope_len <= scope_len) break; Modified: src/tagmanager/tm_parser.c 22 lines changed, 12 insertions(+), 10 deletions(-) =================================================================== @@ -525,6 +525,9 @@ static TMParserMapGroup group_HASKELL[] = { {_("Functions"), TM_ICON_METHOD, tm_tag_function_t}, }; +#define map_UNUSED1 map_HASKELL +#define group_UNUSED1 group_HASKELL + static TMParserMapEntry map_CSHARP[] = { {'c', tm_tag_class_t}, // class {'d', tm_tag_macro_t}, // macro @@ -615,25 +618,28 @@ static TMSubparserMapEntry subparser_HTML_javascript_map[] = { {tm_tag_function_t, tm_tag_function_t}, }; -static TMParserMapEntry map_F77[] = { +static TMParserMapEntry map_FORTRAN[] = { {'b', tm_tag_undef_t}, // blockData {'c', tm_tag_macro_t}, // common {'e', tm_tag_undef_t}, // entry + {'E', tm_tag_enum_t}, // enum {'f', tm_tag_function_t}, // function {'i', tm_tag_interface_t}, // interface {'k', tm_tag_member_t}, // component {'l', tm_tag_undef_t}, // label {'L', tm_tag_undef_t}, // local {'m', tm_tag_namespace_t}, // module + {'M', tm_tag_member_t}, // method {'n', tm_tag_undef_t}, // namelist + {'N', tm_tag_enumerator_t}, // enumerator {'p', tm_tag_struct_t}, // program + {'P', tm_tag_undef_t}, // prototype {'s', tm_tag_method_t}, // subroutine {'t', tm_tag_class_t}, // type {'v', tm_tag_variable_t}, // variable - {'E', tm_tag_enum_t}, // enum - {'N', tm_tag_enumerator_t}, // enumerator + {'S', tm_tag_undef_t}, // submodule }; -static TMParserMapGroup group_F77[] = { +static TMParserMapGroup group_FORTRAN[] = { {_("Module"), TM_ICON_CLASS, tm_tag_namespace_t}, {_("Programs"), TM_ICON_CLASS, tm_tag_struct_t}, {_("Interfaces"), TM_ICON_STRUCT, tm_tag_interface_t}, @@ -645,9 +651,6 @@ static TMParserMapGroup group_F77[] = { {_("Enums"), TM_ICON_STRUCT, tm_tag_enum_t}, }; -#define map_FORTRAN map_F77 -#define group_FORTRAN group_F77 - static TMParserMapEntry map_MATLAB[] = { {'f', tm_tag_function_t}, // function {'s', tm_tag_struct_t}, // struct @@ -1072,7 +1075,7 @@ static TMParserMap parser_map[] = { MAP_ENTRY(HAXE), MAP_ENTRY(REST), MAP_ENTRY(HTML), - MAP_ENTRY(F77), + MAP_ENTRY(UNUSED1), MAP_ENTRY(CUDA), MAP_ENTRY(MATLAB), MAP_ENTRY(VALA), @@ -1360,7 +1363,7 @@ gboolean tm_parser_is_anon_name(TMParserType lang, gchar *name) return TRUE; else if (lang == TM_PARSER_C || lang == TM_PARSER_CPP) /* legacy Geany tags files */ return sscanf(name, "anon_%*[a-z]_%u%c", &i, &dummy) == 1; - else if (lang == TM_PARSER_FORTRAN || lang == TM_PARSER_F77) /* legacy Geany tags files */ + else if (lang == TM_PARSER_FORTRAN) /* legacy Geany tags files */ { return sscanf(name, "Structure#%u%c", &i, &dummy) == 1 || sscanf(name, "Interface#%u%c", &i, &dummy) == 1 || @@ -1614,7 +1617,6 @@ gboolean tm_parser_has_full_scope(TMParserType lang) case TM_PARSER_CLOJURE: case TM_PARSER_CONF: case TM_PARSER_ERLANG: - case TM_PARSER_F77: case TM_PARSER_FORTRAN: case TM_PARSER_OBJC: case TM_PARSER_REST: Modified: src/tagmanager/tm_parser.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -89,7 +89,7 @@ enum TM_PARSER_HAXE, TM_PARSER_REST, TM_PARSER_HTML, - TM_PARSER_F77, + TM_PARSER_UNUSED1, /* dummy entry, replace with some new parser */ TM_PARSER_CUDA, TM_PARSER_MATLAB, TM_PARSER_VALA, Modified: src/tagmanager/tm_parsers.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -45,7 +45,7 @@ HaxeParser,\ RstParser, \ HtmlParser, \ - F77Parser, \ + LiterateHaskellParser, /* dummy entry, replace with some new parser */ \ CUDAParser, \ MatLabParser, \ ValaParser, \ Modified: tests/ctags/bug565813.f90.tags 4 lines changed, 2 insertions(+), 2 deletions(-) =================================================================== @@ -3,6 +3,6 @@ N bar�64�foo_t�0 ctags_bug�256�0 foo_getbar�16�ctags_bug�0 -foo_set_bar�128�ctags_bug�0 -foo_setbar�128�ctags_bug�0 +foo_set_bar�128�(f, b)�ctags_bug�0 +foo_setbar�128�(f, b)�ctags_bug�0 foo_t�1�ctags_bug�0 Modified: tests/ctags/bug670433.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,5 +1,5 @@ # format=tagmanager -bar�128�foobar�0 +bar�128�(n)�foobar�0 f�16�foo�0 foo�16�foobar�0 foobar�256�0 Modified: tests/ctags/bug726712.f90.tags 6 lines changed, 3 insertions(+), 3 deletions(-) =================================================================== @@ -1,4 +1,4 @@ # format=tagmanager -sub1�128�0 -sub2�128�0 -tagstest_ctrl�128�0 +sub1�128�(a)�0 +sub2�128�(a)�0 +tagstest_ctrl�128�()�0 Modified: tests/ctags/enum.f90.tags 26 lines changed, 13 insertions(+), 13 deletions(-) =================================================================== @@ -8,22 +8,22 @@ Named4 Named5�2�Constants�0 Named6�2�Constants�0 Named7�2�Constants�0 -a�4�Enum#1�0 +a�4�anon_enum_2�0 anon_enum_1�2�Constants�1 anon_enum_2�2�Constants�1 -b�4�Enum#1�0 -black�4�Enum#0�0 -blue�4�Enum#0�0 -bronze�4�Enum#0�0 -c�4�Enum#1�0 -gold�4�Enum#0�0 +b�4�anon_enum_2�0 +black�4�anon_enum_1�0 +blue�4�anon_enum_1�0 +bronze�4�anon_enum_1�0 +c�4�anon_enum_2�0 +gold�4�anon_enum_1�0 hc�16384�Constants�0 -lavender�4�Enum#0�0 +lavender�4�anon_enum_1�0 pi�16384�Constants�0 -pink�4�Enum#0�0 -purple�4�Enum#0�0 -red�4�Enum#0�0 -silver�4�Enum#0�0 +pink�4�anon_enum_1�0 +purple�4�anon_enum_1�0 +red�4�anon_enum_1�0 +silver�4�anon_enum_1�0 x1�4�Named1�0 x2�4�Named2�0 x3�4�Named3�0 @@ -38,7 +38,7 @@ y4 y5�4�Named5�0 y6�4�Named6�0 y7�4�Named7�0 -yellow�4�Enum#0�0 +yellow�4�anon_enum_1�0 z1�4�Named1�0 z2�4�Named2�0 z3�4�Named3�0 Modified: tests/ctags/forall_module.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,5 +1,5 @@ # format=tagmanager a�16384�with_forall�0 -sub_with_forall�128�with_forall�0 +sub_with_forall�128�(x)�with_forall�0 two�16�with_forall�0 with_forall�256�0 Modified: tests/ctags/fortran_associate.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,5 +1,5 @@ # format=tagmanager a�16384�with_associate�0 -do_other_stuff�128�with_associate�0 +do_other_stuff�128�(a)�with_associate�0 do_stuff�16�with_associate�0 with_associate�256�0 Modified: tests/ctags/members.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -2,7 +2,7 @@ HasMembers�1�Members�0 Members�256�0 MyMethod�64�HasMembers�0 -MySubroutine�128�Members�0 +MySubroutine�128�(arg)�Members�0 kind_member�64�HasMembers�0 len_member�64�HasMembers�0 member�64�HasMembers�0 Modified: tests/ctags/numlib.f90.tags 1 lines changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -1,3 +1,4 @@ # format=tagmanager anon_interface_1�32�numerical_libraries�1 +anon_interface_2�32�b2lsf�1 numerical_libraries�256�0 Modified: tests/ctags/procedure_pointer_module.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -2,4 +2,4 @@ a�16384�proc_pointer�0 my_pointer�16384�proc_pointer�0 proc_pointer�256�0 -sub�128�proc_pointer�0 +sub�128�(x)�proc_pointer�0 Modified: tests/ctags/qualified_types.f90 4 lines changed, 2 insertions(+), 2 deletions(-) =================================================================== @@ -2,8 +2,8 @@ module test implicit none type goodtype(p1, p2, p3, p4) ! the stuff in brackets after the name of the type shouldn't appear in the type's name ! this is already correctly handled, so that's fine - integer, kind :: p1, p3 - integer, len :: p2, p4 ! the question is whether or not these "kind" and "len"s should be shown as members + integer, kind :: p1, p3 ! the question is whether or not these "kind" and "len"s should be shown as members + integer, len :: p2, p4 real(kind=p1) :: c1 character(len=p2) :: c2 complex :: c3(p3) Modified: tests/ctags/square_parens.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,7 +1,7 @@ # format=tagmanager Symmetry�1�squaretest�0 assignee�16384�squaretest�0 -execute�128�squaretest�0 +execute�128�(state)�squaretest�0 invisible�16384�squaretest�0 invisible_four�16384�squaretest�0 invisible_three�16384�squaretest�0 Modified: tests/ctags/stdcall.f.tags 4 lines changed, 2 insertions(+), 2 deletions(-) =================================================================== @@ -1,6 +1,6 @@ # format=tagmanager D02CJW�16384�0 -FCN�128�0 +FCN�128�(T, Y, F)�0 G�16�0 G�16384�0 H�16384�0 @@ -11,7 +11,7 @@ J K�16384�0 N�16384�0 NOUT�16384�0 -OUT�128�0 +OUT�128�(X, Y)�0 PI�16384�0 RELABS�16384�0 TOL�16384�0 Modified: tests/ctags/structure.f.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,5 +1,5 @@ # format=tagmanager -a�64�Structure#0�0 +a�64�anon_type_1�0 anon_type_1�1�nested�1 clouds�64�weather�0 day�64�weather�0 -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 083798: Add keybindings for "Project->New from Folder"
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: Jiří Techet <techet(a)gmail.com> Date: Sat, 19 Mar 2022 16:50:22 UTC Commit: 0837989188fa0adcfec4ccf84cd344faae736713 https://github.com/geany/geany/commit/0837989188fa0adcfec4ccf84cd344faae736… Log Message: ----------- Add keybindings for "Project->New from Folder" Modified Paths: -------------- src/keybindings.c src/keybindings.h src/plugindata.h Modified: src/keybindings.c 5 lines changed, 5 insertions(+), 0 deletions(-) =================================================================== @@ -366,6 +366,8 @@ static void init_default_kb(void) add_kb(group, GEANY_KEYS_PROJECT_NEW, NULL, 0, 0, "project_new", _("New"), "project_new1"); + add_kb(group, GEANY_KEYS_PROJECT_NEW_FROM_FOLDER, NULL, + 0, 0, "project_new_from_folder", _("New from Folder"), "project_new_from_folder1"); add_kb(group, GEANY_KEYS_PROJECT_OPEN, NULL, 0, 0, "project_open", _("Open"), "project_open1"); add_kb(group, GEANY_KEYS_PROJECT_PROPERTIES, NULL, @@ -1502,6 +1504,9 @@ static gboolean cb_func_project_action(guint key_id) case GEANY_KEYS_PROJECT_NEW: on_project_new1_activate(NULL, NULL); break; + case GEANY_KEYS_PROJECT_NEW_FROM_FOLDER: + on_project_new_from_folder1_activate(NULL, NULL); + break; case GEANY_KEYS_PROJECT_OPEN: on_project_open1_activate(NULL, NULL); break; Modified: src/keybindings.h 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -277,6 +277,8 @@ enum GeanyKeyBindingID * @since 1.34 (API 238) */ GEANY_KEYS_FILE_RELOAD_ALL, /**< Keybinding. * @since 1.38 (API 240) */ + GEANY_KEYS_PROJECT_NEW_FROM_FOLDER, /**< Keybinding. + * @since 1.39 (API 243) */ GEANY_KEYS_COUNT /* must not be used by plugins */ }; Modified: src/plugindata.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -58,7 +58,7 @@ G_BEGIN_DECLS * @warning You should not test for values below 200 as previously * @c GEANY_API_VERSION was defined as an enum value, not a macro. */ -#define GEANY_API_VERSION 243 +#define GEANY_API_VERSION 244 /* hack to have a different ABI when built with different GTK major versions * because loading plugins linked to a different one leads to crashes. -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] ce66dc: Improve user experience when creating new projects
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: Jiří Techet <techet(a)gmail.com> Date: Tue, 15 Mar 2022 19:44:59 UTC Commit: ce66dc92231cf7fb4aa47e1846f4ab127b8ee873 https://github.com/geany/geany/commit/ce66dc92231cf7fb4aa47e1846f4ab127b8ee… Log Message: ----------- Improve user experience when creating new projects At the moment, when creating a project, the user is greeted with the dialog containing: 1. Name 2. Filename 3. Base path The user is expected to type the name of the project into (1), and then, Geany tries to guess the base path and file name. The guess simply takes the project directory specified in settings and appends the name. When the project is located anywhere else than in the projects directory, the guessed values are wrong and have to be entered manually which is quite annoying. In addition, the dialog doesn't make it clear that the user should start with (1), when he starts with (2) or (3), he has to fill in all 3 values manually. This patch adds another method of project creation which is more suitable for creating projects from existing directory with source files. There's a new "Project->New from Folder..." option that in the first step asks user to provide the base path and based on this path fills in the entries in the New Project dialog. With this approach, Project->New from Folder...: a. First pops up a open directory dialog to specify base path b. After that, opens the (currently used) New Project dialog which is pre-filled in the following way: 1. Name: The last directory in base_path 2. Filename: depending on "store project file inside the project base directory" settings either in base_path/(1).geany or projects_dir/(1).geany 3. Base path: path specified in (a) This way, in most cases, the user will only have to select the base directory in the first step and use the pre-filled values without any modification no matter whether the project is stored in the projects directory or not. After this patch, there will be 2 different ways to create projects: 1. Project->New - more suitable for creating empty projects from scratch inside the "projects" directory 2. Project->New from Folder - more suitable for creating projects from existing sources Modified Paths: -------------- data/geany.glade src/callbacks.c src/callbacks.h src/project.c src/project.h src/ui_utils.c src/ui_utils.h Modified: data/geany.glade 17 lines changed, 17 insertions(+), 0 deletions(-) =================================================================== @@ -704,6 +704,12 @@ <property name="stock">gtk-find</property> <property name="icon_size">1</property> </object> + <object class="GtkImage" id="image7"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="stock">gtk-new</property> + <property name="icon-size">1</property> + </object> <object class="GtkListStore" id="indent_mode_list"> <columns>  @@ -7897,6 +7903,17 @@ <signal name="activate" handler="on_project_new1_activate" swapped="no"/> </object> </child> + <child> + <object class="GtkImageMenuItem" id="project_new_from_folder1"> + <property name="label" translatable="yes">New from _Folder...</property> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="use_underline">True</property> + <property name="image">image7</property> + <property name="use_stock">False</property> + <signal name="activate" handler="on_project_new_from_folder1_activate" swapped="no"/> + </object> + </child> <child> <object class="GtkImageMenuItem" id="project_open1"> <property name="label" translatable="yes">_Open...</property> Modified: src/callbacks.c 8 lines changed, 7 insertions(+), 1 deletions(-) =================================================================== @@ -1387,7 +1387,13 @@ void on_previous_message1_activate(GtkMenuItem *menuitem, gpointer user_data) void on_project_new1_activate(GtkMenuItem *menuitem, gpointer user_data) { - project_new(); + project_new(FALSE); +} + + +void on_project_new_from_folder1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + project_new(TRUE); } Modified: src/callbacks.h 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -144,6 +144,8 @@ void on_next_message1_activate(GtkMenuItem *menuitem, gpointer user_data); void on_project_new1_activate(GtkMenuItem *menuitem, gpointer user_data); +void on_project_new_from_folder1_activate(GtkMenuItem *menuitem, gpointer user_data); + void on_project_open1_activate(GtkMenuItem *menuitem, gpointer user_data); void on_project_close1_activate(GtkMenuItem *menuitem, gpointer user_data); Modified: src/project.c 75 lines changed, 58 insertions(+), 17 deletions(-) =================================================================== @@ -83,6 +83,8 @@ static gboolean update_config(const PropertyDialogElements *e, gboolean new_proj static void on_file_save_button_clicked(GtkButton *button, PropertyDialogElements *e); static gboolean load_config(const gchar *filename); static gboolean write_config(void); +static void update_new_project_dlg(GtkEditable *editable, PropertyDialogElements *e, + const gchar *base_p); static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements *e); static void on_entries_changed(GtkEditable *editable, PropertyDialogElements *e); static void on_radio_long_line_custom_toggled(GtkToggleButton *radio, GtkWidget *spin_long_line); @@ -141,7 +143,7 @@ static gboolean handle_current_session(void) /* TODO: this should be ported to Glade like the project preferences dialog, * then we can get rid of the PropertyDialogElements struct altogether as * widgets pointers can be accessed through ui_lookup_widget(). */ -void project_new(void) +void project_new(gboolean from_folder) { GtkWidget *vbox; GtkWidget *table; @@ -150,8 +152,16 @@ void project_new(void) GtkWidget *bbox; GtkWidget *label; gchar *tooltip; + gchar *base_path = NULL; PropertyDialogElements e = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, FALSE }; + if (from_folder) + { + base_path = ui_get_project_directory(local_prefs.project_file_path); + if (!base_path) + return; + } + e.dialog = gtk_dialog_new_with_buttons(_("New Project"), GTK_WINDOW(main_widgets.window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); @@ -218,13 +228,20 @@ void project_new(void) gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0); - /* signals */ - g_signal_connect(e.name, "changed", G_CALLBACK(on_name_entry_changed), &e); - /* run the callback manually to initialise the base_path and file_name fields */ - on_name_entry_changed(GTK_EDITABLE(e.name), &e); + if (base_path) + { + update_new_project_dlg(GTK_EDITABLE(e.name), &e, base_path); + g_free(base_path); + } + else + { + /* signals */ + g_signal_connect(e.name, "changed", G_CALLBACK(on_name_entry_changed), &e); + g_signal_connect(e.file_name, "changed", G_CALLBACK(on_entries_changed), &e); + g_signal_connect(e.base_path, "changed", G_CALLBACK(on_entries_changed), &e); - g_signal_connect(e.file_name, "changed", G_CALLBACK(on_entries_changed), &e); - g_signal_connect(e.base_path, "changed", G_CALLBACK(on_entries_changed), &e); + update_new_project_dlg(GTK_EDITABLE(e.name), &e, NULL); + } gtk_widget_show_all(e.dialog); run_new_dialog(&e); @@ -950,8 +967,9 @@ static void on_file_save_button_clicked(GtkButton *button, PropertyDialogElement } -/* sets the project base path and the project file name according to the project name */ -static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements *e) +/* sets the New Project dialog entries according to the base path or project name */ +static void update_new_project_dlg(GtkEditable *editable, PropertyDialogElements *e, + const gchar *base_p) { gchar *base_path; gchar *file_name; @@ -961,24 +979,41 @@ static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements if (e->entries_modified) return; - name = gtk_editable_get_chars(editable, 0, -1); - if (!EMPTY(name)) + if (!EMPTY(base_p)) { - base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, - name, G_DIR_SEPARATOR_S, NULL); + gchar *name = g_path_get_basename(base_p); + + base_path = g_strdup(base_p); + gtk_entry_set_text(GTK_ENTRY(e->name), name); if (project_prefs.project_file_in_basedir) - file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, name, G_DIR_SEPARATOR_S, + file_name = g_strconcat(base_path, G_DIR_SEPARATOR_S, name, "." GEANY_PROJECT_EXT, NULL); else file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, name, "." GEANY_PROJECT_EXT, NULL); + g_free(name); } else { - base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL); - file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL); + gchar *name = gtk_editable_get_chars(editable, 0, -1); + if (!EMPTY(name)) + { + base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, + name, G_DIR_SEPARATOR_S, NULL); + if (project_prefs.project_file_in_basedir) + file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, name, G_DIR_SEPARATOR_S, + name, "." GEANY_PROJECT_EXT, NULL); + else + file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, + name, "." GEANY_PROJECT_EXT, NULL); + } + else + { + base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL); + file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL); + } + g_free(name); } - g_free(name); gtk_entry_set_text(GTK_ENTRY(e->base_path), base_path); gtk_entry_set_text(GTK_ENTRY(e->file_name), file_name); @@ -990,6 +1025,12 @@ static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements } +static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements *e) +{ + update_new_project_dlg(editable, e, NULL); +} + + static void on_entries_changed(GtkEditable *editable, PropertyDialogElements *e) { e->entries_modified = TRUE; Modified: src/project.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -66,7 +66,7 @@ void project_init(void); void project_finalize(void); -void project_new(void); +void project_new(gboolean from_folder); void project_open(void); Modified: src/ui_utils.c 15 lines changed, 15 insertions(+), 0 deletions(-) =================================================================== @@ -1999,6 +1999,21 @@ static gchar *run_file_chooser(const gchar *title, GtkFileChooserAction action, #endif +gchar *ui_get_project_directory(const gchar *path) +{ + gchar *utf8_path; + const gchar *title = _("Select Project Base Path"); + +#ifdef G_OS_WIN32 + utf8_path = win32_show_folder_dialog(ui_widgets.prefs_dialog, title, path); +#else + utf8_path = run_file_chooser(title, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, path); +#endif + + return utf8_path; +} + + static void ui_path_box_open_clicked(GtkButton *button, gpointer user_data) { GtkFileChooserAction action = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "action")); Modified: src/ui_utils.h 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -365,6 +365,8 @@ gint ui_encodings_combo_box_get_active_encoding(GtkComboBox *combo); gboolean ui_encodings_combo_box_set_active_encoding(GtkComboBox *combo, gint enc); +gchar *ui_get_project_directory(const gchar *path); + #endif /* GEANY_PRIVATE */ G_END_DECLS -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 1bc7d8: Store project files in base directory by default
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: Jiří Techet <techet(a)gmail.com> Date: Sat, 19 Mar 2022 16:50:30 UTC Commit: 1bc7d8ff4eefc859f9bf2c2bf81d0952f8663c40 https://github.com/geany/geany/commit/1bc7d8ff4eefc859f9bf2c2bf81d0952f8663… Log Message: ----------- Store project files in base directory by default Project files are, by default, stored inside the configured "projects" directory. The problem is that for new users of Geany, the default ~/projects most probably points to a non-existent directory and then, the project creation experience is not quite optimal. In addition, this is what most editors do and most Geany newcomers will expect this behavior. Modified Paths: -------------- src/keyfile.c Modified: src/keyfile.c 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -801,7 +801,7 @@ static void load_dialog_prefs(GKeyFile *config) prefs.confirm_exit = utils_get_setting_boolean(config, PACKAGE, "pref_main_confirm_exit", FALSE); prefs.suppress_status_messages = utils_get_setting_boolean(config, PACKAGE, "pref_main_suppress_status_messages", FALSE); prefs.load_session = utils_get_setting_boolean(config, PACKAGE, "pref_main_load_session", TRUE); - project_prefs.project_file_in_basedir = utils_get_setting_boolean(config, PACKAGE, "pref_main_project_file_in_basedir", FALSE); + project_prefs.project_file_in_basedir = utils_get_setting_boolean(config, PACKAGE, "pref_main_project_file_in_basedir", TRUE); prefs.save_winpos = utils_get_setting_boolean(config, PACKAGE, "pref_main_save_winpos", TRUE); prefs.save_wingeom = utils_get_setting_boolean(config, PACKAGE, "pref_main_save_wingeom", prefs.save_winpos); prefs.beep_on_errors = utils_get_setting_boolean(config, PACKAGE, "beep_on_errors", TRUE); -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] f87683: Make the New Project dialog a little wider
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: Jiří Techet <techet(a)gmail.com> Date: Sat, 19 Mar 2022 16:50:30 UTC Commit: f8768399d32b817ecaccd2f28f43e8e0d55a06e6 https://github.com/geany/geany/commit/f8768399d32b817ecaccd2f28f43e8e0d55a0… Log Message: ----------- Make the New Project dialog a little wider With the current width, the created project file name gets hidden even for not-so-long paths. Consider for instance the following path: /home/my_name/projects/project/project.geany It consists of 43 characters where "/home/my_name/projects/" is a typical prefix of someone with not terribly long user name and also "project/project.geany" is fairly normal project name and directory name length. Even though the patch says 40, this 43-character string still fits in on my machine (50 makes the window a little too wide). Modified Paths: -------------- src/project.c Modified: src/project.c 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -195,7 +195,7 @@ void project_new(gboolean from_folder) e.file_name = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(e.file_name), TRUE); ui_entry_add_clear_icon(GTK_ENTRY(e.file_name)); - gtk_entry_set_width_chars(GTK_ENTRY(e.file_name), 30); + gtk_entry_set_width_chars(GTK_ENTRY(e.file_name), 40); tooltip = g_strdup_printf( _("Path of the file representing the project and storing its settings. " "It should normally have the \"%s\" extension."), "."GEANY_PROJECT_EXT); -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 8abf31: Improve project directory determination
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: Jiří Techet <techet(a)gmail.com> Date: Sat, 19 Mar 2022 16:50:30 UTC Commit: 8abf31d3c6f559df18505fd1c69ac771b23cd94c https://github.com/geany/geany/commit/8abf31d3c6f559df18505fd1c69ac771b23cd… Log Message: ----------- Improve project directory determination When using "New from Folder", open the directory selection dialog at current document's directory to simplify new project creation for opened files. Fall back to "project files" directory if no file opened and if this directory isn't set in preferences, fall back to user's home directory. In addition take into account that the "project files" directory may not be set when filling in entries in the "New Project" dialog and fall back to currently opened document's directory or to home directory when no document is opened. Modified Paths: -------------- src/project.c Modified: src/project.c 30 lines changed, 27 insertions(+), 3 deletions(-) =================================================================== @@ -157,7 +157,19 @@ void project_new(gboolean from_folder) if (from_folder) { - base_path = ui_get_project_directory(local_prefs.project_file_path); + GeanyDocument *doc = document_get_current(); + gchar *start_path; + + if (doc && doc->file_name) + start_path = g_path_get_dirname(doc->file_name); + else if (!EMPTY(local_prefs.project_file_path)) + start_path = g_strdup(local_prefs.project_file_path); + else + start_path = utils_get_utf8_from_locale(g_get_home_dir()); + + base_path = ui_get_project_directory(start_path); + g_free(start_path); + if (!base_path) return; } @@ -973,12 +985,23 @@ static void update_new_project_dlg(GtkEditable *editable, PropertyDialogElements { gchar *base_path; gchar *file_name; - gchar *name; - const gchar *project_dir = local_prefs.project_file_path; + gchar *project_dir = NULL; if (e->entries_modified) return; + if (!EMPTY(local_prefs.project_file_path)) + project_dir = g_strdup(local_prefs.project_file_path); + else + { + GeanyDocument *doc = document_get_current(); + + if (doc && doc->file_name) + project_dir = g_path_get_dirname(doc->file_name); + else + project_dir = utils_get_utf8_from_locale(g_get_home_dir()); + } + if (!EMPTY(base_p)) { gchar *name = g_path_get_basename(base_p); @@ -1022,6 +1045,7 @@ static void update_new_project_dlg(GtkEditable *editable, PropertyDialogElements g_free(base_path); g_free(file_name); + g_free(project_dir); } -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] 4b573b: Merge pull request #3042 from techee/project_create2
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: GitHub <noreply(a)github.com> Date: Fri, 13 May 2022 00:19:35 UTC Commit: 4b573b7a402347cb6b74c07057d862b66959fa2a https://github.com/geany/geany/commit/4b573b7a402347cb6b74c07057d862b66959f… Log Message: ----------- Merge pull request #3042 from techee/project_create2 Improve user experience when creating new projects, attempt 2 Modified Paths: -------------- data/geany.glade doc/geany.txt src/callbacks.c src/callbacks.h src/keybindings.c src/keybindings.h src/keyfile.c src/plugindata.h src/project.c src/project.h src/ui_utils.c src/ui_utils.h Modified: data/geany.glade 17 lines changed, 17 insertions(+), 0 deletions(-) =================================================================== @@ -704,6 +704,12 @@ <property name="stock">gtk-find</property> <property name="icon_size">1</property> </object> + <object class="GtkImage" id="image7"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="stock">gtk-new</property> + <property name="icon-size">1</property> + </object> <object class="GtkListStore" id="indent_mode_list"> <columns>  @@ -7897,6 +7903,17 @@ <signal name="activate" handler="on_project_new1_activate" swapped="no"/> </object> </child> + <child> + <object class="GtkImageMenuItem" id="project_new_from_folder1"> + <property name="label" translatable="yes">New from _Folder...</property> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="use_underline">True</property> + <property name="image">image7</property> + <property name="use_stock">False</property> + <signal name="activate" handler="on_project_new_from_folder1_activate" swapped="no"/> + </object> + </child> <child> <object class="GtkImageMenuItem" id="project_open1"> <property name="label" translatable="yes">_Open...</property> Modified: doc/geany.txt 37 lines changed, 29 insertions(+), 8 deletions(-) =================================================================== @@ -2776,14 +2776,35 @@ The project menu items are detailed below. New project ^^^^^^^^^^^ -To create a new project, fill in the *Name* field. By default this -will setup a new project file ``~/projects/name.geany``. Usually it's -best to store all your project files in the same directory (they are -independent of any source directory trees). - -The Base path text field is setup to use ``~/projects/name``. This -can safely be set to any existing path -- it will not touch the file -structure contained in it. +There are two ways of creating new projects, either by using +*Project->New* menu item or by using *Project->New from Folder* menu +item. + +New + This method is more suitable for creating new, empty projects from + scratch at the default location without having any existing sources. + + To create a new project, fill in the *Name* field. By default this + will setup a new project file ``~/projects/name/name.geany``. + + The *Base path* text field is setup to use ``~/projects/name``. This + can safely be set to any existing path -- it will not touch the file + structure contained in it. + +New from Folder + This method is more suitable when there is already some folder + containing source files for which you want to create a new project. + + When using this method, Geany first opens a directory selection + dialog to select the folder containing the sources, and the + *Base path* field is set to that value. + + Afterwards, Geany shows the same dialog as the *Project->New* + method but already pre-filled with the values based on the + *Base path* selection. The *Name* field is filled with the folder + name, the *Filename* field is filled with + ``base_path/name.geany`` and the *Base path* field is filled with + the path specified in the previous dialog. Project properties Modified: src/callbacks.c 8 lines changed, 7 insertions(+), 1 deletions(-) =================================================================== @@ -1387,7 +1387,13 @@ void on_previous_message1_activate(GtkMenuItem *menuitem, gpointer user_data) void on_project_new1_activate(GtkMenuItem *menuitem, gpointer user_data) { - project_new(); + project_new(FALSE); +} + + +void on_project_new_from_folder1_activate(GtkMenuItem *menuitem, gpointer user_data) +{ + project_new(TRUE); } Modified: src/callbacks.h 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -144,6 +144,8 @@ void on_next_message1_activate(GtkMenuItem *menuitem, gpointer user_data); void on_project_new1_activate(GtkMenuItem *menuitem, gpointer user_data); +void on_project_new_from_folder1_activate(GtkMenuItem *menuitem, gpointer user_data); + void on_project_open1_activate(GtkMenuItem *menuitem, gpointer user_data); void on_project_close1_activate(GtkMenuItem *menuitem, gpointer user_data); Modified: src/keybindings.c 5 lines changed, 5 insertions(+), 0 deletions(-) =================================================================== @@ -366,6 +366,8 @@ static void init_default_kb(void) add_kb(group, GEANY_KEYS_PROJECT_NEW, NULL, 0, 0, "project_new", _("New"), "project_new1"); + add_kb(group, GEANY_KEYS_PROJECT_NEW_FROM_FOLDER, NULL, + 0, 0, "project_new_from_folder", _("New from Folder"), "project_new_from_folder1"); add_kb(group, GEANY_KEYS_PROJECT_OPEN, NULL, 0, 0, "project_open", _("Open"), "project_open1"); add_kb(group, GEANY_KEYS_PROJECT_PROPERTIES, NULL, @@ -1502,6 +1504,9 @@ static gboolean cb_func_project_action(guint key_id) case GEANY_KEYS_PROJECT_NEW: on_project_new1_activate(NULL, NULL); break; + case GEANY_KEYS_PROJECT_NEW_FROM_FOLDER: + on_project_new_from_folder1_activate(NULL, NULL); + break; case GEANY_KEYS_PROJECT_OPEN: on_project_open1_activate(NULL, NULL); break; Modified: src/keybindings.h 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -277,6 +277,8 @@ enum GeanyKeyBindingID * @since 1.34 (API 238) */ GEANY_KEYS_FILE_RELOAD_ALL, /**< Keybinding. * @since 1.38 (API 240) */ + GEANY_KEYS_PROJECT_NEW_FROM_FOLDER, /**< Keybinding. + * @since 1.39 (API 243) */ GEANY_KEYS_COUNT /* must not be used by plugins */ }; Modified: src/keyfile.c 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -824,7 +824,7 @@ static void load_dialog_prefs(GKeyFile *config) prefs.confirm_exit = utils_get_setting_boolean(config, PACKAGE, "pref_main_confirm_exit", FALSE); prefs.suppress_status_messages = utils_get_setting_boolean(config, PACKAGE, "pref_main_suppress_status_messages", FALSE); prefs.load_session = utils_get_setting_boolean(config, PACKAGE, "pref_main_load_session", TRUE); - project_prefs.project_file_in_basedir = utils_get_setting_boolean(config, PACKAGE, "pref_main_project_file_in_basedir", FALSE); + project_prefs.project_file_in_basedir = utils_get_setting_boolean(config, PACKAGE, "pref_main_project_file_in_basedir", TRUE); prefs.save_winpos = utils_get_setting_boolean(config, PACKAGE, "pref_main_save_winpos", TRUE); prefs.save_wingeom = utils_get_setting_boolean(config, PACKAGE, "pref_main_save_wingeom", prefs.save_winpos); prefs.beep_on_errors = utils_get_setting_boolean(config, PACKAGE, "beep_on_errors", TRUE); Modified: src/plugindata.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -57,7 +57,7 @@ G_BEGIN_DECLS * @warning You should not test for values below 200 as previously * @c GEANY_API_VERSION was defined as an enum value, not a macro. */ -#define GEANY_API_VERSION 243 +#define GEANY_API_VERSION 244 /* hack to have a different ABI when built with different GTK major versions * because loading plugins linked to a different one leads to crashes. Modified: src/project.c 105 lines changed, 85 insertions(+), 20 deletions(-) =================================================================== @@ -83,6 +83,8 @@ static gboolean update_config(const PropertyDialogElements *e, gboolean new_proj static void on_file_save_button_clicked(GtkButton *button, PropertyDialogElements *e); static gboolean load_config(const gchar *filename); static gboolean write_config(void); +static void update_new_project_dlg(GtkEditable *editable, PropertyDialogElements *e, + const gchar *base_p); static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements *e); static void on_entries_changed(GtkEditable *editable, PropertyDialogElements *e); static void on_radio_long_line_custom_toggled(GtkToggleButton *radio, GtkWidget *spin_long_line); @@ -141,7 +143,7 @@ static gboolean handle_current_session(void) /* TODO: this should be ported to Glade like the project preferences dialog, * then we can get rid of the PropertyDialogElements struct altogether as * widgets pointers can be accessed through ui_lookup_widget(). */ -void project_new(void) +void project_new(gboolean from_folder) { GtkWidget *vbox; GtkWidget *table; @@ -150,8 +152,28 @@ void project_new(void) GtkWidget *bbox; GtkWidget *label; gchar *tooltip; + gchar *base_path = NULL; PropertyDialogElements e = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, FALSE }; + if (from_folder) + { + GeanyDocument *doc = document_get_current(); + gchar *start_path; + + if (doc && doc->file_name) + start_path = g_path_get_dirname(doc->file_name); + else if (!EMPTY(local_prefs.project_file_path)) + start_path = g_strdup(local_prefs.project_file_path); + else + start_path = utils_get_utf8_from_locale(g_get_home_dir()); + + base_path = ui_get_project_directory(start_path); + g_free(start_path); + + if (!base_path) + return; + } + e.dialog = gtk_dialog_new_with_buttons(_("New Project"), GTK_WINDOW(main_widgets.window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); @@ -185,7 +207,7 @@ void project_new(void) e.file_name = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(e.file_name), TRUE); ui_entry_add_clear_icon(GTK_ENTRY(e.file_name)); - gtk_entry_set_width_chars(GTK_ENTRY(e.file_name), 30); + gtk_entry_set_width_chars(GTK_ENTRY(e.file_name), 40); tooltip = g_strdup_printf( _("Path of the file representing the project and storing its settings. " "It should normally have the \"%s\" extension."), "."GEANY_PROJECT_EXT); @@ -218,13 +240,20 @@ void project_new(void) gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0); - /* signals */ - g_signal_connect(e.name, "changed", G_CALLBACK(on_name_entry_changed), &e); - /* run the callback manually to initialise the base_path and file_name fields */ - on_name_entry_changed(GTK_EDITABLE(e.name), &e); + if (base_path) + { + update_new_project_dlg(GTK_EDITABLE(e.name), &e, base_path); + g_free(base_path); + } + else + { + /* signals */ + g_signal_connect(e.name, "changed", G_CALLBACK(on_name_entry_changed), &e); + g_signal_connect(e.file_name, "changed", G_CALLBACK(on_entries_changed), &e); + g_signal_connect(e.base_path, "changed", G_CALLBACK(on_entries_changed), &e); - g_signal_connect(e.file_name, "changed", G_CALLBACK(on_entries_changed), &e); - g_signal_connect(e.base_path, "changed", G_CALLBACK(on_entries_changed), &e); + update_new_project_dlg(GTK_EDITABLE(e.name), &e, NULL); + } gtk_widget_show_all(e.dialog); run_new_dialog(&e); @@ -950,35 +979,64 @@ static void on_file_save_button_clicked(GtkButton *button, PropertyDialogElement } -/* sets the project base path and the project file name according to the project name */ -static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements *e) +/* sets the New Project dialog entries according to the base path or project name */ +static void update_new_project_dlg(GtkEditable *editable, PropertyDialogElements *e, + const gchar *base_p) { gchar *base_path; gchar *file_name; - gchar *name; - const gchar *project_dir = local_prefs.project_file_path; + gchar *project_dir = NULL; if (e->entries_modified) return; - name = gtk_editable_get_chars(editable, 0, -1); - if (!EMPTY(name)) + if (!EMPTY(local_prefs.project_file_path)) + project_dir = g_strdup(local_prefs.project_file_path); + else { - base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, - name, G_DIR_SEPARATOR_S, NULL); + GeanyDocument *doc = document_get_current(); + + if (doc && doc->file_name) + project_dir = g_path_get_dirname(doc->file_name); + else + project_dir = utils_get_utf8_from_locale(g_get_home_dir()); + } + + if (!EMPTY(base_p)) + { + gchar *name = g_path_get_basename(base_p); + + base_path = g_strdup(base_p); + gtk_entry_set_text(GTK_ENTRY(e->name), name); if (project_prefs.project_file_in_basedir) - file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, name, G_DIR_SEPARATOR_S, + file_name = g_strconcat(base_path, G_DIR_SEPARATOR_S, name, "." GEANY_PROJECT_EXT, NULL); else file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, name, "." GEANY_PROJECT_EXT, NULL); + g_free(name); } else { - base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL); - file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL); + gchar *name = gtk_editable_get_chars(editable, 0, -1); + if (!EMPTY(name)) + { + base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, + name, G_DIR_SEPARATOR_S, NULL); + if (project_prefs.project_file_in_basedir) + file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, name, G_DIR_SEPARATOR_S, + name, "." GEANY_PROJECT_EXT, NULL); + else + file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, + name, "." GEANY_PROJECT_EXT, NULL); + } + else + { + base_path = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL); + file_name = g_strconcat(project_dir, G_DIR_SEPARATOR_S, NULL); + } + g_free(name); } - g_free(name); gtk_entry_set_text(GTK_ENTRY(e->base_path), base_path); gtk_entry_set_text(GTK_ENTRY(e->file_name), file_name); @@ -987,6 +1045,13 @@ static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements g_free(base_path); g_free(file_name); + g_free(project_dir); +} + + +static void on_name_entry_changed(GtkEditable *editable, PropertyDialogElements *e) +{ + update_new_project_dlg(editable, e, NULL); } Modified: src/project.h 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -66,7 +66,7 @@ void project_init(void); void project_finalize(void); -void project_new(void); +void project_new(gboolean from_folder); void project_open(void); Modified: src/ui_utils.c 15 lines changed, 15 insertions(+), 0 deletions(-) =================================================================== @@ -1999,6 +1999,21 @@ static gchar *run_file_chooser(const gchar *title, GtkFileChooserAction action, #endif +gchar *ui_get_project_directory(const gchar *path) +{ + gchar *utf8_path; + const gchar *title = _("Select Project Base Path"); + +#ifdef G_OS_WIN32 + utf8_path = win32_show_folder_dialog(ui_widgets.prefs_dialog, title, path); +#else + utf8_path = run_file_chooser(title, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, path); +#endif + + return utf8_path; +} + + static void ui_path_box_open_clicked(GtkButton *button, gpointer user_data) { GtkFileChooserAction action = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "action")); Modified: src/ui_utils.h 2 lines changed, 2 insertions(+), 0 deletions(-) =================================================================== @@ -366,6 +366,8 @@ gint ui_encodings_combo_box_get_active_encoding(GtkComboBox *combo); gboolean ui_encodings_combo_box_set_active_encoding(GtkComboBox *combo, gint enc); +gchar *ui_get_project_directory(const gchar *path); + #endif /* GEANY_PRIVATE */ G_END_DECLS -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

[geany/geany] d82cd9: Update unit tests
by Jiří Techet 13 May '22

13 May '22

Branch: refs/heads/master Author: Jiří Techet <techet(a)gmail.com> Committer: Jiří Techet <techet(a)gmail.com> Date: Fri, 13 May 2022 00:15:57 UTC Commit: d82cd9879fb778dc4cca89a4811e23a6d3e13195 https://github.com/geany/geany/commit/d82cd9879fb778dc4cca89a4811e23a6d3e13… Log Message: ----------- Update unit tests Update qualified_types.f90 and members.f90 to remove the "kind" and "len" specifiers after integers. I haven't seen this usage documented anywhere and the syntax, when used should include braces such as integer(len=5). The previous Geany Fortran parser used to parse these but since I don't think it's a valid syntax, I didn't submit the corresponding patch upstream. The rest of the tests is mostly added function arguments and different names for anonymous tags. Modified Paths: -------------- tests/ctags/bug565813.f90.tags tests/ctags/bug670433.f90.tags tests/ctags/bug726712.f90.tags tests/ctags/enum.f90.tags tests/ctags/forall_module.f90.tags tests/ctags/fortran_associate.f90.tags tests/ctags/members.f90.tags tests/ctags/numlib.f90.tags tests/ctags/procedure_pointer_module.f90.tags tests/ctags/qualified_types.f90 tests/ctags/square_parens.f90.tags tests/ctags/stdcall.f.tags tests/ctags/structure.f.tags Modified: tests/ctags/bug565813.f90.tags 4 lines changed, 2 insertions(+), 2 deletions(-) =================================================================== @@ -3,6 +3,6 @@ N bar�64�foo_t�0 ctags_bug�256�0 foo_getbar�16�ctags_bug�0 -foo_set_bar�128�ctags_bug�0 -foo_setbar�128�ctags_bug�0 +foo_set_bar�128�(f, b)�ctags_bug�0 +foo_setbar�128�(f, b)�ctags_bug�0 foo_t�1�ctags_bug�0 Modified: tests/ctags/bug670433.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,5 +1,5 @@ # format=tagmanager -bar�128�foobar�0 +bar�128�(n)�foobar�0 f�16�foo�0 foo�16�foobar�0 foobar�256�0 Modified: tests/ctags/bug726712.f90.tags 6 lines changed, 3 insertions(+), 3 deletions(-) =================================================================== @@ -1,4 +1,4 @@ # format=tagmanager -sub1�128�0 -sub2�128�0 -tagstest_ctrl�128�0 +sub1�128�(a)�0 +sub2�128�(a)�0 +tagstest_ctrl�128�()�0 Modified: tests/ctags/enum.f90.tags 26 lines changed, 13 insertions(+), 13 deletions(-) =================================================================== @@ -8,22 +8,22 @@ Named4 Named5�2�Constants�0 Named6�2�Constants�0 Named7�2�Constants�0 -a�4�Enum#1�0 +a�4�anon_enum_2�0 anon_enum_1�2�Constants�1 anon_enum_2�2�Constants�1 -b�4�Enum#1�0 -black�4�Enum#0�0 -blue�4�Enum#0�0 -bronze�4�Enum#0�0 -c�4�Enum#1�0 -gold�4�Enum#0�0 +b�4�anon_enum_2�0 +black�4�anon_enum_1�0 +blue�4�anon_enum_1�0 +bronze�4�anon_enum_1�0 +c�4�anon_enum_2�0 +gold�4�anon_enum_1�0 hc�16384�Constants�0 -lavender�4�Enum#0�0 +lavender�4�anon_enum_1�0 pi�16384�Constants�0 -pink�4�Enum#0�0 -purple�4�Enum#0�0 -red�4�Enum#0�0 -silver�4�Enum#0�0 +pink�4�anon_enum_1�0 +purple�4�anon_enum_1�0 +red�4�anon_enum_1�0 +silver�4�anon_enum_1�0 x1�4�Named1�0 x2�4�Named2�0 x3�4�Named3�0 @@ -38,7 +38,7 @@ y4 y5�4�Named5�0 y6�4�Named6�0 y7�4�Named7�0 -yellow�4�Enum#0�0 +yellow�4�anon_enum_1�0 z1�4�Named1�0 z2�4�Named2�0 z3�4�Named3�0 Modified: tests/ctags/forall_module.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,5 +1,5 @@ # format=tagmanager a�16384�with_forall�0 -sub_with_forall�128�with_forall�0 +sub_with_forall�128�(x)�with_forall�0 two�16�with_forall�0 with_forall�256�0 Modified: tests/ctags/fortran_associate.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,5 +1,5 @@ # format=tagmanager a�16384�with_associate�0 -do_other_stuff�128�with_associate�0 +do_other_stuff�128�(a)�with_associate�0 do_stuff�16�with_associate�0 with_associate�256�0 Modified: tests/ctags/members.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -2,7 +2,7 @@ HasMembers�1�Members�0 Members�256�0 MyMethod�64�HasMembers�0 -MySubroutine�128�Members�0 +MySubroutine�128�(arg)�Members�0 kind_member�64�HasMembers�0 len_member�64�HasMembers�0 member�64�HasMembers�0 Modified: tests/ctags/numlib.f90.tags 1 lines changed, 1 insertions(+), 0 deletions(-) =================================================================== @@ -1,3 +1,4 @@ # format=tagmanager anon_interface_1�32�numerical_libraries�1 +anon_interface_2�32�b2lsf�1 numerical_libraries�256�0 Modified: tests/ctags/procedure_pointer_module.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -2,4 +2,4 @@ a�16384�proc_pointer�0 my_pointer�16384�proc_pointer�0 proc_pointer�256�0 -sub�128�proc_pointer�0 +sub�128�(x)�proc_pointer�0 Modified: tests/ctags/qualified_types.f90 4 lines changed, 2 insertions(+), 2 deletions(-) =================================================================== @@ -2,8 +2,8 @@ module test implicit none type goodtype(p1, p2, p3, p4) ! the stuff in brackets after the name of the type shouldn't appear in the type's name ! this is already correctly handled, so that's fine - integer, kind :: p1, p3 - integer, len :: p2, p4 ! the question is whether or not these "kind" and "len"s should be shown as members + integer, kind :: p1, p3 ! the question is whether or not these "kind" and "len"s should be shown as members + integer, len :: p2, p4 real(kind=p1) :: c1 character(len=p2) :: c2 complex :: c3(p3) Modified: tests/ctags/square_parens.f90.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,7 +1,7 @@ # format=tagmanager Symmetry�1�squaretest�0 assignee�16384�squaretest�0 -execute�128�squaretest�0 +execute�128�(state)�squaretest�0 invisible�16384�squaretest�0 invisible_four�16384�squaretest�0 invisible_three�16384�squaretest�0 Modified: tests/ctags/stdcall.f.tags 4 lines changed, 2 insertions(+), 2 deletions(-) =================================================================== @@ -1,6 +1,6 @@ # format=tagmanager D02CJW�16384�0 -FCN�128�0 +FCN�128�(T, Y, F)�0 G�16�0 G�16384�0 H�16384�0 @@ -11,7 +11,7 @@ J K�16384�0 N�16384�0 NOUT�16384�0 -OUT�128�0 +OUT�128�(X, Y)�0 PI�16384�0 RELABS�16384�0 TOL�16384�0 Modified: tests/ctags/structure.f.tags 2 lines changed, 1 insertions(+), 1 deletions(-) =================================================================== @@ -1,5 +1,5 @@ # format=tagmanager -a�64�Structure#0�0 +a�64�anon_type_1�0 anon_type_1�1�nested�1 clouds�64�weather�0 day�64�weather�0 -------------- This E-Mail was brought to you by github_commit_mail.py (Source: https://github.com/geany/infrastructure).

1 0

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

Commits May 2022