parser_common.h

Go to the documentation of this file.

#ifndef VOLK_PARSER_COMMON_H
#define VOLK_PARSER_COMMON_H
 
#include "volksdata/codec_interface.h"
 

#define YYCTYPE     uint8_t
#define YYCURSOR    it->cur
#define YYMARKER    it->mar
#define YYLIMIT     it->lim
#define YYFILL      fill(it) == 0
 
 
typedef struct parse_it_t {
    FILE          * fh;         
    const char    * sh;         
    size_t          buf_size;   
    YYCTYPE       * buf,        
                  * lim,        
                  * cur,        
                  * mar,        
                  * tok,        
                  * bol;        
    unsigned        line;       
    unsigned        ct;         
    bool            eof;        
} ParseIterator;
 
 
static int fill(ParseIterator *it);
 

static void parse_init (ParseIterator *it, FILE *fh, const char *sh)
{
    if(fh) {
        // Stream handling. It engages YYFILL and reads by chunks.
        it->fh = fh;
        it->sh = NULL;
        it->buf_size = CHUNK_SIZE;
        it->buf = malloc(it->buf_size);
        if (!it->buf) log_error ("Error allocating lexer buffer.");
        it->cur = it->mar = it->tok = it->lim = it->buf + it->buf_size - 1;
        it->bol = it->buf;
        it->eof = false;
        it->lim[0] = 0;
    } else {
        // String handling. Uses the provided string as the buffer.
        it->fh = NULL;
        it->sh = sh;
        it->buf_size = strlen(sh) + 1;
        it->buf = NULL;
        it->cur = it->tok = (YYCTYPE*)it->sh;
        it->lim = it->mar = it->cur + it->buf_size - 1;
        it->bol = it->cur;
        it->eof = true;
    }
    it->line = 1;
    it->ct = 0;
}
 
 
int
fill(ParseIterator *it)
{
    log_debug ("Filling codec buffer @ %p.", it->buf);
    if (it->eof) return 1;
 
    size_t shift = it->tok - it->buf;
    size_t used = it->lim - it->tok;
 
    // If buffer is too small for the lexeme, double the capacity.
    if (shift < 1) {
        shift += it->buf_size;
        it->buf_size *= 2;
        // Store offsets to reapply to moved buffer.
        size_t
            cur_off = it->cur - it->buf,
            tok_off = it->tok - it->buf,
            lim_off = it->lim - it->buf,
            mar_off = it->mar - it->buf;
 
        log_debug ("Reallocating buffer to %zu bytes.", it->buf_size);
        YYCTYPE *tmp = realloc (it->buf, it->buf_size);
        if (!tmp) {
            log_error ("Memory allocation error.");
            return -1;
        }
        it->buf = tmp;
        // Move all relative points if address changed.
        it->cur = it->buf + cur_off;
        it->tok = it->buf + tok_off;
        it->lim = it->buf + lim_off;
        it->mar = it->buf + mar_off;
    } else {
        log_debug ("Shifting bytes: %zu", shift);
        memmove (it->buf, it->tok, used);
        log_trace ("Limit offset before reading data: %zu", it->lim - it->tok);
        it->lim -= shift;
        it->cur -= shift;
        it->mar -= shift;
        it->tok -= shift;
    }
    it->lim += fread (it->lim, 1, it->buf_size - used - 1, it->fh);
    log_trace ("Cursor offset from last token: %zu", it->cur - it->tok);
    log_trace ("Limit offset from last token: %zu", it->lim - it->tok);
    it->lim[0] = 0;
    it->eof = it->lim < it->buf + it->buf_size - 1;
    return 0;
}
 
 
#endif // VOLK_PARSER_COMMON_H