asp.c

   1 /*
   2 *   $Id: asp.c 711 2009-07-04 16:52:11Z dhiebert $
   3 *
   4 *   Copyright (c) 2000, Patrick Dehne <patrick@steidle.net>
   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 ASP (Active
  10 *   Server Pages) web page scripting language.
  11 */
  12
  13 /*
  14 *   INCLUDE FILES
  15 */
  16 #include "general.h"  /* must always come first */
  17
  18 #include <string.h>
  19
  20 #include "parse.h"
  21 #include "read.h"
  22 #include "vstring.h"
  23
  24 /*
  25 *   DATA DEFINITIONS
  26 */
  27 typedef enum {
  28         K_CONST, K_CLASS, K_FUNCTION, K_SUB, K_DIM
  29 } aspKind;
  30
  31 static kindOption AspKinds [] = {
  32         { TRUE, 'd', "constant",   "constants"},
  33         { TRUE, 'c', "class",      "classes"},
  34         { TRUE, 'f', "function",   "functions"},
  35         { TRUE, 's', "subroutine", "subroutines"},
  36         { TRUE, 'v', "variable",   "variables"}
  37 };
  38
  39 /*
  40 *   FUNCTION DEFINITIONS
  41 */
  42
  43 static void findAspTags (void)
  44 {
  45         vString *name = vStringNew ();
  46         const unsigned char *line;
  47
  48         while ((line = fileReadLine ()) != NULL)
  49         {
  50                 const unsigned char *cp = line;
  51
  52                 while (*cp != '\0')
  53                 {
  54                         /* jump over whitespace */
  55                         while (isspace ((int)*cp))
  56                                 cp++;
  57
  58                         /* jump over strings */
  59                         if (*cp == '"')
  60                         {
  61                                 cp++;
  62                                 while (*cp!='"' && *cp!='\0')
  63                                         cp++;
  64                         }
  65
  66                         /* jump over comments */
  67                         else if (*cp == '\'')
  68                                 break;
  69
  70                         /* jump over end function/sub lines */
  71                         else if (strncasecmp ((const char*) cp, "end", (size_t) 3)== 0)
  72                         {
  73                                 cp += 3;
  74                                 if (isspace ((int)*cp))
  75                                 {
  76                                         while (isspace ((int)*cp))
  77                                                 ++cp;
  78
  79                                         if (strncasecmp ((const char*) cp, "function", (size_t) 8) == 0)
  80                                         {
  81                                                 cp+=8;
  82                                                 break;
  83                                         }
  84
  85                                         else if (strncasecmp ((const char*) cp, "sub", (size_t) 3) == 0)
  86                                         {
  87                                                 cp+=3;
  88                                                 break;
  89                                         }
  90                                 }
  91                         }
  92
  93                         /* jump over exit function/sub lines */
  94                         else if (strncasecmp ((const char*) cp, "exit", (size_t) 4)==0)
  95                         {
  96                                 cp += 4;
  97                                 if (isspace ((int) *cp))
  98                                 {
  99                                         while (isspace ((int) *cp))
 100                                                 ++cp;
 101
 102                                         if (strncasecmp ((const char*) cp, "function", (size_t) 8) == 0)
 103                                         {
 104                                                 cp+=8;
 105                                                 break;
 106                                         }
 107
 108                                         else if (strncasecmp ((const char*) cp, "sub", (size_t) 3) == 0)
 109                                         {
 110                                                 cp+=3;
 111                                                 break;
 112                                         }
 113                                 }
 114                         }
 115
 116                         /* class member? */
 117                         else if (strncasecmp ((const char*) cp, "public", (size_t) 6) == 0)
 118                         {
 119                                 cp += 6;
 120                                 if (isspace ((int) *cp))
 121                                 {
 122                                         while (isspace ((int) *cp))
 123                                                 ++cp;
 124                                         if (strncasecmp ((const char*) cp, "function", (size_t) 8) == 0)
 125                                         {
 126                                                 cp+=8;
 127                                             while (isspace ((int) *cp))
 128                                                     ++cp;
 129                                             while (isalnum ((int) *cp)  ||  *cp == '_')
 130                                             {
 131                                                     vStringPut (name, (int) *cp);
 132                                                     ++cp;
 133                                             }
 134                                             vStringTerminate (name);
 135                                             makeSimpleTag (name, AspKinds, K_FUNCTION);
 136                                             vStringClear (name);
 137                                         }
 138                                         else if (strncasecmp ((const char*) cp, "sub", (size_t) 3) == 0)
 139                                         {
 140                                                 cp+=3;
 141                                             while (isspace ((int) *cp))
 142                                                     ++cp;
 143                                             while (isalnum ((int) *cp)  ||  *cp == '_')
 144                                             {
 145                                                     vStringPut (name, (int) *cp);
 146                                                     ++cp;
 147                                             }
 148                                             vStringTerminate (name);
 149                                             makeSimpleTag (name, AspKinds, K_SUB);
 150                                             vStringClear (name);
 151                                         }
 152                                         else {
 153                                             while (isalnum ((int) *cp)  ||  *cp == '_')
 154                                             {
 155                                                     vStringPut (name, (int) *cp);
 156                                                     ++cp;
 157                                             }
 158                                             vStringTerminate (name);
 159                                             makeSimpleTag (name, AspKinds, K_DIM);
 160                                             vStringClear (name);
 161                                         }
 162                                 }
 163                         }
 164                         else if (strncasecmp ((const char*) cp, "private", (size_t) 7) == 0)
 165                         {
 166                                 cp += 7;
 167                                 if (isspace ((int) *cp))
 168                                 {
 169                                         while (isspace ((int) *cp))
 170                                                 ++cp;
 171                                         if (strncasecmp ((const char*) cp, "function", (size_t) 8) == 0)
 172                                         {
 173                                                 cp+=8;
 174                                             while (isspace ((int) *cp))
 175                                                     ++cp;
 176                                             while (isalnum ((int) *cp)  ||  *cp == '_')
 177                                             {
 178                                                     vStringPut (name, (int) *cp);
 179                                                     ++cp;
 180                                             }
 181                                             vStringTerminate (name);
 182                                             makeSimpleTag (name, AspKinds, K_FUNCTION);
 183                                             vStringClear (name);
 184                                         }
 185                                         else if (strncasecmp ((const char*) cp, "sub", (size_t) 3) == 0)
 186                                         {
 187                                                 cp+=3;
 188                                             while (isspace ((int) *cp))
 189                                                     ++cp;
 190                                             while (isalnum ((int) *cp)  ||  *cp == '_')
 191                                             {
 192                                                     vStringPut (name, (int) *cp);
 193                                                     ++cp;
 194                                             }
 195                                             vStringTerminate (name);
 196                                             makeSimpleTag (name, AspKinds, K_SUB);
 197                                             vStringClear (name);
 198                                         }
 199                                         else {
 200                                             while (isalnum ((int) *cp)  ||  *cp == '_')
 201                                             {
 202                                                     vStringPut (name, (int) *cp);
 203                                                     ++cp;
 204                                             }
 205                                             vStringTerminate (name);
 206                                             makeSimpleTag (name, AspKinds, K_DIM);
 207                                             vStringClear (name);
 208                                         }
 209                                 }
 210                         }
 211
 212                         /* function? */
 213                         else if (strncasecmp ((const char*) cp, "function", (size_t) 8) == 0)
 214                         {
 215                                 cp += 8;
 216
 217                                 if (isspace ((int) *cp))
 218                                 {
 219                                         while (isspace ((int) *cp))
 220                                                 ++cp;
 221                                         while (isalnum ((int) *cp)  ||  *cp == '_')
 222                                         {
 223                                                 vStringPut (name, (int) *cp);
 224                                                 ++cp;
 225                                         }
 226                                         vStringTerminate (name);
 227                                         makeSimpleTag (name, AspKinds, K_FUNCTION);
 228                                         vStringClear (name);
 229                                 }
 230                         }
 231
 232                         /* sub? */
 233                         else if (strncasecmp ((const char*) cp, "sub", (size_t) 3) == 0)
 234                         {
 235                                 cp += 3;
 236                                 if (isspace ((int) *cp))
 237                                 {
 238                                         while (isspace ((int) *cp))
 239                                                 ++cp;
 240                                         while (isalnum ((int) *cp)  ||  *cp == '_')
 241                                         {
 242                                                 vStringPut (name, (int) *cp);
 243                                                 ++cp;
 244                                         }
 245                                         vStringTerminate (name);
 246                                         makeSimpleTag (name, AspKinds, K_SUB);
 247                                         vStringClear (name);
 248                                 }
 249                         }
 250
 251                         /* dim variable? */
 252                         else if (strncasecmp ((const char*) cp, "dim", (size_t) 3) == 0)
 253                         {
 254                                 cp += 3;
 255                                 if (isspace ((int) *cp))
 256                                 {
 257                                         while (isspace ((int) *cp))
 258                                                 ++cp;
 259                                         while (isalnum ((int) *cp)  ||  *cp == '_')
 260                                         {
 261                                                 vStringPut (name, (int) *cp);
 262                                                 ++cp;
 263                                         }
 264                                         vStringTerminate (name);
 265                                         makeSimpleTag (name, AspKinds, K_DIM);
 266                                         vStringClear (name);
 267                                 }
 268                         }
 269
 270                         /* class declaration? */
 271                         else if (strncasecmp ((const char*) cp, "class", (size_t) 5) == 0)
 272                         {
 273                                 cp += 5;
 274                                 if (isspace ((int) *cp))
 275                                 {
 276                                         while (isspace ((int) *cp))
 277                                                 ++cp;
 278                                         while (isalnum ((int) *cp)  ||  *cp == '_')
 279                                         {
 280                                                 vStringPut (name, (int) *cp);
 281                                                 ++cp;
 282                                         }
 283                                         vStringTerminate (name);
 284                                         makeSimpleTag (name, AspKinds, K_CLASS);
 285                                         vStringClear (name);
 286                                 }
 287                         }
 288
 289                         /* const declaration? */
 290                         else if (strncasecmp ((const char*) cp, "const", (size_t) 5) == 0)
 291                         {
 292                                 cp += 5;
 293                                 if (isspace ((int) *cp))
 294                                 {
 295                                         while (isspace ((int) *cp))
 296                                                 ++cp;
 297                                         while (isalnum ((int) *cp)  ||  *cp == '_')
 298                                         {
 299                                                 vStringPut (name, (int) *cp);
 300                                                 ++cp;
 301                                         }
 302                                         vStringTerminate (name);
 303                                         makeSimpleTag (name, AspKinds, K_CONST);
 304                                         vStringClear (name);
 305                                 }
 306                         }
 307
 308                         /* nothing relevant */
 309                         else if (*cp != '\0')
 310                                 cp++;
 311                 }
 312         }
 313         vStringDelete (name);
 314 }
 315
 316 extern parserDefinition* AspParser (void)
 317 {
 318         static const char *const extensions [] = { "asp", "asa", NULL };
 319         parserDefinition* def = parserNew ("Asp");
 320         def->kinds      = AspKinds;
 321         def->kindCount  = KIND_COUNT (AspKinds);
 322         def->extensions = extensions;
 323         def->parser     = findAspTags;
 324         return def;
 325 }
 326
 327 /* vi:set tabstop=4 shiftwidth=4: */
 328