tagmanager/make.c

   1 /*
   2 *   $Id$
   3 *
   4 *   Copyright (c) 2000-2005, Darren Hiebert
   5 *
   6 *   This source code is released for free distribution under the terms of the
   7 *   GNU General Public License.
   8 *
   9 *   This module contains functions for generating tags for makefiles.
  10 */
  11
  12 /*
  13 *   INCLUDE FILES
  14 */
  15 #include "general.h"  /* must always come first */
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <ctype.h>
  20
  21 #include "options.h"
  22 #include "parse.h"
  23 #include "read.h"
  24 #include "vstring.h"
  25
  26 /*
  27 *   DATA DEFINITIONS
  28 */
  29 typedef enum {
  30         K_MACRO, K_TARGET
  31 } shKind;
  32
  33 static kindOption MakeKinds [] = {
  34         { TRUE, 'm', "macro",  "macros"},
  35         { TRUE, 't', "function", "targets"}
  36 };
  37
  38 /*
  39 *   FUNCTION DEFINITIONS
  40 */
  41
  42 static int nextChar (void)
  43 {
  44         int c = fileGetc ();
  45         if (c == '\\')
  46         {
  47                 c = fileGetc ();
  48                 if (c == '\n')
  49                         c = fileGetc ();
  50         }
  51         return c;
  52 }
  53
  54 static void skipLine (void)
  55 {
  56         int c;
  57         do
  58                 c = nextChar ();
  59         while (c != EOF  &&  c != '\n');
  60         if (c == '\n')
  61                 fileUngetc (c);
  62 }
  63
  64 static int skipToNonWhite (void)
  65 {
  66         int c;
  67         do
  68                 c = nextChar ();
  69         while (c != '\n' && isspace (c));
  70         return c;
  71 }
  72
  73 static boolean isIdentifier (int c)
  74 {
  75         return (boolean)(c != '\0' && (isalnum (c)  ||  strchr (".-_/", c) != NULL));
  76 }
  77
  78 static boolean isSpecialTarget (vString *const name)
  79 {
  80         size_t i = 0;
  81         /* All special targets begin with '.'. */
  82         if (vStringChar (name, i++) != '.') {
  83                 return FALSE;
  84         }
  85         while (i < vStringLength (name)) {
  86                 char ch = vStringChar (name, i++);
  87                 if (ch != '_' && !isupper (ch))
  88                 {
  89                         return FALSE;
  90                 }
  91         }
  92         return TRUE;
  93 }
  94
  95 static void newTarget (vString *const name)
  96 {
  97         /* Ignore GNU Make's "special targets". */
  98         if  (isSpecialTarget (name))
  99         {
 100                 return;
 101         }
 102         makeSimpleTag (name, MakeKinds, K_TARGET);
 103 }
 104
 105 static void newMacro (vString *const name)
 106 {
 107         makeSimpleTag (name, MakeKinds, K_MACRO);
 108 }
 109
 110 static void newMacroFromDefine (vString *const name)
 111 {
 112         /* name is something like "define JAVAHPP_RULE", find the space and jump to the next char */
 113         char *name_val = strchr (vStringValue (name), ' ');
 114
 115         if (name_val != NULL) {
 116                 vStringCopyS (name, name_val + 1);
 117                 makeSimpleTag (name, MakeKinds, K_MACRO);
 118         }
 119 }
 120
 121 static void readIdentifier (const int first, vString *const id)
 122 {
 123         int c = first;
 124         int c_prev = first;
 125         int c_next = first;
 126         vStringClear (id);
 127         while (isIdentifier (c) || c == ' ')
 128         {
 129                 c_next = nextChar ();
 130                 if (c == ' ') {
 131                         /* add the space character only if the previous and
 132                          * next character are valid identifiers */
 133                         if (isIdentifier (c_prev) && isIdentifier (c_next))
 134                                 vStringPut (id, c);
 135                 }
 136                 else {
 137                         vStringPut (id, c);
 138                 }
 139                 c_prev = c;
 140                 c = c_next;
 141         }
 142         fileUngetc (c);
 143         vStringTerminate (id);
 144 }
 145
 146 static void skipToMatch (const char *const pair)
 147 {
 148         const int begin = pair [0], end = pair [1];
 149         const unsigned long inputLineNumber = getInputLineNumber ();
 150         int matchLevel = 1;
 151         int c = '\0';
 152
 153         while (matchLevel > 0)
 154         {
 155                 c = nextChar ();
 156                 if (c == begin)
 157                         ++matchLevel;
 158                 else if (c == end)
 159                         --matchLevel;
 160                 else if (c == '\n')
 161                         break;
 162         }
 163         if (c == EOF)
 164                 verbose ("%s: failed to find match for '%c' at line %lu\n",
 165                                 getInputFileName (), begin, inputLineNumber);
 166 }
 167
 168 static void findMakeTags (void)
 169 {
 170         vString *name = vStringNew ();
 171         boolean newline = TRUE;
 172         boolean in_define = FALSE;
 173         boolean in_rule = FALSE;
 174         boolean variable_possible = TRUE;
 175         int c;
 176
 177         while ((c = nextChar ()) != EOF)
 178         {
 179                 if (newline)
 180                 {
 181                         if (in_rule)
 182                         {
 183                                 if (c == '\t')
 184                                 {
 185                                         skipLine ();  /* skip rule */
 186                                         continue;
 187                                 }
 188                                 else
 189                                         in_rule = FALSE;
 190                         }
 191                         variable_possible = (boolean)(!in_rule);
 192                         newline = FALSE;
 193                 }
 194                 if (c == '\n')
 195                         newline = TRUE;
 196                 else if (isspace (c))
 197                         continue;
 198                 else if (c == '#')
 199                         skipLine ();
 200                 else if (c == '(')
 201                         skipToMatch ("()");
 202                 else if (c == '{')
 203                         skipToMatch ("{}");
 204                 else if (c == ':')
 205                 {
 206                         variable_possible = TRUE;
 207                         in_rule = TRUE;
 208                 }
 209                 else if (variable_possible && isIdentifier (c))
 210                 {
 211                         readIdentifier (c, name);
 212                         if (strncmp (vStringValue (name), "endef", 5) == 0)
 213                                 in_define = FALSE;
 214                         else if (in_define)
 215                                 skipLine ();
 216                         else if (strncmp (vStringValue (name), "define", 6) == 0  &&
 217                                 isIdentifier (c))
 218                         {
 219                                 in_define = TRUE;
 220                                 c = skipToNonWhite ();
 221                                 newMacroFromDefine (name);
 222                                 skipLine ();
 223                         }
 224                         else {
 225                                 c = skipToNonWhite ();
 226                                 if (strchr (":?+", c) != NULL)
 227                                 {
 228                                         boolean append = (boolean)(c == '+');
 229                                         boolean was_colon = (c == ':');
 230                                         c = nextChar ();
 231                                         if (was_colon)
 232                                         {
 233                                                 if (c == '=')
 234                                                 {
 235                                                         newMacro (name);
 236                                                         in_rule = FALSE;
 237                                                         skipLine ();
 238                                                 }
 239                                                 else
 240                                                 {
 241                                                         in_rule = TRUE;
 242                                                         newTarget (name);
 243                                                 }
 244                                         }
 245                                         else if (append)
 246                                         {
 247                                                 skipLine ();
 248                                                 continue;
 249                                         }
 250                                         else
 251                                         {
 252                                                 fileUngetc (c);
 253                                         }
 254                                 }
 255                                 else if (c == '=')
 256                                 {
 257                                         newMacro (name);
 258                                         in_rule = FALSE;
 259                                         skipLine ();
 260                                 }
 261                                 else
 262                                 {
 263                                         fileUngetc (c);
 264                                 }
 265                         }
 266                 }
 267                 else
 268                         variable_possible = FALSE;
 269         }
 270         vStringDelete (name);
 271 }
 272
 273 extern parserDefinition* MakefileParser (void)
 274 {
 275         static const char *const patterns [] = { "[Mm]akefile", NULL };
 276         static const char *const extensions [] = { "mak", "mk", NULL };
 277         parserDefinition* const def = parserNew ("Make");
 278         def->kinds      = MakeKinds;
 279         def->kindCount  = KIND_COUNT (MakeKinds);
 280         def->patterns   = patterns;
 281         def->extensions = extensions;
 282         def->parser     = findMakeTags;
 283         return def;
 284 }
 285
 286 /* vi:set tabstop=4 shiftwidth=4: */