/ray/src/lib/sourcepos/sparchive.cc

Go to the documentation of this file.

/*
 * lib/sourcepos/sparchive.cc
 * 
 * Classes for sophisticated source position (file/line/lpos, 
 * include hierarchy) handling. 
 * 
 * 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.
 * 
 */

#include "sparchive.h"
#include "spcache.h"

#include <stdio.h>


_InternalSourceFileNode *SourcePositionArchive::AllocISF(
    const TLString &path,SourceFileNode &parent)
{
    _InternalSourceFileNode *isf=new _InternalSourceFileNode(path,
        &*parent,this);
    
    ++tot_file_nodes;
    ++curr_file_nodes;
    if(max_file_nodes<curr_file_nodes)
    {  max_file_nodes=curr_file_nodes;  }
    
    return(isf);
}

void SourcePositionArchive::DestroyingISF(_InternalSourceFileNode *isf)
{
    // Normally called by _InternalSourceFileNode's destructor. 
    if(!isf)  return;
    
    --curr_file_nodes;
    
    // This may actually not happen as long as we still exist and 
    // need that; this is guaranteed by reference conting. 
    
}


// This will NOT see if we have the required position in the cache. 
// JUST allocate a new one. 
_InternalSourcePosition *SourcePositionArchive::AllocISPNoCache(
    const SourceFileNode &fnode,int line,int lpos)
{
    _InternalSourcePosition *isp=new _InternalSourcePosition(fnode,line,lpos);
    
    ++tot_src_pos;
    ++curr_src_pos;
    if(max_src_pos<curr_src_pos)
    {  max_src_pos=curr_src_pos;  }
    
    return(isp);
}

void SourcePositionArchive::DestroyingISP(_InternalSourcePosition *isp)
{
    // Normally called by _InternalSourcePosition's destructor. 
    if(!isp)  return;
    
    --curr_src_pos;
}


SourceFileNode SourcePositionArchive::IncludeFile(const TLString &file,
    int line,int lpos,
    filepos_t include_stmt_pos,size_t include_stmt_len)
{
    Assert(current);
    
    _InternalSourceFileNode *isf=AllocISF(file,/*parent=*/current);
    
    isf->parent_include_line=line;
    isf->parent_include_lpos=lpos;
    isf->include_stmt_pos=include_stmt_pos;
    isf->include_stmt_len=include_stmt_len;
    
    current=SourceFileNode(isf);
    return(current);
}


SourceFileNode SourcePositionArchive::EndFile()
{
    Assert(current);
    
    // Can delete the position cache here because it will no 
    // longer be used. 
    // OTOH, can also keep it because it is small...
    current->_DestroyPosCache();
    
    current=SourceFileNode(current->up);   // ..which may be NULL (primary input EOF)
    return(current);
}


SourcePosition SourcePositionArchive::GetPos(int line,int lpos)
{
    Assert(current);
    
    // Query the cache: 
    if(current->pos_cache)
    {
        SourcePosition sp=current->pos_cache->find(line,lpos);
        if(sp)  return(sp);
    }
    
    // Allocate a new position object: 
    SourcePosition sp((line>=0) ? AllocISPNoCache(current,line,lpos) : NULL);
    
    // Add it to cache: 
    if(current->pos_cache)
    {  current->pos_cache->store(sp);  }
    
    return(sp);
}


// Recursively call _DetachArchive() for all InternalSourceFileNodes. 
void SourcePositionArchive::_RecursiveDetachArchive(
    _InternalSourceFileNode *head)
{
    if(!head)  return;
    
    // Make sure we keep a reference: 
    SourceFileNode tmp(head);
    
    for(_InternalSourceFileNode *_i=head->down.first(); _i; )
    {
        _InternalSourceFileNode *i=_i;
        _i=_i->next;
        
        _RecursiveDetachArchive(i);
    }
    
    head->_DetachArchive();
}

SourcePositionArchive::SourcePositionArchive(const TLString &path) : 
    head(),
    current(head)
{
    tot_file_nodes=0;
    max_file_nodes=0;
    curr_file_nodes=0;
    
    tot_src_pos=0;
    max_src_pos=0;
    curr_src_pos=0;
    
    _InternalSourceFileNode *isf=AllocISF(path,
        /*parent=*/current/*, which is NULL ref*/);
    head=SourceFileNode(isf);
    current=head;
}

SourcePositionArchive::~SourcePositionArchive()
{
    current=SourceFileNode();
    
    // Tell all the SourceFileNodes that the archive no longer exists: 
    _RecursiveDetachArchive(&*head);
    
    // This is debug; should be commented out. 
    fprintf(stderr,"SourcePositionArchive: files: tot=%d, max=%d (%u bytes)\n",
        tot_file_nodes,max_file_nodes,
        max_file_nodes*sizeof(_InternalSourceFileNode));
    fprintf(stderr,"    src pos: tot=%u, max=%u (%u bytes)\n",
        tot_src_pos,max_src_pos,max_src_pos*sizeof(_InternalSourcePosition));
}

---