ctags/parsers/haxe.c

   1 /*
   2  *       Copyright (c) 2007, Ritchie Turner
   3  *
   4  *       This source code is released for free distribution under the terms of the
   5  *       GNU General Public License.
   6  *
   7  *              borrowed from PHP
   8  */
   9
  10 /*
  11  *       INCLUDE FILES
  12  */
  13 #include "general.h"    /* must always come first */
  14 #include <ctype.h>      /* to define isalpha () */
  15 #include <setjmp.h>
  16 #ifdef DEBUG
  17 #include <stdio.h>
  18 #endif
  19 #include <string.h>
  20 #include "entry.h"
  21 #include "keyword.h"
  22 #include "parse.h"
  23 #include "read.h"
  24 #include "vstring.h"
  25 #include "routines.h"
  26
  27 /*
  28  *       MACROS
  29  */
  30 #define isType(token,t)         (bool) ((token)->type == (t))
  31 #define isKeyword(token,k)      (bool) ((token)->keyword == (k))
  32
  33 /*
  34  *      DATA DEFINITIONS
  35  */
  36
  37 /*static jmp_buf Exception;*/
  38
  39 typedef enum {
  40         HXTAG_METHODS,
  41         HXTAG_CLASS,
  42         HXTAG_ENUM,
  43         HXTAG_VARIABLE,
  44         HXTAG_INTERFACE,
  45         HXTAG_TYPEDEF,
  46         HXTAG_COUNT
  47 } hxKind;
  48
  49 static kindDefinition HxKinds [] = {
  50         { true,  'm', "method",         "methods" },
  51         { true,  'c', "class",          "classes" },
  52         { true,  'e', "enum",           "enumerations" },
  53         { true,  'v', "variable",       "variables" },
  54         { true,  'i', "interface",      "interfaces" },
  55         { true,  't', "typedef",        "typedefs" },
  56 };
  57
  58 static void findHxTags (void)
  59 {
  60         vString *name = vStringNew ();
  61         vString *clsName = vStringNew();
  62         vString *scope2 = vStringNew();
  63         vString *laccess = vStringNew();
  64         const char *const priv = "private";
  65         const char *const pub = "public";
  66
  67         const unsigned char *line;
  68
  69         while ((line = readLineFromInputFile ()) != NULL)
  70         {
  71                 const unsigned char *cp = line;
  72 another:
  73                 while (isspace (*cp))
  74                         cp++;
  75
  76                 vStringCopyS(laccess,priv);
  77
  78                 if (strncmp ((const char*) cp, "var", (size_t) 3) == 0  &&
  79                         isspace ((int) cp [3]))
  80                 {
  81                         cp += 3;
  82
  83                         while (isspace ((int) *cp))
  84                                 ++cp;
  85
  86                         vStringClear (name);
  87                         while (isalnum ((int) *cp)  ||  *cp == '_')
  88                         {
  89                                 vStringPut (name, (int) *cp);
  90                                 ++cp;
  91                         }
  92                         makeSimpleTag (name, HXTAG_VARIABLE);
  93
  94                         vStringClear (name);
  95                 }
  96                 else if (strncmp ((const char*) cp, "function", (size_t) 8) == 0  &&
  97                         isspace ((int) cp [8]))
  98                 {
  99                         cp += 8;
 100
 101                         while (isspace ((int) *cp))
 102                                 ++cp;
 103
 104                         vStringClear (name);
 105                         while (isalnum ((int) *cp)  ||  *cp == '_')
 106                         {
 107                                 vStringPut (name, (int) *cp);
 108                                 ++cp;
 109                         }
 110                         makeSimpleTag (name, HXTAG_METHODS);
 111
 112                         vStringClear (name);
 113                 }
 114                 else if (strncmp ((const char*) cp, "class", (size_t) 5) == 0 &&
 115                                  isspace ((int) cp [5]))
 116                 {
 117                         cp += 5;
 118
 119                         while (isspace ((int) *cp))
 120                                 ++cp;
 121                         vStringClear (name);
 122                         while (isalnum ((int) *cp)  ||  *cp == '_')
 123                         {
 124                                 vStringPut (name, (int) *cp);
 125                                 ++cp;
 126                         }
 127                         makeSimpleTag (name, HXTAG_CLASS);
 128                         vStringCopy(clsName,name);
 129                         vStringClear (name);
 130                 }
 131                 else if (strncmp ((const char*) cp, "enum", (size_t) 4) == 0 &&
 132                                   isspace ((int) cp [4]))
 133                 {
 134                         cp += 4;
 135
 136                         while (isspace ((int) *cp))
 137                                 ++cp;
 138                         vStringClear (name);
 139                         while (isalnum ((int) *cp)  ||  *cp == '_')
 140                         {
 141                                 vStringPut (name, (int) *cp);
 142                                 ++cp;
 143                         }
 144                         makeSimpleTag (name, HXTAG_ENUM);
 145                         vStringClear (name);
 146                 } else if (strncmp ((const char*) cp, "public", (size_t) 6) == 0 &&
 147                                  isspace((int) cp [6]))
 148                 {
 149                         cp += 6;
 150                         while (isspace ((int) *cp))
 151                                 ++cp;
 152                         vStringCopyS(laccess,pub);
 153                         goto another;
 154                 } else if (strncmp ((const char*) cp, "static", (size_t) 6) == 0 &&
 155                                  isspace((int) cp [6]))
 156                 {
 157                         cp += 6;
 158                         while (isspace ((int) *cp))
 159                                 ++cp;
 160                         goto another;
 161                 } else if (strncmp ((const char*) cp, "interface", (size_t) 9) == 0 &&
 162                         isspace((int) cp [9]))
 163                 {
 164                         cp += 9;
 165
 166                         while (isspace ((int) *cp))
 167                                 ++cp;
 168                         vStringClear (name);
 169                         while (isalnum ((int) *cp)  ||  *cp == '_') {
 170                                 vStringPut (name, (int) *cp);
 171                                 ++cp;
 172                         }
 173                         makeSimpleTag (name, HXTAG_INTERFACE);
 174                         vStringClear (name);
 175                 } else if (strncmp ((const char *) cp,"typedef",(size_t) 7) == 0 && isspace(((int) cp[7]))) {
 176                         cp += 7;
 177
 178                         while (isspace ((int) *cp))
 179                                 ++cp;
 180                         vStringClear (name);
 181                         while (isalnum ((int) *cp)  ||  *cp == '_') {
 182                                 vStringPut (name, (int) *cp);
 183                                 ++cp;
 184                         }
 185                         makeSimpleTag (name, HXTAG_TYPEDEF);
 186                         vStringClear (name);
 187                 }
 188
 189
 190         }
 191
 192         vStringDelete(name);
 193         vStringDelete(clsName);
 194         vStringDelete(scope2);
 195         vStringDelete(laccess);
 196 }
 197
 198
 199 /* Create parser definition structure */
 200 extern parserDefinition* HaxeParser (void)
 201 {
 202         static const char *const extensions [] = { "hx", NULL };
 203
 204         parserDefinition *const def = parserNew ("Haxe");
 205         def->extensions = extensions;
 206         /*
 207          * New definitions for parsing instead of regex
 208          */
 209         def->kindTable          = HxKinds;
 210         def->kindCount  = ARRAY_SIZE (HxKinds);
 211         def->parser             = findHxTags;
 212         /*def->initialize = initialize;*/
 213         return def;
 214 }
 215
 216
 217