tagmanager/ctags/css.c

   1 /***************************************************************************
   2  * css.c
   3  * Token-based parser for CSS definitions
   4  * Author - Colomban Wendling <colomban@geany.org>
   5  **************************************************************************/
   6 #include "general.h"
   7
   8 #include <string.h>
   9 #include <ctype.h>
  10
  11 #include "entry.h"
  12 #include "parse.h"
  13 #include "read.h"
  14
  15
  16 typedef enum eCssKinds {
  17         K_CLASS, K_SELECTOR, K_ID
  18 } cssKind;
  19
  20 static kindOption CssKinds [] = {
  21         { TRUE, 'c', "class",           "classes" },
  22         { TRUE, 's', "struct",          "selectors" },
  23         { TRUE, 'v', "variable",        "identities" }
  24 };
  25
  26 typedef enum {
  27         /* any ASCII */
  28         TOKEN_EOF = 257,
  29         TOKEN_SELECTOR,
  30         TOKEN_STRING
  31 } tokenType;
  32
  33 typedef struct {
  34         tokenType type;
  35         vString *string;
  36 } tokenInfo;
  37
  38
  39 static boolean isSelectorChar (const int c)
  40 {
  41         /* attribute selectors are handled separately */
  42         return (isalnum (c) ||
  43                         c == '_' || // allowed char
  44                         c == '-' || // allowed char
  45                         c == '+' || // allow all sibling in a single tag
  46                         c == '>' || // allow all child in a single tag
  47                         c == '|' || // allow namespace separator
  48                         c == '(' || // allow pseudo-class arguments
  49                         c == ')' ||
  50                         c == '.' || // allow classes and selectors
  51                         c == ':' || // allow pseudo classes
  52                         c == '*' || // allow globs as P + *
  53                         c == '#');  // allow ids
  54 }
  55
  56 static void parseSelector (vString *const string, const int firstChar)
  57 {
  58         int c = firstChar;
  59         do
  60         {
  61                 vStringPut (string, (char) c);
  62                 c = fileGetc ();
  63         } while (isSelectorChar (c));
  64         fileUngetc (c);
  65         vStringTerminate (string);
  66 }
  67
  68 static void readToken (tokenInfo *const token)
  69 {
  70         int c;
  71
  72         vStringClear (token->string);
  73
  74 getNextChar:
  75
  76         c = fileGetc ();
  77         while (isspace (c))
  78                 c = fileGetc ();
  79
  80         token->type = c;
  81         switch (c)
  82         {
  83                 case EOF: token->type = TOKEN_EOF; break;
  84
  85                 case '\'':
  86                 case '"':
  87                 {
  88                         const int delimiter = c;
  89                         do
  90                         {
  91                                 vStringPut (token->string, c);
  92                                 c = fileGetc ();
  93                                 if (c == '\\')
  94                                         c = fileGetc ();
  95                         }
  96                         while (c != EOF && c != delimiter);
  97                         if (c != EOF)
  98                                 vStringPut (token->string, c);
  99                         token->type = TOKEN_STRING;
 100                         break;
 101                 }
 102
 103                 case '/': /* maybe comment start */
 104                 {
 105                         int d = fileGetc ();
 106                         if (d != '*')
 107                         {
 108                                 fileUngetc (d);
 109                                 vStringPut (token->string, c);
 110                                 token->type = c;
 111                         }
 112                         else
 113                         {
 114                                 d = fileGetc ();
 115                                 do
 116                                 {
 117                                         c = d;
 118                                         d = fileGetc ();
 119                                 }
 120                                 while (d != EOF && ! (c == '*' && d == '/'));
 121                                 goto getNextChar;
 122                         }
 123                         break;
 124                 }
 125
 126                 default:
 127                         if (! isSelectorChar (c))
 128                         {
 129                                 vStringPut (token->string, c);
 130                                 token->type = c;
 131                         }
 132                         else
 133                         {
 134                                 parseSelector (token->string, c);
 135                                 token->type = TOKEN_SELECTOR;
 136                         }
 137                         break;
 138         }
 139 }
 140
 141 /* sets selector kind in @p kind if found, otherwise don't touches @p kind */
 142 static cssKind classifySelector (const vString *const selector)
 143 {
 144         size_t i;
 145
 146         for (i = vStringLength (selector); i > 0; --i)
 147         {
 148                 char c = vStringItem (selector, i - 1);
 149                 if (c == '.')
 150                         return K_CLASS;
 151                 else if (c == '#')
 152                         return K_ID;
 153         }
 154         return K_SELECTOR;
 155 }
 156
 157 static void findCssTags (void)
 158 {
 159         boolean readNextToken = TRUE;
 160         tokenInfo token;
 161
 162         token.string = vStringNew ();
 163
 164         do
 165         {
 166                 if (readNextToken)
 167                         readToken (&token);
 168
 169                 readNextToken = TRUE;
 170
 171                 if (token.type == '@')
 172                 { /* At-rules, from the "@" to the next block or semicolon */
 173                         boolean useContents;
 174                         readToken (&token);
 175                         useContents = (strcmp (vStringValue (token.string), "media") == 0 ||
 176                                                    strcmp (vStringValue (token.string), "supports") == 0);
 177                         while (token.type != TOKEN_EOF &&
 178                                    token.type != ';' && token.type != '{')
 179                         {
 180                                 readToken (&token);
 181                         }
 182                         /* HACK: we *eat* the opening '{' for medias and the like so that
 183                          *       the content is parsed as if it was at the root */
 184                         readNextToken = useContents && token.type == '{';
 185                 }
 186                 else if (token.type == TOKEN_SELECTOR)
 187                 { /* collect selectors and make a tag */
 188                         cssKind kind = K_SELECTOR;
 189                         MIOPos filePosition;
 190                         unsigned long lineNumber;
 191                         vString *selector = vStringNew ();
 192                         do
 193                         {
 194                                 if (vStringLength (selector) > 0)
 195                                         vStringPut (selector, ' ');
 196                                 vStringCat (selector, token.string);
 197
 198                                 kind = classifySelector (token.string);
 199                                 lineNumber = getSourceLineNumber ();
 200                                 filePosition = getInputFilePosition ();
 201
 202                                 readToken (&token);
 203
 204                                 /* handle attribute selectors */
 205                                 if (token.type == '[')
 206                                 {
 207                                         int depth = 1;
 208                                         while (depth > 0 && token.type != TOKEN_EOF)
 209                                         {
 210                                                 vStringCat (selector, token.string);
 211                                                 readToken (&token);
 212                                                 if (token.type == '[')
 213                                                         depth++;
 214                                                 else if (token.type == ']')
 215                                                         depth--;
 216                                         }
 217                                         if (token.type != TOKEN_EOF)
 218                                                 vStringCat (selector, token.string);
 219                                         readToken (&token);
 220                                 }
 221                         }
 222                         while (token.type == TOKEN_SELECTOR);
 223                         /* we already consumed the next token, don't read it twice */
 224                         readNextToken = FALSE;
 225
 226                         vStringTerminate (selector);
 227                         if (CssKinds[kind].enabled)
 228                         {
 229                                 tagEntryInfo e;
 230                                 initTagEntry (&e, vStringValue (selector));
 231
 232                                 e.lineNumber    = lineNumber;
 233                                 e.filePosition  = filePosition;
 234                                 e.kindName              = CssKinds[kind].name;
 235                                 e.kind                  = (char) CssKinds[kind].letter;
 236
 237                                 makeTagEntry (&e);
 238                         }
 239                         vStringDelete (selector);
 240                 }
 241                 else if (token.type == '{')
 242                 { /* skip over { ... } */
 243                         int depth = 1;
 244                         while (depth > 0 && token.type != TOKEN_EOF)
 245                         {
 246                                 readToken (&token);
 247                                 if (token.type == '{')
 248                                         depth++;
 249                                 else if (token.type == '}')
 250                                         depth--;
 251                         }
 252                 }
 253         }
 254         while (token.type != TOKEN_EOF);
 255
 256         vStringDelete (token.string);
 257 }
 258
 259 /* parser definition */
 260 extern parserDefinition* CssParser (void)
 261 {
 262     static const char *const extensions [] = { "css", NULL };
 263     parserDefinition* def = parserNew ("CSS");
 264     def->kinds      = CssKinds;
 265     def->kindCount  = KIND_COUNT (CssKinds);
 266     def->extensions = extensions;
 267     def->parser     = findCssTags;
 268     return def;
 269 }
 270