tagmanager/ctags/vhdl.c

   1 /*
   2 *   $Id: vhdl.c,v 1.0 2005/11/05
   3 *
   4 *   Copyright (c) 2005, Klaus Dannecker
   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 the Vhdl HDL
  10 *   (Hardware Description Language).
  11 *
  12 */
  13
  14 /*
  15  *   INCLUDE FILES
  16  */
  17 #include "general.h"    /* must always come first */
  18
  19 #include <string.h>
  20 #include <setjmp.h>
  21
  22 #include "keyword.h"
  23 #include "parse.h"
  24 #include "read.h"
  25 #include "vstring.h"
  26
  27 /*
  28  *   DATA DECLARATIONS
  29  */
  30 typedef enum eException { ExceptionNone, ExceptionEOF } exception_t;
  31
  32 typedef enum {
  33     K_UNDEFINED = -1,
  34     K_CONSTANT,
  35     K_TYPE,
  36     K_VARIABLE,
  37     K_ATRIBUTE,
  38     K_SIGNAL,
  39     K_FUNCTION,
  40     K_PROCEDURE,
  41     K_COMPONENT,
  42     K_PACKAGE,
  43     K_PROCESS,
  44     K_ENTITY,
  45     K_ARCHITECTURE,
  46     K_PORT,
  47     K_BLOCK,
  48     K_ALIAS
  49 } vhdlKind;
  50
  51 typedef struct {
  52     const char *keyword;
  53     vhdlKind kind;
  54 } keywordAssoc;
  55
  56 /*
  57  *   DATA DEFINITIONS
  58  */
  59 static int Ungetc;
  60 static int Lang_vhdl;
  61 static jmp_buf Exception;
  62 static vString* Name=NULL;
  63 static vString* Lastname=NULL;
  64 static vString* Keyword=NULL;
  65 static vString* TagName=NULL;
  66
  67 static kindOption VhdlKinds [] = {
  68  { TRUE, 'c', "variable",     "constants" },
  69  { TRUE, 't', "typedef",      "types" },
  70  { TRUE, 'v', "variable",     "variables" },
  71  { TRUE, 'a', "atribute",     "atributes" },
  72  { TRUE, 's', "variable",     "signals" },
  73  { TRUE, 'f', "function",     "functions" },
  74  { TRUE, 'p', "function",     "procedure" },
  75  { TRUE, 'k', "member",       "components" },
  76  { TRUE, 'l', "namespace",    "packages" },
  77  { TRUE, 'm', "member",       "process" },
  78  { TRUE, 'n', "class",        "entity" },
  79  { TRUE, 'o', "struct",       "architecture" },
  80  { TRUE, 'u', "port",         "ports" },
  81  { TRUE, 'b', "member",       "blocks" },
  82  { TRUE, 'v', "typedef",      "alias" }
  83  };
  84
  85 static keywordAssoc VhdlKeywordTable [] = {
  86     { "constant",     K_CONSTANT },
  87     { "variable",     K_VARIABLE },
  88     { "type",         K_TYPE },
  89     { "subtype",      K_TYPE },
  90     { "signal",       K_SIGNAL },
  91     { "function",     K_FUNCTION },
  92     { "procedure",    K_PROCEDURE },
  93     { "component",    K_COMPONENT },
  94     { "package",      K_PACKAGE },
  95     { "process",      K_PROCESS },
  96     { "entity",       K_ENTITY },
  97     { "architecture", K_ARCHITECTURE },
  98     { "inout",        K_PORT },
  99     { "in",           K_PORT },
 100     { "out",          K_PORT },
 101     { "block",        K_BLOCK },
 102     { "alias",        K_ALIAS }
 103 };
 104
 105
 106 /*
 107  *   FUNCTION DEFINITIONS
 108  */
 109
 110 static void initialize (const langType language)
 111 {
 112     size_t i;
 113     const size_t count = sizeof (VhdlKeywordTable) /
 114                          sizeof (VhdlKeywordTable [0]);
 115     Lang_vhdl = language;
 116     for (i = 0  ;  i < count  ;  ++i)
 117     {
 118                 const keywordAssoc* const p = &VhdlKeywordTable [i];
 119                 addKeyword (p->keyword, language, (int) p->kind);
 120     }
 121 }
 122
 123 static void vUngetc (int c)
 124 {
 125     Assert (Ungetc == '\0');
 126     Ungetc = c;
 127 }
 128
 129 static int vGetc (void)
 130 {
 131     int c;
 132     if (Ungetc == '\0')
 133         c = fileGetc ();
 134     else
 135     {
 136                 c = Ungetc;
 137                 Ungetc = '\0';
 138     }
 139     if (c == '-')
 140     {
 141                 int c2 = fileGetc ();
 142                 if (c2 == EOF)
 143                         longjmp (Exception, (int) ExceptionEOF);
 144                 else if (c2 == '-')   /* strip comment until end-of-line */
 145                 {
 146                         do
 147                         c = fileGetc ();
 148                         while (c != '\n'  &&  c != EOF);
 149                 }
 150                 else
 151                         Ungetc = c2;
 152         }
 153     if (c == EOF)
 154                 longjmp (Exception, (int) ExceptionEOF);
 155         return c;
 156 }
 157
 158 static boolean isIdentifierCharacter (const int c)
 159 {
 160     return (boolean)(isalnum (c)  ||  c == '_'  ||  c == '`');
 161 }
 162
 163 static int skipWhite (int c)
 164 {
 165     while (c==' ')
 166         c = vGetc ();
 167     return c;
 168 }
 169
 170 static boolean readIdentifier (vString *const name, int c)
 171 {
 172     vStringClear (name);
 173     if (isIdentifierCharacter (c))
 174     {
 175                 while (isIdentifierCharacter (c))
 176                 {
 177                         vStringPut (name, c);
 178                         c = vGetc ();
 179                 }
 180                 vUngetc (c);
 181                 vStringTerminate (name);
 182     }
 183     return (boolean)(name->length > 0);
 184 }
 185
 186 static void tagNameList (const vhdlKind kind, int c)
 187 {
 188     Assert (isIdentifierCharacter (c));
 189         if (isIdentifierCharacter (c))
 190         {
 191                 readIdentifier (TagName, c);
 192                 makeSimpleTag (TagName, VhdlKinds, kind);
 193         }
 194 }
 195
 196 static void findTag (vString *const name)
 197 {
 198         int c = '\0';
 199         vhdlKind kind;
 200     vStringCopyToLower (Keyword, name);
 201     kind = (vhdlKind)lookupKeyword (vStringValue (Keyword), Lang_vhdl);
 202     if (kind == K_UNDEFINED)
 203         {
 204                 c = skipWhite (vGetc ());
 205                 vStringCopyS(Lastname,vStringValue(name));
 206                         if (c == ':')
 207                         {
 208                                 c = skipWhite (vGetc ());
 209                                 if (isIdentifierCharacter (c))
 210                                 {
 211                                         readIdentifier (name, c);
 212                                         vStringCopyToLower (Keyword, name);
 213                                         lookupKeyword (vStringValue (Keyword), Lang_vhdl);
 214                                         kind = (vhdlKind)lookupKeyword (vStringValue (Keyword), Lang_vhdl);
 215                                         if (kind == K_PROCESS || kind == K_BLOCK || kind == K_PORT)
 216                                         {
 217                                                 makeSimpleTag (Lastname, VhdlKinds, kind);
 218                                         }
 219                                 }
 220                         } else {
 221                                 vUngetc (c);
 222                         }
 223         }
 224         else
 225         {
 226                 if (kind == K_SIGNAL) {
 227                         while (c!=':') {
 228                                 c = skipWhite (vGetc ());
 229                                 if (c==',')
 230                                         c = vGetc ();
 231                                 if (isIdentifierCharacter (c))
 232                                         tagNameList (kind, c);
 233                                 else
 234                                         break;
 235                                 c = vGetc ();
 236                         }
 237                 }
 238                 else if (kind == K_PROCESS || kind == K_BLOCK) {
 239                         vStringCopyS(TagName,"unnamed");
 240                         makeSimpleTag (TagName, VhdlKinds, kind);
 241                 } else {
 242                         c = skipWhite (vGetc ());
 243                         if (c=='\"')
 244                                 c = vGetc ();
 245                         if (isIdentifierCharacter (c))
 246                                 tagNameList (kind, c);
 247                 }
 248         }
 249 }
 250
 251 static void findVhdlTags (void)
 252 {
 253     volatile boolean newStatement = TRUE;
 254     volatile int c = '\0';
 255     exception_t exception = (exception_t) setjmp (Exception);
 256         Name = vStringNew ();
 257     Lastname = vStringNew ();
 258     Keyword = vStringNew ();
 259     TagName = vStringNew ();
 260
 261     if (exception == ExceptionNone) while (c != EOF)
 262     {
 263                 c = vGetc ();
 264                 switch (c)
 265                 {
 266                         case ';':
 267                         case '\n':
 268                         newStatement = TRUE;
 269                         break;
 270
 271                         case ' ':
 272                         case '\t':
 273                         break;
 274
 275                         default:
 276                         if (newStatement && readIdentifier (Name, c)) {
 277                                 findTag (Name);
 278                                 }
 279                         newStatement = FALSE;
 280                         break;
 281                 }
 282     }
 283     vStringDelete (Name);
 284     vStringDelete (Lastname);
 285     vStringDelete (Keyword);
 286     vStringDelete (TagName);
 287 }
 288
 289 extern parserDefinition* VhdlParser (void)
 290 {
 291     static const char *const extensions [] = { "vhdl", "vhd", NULL };
 292     parserDefinition* def = parserNew ("Vhdl");
 293     def->kinds      = VhdlKinds;
 294     def->kindCount  = KIND_COUNT (VhdlKinds);
 295     def->extensions = extensions;
 296     def->parser     = findVhdlTags;
 297     def->initialize = initialize;
 298     return def;
 299 }
 300
 301 /* vi:set tabstop=8 shiftwidth=4: */