tagmanager/basic.c

   1 /*
   2  *   $Id$
   3  *
   4  *   Copyright (c) 2000-2006, Darren Hiebert, Elias Pschernig
   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 BlitzBasic
  10  *   (BlitzMax), PureBasic and FreeBasic language files. For now, this is kept
  11  *   quite simple - but feel free to ask for more things added any time -
  12  *   patches are of course most welcome.
  13  */
  14
  15 /*
  16  *   INCLUDE FILES
  17  */
  18 #include "general.h" /* must always come first */
  19
  20 #include <string.h>
  21
  22 #include "parse.h"
  23 #include "read.h"
  24 #include "vstring.h"
  25
  26 /*
  27  *   DATA DEFINITIONS
  28  */
  29 typedef enum {
  30         K_CONST,
  31         K_FUNCTION,
  32         K_LABEL,
  33         K_TYPE,
  34         K_VARIABLE,
  35         K_ENUM
  36 } BasicKind;
  37
  38 typedef struct {
  39         char const *token;
  40         BasicKind kind;
  41 } KeyWord;
  42
  43 static kindOption BasicKinds[] = {
  44         {TRUE, 'c', "macro", "constants"},
  45         {TRUE, 'f', "function", "functions"},
  46         {TRUE, 'l', "namespace", "labels"},
  47         {TRUE, 't', "struct", "types"},
  48         {TRUE, 'v', "variable", "variables"},
  49         {TRUE, 'g', "externvar", "enumerations"}
  50 };
  51
  52 static KeyWord freebasic_keywords[] = {
  53         {"dim", K_VARIABLE}, /* must always be the first */
  54         {"common", K_VARIABLE}, /* must always be the second */
  55         {"const", K_CONST}, /* must always be the third */
  56         {"function", K_FUNCTION},
  57         {"sub", K_FUNCTION},
  58         {"property", K_FUNCTION},
  59         {"constructor", K_FUNCTION},
  60         {"destructor", K_FUNCTION},
  61         {"private sub", K_FUNCTION},
  62         {"public sub", K_FUNCTION},
  63         {"private function", K_FUNCTION},
  64         {"public function", K_FUNCTION},
  65         {"type", K_TYPE},
  66         {"enum", K_ENUM},
  67         {NULL, 0}
  68 };
  69
  70 /*
  71  *   FUNCTION DEFINITIONS
  72  */
  73
  74 /* Match the name of a dim or const starting at pos. */
  75 static int extract_dim (char const *pos, vString * name, BasicKind kind)
  76 {
  77         const char *old_pos = pos;
  78         while (isspace (*pos))
  79                 pos++;
  80
  81         /* create tags only if there is some space between the keyword and the identifier */
  82         if (old_pos == pos)
  83                 return 0;
  84
  85         vStringClear (name);
  86
  87         if (strncasecmp (pos, "shared", 6) == 0)
  88                 pos += 6; /* skip keyword "shared" */
  89
  90         while (isspace (*pos))
  91                 pos++;
  92
  93         /* capture "dim as String str" */
  94         if (strncasecmp (pos, "as", 2) == 0)
  95         {
  96                         pos += 2; /* skip keyword "as" */
  97
  98                 while (isspace (*pos))
  99                         pos++;
 100                 while (!isspace (*pos)) /* skip next part which is a type */
 101                         pos++;
 102                 while (isspace (*pos))
 103                         pos++;
 104                 /* now we are at the name */
 105         }
 106         /* capture "dim as foo ptr bar" */
 107         if (strncasecmp (pos, "ptr", 3) == 0 && isspace(*(pos+4)))
 108         {
 109                 pos += 3; /* skip keyword "ptr" */
 110                 while (isspace (*pos))
 111                         pos++;
 112         }
 113         /*      capture "dim as string * 4096 chunk" */
 114         if (strncmp (pos, "*", 1) == 0)
 115         {
 116                 pos += 1; /* skip "*" */
 117                 while (isspace (*pos) || isdigit(*pos) || ispunct(*pos))
 118                         pos++;
 119         }
 120
 121         for (; *pos && !isspace (*pos) && *pos != '(' && *pos != ',' && *pos != '='; pos++)
 122                 vStringPut (name, *pos);
 123         vStringTerminate (name);
 124         makeSimpleTag (name, BasicKinds, kind);
 125
 126         /* if the line contains a ',', we have multiple declarations */
 127         while (*pos && strchr (pos, ','))
 128         {
 129                 /* skip all we don't need(e.g. "..., new_array(5), " we skip "(5)") */
 130                 while (*pos != ',' && *pos != '\'')
 131                         pos++;
 132
 133                 if (*pos == '\'')
 134                         return 0; /* break if we are in a comment */
 135
 136                 while (isspace (*pos) || *pos == ',')
 137                         pos++;
 138
 139                 if (*pos == '\'')
 140                         return 0; /* break if we are in a comment */
 141
 142                 vStringClear (name);
 143                 for (; *pos && !isspace (*pos) && *pos != '(' && *pos != ',' && *pos != '='; pos++)
 144                         vStringPut (name, *pos);
 145                 vStringTerminate (name);
 146                 makeSimpleTag (name, BasicKinds, kind);
 147         }
 148
 149         vStringDelete (name);
 150         return 1;
 151 }
 152
 153 /* Match the name of a tag (function, variable, type, ...) starting at pos. */
 154 static char const *extract_name (char const *pos, vString * name)
 155 {
 156         while (isspace (*pos))
 157                 pos++;
 158         vStringClear (name);
 159         for (; *pos && !isspace (*pos) && *pos != '(' && *pos != ',' && *pos != '='; pos++)
 160                 vStringPut (name, *pos);
 161         vStringTerminate (name);
 162         return pos;
 163 }
 164
 165 /* Match a keyword starting at p (case insensitive). */
 166 static int match_keyword (const char *p, KeyWord const *kw)
 167 {
 168         vString *name;
 169         size_t i;
 170         int j;
 171         const char *old_p;
 172         for (i = 0; i < strlen (kw->token); i++)
 173         {
 174                 if (tolower (p[i]) != kw->token[i])
 175                         return 0;
 176         }
 177         name = vStringNew ();
 178         p += i;
 179         if (kw == &freebasic_keywords[0] ||
 180                 kw == &freebasic_keywords[1] ||
 181                 kw == &freebasic_keywords[2])
 182                 return extract_dim (p, name, kw->kind); /* extract_dim adds the found tag(s) */
 183
 184         old_p = p;
 185         while (isspace (*p))
 186                 p++;
 187
 188         /* create tags only if there is some space between the keyword and the identifier */
 189         if (old_p == p)
 190         {
 191                 vStringDelete (name);
 192                 return 0;
 193         }
 194
 195         for (j = 0; j < 1; j++)
 196         {
 197                 p = extract_name (p, name);
 198         }
 199         makeSimpleTag (name, BasicKinds, kw->kind);
 200         vStringDelete (name);
 201
 202         return 1;
 203 }
 204
 205 /* Match a "label:" style label. */
 206 static void match_colon_label (char const *p)
 207 {
 208         char const *end = p + strlen (p) - 1;
 209         while (isspace (*end))
 210                 end--;
 211         if (*end == ':')
 212         {
 213                 vString *name = vStringNew ();
 214                 vStringNCatS (name, p, end - p);
 215                 makeSimpleTag (name, BasicKinds, K_LABEL);
 216                 vStringDelete (name);
 217         }
 218 }
 219
 220 static void findBasicTags (void)
 221 {
 222         const char *line;
 223         KeyWord *keywords;
 224
 225         keywords = freebasic_keywords;
 226
 227         while ((line = (const char *) fileReadLine ()) != NULL)
 228         {
 229                 const char *p = line;
 230                 KeyWord const *kw;
 231
 232                 while (isspace (*p))
 233                         p++;
 234
 235                 /* Empty line or comment? */
 236                 if (!*p || *p == '\'')
 237                         continue;
 238
 239                 /* In Basic, keywords always are at the start of the line. */
 240                 for (kw = keywords; kw->token; kw++)
 241                         if (match_keyword (p, kw)) break;
 242
 243                 /* Is it a label? */
 244                 match_colon_label (p);
 245         }
 246 }
 247
 248 parserDefinition *FreeBasicParser (void)
 249 {
 250         static char const *extensions[] = { "bas", "bi", "bb", "pb", NULL };
 251         parserDefinition *def = parserNew ("FreeBasic");
 252         def->kinds = BasicKinds;
 253         def->kindCount = KIND_COUNT (BasicKinds);
 254         def->extensions = extensions;
 255         def->parser = findBasicTags;
 256         return def;
 257 }
 258
 259 /* vi:set tabstop=4 shiftwidth=4: */