lex.h

Go to the documentation of this file.

// ============================================================================
// Project:     Deductive Database
// Filename:    lex.h
// Purpose:     Lexical Scanner
// Last Change: 04.08.2017
// Language:    C++
// EMail:       brass@informatik.uni-halle.de
// WWW:         http://www.informatik.uni-halle.de/~brass/
// Address:     Feldschloesschen 15, D-06120 Halle (Saale), GERMANY
// Copyright:   (c) 1997-2017 by Stefan Brass
// License:     See file "LICENSE" for copying conditions.
// Note:        There is no warranty at all - this code may contain bugs.
// ============================================================================


//=============================================================================
// Include File Frame:
//=============================================================================

#ifndef LEX_INCLUDED
#define LEX_INCLUDED

//=============================================================================
// Used Types and Macros:
//=============================================================================

#ifndef VER_INCLUDED
#include "../base/ver.h"
#endif

#ifndef STR_INCLUDED
#include "../base/str.h"
#endif

#ifndef CHECK_INCLUDED
#include "../base/check.h"
#endif

#ifndef IN_INCLUDED
#include "../input/in.h"
#endif

#ifndef TOK_INCLUDED
#include "tok.h"
#endif

#ifndef SYN_INCLUDED
#include "syn.h"
#endif

//=============================================================================
// Private Constants:
//=============================================================================

//-----------------------------------------------------------------------------
// LEX_LINESIZE: Maximal number of characters in an input line.
//-----------------------------------------------------------------------------

static const int LEX_LINESIZE   = 4096;

//-----------------------------------------------------------------------------
// LEX_BLOCKSIZE: Number of input characters to read in one chunck.
//-----------------------------------------------------------------------------

static const int LEX_BLOCKSIZE = 8192;

//-----------------------------------------------------------------------------
// LEX_MAX_INT: Maximal positive value for integer tokens.
//-----------------------------------------------------------------------------

static const int LEX_MAX_INT = 65535;

//-----------------------------------------------------------------------------
// LEX_MIN_INT: Maximal negative value for integer tokens.
//-----------------------------------------------------------------------------

static const int LEX_MIN_INT = -65536;
// We assume that LEX_MIN_INT <= -LEX_MAX_INT (as usual).
// -LEX_MAX_INT must still be an int value,
// or there will be overflows.
// In addition, the code will wrongly declare an out-of-range integer
// if LEX_MIN_INT <= -LEX_MAX_INT does not hold.

//-----------------------------------------------------------------------------
// Magic: Magic number (identifies objects of this class for debugging).
//-----------------------------------------------------------------------------

static const long LEX_MAGIC = 0x4C45580AL;      // 'LEX\n'

//=============================================================================
// Class for Currently Scanned File:
//=============================================================================

class lex_c {
        public:

//-----------------------------------------------------------------------------
// Methods:
//-----------------------------------------------------------------------------

        // Constructor:
        lex_c(in_c* input);

        // Destructor:
        ~lex_c(void);

        // tok_type: Get type of current token.
        inline tok_t tok_type() const
                { CHECK_VALID("lex_c::tok_type");
                  return(TokType); }

        // tok_ptr: Get pointer to start of token.
        inline str_t tok_ptr() const
                { CHECK_VALID("lex_c::tok_ptr");
                  return(TokPtr); }

        // tok_end: Get pointer to current character (just after token).
        inline str_t tok_end() const
                { CHECK_VALID("lex_c::tok_end");
                  return(TokEnd); }

        // tok_int: Integer value of current token (must be TOK_INT).
        inline int tok_int() const
                { CHECK_VALID("lex_c::tok_int");
                  CHECK(TokType == TOK_INT,
                        "lex_c::tok_int: Current token is no integer");
                  return(TokInt); }

        // next: Read next token.
        void    next(void);

        // filename: Return the current filename.
        inline str_t filename() const
                { CHECK_VALID("lex_c::filename");
                  return(Input->filename()); }

        // line_no: Return the current line number.
        inline int line_no() const
                { CHECK_VALID("lex_c::line_no");
                  return(LineNo); }

        // show_err: Show error for the current token in the current line.
        void    show_err(syn_t syn) const;

//-----------------------------------------------------------------------------
// Debugging Support:
//-----------------------------------------------------------------------------

#if     VER_DEBUG
        // Integrity check:
        public:
        str_t   check() const;

        // Magic number (identifies objects of this class for debugging).
        private:
        long    Magic;          // Must be "LEX_MAGIC".
#endif

//-----------------------------------------------------------------------------
// Copy-constructor and assignment operator are not supported for this class:
//-----------------------------------------------------------------------------

        private:

        lex_c(const lex_c& lex);                // Not implemented
        lex_c& operator=(const lex_c& lex);     // Not implemented


//-----------------------------------------------------------------------------
// Private Class Members:
//-----------------------------------------------------------------------------

        private:

        // Input: The input stream for this file.
        in_t    Input;

        // Eof: Was the end of file reached?
        bool    Eof;

        // Buf: Input buffer.
        char    Buf[LEX_LINESIZE+LEX_BLOCKSIZE];

        // Bytes: Number of Bytes in Buffer.
        int     Bytes;

        // LineNo: Current line number.
        int     LineNo;

        // LinePtr: Begin of current line in buffer.
        char    *LinePtr;

        // LineEnd: End of current line in buffer (points to '\n').
        char    *LineEnd;

        // TokType: Type of current token.
        tok_t   TokType;

        // TokPtr: Begin of current token in buffer.
        char    *TokPtr;

        // TokEnd: End of current token in buffer
        //         (points to next char after token).
        char    *TokEnd;

        // TokInt: Integer value of the current token.
        int     TokInt;

//-----------------------------------------------------------------------------
// Auxillary Functions:
//-----------------------------------------------------------------------------

        private:

        // getline: Set LinePtr and LineEnd on the next line,
        //          fill buffer if necessary:
        void    getline();

        // scan_int: Convert current token into integer.
        bool scan_int(register str_t p, register str_t end_p, int *value);

//=============================================================================
// End of Class:
//=============================================================================

};

//-----------------------------------------------------------------------------
// Define pointer type:
//-----------------------------------------------------------------------------

typedef lex_c *lex_t;

//-----------------------------------------------------------------------------
// Define null pointer:
//-----------------------------------------------------------------------------

#define LEX_NULL (static_cast<lex_t>(0))

//=============================================================================
// End of Include File:
//=============================================================================

#endif