/ray/src/vm/input/nspcinfo.cc

Go to the documentation of this file.

/*
 * vm/input/nspcinfo.cc
 * 
 * VM namespace information. 
 * 
 * Copyright (c) 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 "nspcinfo.h"
#include <lib/lex/strtreedump.h>
#include <lib/lex/fastval2str.h>


namespace VM
{

const char *NamespaceInfo::NSType2String(NSType t)
{
    switch(t)
    {
        case NSNamespace:  return("namespace");
        case NSClass:      return("class");
    }
    return("???");
}


const char *NamespaceInfo::SymbolEntryE::ExtID2String(ExtID e)
{
    switch(e)
    {
        case ExtUnknown:   return("[unknown]");
        case ExtFunction:  return("function");
        case ExtVariable:  return("variable");
    }
    return("???");
}


TLString NamespaceInfo::SymbolEntryB::CompleteName() const
{
    TLString tmp;
    
    const SymbolEntryE *see=ep();
    if(see)
    {
        Assert(symref>=0);
        
        if(see->nspc)
        {
            tmp=see->nspc->CompleteName();
            if(see->nspc->parent)
            {  tmp+="::";  }
        }
        else
        {  tmp="???::";  }
        
        tmp+=see->name;
    }
    else
    {
        Assert(symref<0);
        
        char ntmp[sizeof(SymRef)*2+1+1],*e=ntmp;
        *e++='@';
        e=FastInt2String(e,-symref,/*base=*/0);
        *e='\0';
        tmp+=ntmp;
    }
    
    return(tmp);
}


bool NamespaceInfo::SymbolEntryB::CompareTo(const SymbolEntryB &e) const
{
    const SymbolEntryE *seA=ep(),*seB=e.ep();
    if(seA && seB)
    {
        if(seA->extid!=seB->extid)  return(0);
        
        // Both non-internal symbols. 
        switch(seA->extid)
        {
            case SymbolEntryE::ExtUnknown:
                break;
            case SymbolEntryE::ExtFunction:
                if(seA->ftype!=seB->ftype)  return(0);
                break;
            case SymbolEntryE::ExtVariable:
                if(seA->vtype!=seB->vtype)  return(0);
                break;
            default: Assert(0);
        }
        
        // Otherwise (non-internal) the name must be set. 
        Assert(seA->name);
        Assert(seB->name);
        return(seA->name==seB->name);
    }
    
    if(!seA && !seB)
    {
        // For internal symbols, the symrefs must match. 
        return(symref==e.symref);
    }
    
    // Comparing internal with non-internal symbol. 
    return(0);
}


NamespaceInfo::SymbolEntryE &NamespaceInfo::SymbolEntryE::operator=(
    const SymbolEntryE &se)
{
    symref=se.symref;
    
    extid=se.extid;
    ftype=se.ftype;
    vtype=se.vtype;
    name=se.name;
    nspc=se.nspc;
    linked=se.linked;
    
    return(*this);
}


NamespaceInfo::SymbolEntryE::SymbolEntryE(const SymbolEntryE &se) : 
    SymbolEntryB(se),
    extid(se.extid),
    ftype(se.ftype),
    vtype(se.vtype),
    name(se.name),
    nspc(se.nspc),
    linked(se.linked)
{
    // empty
}

NamespaceInfo::SymbolEntryE::SymbolEntryE(NamespaceInfo *_nspc) : 
    SymbolEntryB(),
    extid(ExtUnknown),
    ftype(),
    vtype(),
    name(),
    nspc(_nspc),
    linked(NULL)
{
    // empty
}

//------------------------------------------------------------------------------

void NamespaceInfo::SortNamespaceTree()
{
    // No child? Then nothing to do at all. 
    if(down.IsEmpty()) return;
    
    if(down.first()==down.last())
    {
        // One child. No sorting here, just go on to child. 
        down.first()->SortNamespaceTree();
        return;
    }
    
    /*if(down.first()->next==down.last())
    {
        // 2 children. Sorting is easy. 
        // NOT IMPLEMENTED; using general case below. 
        return;
    }*/
    
    // Several children. Go sorting. 
    down.MergeSort(_Operators());
    
    // Recursively process children: 
    for(NamespaceInfo *i=down.first(); i; i=i->next)
    {  i->SortNamespaceTree();  }
}


TLString NamespaceInfo::CompleteName() const
{
    if(!parent)
    {  return TLString("::");  }
    
    TLString res(name);
    for(const NamespaceInfo *i=parent; i; i=i->parent)
    {
        if(!i->name)  continue;
        res.prepend(i->name+"::");
    }
    
    return(res);
}


void NamespaceInfo::DumpTree(StringTreeDump &dump,bool IDs_resolved,
    bool recurse) const
{
    TLString tmp;
    tmp.sprintf(
        "%s %s\n"
        "  link_info_set=%s, linked=%s, children: %d\n"
        ,parent ? NSType2String(nstype) : "NAMESPACE",
        parent ? name.str() : "ROOT",
        link_info_set ? "yes" : "no",linked ? "yes" : "no",(int)down.count());
    dump+=tmp;
    uint32 scnt=0;
    for(SymbolList::Iterator i(symbol); i; i++,scnt++)
    {
        const SymbolEntryE *se=*i;
        tmp.sprintf(
            "  symbol[%u]={ extid=%s, ftype=%s, vtype=%s, name=%s, "
            "symref=%d }\n",
            (uint)scnt,
            SymbolEntryE::ExtID2String(se->extid),
            se->ftype.TypeString().str(),
            se->vtype.TypeString().str(),
            se->name.str(),
            (int)se->symref);
        dump+=tmp;
        // No internal symbols in this queue. 
        Assert(se->symref>=0 && se->nspc==this);
    }
    tmp.deref();
    
    // Recurse: 
    if(recurse && !down.IsEmpty())
    {
        dump.AddIndent();
        for(NamespaceInfo *i=down.first(); i; i=i->next)
        {  i->DumpTree(dump,IDs_resolved,recurse);  }
        dump.SubIndent();
    }
}


void NamespaceInfo::_AddChild(NamespaceInfo *child)
{
    Assert(!(child->next || down.last()==child));
    
    // Add to the child list: 
    down.append(child);
    
    // Must have a non-NULL name unless it is the root. 
    // Obviously, *child cannot be the root. 
    Assert(child->name);
    
    // Add to the name-to-child map: 
    int _unused_ rv=map_name2child.store(child,/*allow_update=*/0);
    Assert(rv==0);
}

void NamespaceInfo::_DelChild(NamespaceInfo *child)
{
    // Remove from child list: 
    if(child->next || down.last()==child)
    {  down.dequeue(child);  }
    
    // We need the name to remove from the B-tree. . 
    Assert(child->name);
    // Also remove from name-to-child map: 
    int _unused_ rv=map_name2child.remove(child);
    Assert(rv==0);
}


void NamespaceInfo::AddChild(NamespaceInfo *child)
{
    if(!child)  return;  // Important; linker relies on it. 
    
    Assert(!child->parent);
    child->parent=this;
    
    _AddChild(child);
}


NamespaceInfo::NamespaceInfo(const TLString &_name,NamespaceInfo *_parent,
    NSType _nstype) : 
    LinkedListBase<NamespaceInfo>(),
    parent(_parent),
    down(),
    name(_name),
    nstype(_nstype),
    asm_loc(),
    linked(NULL),
    symbol(/*size of chunk*/16,/*old chunks*/1),
    map_name2child(/*m=*/_nstype==NSNamespace ? 16 : 6)
{
    link_info_set=0;
    recursion_flag=0;
    
    // Register at parent. 
    if(parent)
    {  parent->_AddChild(this);  }
}

NamespaceInfo::~NamespaceInfo()
{
    // Delete all children: 
    while(!down.IsEmpty())
    {  delete down.PopFirst();  }
    
    linked=NULL;
    // symbol tidies up itself. 
    
    // Unregister at parent. 
    if(parent)
    {  parent->_DelChild(this);  }
}

}  // end of namespace VM

---