scanner.cc

Go to the documentation of this file.

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <new>

#include "src/codegen/label.h"
#include "src/codegen/output.h"
#include "src/conf/opt.h"
#include "src/globals.h"
#include "src/parse/scanner.h"
#include "src/util/counter.h"

// used by Scanner::fatal_at and Scanner::fatalf
#if defined(_MSC_VER) && !defined(vsnprintf)
#    define vsnprintf _vsnprintf
#endif

namespace re2c {

const uint32_t Scanner::BSIZE = 8192;

ScannerState::ScannerState ()
    : tok (NULL)
    , ptr (NULL)
    , cur (NULL)
    , pos (NULL)
    , ctx (NULL)
    , bot (NULL)
    , lim (NULL)
    , top (NULL)
    , eof (NULL)
    , tchar (0)
    , tline (0)
    , cline (1)
    , in_parse (false)
    , lexer_state (LEX_NORMAL)
{}

ScannerState::ScannerState (const ScannerState & s)
    : tok (s.tok)
    , ptr (s.ptr)
    , cur (s.cur)
    , pos (s.pos)
    , ctx (s.ctx)
    , bot (s.bot)
    , lim (s.lim)
    , top (s.top)
    , eof (s.eof)
    , tchar (s.tchar)
    , tline (s.tline)
    , cline (s.cline)
    , in_parse (s.in_parse)
    , lexer_state (s.lexer_state)
{}

ScannerState & ScannerState::operator = (const ScannerState & s)
{
    this->~ScannerState ();
    new (this) ScannerState (s);
    return * this;
}

Scanner::Scanner (Input & i, OutputFile & o)
    : ScannerState ()
    , in (i)
    , out (o)
{}

void Scanner::fill (uint32_t need)
{
    if(!eof)
    {
        /* Do not get rid of anything when rFlag is active. Otherwise
         * get rid of everything that was already handedout. */
        if (!opts->rFlag)
        {
            const ptrdiff_t diff = tok - bot;
            if (diff > 0)
            {
                const size_t move = static_cast<size_t> (top - tok);
                memmove (bot, tok, move);
                tok -= diff;
                ptr -= diff;
                cur -= diff;
                pos -= diff;
                lim -= diff;
                ctx -= diff;
            }
        }
        /* In crease buffer size. */
        if (BSIZE > need)
        {
            need = BSIZE;
        }
        if (static_cast<uint32_t> (top - lim) < need)
        {
            const size_t copy = static_cast<size_t> (lim - bot);
            char * buf = new char[copy + need];
            if (!buf)
            {
                fatal("Out of memory");
            }
            memcpy (buf, bot, copy);
            tok = &buf[tok - bot];
            ptr = &buf[ptr - bot];
            cur = &buf[cur - bot];
            pos = &buf[pos - bot];
            lim = &buf[lim - bot];
            top = &lim[need];
            ctx = &buf[ctx - bot];
            delete [] bot;
            bot = buf;
        }
        /* Append to buffer. */
        const size_t have = fread (lim, 1, need, in.file);
        if (have != need)
        {
            eof = &lim[have];
            *eof++ = '\0';
        }
        lim += have;
    }
}

void Scanner::set_in_parse(bool new_in_parse)
{
    in_parse = new_in_parse;
}

void Scanner::fatal_at(uint32_t line, ptrdiff_t ofs, const char *msg) const
{
    std::cerr << "re2c: error: "
        << "line " << line << ", column " << (tchar + ofs + 1) << ": "
        << msg << std::endl;
    exit(1);
}

void Scanner::fatal(ptrdiff_t ofs, const char *msg) const
{
    fatal_at(in_parse ? tline : cline, ofs, msg);
}

void Scanner::fatalf_at(uint32_t line, const char* fmt, ...) const
{
    char szBuf[4096];

    va_list args;
    
    va_start(args, fmt);
    vsnprintf(szBuf, sizeof(szBuf), fmt, args);
    va_end(args);
    
    szBuf[sizeof(szBuf)-1] = '0';
    
    fatal_at(line, 0, szBuf);
}

void Scanner::fatalf(const char *fmt, ...) const
{
    char szBuf[4096];

    va_list args;
    
    va_start(args, fmt);
    vsnprintf(szBuf, sizeof(szBuf), fmt, args);
    va_end(args);
    
    szBuf[sizeof(szBuf)-1] = '0';
    
    fatal(szBuf);
}

Scanner::~Scanner()
{
    delete [] bot;
}

void Scanner::reuse()
{
    out.label_counter.reset ();
    last_fill_index = 0;
    bWroteGetState = false;
    bWroteCondCheck = false;
    opts.reset_mapCodeName ();
}

void Scanner::restore_state(const ScannerState& state)
{
    ptrdiff_t diff = bot - state.bot;
    char *old_bot = bot;
    char *old_lim = lim;
    char *old_top = top;
    char *old_eof = eof;
    *(ScannerState*)this = state;
    if (diff)
    {
        tok -= diff;
        ptr -= diff;
        cur -= diff;
        pos -= diff;
        ctx -= diff;        
        bot = old_bot;
        lim = old_lim;
        top = old_top;
        eof = old_eof;
    }
}

} // namespace re2c