src/apc/lexer.c

   1 /*!@file
   2   \brief   lexical analyzer implementation for APC
   3   \details The lexer manages two FIFO stacks.  One for maintaining tokens, the
   4            other for maintaining a list of files to be scanned.  During
   5            execution, the lexer will return a token from its token queue if any
   6            are present.  If not, the lexer will will pop an element from its
   7            file queue to 'scanner' to be tokenized.  If the file queue is empty,
   8            the lexer will instead call 'parsedir' to traverse the directory tree
   9            and tokenize the results.  If 'parsedir' does not generate any new
  10            tokens, we are done.
  11   \author  Jordan Lavatai
  12   \date    Aug 2016
  13   ----------------------------------------------------------------------------*/
  14 /* Standard */
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include <errno.h>
  18 /* Posix */
  19 #include <unistd.h>
  20 #include <stdlib.h>
  21 #include <limits.h> //realpath, NAME_MAX, PATH_MAX
  22 #include <dirent.h>
  23 /* Local */
  24 #include "parser.tab.h"
  25 #ifndef DE_STACKSIZE
  26 #define DE_STACKSIZE 1024
  27 #endif
  28 #ifndef TK_STACKSIZE
  29 #define TK_STACKSIZE 1024
  30 #endif
  31 /* Public */
  32 int         lexer_init(void);
  33 int         lexer(void);
  34 int         lexer_lexfile(const char*);
  35 void        lexer_pushtok(int, YYSTYPE);
  36 char const* lexer_get_current_filepath(void);
  37 struct dirent* lexer_direntpa[DE_STACKSIZE],** lexer_direntpp,** lexer_direntpb;
  38 /* Private */
  39 extern //lexer_lex.rl
  40 int         lexer_lex(const char*);
  41 extern //scanner.c
  42 int         scanner_init(void);
  43 extern //scanner.c
  44 int         scanner(void);
  45 static inline
  46 int         dredge_current_depth(void);
  47 extern //bison
  48 YYSTYPE     yylval;
  49 static
  50 FILE*       current_open_file;
  51 static
  52 char const* current_filename;
  53 static
  54 struct tok
  55 { YYSTYPE lval;  //token val
  56   int     tok_t; //token type
  57 } token_stack[TK_STACKSIZE], *tsp, *tsx;
  58
  59 /* Directory Entity Array/Stack
  60    Simple array for keeping track of dirents yet to be processed by the scanner.
  61    If this list is empty and there are no tokens, the lexer is done.
  62    This array is populated by the scanner as an array, and popped locally by the
  63    lexer as a stack, and is popped as a FIFO stack.
  64 */
  65 #define DE_STACK    (lexer_direntpa)
  66 #define DE_STACKP   (lexer_direntpp)
  67 #define DE_STACKB   (lexer_direntpb)
  68 #define DE_LEN()    (DE_STACKP - DE_STACKB)
  69 #define DE_INIT()   (DE_STACKP = DE_STACKB = DE_STACK)
  70 #define DE_POP()    (*DE_STACKB++)
  71
  72 /* Token Stack
  73    This is a FIFO stack whose pointers are a union of either a pointer to an
  74    integer, or a pointer to two integers (a struct tok).  This way, integers may
  75    be added or removed from the stack either singularly (IPUSH/IPOP), or as a
  76    full token of two integers (PUSH/POP).
  77    An alignment error will occur if IPOP or IPUSH are used a non-even number of
  78    times in a sequence!
  79 */
  80 #define TK_STACK     (token_stack)
  81 #define TK_STACKP    (tsp)
  82 #define TK_STACKX    (tsx)
  83 #define TK_LEN()     (TK_STACKX - TK_STACKP)
  84 #define TK_INIT()    (TK_STACKP = TK_STACKX = TK_STACK)
  85 #define TK_POP()     (*TK_STACKP++)
  86 #define TK_PUSH(T,L) (*TK_STACKX++ = (struct tok){L,T})
  87
  88 /* Initializer
  89    The initializer returns boolean true if an error occurs, which may be handled
  90    with standard errno.
  91 */
  92 int lexer_init
  93 ()
  94 { TK_INIT();
  95   DE_INIT();
  96   current_open_file = NULL;
  97   current_filename  = NULL;
  98   return scanner_init();
  99 }
 100
 101 /* Lexer
 102    If the token buffer is empty, 'lexer' will initialize the token buffer and
 103    call 'lexer_scandir'.  If SCAN_ERROR is returned, an error is printed
 104    before sending a null return to bison.  If 0 tokens are generated, the error
 105    printing is skipped.  In all other cases, 'yylval' is set, and the token's
 106    integer representation is returned.
 107 */
 108 int lexer
 109 #define $($)#$
 110 #define SCAN_ERROR -1
 111 #define TK_EMPTY   (TK_STACKP == TK_STACKX)
 112 #define FAIL(...)                               \
 113   do {                                          \
 114     fprintf(stderr,__VA_ARGS__);                \
 115     goto done;                                  \
 116   } while (0)
 117 ()
 118 { struct tok token;
 119  start:
 120   while (DE_LEN() > 0)    //lex any directory entries in our stack
 121     if (lexer_lexfile(DE_POP()->d_name) == 0)
 122       FAIL("Lexer failed to tokenize [%s]\n",(*DE_STACKB)->d_name);
 123   if (TK_EMPTY)           //if there are no tokens,
 124     { TK_INIT();            //initialize the token stack back to 0
 125       switch (scanner())
 126         { case SCAN_ERROR:    //if an error occurred,
 127             FAIL("Scanner error\n");
 128           case 0:             //if the the scanner finds no dirents,
 129             goto done;        //then we are done
 130           default:            //if we found some elements to scan,
 131             goto start;       //start over and lex them
 132         }
 133     }
 134   token = TK_POP();
 135   yylval = token.lval;
 136   return token.tok_t;
 137  done:
 138   yylval.val = 0;
 139   return 0;
 140 }
 141
 142
 143 /* Token Receiver
 144    This receiver takes a struct tok and pushes it to the FIFO stack.
 145 */
 146 void lexer_pushtok
 147 #define $($)#$ //stringifier
 148 #define ERR_TK "Fatal: Generated over " $(TK_STACKSIZE) " tokens in one pass."
 149 ( int tok, YYSTYPE lval )
 150 { if (TK_LEN() >= TK_STACKSIZE)
 151     { fprintf(stderr, ERR_TK);
 152       exit(EXIT_FAILURE);
 153     }
 154   TK_PUSH(tok, lval);
 155 }
 156
 157 /* Lexical analysis of a file
 158    Strips a filename to its base name, then sends it to lexer_lex
 159 */
 160 int lexer_lexfile
 161 #define HIDDEN_WARNING "%s is hidden and will not be parsed!\n", filename
 162 ( const char  *filename
 163 )
 164 { static char fname[NAME_MAX];
 165   char        *last_period = NULL, *iter;
 166
 167   if (*filename == '.')
 168     { fprintf (stderr, HIDDEN_WARNING);
 169       return 0;
 170     }
 171   /* Copy the filename and remove its suffix */
 172   strncpy(fname,filename,NAME_MAX);
 173   last_period = NULL;
 174   for (iter = fname; *iter; iter++)  //find the last '.' char
 175     if (*iter == '.')
 176       last_period = iter;
 177   if (last_period)                   //if we found one,
 178     *last_period = '\0';             //truncate the string there
 179   /* Register the current_filename */
 180   current_filename = filename;
 181
 182   return lexer_lex(fname);
 183 }
 184
 185 char const* lexer_get_current_filepath
 186 ()
 187 { static char        current_path[PATH_MAX];
 188   static char const* last_filename;
 189   if ((!last_filename || last_filename != current_filename) &&
 190       (realpath(current_filename, current_path) != current_path))
 191     { perror("realpath: ");
 192       return NULL;
 193     }
 194   return (const char*)current_path;
 195 }