falcon.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (c) 2011, 2012 Steven Oliver <oliver.steven@gmail.com>
   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 Falcon language
  10  * files.
  11  */
  12
  13
  14 /*
  15  * INCLUDE FILES
  16  */
  17 #include "general.h"
  18
  19 #include <string.h>
  20 #include <ctype.h>
  21
  22 #include "parse.h"
  23 #include "read.h"
  24
  25 /*
  26  * Data Definitions
  27  */
  28 typedef enum eFalconKinds {
  29     K_CLASS,
  30     K_FUNCTION,
  31     K_MEMBER,
  32     K_VARIABLE,
  33     K_NAMESPACE
  34 } falconKind;
  35
  36 static kindOption FalconKinds [] = {
  37     {TRUE, 'c', "class",     "classes" },
  38     {TRUE, 'f', "function",  "functions"},
  39     {TRUE, 'm', "member",    "class members"},
  40     {TRUE, 'v', "variable",  "variables"},
  41     {TRUE, 'i', "namespace", "imports"}
  42 };
  43
  44 /*
  45  * Function Definitions
  46  */
  47
  48 static boolean isIdentifierChar (int c)
  49 {
  50     return (boolean) (isalnum (c) || c == '_');
  51 }
  52
  53 static const char *skipSpace (const char *cp)
  54 {
  55     while (isspace ((int) *cp))
  56         ++cp;
  57
  58     return cp;
  59 }
  60
  61 static const char *skipString (const char *cp)
  62 {
  63     const char *start = cp;
  64     int escaped = 0;
  65
  66     for (cp++; *cp; cp++)
  67     {
  68         if (escaped)
  69             escaped--;
  70         else if (*cp == '\\')
  71             escaped++;
  72         else if (*cp == *start)
  73             return cp + 1;
  74     }
  75
  76     return cp;
  77 }
  78
  79 static void findFalconTags (void)
  80 {
  81     vString *name = vStringNew ();
  82     const unsigned char *line;
  83
  84     while ((line = fileReadLine ()) != NULL)
  85     {
  86         const unsigned char *cp = line;
  87
  88         if (*cp == '#')
  89             continue;
  90
  91         if (strncmp ((const char*) cp, "function", (size_t) 8) == 0)
  92         {
  93             cp += 8;
  94             cp = skipSpace (cp);
  95
  96             while (isIdentifierChar ((int) *cp))
  97             {
  98                 vStringPut (name, (int) *cp);
  99                 ++cp;
 100             }
 101             vStringTerminate (name);
 102             makeSimpleTag (name, FalconKinds, K_FUNCTION);
 103             vStringClear (name);
 104         }
 105         else if (strncmp ((const char*) cp, "class", (size_t) 5) == 0)
 106         {
 107             cp += 5;
 108             cp = skipSpace (cp);
 109
 110             while (isIdentifierChar ((int) *cp))
 111             {
 112                 vStringPut (name, (int) *cp);
 113                 ++cp;
 114             }
 115             vStringTerminate (name);
 116             makeSimpleTag (name, FalconKinds, K_CLASS);
 117             vStringClear (name);
 118         }
 119         else if (strncmp ((const char*) cp, "load", (size_t) 4) == 0)
 120         {
 121             cp += 4;
 122             cp = skipSpace (cp);
 123
 124             while (isIdentifierChar ((int) *cp))
 125             {
 126                 vStringPut (name, (int) *cp);
 127                 ++cp;
 128             }
 129             vStringTerminate (name);
 130             makeSimpleTag (name, FalconKinds, K_NAMESPACE);
 131             vStringClear (name);
 132         }
 133     }
 134     vStringDelete (name);
 135 }
 136
 137 /*
 138  * Parser definition structure
 139  */
 140 extern parserDefinition* FalconParser (void)
 141 {
 142     static const char *const extensions [] = { "fal", "ftd", NULL };
 143     parserDefinition *def = parserNew ("Falcon");
 144     def->kinds      = FalconKinds;
 145     def->kindCount  = KIND_COUNT (FalconKinds);
 146     def->extensions = extensions;
 147     def->parser     = findFalconTags;
 148     return def;
 149 }