tagmanager/tcl.c

   1 /*
   2 *   Copyright (c) 2000-2003, Darren Hiebert
   3 *
   4 *   This source code is released for free distribution under the terms of the
   5 *   GNU General Public License.
   6 *
   7 *   This module contains functions for generating tags for TCL scripts.
   8 */
   9
  10 /*
  11 *   INCLUDE FILES
  12 */
  13 #include "general.h"  /* must always come first */
  14
  15 #include <string.h>
  16
  17 #include "parse.h"
  18 #include "read.h"
  19 #include "vstring.h"
  20
  21 /*
  22 *   DATA DEFINITIONS
  23 */
  24 typedef enum {
  25         K_CLASS, K_METHOD, K_PROCEDURE, K_MODULE
  26 } tclKind;
  27
  28 static kindOption TclKinds [] = {
  29         { TRUE, 'c', "class",     "classes" },
  30         { TRUE, 'f', "member",    "methods" },
  31         { TRUE, 'p', "function",  "procedures" },
  32         { TRUE, 'm', "namespace", "modules" }
  33 };
  34
  35 /*
  36 *   FUNCTION DEFINITIONS
  37 */
  38
  39 static const unsigned char *makeTclTag (
  40                 const unsigned char *cp,
  41                 vString *const name,
  42                 const tclKind kind)
  43 {
  44         vStringClear (name);
  45         while ((int) *cp != '\0'  &&  ! isspace ((int) *cp))
  46         {
  47                 vStringPut (name, (int) *cp);
  48                 ++cp;
  49         }
  50         vStringTerminate (name);
  51         makeSimpleTag (name, TclKinds, kind);
  52         return cp;
  53 }
  54
  55 static boolean match (const unsigned char *line, const char *word)
  56 {
  57         size_t len = strlen (word);
  58         boolean matched = (strncmp ((const char*) line, word, len) == 0);
  59
  60         if (matched)
  61         {
  62                 /* check that the word is followed by a space to avoid detecting something
  63                  * like "proc_new ..." */
  64                 matched = isspace (*(line + len));
  65         }
  66         return matched;
  67 }
  68
  69 static void findTclTags (void)
  70 {
  71         vString *name = vStringNew ();
  72         const unsigned char *line;
  73
  74         while ((line = fileReadLine ()) != NULL)
  75         {
  76                 const unsigned char *cp;
  77
  78                 while (isspace (line [0]))
  79                         ++line;
  80
  81                 if (line [0] == '\0'  ||  line [0] == '#')
  82                         continue;
  83
  84                 /* read first word */
  85                 for (cp = line ; *cp != '\0'  &&  ! isspace ((int) *cp) ; ++cp)
  86                         ;
  87                 if (! isspace ((int) *cp))
  88                         continue;
  89                 while (isspace ((int) *cp))
  90                         ++cp;
  91                 /* Now `line' points at first word and `cp' points at next word */
  92
  93                 if (match (line, "proc"))
  94                         cp = makeTclTag (cp, name, K_PROCEDURE);
  95                 else if (match (line, "class") || match (line, "itcl::class"))
  96                         cp = makeTclTag (cp, name, K_CLASS);
  97                 else if (match (line, "public") ||
  98                                 match (line, "protected") ||
  99                                 match (line, "private"))
 100                 {
 101                         if (match (cp, "method"))
 102                         {
 103                                 cp += 6;
 104                                 while (isspace ((int) *cp))
 105                                         ++cp;
 106                                 cp = makeTclTag (cp, name, K_METHOD);
 107                         }
 108                 }
 109                 else if (match (line, "method"))
 110                 {
 111                         cp = makeTclTag (cp, name, K_METHOD);
 112                 }
 113                 else if (match (line, "oo::class") ) {
 114                         if (match (cp, "create"))
 115                         {
 116                                 cp += 6;
 117                                 while (isspace ((int) *cp))
 118                                         ++cp;
 119                                 cp = makeTclTag (cp, name, K_CLASS);
 120                         }
 121                 }
 122                 else if (match (line, "namespace") ) {
 123                         if (match (cp, "eval"))
 124                         {
 125                                 cp += 4;
 126                                 while (isspace ((int) *cp))
 127                                         ++cp;
 128                                 cp = makeTclTag (cp, name, K_MODULE);
 129                         }
 130                 }
 131
 132         }
 133         vStringDelete (name);
 134 }
 135
 136 extern parserDefinition* TclParser (void)
 137 {
 138         static const char *const extensions [] = { "tcl", "tk", "wish", "itcl", NULL };
 139         parserDefinition* def = parserNew ("Tcl");
 140         def->kinds      = TclKinds;
 141         def->kindCount  = KIND_COUNT (TclKinds);
 142         def->extensions = extensions;
 143         def->parser     = findTclTags;
 144         return def;
 145 }
 146
 147 /* vi:set tabstop=4 shiftwidth=4: */