ctags/parsers/matlab.c

   1 /*
   2 *
   3 *   Copyright (c) 2000-2001, Darren Hiebert
   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 Matlab scripts.
   9 *   The tags 'function' and 'struct' are parsed.
  10 *       Author Roland Baudin <roland65@free.fr>
  11 */
  12
  13 /*
  14 *   INCLUDE FILES
  15 */
  16 #include "general.h"    /* must always come first */
  17
  18 #include <string.h>
  19
  20 #include "parse.h"
  21 #include "routines.h"
  22 #include "read.h"
  23 #include "vstring.h"
  24
  25 /*
  26 *   DATA DEFINITIONS
  27 */
  28 typedef enum {
  29         K_FUNCTION,
  30         K_STRUCT
  31 } MatlabKind;
  32
  33 static kindOption MatlabKinds [] = {
  34         { true, 'f', "function", "Functions" },
  35         { true, 's', "struct", "Structures" },
  36 };
  37
  38 /*
  39 *   FUNCTION DEFINITIONS
  40 */
  41
  42 static void findMatlabTags (void)
  43 {
  44         vString *name = vStringNew ();
  45         const unsigned char *line;
  46         const unsigned char *p;
  47
  48         while ((line = readLineFromInputFile ()) != NULL)
  49         {
  50                 int i, ic;
  51
  52                 if (line [0] == '\0'  ||  line [0] == '%')
  53                         continue;
  54
  55                 /* search if the line has a comment */
  56                 for (ic = 0  ;  line [ic] != '\0'  &&  line [ic]!='%'  ;  ++ic)
  57                         ;
  58
  59                 /* function tag */
  60
  61                 /* read first word */
  62                 for (i = 0  ;  line [i] != '\0'  &&  ! isspace (line [i])  ;  ++i)
  63                         ;
  64
  65                 if (strncmp ((const char *) line, "function", (size_t) 8) == 0)
  66                 {
  67                         const unsigned char *cp = line + i;
  68                         const unsigned char *ptr = cp;
  69                         bool eq=false;
  70
  71                         while (isspace ((int) *cp))
  72                                 ++cp;
  73
  74                         /* search for '=' character in the line */
  75                         while (*ptr != '\0')
  76                         {
  77                                 if (*ptr == '=')
  78                                 {
  79                                         eq=true;
  80                                         break;
  81                                 }
  82                                 ptr++;
  83                         }
  84
  85                         /* '=' was found => get the right most part of the line after '=' and before '%' */
  86                         if (eq)
  87                         {
  88                                 ptr++;
  89                                 while (isspace ((int) *ptr))
  90                                         ++ptr;
  91
  92                                 while (*ptr != '\0' && *ptr != '%')
  93                                 {
  94                                         vStringPut (name, (int) *ptr);
  95                                         ++ptr;
  96                                 }
  97                         }
  98
  99                         /* '=' was not found => get the right most part of the line after
 100                          * 'function' and before '%' */
 101                         else
 102                         {
 103                                 while (*cp != '\0' && *cp != '%')
 104                                 {
 105                                         vStringPut (name, (int) *cp);
 106                                         ++cp;
 107                                 }
 108                         }
 109
 110                         makeSimpleTag (name, MatlabKinds, K_FUNCTION);
 111                         vStringClear (name);
 112                 }
 113
 114                 /* struct tag */
 115
 116                 /* search if the line contains the keyword 'struct' */
 117                 p=(const unsigned char*) strstr ((const char*) line, "struct");
 118
 119                 /* and avoid the part after the '%' if any */
 120                 if ( p != NULL && ic>0 && p < line+ic)
 121                 {
 122                         const unsigned char *cp = line;
 123
 124                         /* get the left most part of the line before '=' */
 125                         while (*cp != '\0' && !isspace(*cp) && *cp != '=' )
 126                         {
 127                                 vStringPut (name, (int) *cp);
 128                                 ++cp;
 129                         }
 130
 131                         makeSimpleTag (name, MatlabKinds, K_STRUCT);
 132                         vStringClear (name);
 133                 }
 134         }
 135         vStringDelete (name);
 136 }
 137
 138 extern parserDefinition* MatlabParser (void)
 139 {
 140         static const char *const extensions [] = { "m", NULL };
 141         parserDefinition* def = parserNew ("Matlab");
 142         def->kinds      = MatlabKinds;
 143         def->kindCount  = ARRAY_SIZE (MatlabKinds);
 144         def->extensions = extensions;
 145         def->parser     = findMatlabTags;
 146         return def;
 147 }