/ray/src/lib/lex/scannerbase.h

Go to the documentation of this file.

/*
 * lib/lex/scannerbase.h
 * 
 * Base class for flex-based scanners. 
 * 
 * Copyright (c) 2003--2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifndef _LIB_LEX_FLEXSCANNERBASE_H_
#define _LIB_LEX_FLEXSCANNERBASE_H_ 1

// NOTE!!! This file is under the spell of the PREFIX_FlexScannerBase define 
//         and is NOT meant to include any other file. 

class _InternalFlexScannerBase  // Not "C++-safe". 
{
    public:
        struct Config
        {
            bool loc_use_lpos;
            
            int tab_width;
            
            int max_file_depth;
            
            int ahead_toks_wanted;
            int old_toks_wanted;
            
            Config();
            inline ~Config() {}
        };
        
        struct XYPos
        {
            int line;   
            int lpos;   
            
            inline XYPos(int l,int p) : line(l),lpos(p) {}
            inline ~XYPos() {}
        };
        
        struct TokenEntry : LinkedListBase<TokenEntry>
        {
            int token;              
            SCLocationRange lloc;   
            
            virtual bool MayBeCleared() const;
            
            virtual void clear(bool force=0);
            
            inline TokenEntry() : LinkedListBase<TokenEntry>(),
                token(-1),lloc() {}
            virtual ~TokenEntry()
                {  TokenEntry::clear();  /* non-virtual version */ }
            
            private:
                TokenEntry(const TokenEntry &);
                void operator=(const TokenEntry &);
        };
        
        struct LexerInput
        {
            LexerInput *down;
            
FILE *fp; // FIXME: stream!
TLString fp_path;  // Stored path name for error diagnostics. 
            
            XYPos saved;
            
            bool must_pop_state;
            bool must_pop_pos_arch;
            
            bool read_eof;
            
            int special_next_tok;
            
            LinkedList<TokenEntry> next_toks;  
            LinkedList<TokenEntry> prev_toks;  
            
            private:
                LexerInput(const LexerInput &);
                void operator=(const LexerInput &);
            public:
                LexerInput(LexerInput *down);
                ~LexerInput();
                
                int OpenFile(const TLString &path,SError &error);
                
                ssize_t read(char *buf,size_t len);
        };
        
    protected:
        uint32 magic;
        static const uint32 MyMagic=0xdeadbeefU;
        
        //------
        // (Note that yyscan_t is actually a void *, so we're lucky...)
        void *scanner;
        
        TokenEntry *lex_token;
        
        LexerInput *top_inp;
        LexerInput *read_inp;
        
        int file_depth;
        
        int n_errors;
        
        LinkedList<TokenEntry> zombie_list;
        int zombie_list_nents;
        static const int zombie_list_threash=256;
        
        void __TidyUpZombieList(bool force);
        int last_zombie_list_nents;  

        inline void _TidyUpZombieList(bool force=0)
        {
            if(force || 
                zombie_list_nents>=last_zombie_list_nents+zombie_list_threash)
            {  __TidyUpZombieList(force);  }
        }
        
        XYPos p0;
        XYPos p1;
        
        SourcePositionArchive *pos_arch;
        
        bool pos_arch_allocated;
        
        Config cfg;
        
        //---------------------------------------------------------------------
        // Interface to the flex lexer routine to update position info. 
        inline void _pi_tok(size_t l)
            {  p1.lpos+=l;   }
        inline void _pi_tab()
            {  p1.lpos=(p1.lpos/cfg.tab_width+1)*cfg.tab_width;  }
        inline void _pi_line()
            {  ++p1.line;  p1.lpos=0;  }
        void _pi_char(char c);
        void _pi_str(const char *str,size_t len);
        inline void _pi_start()
            {  p0=p1;  /* C++ assignment */ }
        void _pi_eof();
        inline TokenEntry *_tok_ptr()
            {  return(lex_token);  }
        
    protected:
        SCLocation _MakeCurrLoc() const;
        SCLocation _MakeCurrEndLoc() const;
        SCLocationRange _MakeCurrLocRange() const;
        
        //---------------------------------------------------------------------
        // Functions which can be overridden by the derived class. 
        
        virtual TokenEntry *AllocTokenEntry();
        
        virtual void reset();
        
        //---------------------------------------------------------------------
        
        void _RawYYLex(TokenEntry *dest);
        
        void _reset(bool no_virtuals=0);
        
        //---------------------------------------------------------------------
        // These functions must be provided by the derived PREFIX_ class. 
        // They are implemented in the flex-generated scanner. 
        
        virtual int _lex(void *scanner);
        virtual int _lex_init(void **scanner_p);
        virtual void _lex_destroy(void *scanner);
        virtual int _wrap();
        virtual int _SetInputBH(LexerInput *inp,bool included,
            XYPos alt_pos,SourcePositionArchive *alt_pos_arch);
    
    private:
        _InternalFlexScannerBase(const _InternalFlexScannerBase &);
        void operator=(const _InternalFlexScannerBase &);
        
    protected:
        _InternalFlexScannerBase();
    public:
        virtual ~_InternalFlexScannerBase();
        
        int SetInput(const TLString &path,SError &error,bool included,
            int first_token=-1,
            XYPos alt_pos=XYPos(1,0),SourcePositionArchive *alt_pos_arch=NULL);
        
        TokenEntry *LexNextToken();
        
        inline SCLocation CurrLoc() const
            {  return(_MakeCurrLoc());  }
};


#ifdef PREFIX_FlexScannerBase

class PREFIX_FlexScannerBase : public _InternalFlexScannerBase
{
    protected:
        int _lex(void *scanner);
        int _lex_init(void **scanner_p);
        void _lex_destroy(void *scanner);
        int _wrap();
        int _SetInputBH(LexerInput *inp,bool included,
            XYPos alt_pos,SourcePositionArchive *alt_pos_arch);
        
    private:
        PREFIX_FlexScannerBase(const PREFIX_FlexScannerBase &);
        void operator=(const PREFIX_FlexScannerBase &);
    public:
        PREFIX_FlexScannerBase();
        virtual ~PREFIX_FlexScannerBase();
};

#endif  /* PREFIX_FlexScannerBase */

#endif  /* _LIB_LEX_FLEXSCANNERBASE_H_ */

---