/*!@file
  \brief   lexical analyzer implementation for APC
  \details The lexer manages two FIFO stacks.  One for maintaining tokens, the
           other for maintaining a list of files to be scanned.  During
           execution, the lexer will return a token from its token queue if any
           are present.  If not, the lexer will will pop an element from its
           file queue to 'scanner' to be tokenized.  If the file queue is empty,
           the lexer will instead call 'parsedir' to traverse the directory tree
           and tokenize the results.  If 'parsedir' does not generate any new
           tokens, we are done.
  \author  Jordan Lavatai
  \date    Aug 2016
  ----------------------------------------------------------------------------*/
/* Standard */
#include <stdio.h>
#include <string.h>
#include <errno.h>
/* Posix */
#include <unistd.h>
#include <stdlib.h>
#include <dirent.h>
/* Local */
//#include "parser.tab.h"
#ifndef DP_STACKSIZE
#define DP_STACKSIZE 1024
#endif
#ifndef TK_STACKSIZE
#define TK_STACKSIZE 1024
#endif
/* Public */
struct tok
{ int lval;
  int tok;
};
int            lexer_init(void);
int            lexer(void);
inline
void           lexer_pushtok(int int);
struct dirent* lexer_direntpa[DP_STACKSIZE];
/* Private */
static inline
int scan(void);
static inline
int dredge_current_depth(void);
static
struct dirent** dps;
static
struct tok token_stack[TK_STACKSIZE];
static
union tokp
{ int*        i;
  struct tok* t;
} tks, tkx;

/* Directory Entity Array/Stack
   Simple array for keeping track of dirents yet to be processed by the scanner.
   If this list is empty and there are no tokens, the lexer is done.
*/
#define DP_STACK    (lexer_direntpa)
#define DP_STACKP   (dps)
#define DP_LEN()    (DP_STACKP - DP_STACK)
#define DP_INIT()   (DP_STACKP = DP_STACK)
#define DP_POP()    (*--DP_STACKP)

/* Token Stack
   This is a FIFO stack whose pointers are a union of either a pointer to an
   integer, or a pointer to two integers (a struct tok).  This way, integers may
   be added or removed from the stack either singularly (IPUSH/IPOP), or as a
   full token of two integers (PUSH/POP).
   An alignment error will occur if IPOP or IPUSH are used a non-even number of
   times in a sequence!
*/
#define TK_STACK          (token_stack)
#define TK_STACKP   (tks.t)
#define TK_STACKPI  (tks.i)
#define TK_STACKX   (tkx.t)
#define TK_STACKXI  (tkx.i)
#define TK_LEN()    (TK_STACKP - TK_STACKX)
#define TK_INIT()   (TK_STACKP = TK_STACKX = TK_STACK)
#define TK_POP()    (*TK_STACKP++)
#define TK_POPI()   (*TK_STACKPI++);
#define TK_PUSH(T)  (*TKSTACKX++ = T)
#define TK_PUSHI(I) (*TKSTACKXI++ = (I))

extern //main.c
const char* cargs['Z'];

extern //scanner.c
int scanner_init(void);
extern //scanner.c
int scanner(struct dirent**);

/* Initializer
   The initializer returns boolean true if an error occurs, which may be handled   with standard errno.
*/
int lexer_init
()
{ TK_INIT();
  DP_INIT();
  return scanner_init();
}

/* Lexer
   If the token buffer is empty, 'lexer' will initialize the token buffer and
   call 'lexer_scandir'.  If #SCANDIR_ERROR is returned, an error is printed
   before sending a null return to bison.  If 0 tokens are generated, the error
   printing is skipped.  In all other cases, 'yylval' is set, and the token's
   integer representation is returned.
*/
int lexer
#define SCAN_ERROR -1
#define TK_EMPTY   (TK_STACKP == TK_STACKX)
()
{ if (TK_EMPTY)
    { switch (parsedir())
        { case SCAN_ERROR:
            perror("lexer_scan");
          case 0:
            yylval = 0;
            return 0;
          default:
            break;
        }
    }
  yylval = TK_IPOP();
  return TK_IPOP();
}

/* Token Receiver
   This receiver takes a struct tok and pushes it to the FIFO stack.
*/
inline
void lexer_pushtok
#define ERR_TK "Fatal: Generated over " S(TK_STACKSIZE) " tokens in one pass."
( struct tok token )
{ if (TK_LEN >= TK_STACKSIZE)
    { fprintf(stderr, ERR_TK);
      exit(EXIT_FAILURE);
    }
  TK_PUSH(token);
}

/* Lexical Analysis
   Ragel state machine for tokenizing text.
 */
void lexer_lex
(const char* str)
{ struct tok token;
  token.TOK = 1;
  token.LVAL = 2;
  lexer_pushtok(token);
  printf (str);
}

/*  init_file:
    if (lsp != NULL)
    while ((c = *lsp++) == *csp)
    { switch (c)
    { case DELIM:
    delimeters_skipped++;
    default:
    csp++; //delayed to ensure csp is the start of scannable text
    break;
    }
    }
    last_string = string;
    scan_text:
    return scanner_tokenize(csp);
*/