tagmanager/latex.c

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