/ray/src/lib/lex/scannerbase.cc

Go to the documentation of this file.

/*
 * flex/scannerbase.cc
 * 
 * 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.
 * 
 */

// THIS FILE IS SPECIAL!
// It does NOT include any files; it gets included itself into a flex(1) 
// .ll scanner. 

#ifndef FLEX_BOTTOM_PART

#define YY_NO_UNPUT



#define PI_TOK()           do { yyextra->_pi_tok(yyleng);  } while(0)

#define PI_TOKL(l)         do { yyextra->_pi_tok(l);  } while(0)

#define PI_TAB()           do { yyextra->_pi_tab();  } while(0)

#define PI_LINE()          do { yyextra->_pi_line(); } while(0)

#define PI_CHAR(c)         do { yyextra->_pi_char(c); } while(0)

#define PI_STR(str,len)    do { yyextra->_pi_str(str,len); } while(0)

#define PI_START()         do { yyextra->_pi_start(); } while(0)

#define PI_EOF()           do { yyextra->_pi_eof(); } while(0)

#define YY_INPUT(buf,result,max_size) \
    { \
        _InternalFlexScannerBase::LexerInput *inp= \
            (_InternalFlexScannerBase::LexerInput*)yyin;  \
        ssize_t res=inp->read(buf,max_size); \
        if(res<0)  /* fatal error */  \
        {  abort();  }  \
        result=res;  \
    }

/* This macro is needed to set the yyscanner pointer used by the 
 * access macros like yyextra, yyin, etc. */
#define YY_SCANNER_MAGIC \
    yyscan_t yyscanner=scanner; \
    /* Special hack because the macros yyextra, etc. need yyg... (flex-2.5.31) */ \
    struct yyguts_t *yyg = (struct yyguts_t*)yyscanner;


#else  /* defined(FLEX_BOTTOM_PART) */


int PREFIX_FlexScannerBase::_lex(void *scanner)
{
    return(PREFIX_lex(scanner));
}

int PREFIX_FlexScannerBase::_lex_init(void **scanner_p)
{
    int rv=PREFIX_lex_init(scanner_p);
    if(!rv)
    {  PREFIX_set_extra(this,scanner);  }
    return(rv);
}

void PREFIX_FlexScannerBase::_lex_destroy(void *scanner)
{
    PREFIX_lex_destroy(scanner);
}


int PREFIX_FlexScannerBase::_wrap()
{
    Assert(magic==MyMagic);
    Assert(scanner);  /* Otherwise we may not be here. */
    
    YY_SCANNER_MAGIC
    
    // See if we are currently reading a buffer 
    // (i.e. there is one on the stack): 
    if(YY_CURRENT_BUFFER==NULL)
    {  Assert(!top_inp);  return(1);  }
    
    //fprintf(stderr,"YYWRAP %s --> ",
    //  yyin ? ((LexerInput*)yyin)->fp_path.str() : "NULL");
    
    // Close input file if needed: 
    bool must_pop_state=0;
    if(yyin)
    {
        LexerInput *inp=(LexerInput*)yyin;
        Assert(top_inp==inp);
        Assert(read_inp!=inp);
        
        must_pop_state=inp->must_pop_state;
        if(inp->must_pop_pos_arch)
        {
            Assert(pos_arch);
            pos_arch->EndFile();
        }
        
        // Must save the previous tokens which may not (yet) be deleted: 
        for(TokenEntry *_i=inp->prev_toks.first(); _i; )
        {
            TokenEntry *i=_i;
            _i=_i->next;
            
            if(!i->MayBeCleared())
            {
                zombie_list.append(inp->prev_toks.dequeue(i));
                ++zombie_list_nents;
            }
        }
        _TidyUpZombieList();  /* inline check */
        
        // We want <=old_toks_wanted in prev_toks, allow 1 more here. 
        if(inp->prev_toks.count()>cfg.old_toks_wanted+1)
        {  Error("OOPS: ~TokenInput: %d tokens left in prev_toks.",
            inp->prev_toks.count());  }
        
        delete inp;
        yyin=NULL;
        top_inp=NULL;
    }
    else Assert(top_inp==NULL);
    
    // Delete the current buffer. yypop_buffer_state() 
    // internally calls yy_delete_buffer(). 
    PREFIX_pop_buffer_state(scanner);
    --file_depth;
    //_lex_delete_buffer(buf,scanner);
    
    int retval;
    if(YY_CURRENT_BUFFER==NULL)
    {
        // Cannot read on; we're at EOF. 
        Assert(yyin==NULL);
        Assert(!file_depth);
        retval=1;
        //fprintf(stderr,"EOF\n");
    }
    else
    {
        // We'll read on... 
        Assert(yyin!=NULL);
        Assert(file_depth>0);
        top_inp=(LexerInput*)yyin;
        
        // Restore position: 
        p1=top_inp->saved;
        
        /* Pop state if needed: */
        if(must_pop_state)
        {  yy_pop_state(scanner);  }
        
        retval=0;
        //fprintf(stderr,"%s  [pos=%d:%d]\n",top_inp->fp_path.str(),
        //  p1.line,p1.lpos);*/
    }
    
    return(retval);
}


int PREFIX_FlexScannerBase::_SetInputBH(LexerInput *inp,bool included,
    XYPos alt_pos,SourcePositionArchive *alt_pos_arch)
{
    bool need_push=included;
    
    // See if we really need to push: 
    YY_SCANNER_MAGIC
    if(YY_CURRENT_BUFFER==NULL)
    {  need_push=0;  }
    
    // Set the input: 
    size_t needlen=YY_BUF_SIZE;
    // Notice that I pass the LexerInput instead of the FILE. 
    YY_BUFFER_STATE buf=PREFIX_create_buffer((FILE*)inp,needlen,scanner);
    if(!buf)  _AllocFailure(needlen);
    
    // Save the current position (in old top_inp): 
    if(top_inp)
    {  top_inp->saved=p1;  }
    
    // Read on in passed LexerInput: 
    p0=alt_pos;
    p1=alt_pos;
    if(need_push)
    {
        Assert(pos_arch);
        Assert(!alt_pos_arch);  // Checks above should return error in 
                                   // that case.
        PREFIX_push_buffer_state(buf,scanner);
        ++file_depth;
    }
    else
    {
        Assert(!pos_arch);
        
        const TLString &file_name=inp->fp_path;
        
        if(alt_pos_arch)
        {
            pos_arch=alt_pos_arch;
            pos_arch_allocated=0;
            // Check that the passed source pos archive contains 
            // the correct file. 
            if(pos_arch->CurrentFile()->path()!=file_name)
            {  Assert(0);  }
        }
        else
        {
            //fprintf(stderr,"SPA: %s\n",file_name.str());
            pos_arch=new SourcePositionArchive(file_name);
            pos_arch_allocated=1;
        }
        
        PREFIX_switch_to_buffer(buf,scanner);
        //PREFIX_push_buffer_state(buf,scanner);
        Assert(file_depth==0);
        file_depth=1;
    }
    
    //fprintf(stderr,"SetInput(%s,%s)\n",inp->fp_path.str(),
    //  need_push ? "push" : "switch");
    
    return(0);
}


PREFIX_FlexScannerBase::PREFIX_FlexScannerBase() : 
    _InternalFlexScannerBase()
{
    // Need to be called here due to virtual functions back here. 
    _InternalFlexScannerBase::_reset(/*no_virtuals=*/1);  // <-- CORRECT!
}

PREFIX_FlexScannerBase::~PREFIX_FlexScannerBase()
{
    // Need to be called here due to virtual functions back here. 
    _InternalFlexScannerBase::_reset(/*no_virtuals=*/1);  // <-- CORRECT!
}

#endif  /* FLEX_BOTTOM_PART */

---