tagmanager/ctags/txt2tags.c

   1 /*
   2 *   Copyright (c) 2009, Eric Forgeot
   3 *   Copyright (c) 2014, Colomban Wendling <colomban@geany.org>
   4 *
   5 *   Based on work by Jon Strait
   6 *
   7 *   This source code is released for free distribution under the terms of the
   8 *   GNU General Public License.
   9 *
  10 *   This module contains functions for generating tags for Txt2tags files.
  11 */
  12
  13 /*
  14 *   INCLUDE FILES
  15 */
  16 #include "general.h"    /* must always come first */
  17
  18 #include <ctype.h>
  19 #include <string.h>
  20
  21 #include "parse.h"
  22 #include "read.h"
  23 #include "nestlevel.h"
  24 #include "vstring.h"
  25
  26
  27 /* as any character may happen in an input, use something highly unlikely */
  28 #define SCOPE_SEPARATOR '\x3' /* ASCII ETX */
  29
  30 /*
  31 *   DATA DEFINITIONS
  32 */
  33
  34 typedef enum {
  35         K_SECTION = 0
  36 } Txt2tagsKind;
  37
  38 static kindOption Txt2tagsKinds[] = {
  39         { TRUE, 'm', "member", "sections" }
  40 };
  41
  42 /*
  43 *   FUNCTION DEFINITIONS
  44 */
  45
  46 static void makeTxt2tagsTag (const vString* const name,
  47                              const NestingLevels *const nls,
  48                              Txt2tagsKind type)
  49 {
  50         tagEntryInfo e;
  51         vString *scope = NULL;
  52         kindOption *kind = &Txt2tagsKinds[type];
  53         initTagEntry (&e, vStringValue(name));
  54
  55         e.kindName = kind->name;
  56         e.kind = kind->letter;
  57
  58         if (nls->n > 0) {
  59                 int i;
  60                 kindOption *parentKind;
  61
  62                 scope = vStringNew();
  63                 for (i = 0; i < nls->n; i++) {
  64                         if (vStringLength(scope) > 0)
  65                                 vStringPut(scope, SCOPE_SEPARATOR);
  66                         vStringCat(scope, nls->levels[i].name);
  67                 }
  68                 parentKind = &Txt2tagsKinds[nls->levels[nls->n - 1].type];
  69
  70                 e.extensionFields.scope[0] = parentKind->name;
  71                 e.extensionFields.scope[1] = vStringValue(scope);
  72         }
  73
  74         makeTagEntry(&e);
  75
  76         vStringDelete(scope);
  77 }
  78
  79 /* matches: ^ *[=_-]{20,} *$ */
  80 static boolean isTxt2tagsLine (const unsigned char *line)
  81 {
  82         unsigned int len;
  83
  84         while (isspace(*line)) line++;
  85         for (len = 0; *line == '=' || *line == '-' || *line == '_'; len++)
  86                 line++;
  87         while (isspace(*line)) line++;
  88
  89         return len >= 20 && *line == 0;
  90 }
  91
  92 static boolean parseTxt2tagsTitle (const unsigned char *line,
  93                                    vString *const title,
  94                                    int *const depth_)
  95 {
  96         const int MAX_TITLE_DEPTH = 5; /* maximum length of a title delimiter */
  97         unsigned char delim;
  98         int delim_delta = 0;
  99         const unsigned char *end;
 100
 101         /* skip leading spaces, but no tabs (probably because they create quotes) */
 102         while (*line == ' ') line++;
 103
 104         /* normal/numbered titles */
 105         if (*line != '=' && *line != '+')
 106                 return FALSE;
 107
 108         delim = *line;
 109
 110         /* find the start delimiter length */
 111         while (*line == delim && delim_delta < MAX_TITLE_DEPTH+1)
 112         {
 113                 line++;
 114                 delim_delta++;
 115         }
 116         while (isspace(*line))
 117                 line++;
 118
 119         if (delim_delta > MAX_TITLE_DEPTH) /* invalid */
 120                 return FALSE;
 121
 122         *depth_ = delim_delta;
 123
 124         /* find the end delimiter */
 125         end = line + strlen((const char *) line) - 1;
 126         while (end > line && isspace(*end)) end--;
 127         /* skip a possible label: \[[A-Za-z0-9_-]+\] */
 128         if (*end == ']')
 129         {
 130                 end--;
 131                 while (end > line && (isalnum(*end) || *end == '_' || *end == '-'))
 132                         end--;
 133                 if (*end != '[') /* invalid */
 134                         return FALSE;
 135                 end--;
 136         }
 137         while (end > line && *end == delim && delim_delta >= 0)
 138         {
 139                 delim_delta--;
 140                 end--;
 141         }
 142         while (end > line && isspace(*end)) end--;
 143         end++;
 144
 145         /* if start and end delimiters are not identical, or the the name is empty */
 146         if (delim_delta != 0 || (end - line) <= 0)
 147                 return FALSE;
 148
 149         vStringNCopyS(title, (const char *) line, end - line);
 150         return TRUE;
 151 }
 152
 153 static void findTxt2tagsTags (void)
 154 {
 155         NestingLevels *nls = nestingLevelsNew();
 156         vString *name = vStringNew();
 157         const unsigned char *line;
 158
 159         while ((line = fileReadLine()) != NULL)
 160         {
 161                 int depth;
 162
 163                 if (isTxt2tagsLine(line))
 164                         ; /* skip not to improperly match titles */
 165                 else if (parseTxt2tagsTitle(line, name, &depth))
 166                 {
 167                         NestingLevel *nl = nestingLevelsGetCurrent(nls);
 168                         while (nl && nl->indentation >= depth)
 169                         {
 170                                 nestingLevelsPop(nls);
 171                                 nl = nestingLevelsGetCurrent(nls);
 172                         }
 173
 174                         vStringTerminate(name);
 175                         makeTxt2tagsTag(name, nls, K_SECTION);
 176                         nestingLevelsPush(nls, name, K_SECTION);
 177                         nestingLevelsGetCurrent(nls)->indentation = depth;
 178                 }
 179         }
 180         vStringDelete (name);
 181         nestingLevelsFree(nls);
 182 }
 183
 184 extern parserDefinition* Txt2tagsParser (void)
 185 {
 186         static const char *const patterns [] = { "*.t2t", NULL };
 187         static const char *const extensions [] = { "t2t", NULL };
 188         parserDefinition* const def = parserNew ("Txt2tags");
 189
 190         def->kinds = Txt2tagsKinds;
 191         def->kindCount = KIND_COUNT (Txt2tagsKinds);
 192         def->patterns = patterns;
 193         def->extensions = extensions;
 194         def->parser = findTxt2tagsTags;
 195         return def;
 196 }
 197