ctags/parsers/make.c

   1 /*
   2 *   Copyright (c) 2000-2005, Darren Hiebert
   3 *
   4 *   This source code is released for free distribution under the terms of the
   5 *   GNU General Public License version 2 or (at your option) any later version.
   6 *
   7 *   This module contains functions for generating tags for makefiles.
   8 */
   9
  10 /*
  11 *   INCLUDE FILES
  12 */
  13 #include "general.h"  /* must always come first */
  14
  15 #include <string.h>
  16 #include <ctype.h>
  17
  18 #include "make.h"
  19
  20 #include "kind.h"
  21 #include "parse.h"
  22 #include "read.h"
  23 #include "routines.h"
  24 #include "strlist.h"
  25 #include "vstring.h"
  26 #include "xtag.h"
  27
  28
  29 /*
  30 *   DATA DEFINITIONS
  31 */
  32 typedef enum {
  33         K_MACRO, K_TARGET, K_INCLUDE,
  34 } makeKind;
  35
  36 typedef enum {
  37         R_INCLUDE_GENERIC,
  38         R_INCLUDE_OPTIONAL,
  39 } makeMakefileRole;
  40
  41 static roleDefinition MakeMakefileRoles [] = {
  42         { true, "included", "included" },
  43         { true, "optional", "optionally included"},
  44 };
  45
  46 static kindDefinition MakeKinds [] = {
  47         { true, 'm', "macro",  "macros"},
  48         { true, 't', "target", "targets"},
  49         { true, 'I', "makefile", "makefiles",
  50           .referenceOnly = true, ATTACH_ROLES(MakeMakefileRoles)},
  51 };
  52
  53
  54 /*
  55 *   FUNCTION DEFINITIONS
  56 */
  57
  58 static int nextChar (void)
  59 {
  60         int c = getcFromInputFile ();
  61         if (c == '\\')
  62         {
  63                 c = getcFromInputFile ();
  64                 if (c == '\n')
  65                         c = nextChar ();
  66         }
  67         return c;
  68 }
  69
  70 static void skipLine (void)
  71 {
  72         int c;
  73         do
  74                 c = nextChar ();
  75         while (c != EOF  &&  c != '\n');
  76         if (c == '\n')
  77                 ungetcToInputFile (c);
  78 }
  79
  80 static int skipToNonWhite (int c)
  81 {
  82         while (c != '\n' && isspace (c))
  83                 c = nextChar ();
  84         return c;
  85 }
  86
  87 static bool isIdentifier (int c)
  88 {
  89         return (bool)(c != '\0' && (isalnum (c)  ||  strchr (".-_/$(){}%", c) != NULL));
  90 }
  91
  92 static bool isSpecialTarget (vString *const name)
  93 {
  94         size_t i = 0;
  95         /* All special targets begin with '.'. */
  96         if (vStringLength (name) < 1 || vStringChar (name, i++) != '.') {
  97                 return false;
  98         }
  99         while (i < vStringLength (name)) {
 100                 char ch = vStringChar (name, i++);
 101                 if (ch != '_' && !isupper (ch))
 102                 {
 103                         return false;
 104                 }
 105         }
 106         return true;
 107 }
 108
 109 static void makeSimpleMakeTag (vString *const name, makeKind kind)
 110 {
 111         if (!isLanguageEnabled (getInputLanguage ()))
 112                 return;
 113
 114         makeSimpleTag (name, kind);
 115 }
 116
 117 static void makeSimpleMakeRefTag (const vString* const name, const int kind,
 118                                   int roleIndex)
 119 {
 120         if (!isLanguageEnabled (getInputLanguage ()))
 121                 return;
 122
 123         makeSimpleRefTag (name, kind, roleIndex);
 124 }
 125
 126 static void newTarget (vString *const name)
 127 {
 128         /* Ignore GNU Make's "special targets". */
 129         if  (isSpecialTarget (name))
 130         {
 131                 return;
 132         }
 133         makeSimpleMakeTag (name, K_TARGET);
 134 }
 135
 136 static void newMacro (vString *const name, bool with_define_directive, bool appending)
 137 {
 138         subparser *s;
 139
 140         if (!appending)
 141                 makeSimpleMakeTag (name, K_MACRO);
 142
 143         foreachSubparser(s, false)
 144         {
 145                 makeSubparser *m = (makeSubparser *)s;
 146                 enterSubparser(s);
 147                 if (m->newMacroNotify)
 148                         m->newMacroNotify (m, vStringValue(name), with_define_directive, appending);
 149                 leaveSubparser();
 150         }
 151 }
 152
 153 static void valueFound (vString *const name)
 154 {
 155         subparser *s;
 156         foreachSubparser(s, false)
 157         {
 158                 makeSubparser *m = (makeSubparser *)s;
 159                 enterSubparser(s);
 160                 if (m->valueNotify)
 161                         m->valueNotify (m, vStringValue (name));
 162                 leaveSubparser();
 163         }
 164 }
 165
 166 static void directiveFound (vString *const name)
 167 {
 168         subparser *s;
 169         foreachSubparser (s, false)
 170         {
 171                 makeSubparser *m = (makeSubparser *)s;
 172                 enterSubparser(s);
 173                 if (m->directiveNotify)
 174                         m->directiveNotify (m, vStringValue (name));
 175                 leaveSubparser();
 176         }
 177 }
 178
 179 static void newInclude (vString *const name, bool optional)
 180 {
 181         makeSimpleMakeRefTag (name, K_INCLUDE,
 182                               optional? R_INCLUDE_OPTIONAL: R_INCLUDE_GENERIC);
 183 }
 184
 185 static bool isAcceptableAsInclude (vString *const name)
 186 {
 187         if (strcmp (vStringValue (name), "$") == 0)
 188                 return false;
 189         return true;
 190 }
 191
 192 static void readIdentifier (const int first, vString *const id)
 193 {
 194         int depth = 0;
 195         int c = first;
 196         vStringClear (id);
 197         while (isIdentifier (c) || (depth > 0 && c != EOF && c != '\n'))
 198         {
 199                 if (c == '(' || c == '{')
 200                         depth++;
 201                 else if (depth > 0 && (c == ')' || c == '}'))
 202                         depth--;
 203                 vStringPut (id, c);
 204                 c = nextChar ();
 205         }
 206         ungetcToInputFile (c);
 207 }
 208
 209 static void findMakeTags (void)
 210 {
 211         stringList *identifiers = stringListNew ();
 212         bool newline = true;
 213         bool in_define = false;
 214         bool in_value  = false;
 215         bool in_rule = false;
 216         bool variable_possible = true;
 217         bool appending = false;
 218         int c;
 219         subparser *sub;
 220
 221         sub = getSubparserRunningBaseparser();
 222         if (sub)
 223                 chooseExclusiveSubparser (sub, NULL);
 224
 225         while ((c = nextChar ()) != EOF)
 226         {
 227                 if (newline)
 228                 {
 229                         if (in_rule)
 230                         {
 231                                 if (c == '\t' || (c = skipToNonWhite (c)) == '#')
 232                                 {
 233                                         skipLine ();  /* skip rule or comment */
 234                                         c = nextChar ();
 235                                 }
 236                                 else if (c != '\n')
 237                                         in_rule = false;
 238                         }
 239                         else if (in_value)
 240                                 in_value = false;
 241
 242                         stringListClear (identifiers);
 243                         variable_possible = (bool)(!in_rule);
 244                         newline = false;
 245                 }
 246                 if (c == '\n')
 247                         newline = true;
 248                 else if (isspace (c))
 249                         continue;
 250                 else if (c == '#')
 251                         skipLine ();
 252                 else if (variable_possible && c == '?')
 253                 {
 254                         c = nextChar ();
 255                         ungetcToInputFile (c);
 256                         variable_possible = (c == '=');
 257                 }
 258                 else if (variable_possible && c == '+')
 259                 {
 260                         c = nextChar ();
 261                         ungetcToInputFile (c);
 262                         variable_possible = (c == '=');
 263                         appending = true;
 264                 }
 265                 else if ((! in_value) && variable_possible && c == ':' &&
 266                                  stringListCount (identifiers) > 0)
 267                 {
 268                         c = nextChar ();
 269                         ungetcToInputFile (c);
 270                         if (c != '=')
 271                         {
 272                                 unsigned int i;
 273                                 for (i = 0; i < stringListCount (identifiers); i++)
 274                                         newTarget (stringListItem (identifiers, i));
 275                                 stringListClear (identifiers);
 276                                 in_rule = true;
 277                         }
 278                 }
 279                 else if (variable_possible && c == '=' &&
 280                                  stringListCount (identifiers) == 1)
 281                 {
 282                         newMacro (stringListItem (identifiers, 0), false, appending);
 283
 284                         in_value = true;
 285                         in_rule = false;
 286                         appending = false;
 287                 }
 288                 else if (variable_possible && isIdentifier (c))
 289                 {
 290                         vString *name = vStringNew ();
 291                         readIdentifier (c, name);
 292                         stringListAdd (identifiers, name);
 293
 294                         if (in_value)
 295                                 valueFound(name);
 296
 297                         if (stringListCount (identifiers) == 1)
 298                         {
 299                                 if (in_define && ! strcmp (vStringValue (name), "endef"))
 300                                         in_define = false;
 301                                 else if (in_define)
 302                                         skipLine ();
 303                                 else if (! strcmp (vStringValue (name), "define"))
 304                                 {
 305                                         in_define = true;
 306                                         c = skipToNonWhite (nextChar ());
 307                                         vStringClear (name);
 308                                         /* all remaining characters on the line are the name -- even spaces */
 309                                         while (c != EOF && c != '\n')
 310                                         {
 311                                                 vStringPut (name, c);
 312                                                 c = nextChar ();
 313                                         }
 314                                         if (c == '\n')
 315                                                 ungetcToInputFile (c);
 316                                         vStringStripTrailing (name);
 317
 318                                         newMacro (name, true, false);
 319                                 }
 320                                 else if (! strcmp (vStringValue (name), "export"))
 321                                         stringListClear (identifiers);
 322                                 else if (! strcmp (vStringValue (name), "include")
 323                                          || ! strcmp (vStringValue (name), "sinclude")
 324                                          || ! strcmp (vStringValue (name), "-include"))
 325                                 {
 326                                         bool optional = (vStringValue (name)[0] == 'i')? false: true;
 327                                         while (1)
 328                                         {
 329                                                 c = skipToNonWhite (nextChar ());
 330                                                 readIdentifier (c, name);
 331                                                 vStringStripTrailing (name);
 332                                                 if (isAcceptableAsInclude(name))
 333                                                         newInclude (name, optional);
 334
 335                                                 /* non-space characters after readIdentifier() may
 336                                                  * be rejected by the function:
 337                                                  * e.g.
 338                                                  * include $*
 339                                                  *
 340                                                  * Here, remove such characters from input stream.
 341                                                  */
 342                                                 do
 343                                                         c = nextChar ();
 344                                                 while (c != EOF && c != '\n' && (!isspace (c)));
 345                                                 if (c == '\n')
 346                                                         ungetcToInputFile (c);
 347
 348                                                 if (c == EOF || c == '\n')
 349                                                         break;
 350                                         }
 351                                 }
 352                                 else
 353                                         directiveFound (name);
 354                         }
 355                 }
 356                 else
 357                         variable_possible = false;
 358         }
 359
 360         stringListDelete (identifiers);
 361 }
 362
 363
 364 extern parserDefinition* MakefileParser (void)
 365 {
 366         static const char *const patterns [] = { "[Mm]akefile", "GNUmakefile", NULL };
 367         static const char *const extensions [] = { "mak", "mk", NULL };
 368         static const char *const aliases [] = {
 369                 /* the mode name in emacs */
 370                 "makefile",
 371                 NULL };
 372         parserDefinition* const def = parserNew ("Make");
 373         def->kindTable      = MakeKinds;
 374         def->kindCount  = ARRAY_SIZE (MakeKinds);
 375         def->patterns   = patterns;
 376         def->extensions = extensions;
 377         def->aliases = aliases;
 378         def->parser     = findMakeTags;
 379         return def;
 380 }