tagmanager/ctags/latex.c

   1 /*
   2  *   Copyright (c) 2000-2001, Jérôme Plût
   3  *   Copyright (c) 2006, Enrico Tröger
   4  *
   5  *   This source code is released for free distribution under the terms of the
   6  *   GNU General Public License.
   7  *
   8  *   This module contains functions for generating tags for source files
   9  *   for the TeX formatting system.
  10  */
  11
  12 /*
  13 *   INCLUDE FILES
  14 */
  15 #include "general.h"    /* must always come first */
  16
  17 #include <ctype.h>
  18 #include <string.h>
  19
  20 #include "parse.h"
  21 #include "read.h"
  22 #include "vstring.h"
  23
  24 /*
  25 *   DATA DEFINITIONS
  26 */
  27 typedef enum {
  28      K_COMMAND,
  29      K_ENVIRONMENT,
  30      K_SECTION,
  31      K_SUBSECTION,
  32      K_SUBSUBSECTION,
  33      K_CHAPTER,
  34      K_LABEL
  35 } TeXKind;
  36
  37 static kindOption TeXKinds[] = {
  38      { TRUE, 'f', "function",      "command definitions" },
  39      { TRUE, 'c', "class",         "environment definitions" },
  40      { TRUE, 'm', "member",        "labels, sections and bibliography" },
  41      { TRUE, 'd', "macro",         "subsections" },
  42      { TRUE, 'v', "variable",      "subsubsections" },
  43      { TRUE, 'n', "namespace",     "chapters"},
  44      { TRUE, 's', "struct",        "labels and bibliography" }
  45 };
  46
  47 #define TEX_BRACES (1<<0)
  48 #define TEX_BSLASH (1<<1)
  49 #define TEX_LABEL  (1<<2)
  50
  51 /*
  52 *   FUNCTION DEFINITIONS
  53 */
  54
  55 static int getWord(const char * ref, const char **ptr)
  56 {
  57     const char *p = *ptr;
  58
  59         while ((*ref != '\0') && (*p != '\0') && (*ref == *p))
  60                 ref++, p++;
  61
  62
  63     if (*ref)
  64                 return FALSE;
  65
  66         if (*p == '*') /* to allow something like \section*{foobar} */
  67                 p++;
  68
  69     *ptr = p;
  70         return TRUE;
  71 }
  72
  73 static void createTag(int flags, TeXKind kind, const char * l)
  74 {
  75     vString *name = vStringNew ();
  76
  77     while ((*l == ' '))
  78         l++;
  79     if (flags & (TEX_BRACES | TEX_LABEL))
  80     {
  81         if (*l == '[')
  82         {
  83             while (*l != ']')
  84             {
  85                 if (*l == '\0')
  86                     goto no_tag;
  87                 l++;
  88             }
  89             l++; /* skip the closing square bracket */
  90         }
  91         if (*l != '{')
  92             goto no_tag;
  93         l++;
  94      }
  95      if (flags & TEX_BSLASH)
  96      {
  97         if ((*(l++)) != '\\')
  98             goto no_tag;
  99      }
 100      if (flags & TEX_LABEL)
 101      {
 102         do
 103         {
 104             vStringPut(name, (int) *l);
 105             ++l;
 106         } while ((*l != '\0') && (*l != '}'));
 107         vStringTerminate(name);
 108         if (name->buffer[0] != '}')
 109                 makeSimpleTag(name, TeXKinds, kind);
 110      }
 111      else if (isalpha((int) *l) || *l == '@')
 112      {
 113         do
 114         {
 115             vStringPut (name, (int) *l);
 116             ++l;
 117         } while (isalpha((int) *l) || *l == '@');
 118         vStringTerminate(name);
 119         makeSimpleTag(name, TeXKinds, kind);
 120      }
 121      else
 122      {
 123         vStringPut(name, (int) *l);
 124         vStringTerminate(name);
 125         makeSimpleTag(name, TeXKinds, kind);
 126      }
 127
 128  no_tag:
 129      vStringDelete(name);
 130 }
 131
 132 static void findTeXTags(void)
 133 {
 134     const char *line;
 135
 136     while ((line = (const char*)fileReadLine()) != NULL)
 137     {
 138         const char *cp = line;
 139         /*int escaped = 0;*/
 140
 141         for (; *cp != '\0'; cp++)
 142         {
 143             if (*cp == '%')
 144                         break;
 145             if (*cp == '\\')
 146             {
 147                 cp++;
 148
 149                 /* \newcommand{\command} */
 150                 if (getWord("newcommand", &cp)
 151                     || getWord("providecommand", &cp)
 152                     || getWord("renewcommand", &cp)
 153                     )
 154                 {
 155                     createTag (TEX_BRACES|TEX_BSLASH, K_COMMAND, cp);
 156                     continue;
 157                 }
 158
 159                 /* \DeclareMathOperator{\command} */
 160                 else if (getWord("DeclareMathOperator", &cp))
 161                 {
 162                     if (*cp == '*')
 163                         cp++;
 164                     createTag(TEX_BRACES|TEX_BSLASH, K_COMMAND, cp);
 165                     continue;
 166                 }
 167
 168                 /* \def\command */
 169                 else if (getWord("def", &cp))
 170                 {
 171                     createTag(TEX_BSLASH, K_COMMAND, cp);
 172                     continue;
 173                 }
 174
 175                 /* \newenvironment{name} */
 176                 else if ( getWord("newenvironment", &cp)
 177                     || getWord("newtheorem", &cp)
 178                     || getWord("begin", &cp)
 179                     )
 180                 {
 181                     createTag(TEX_BRACES, K_ENVIRONMENT, cp);
 182                     continue;
 183                 }
 184
 185                 /* \bibitem[label]{key} */
 186                 else if (getWord("bibitem", &cp))
 187                 {
 188                     while (*cp == ' ')
 189                         cp++;
 190                     if (*(cp++) != '[')
 191                         break;
 192                     while ((*cp != '\0') && (*cp != ']'))
 193                         cp++;
 194                     if (*(cp++) != ']')
 195                         break;
 196                     createTag(TEX_LABEL, K_LABEL, cp);
 197                     continue;
 198                 }
 199
 200                 /* \label{key} */
 201                 else if (getWord("label", &cp))
 202                 {
 203                     createTag(TEX_LABEL, K_LABEL, cp);
 204                     continue;
 205                 }
 206                 /* \section{key} */
 207                 else if (getWord("section", &cp))
 208                 {
 209                     createTag(TEX_LABEL, K_SECTION, cp);
 210                     continue;
 211                 }
 212                 /* \subsection{key} */
 213                 else if (getWord("subsection", &cp))
 214                 {
 215                     createTag(TEX_LABEL, K_SUBSECTION, cp);
 216                     continue;
 217                 }
 218                 /* \subsubsection{key} */
 219                 else if (getWord("subsubsection", &cp))
 220                 {
 221                     createTag(TEX_LABEL, K_SUBSUBSECTION, cp);
 222                     continue;
 223                 }
 224                 /* \chapter{key} */
 225                 else if (getWord("chapter", &cp))
 226                 {
 227                     createTag(TEX_LABEL, K_CHAPTER, cp);
 228                     continue;
 229                 }
 230             }
 231         }
 232     }
 233 }
 234
 235 extern parserDefinition* LaTeXParser (void)
 236 {
 237         static const char *const extensions [] = { "tex", "sty", "idx", NULL };
 238         parserDefinition * def = parserNew ("LaTeX");
 239         def->kinds      = TeXKinds;
 240         def->kindCount  = KIND_COUNT (TeXKinds);
 241         def->extensions = extensions;
 242         def->parser     = findTeXTags;
 243         return def;
 244 }