/ray/src/vm/input/classinfo.cc

Go to the documentation of this file.

/*
 * vm/input/classinfo.cc
 * 
 * VM class 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 "classinfo.h"
#include <lib/lex/strtreedump.h>
#include <lib/lex/fastval2str.h>


namespace VM
{

TLString ClassInfoIE::CompleteName() const
{
    const ClassInfo *c=ci();
    if(c)
    {  return(c->NamespaceInfo::CompleteName());  }
    
    char tmp[11+1+1],*e=tmp;
    *e++='I';
    e=FastInt2String(e,-class_tid,10);
    *e='\0';
    return(tmp);  // TLString constructor. 
}

ClassInfoIE::ClassInfoIE(const ClassInfoIE &b) : 
    class_tid(b.class_tid)
{
    // Only allowed for internal classes. 
    Assert(class_tid<0);
}

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

TLString ClassInfo::CompleteName() const
{
    return(ClassInfoIE::CompleteName());
}


void ClassInfo::DumpTree(StringTreeDump &dump,bool IDs_resolved,
    bool recurse) const
{
    NamespaceInfo::DumpTree(dump,/*recurse=*/0);
    
    TLString tmp;
    tmp.sprintf(
        "  TypeID=%d, size=%u, nvirtuals=%u\n",
        (int)class_tid,(uint)size,(uint)nvirtuals);
    dump+=tmp;
    for(uint32 i=0; i<base.n(); i++)
    {
        const BaseEntry *e=&base[i];
        if(IDs_resolved)
        {  tmp.sprintf(
            "  base[%u]={ class=%s, off=%d }\n",
            (uint)i,e->ci ? e->ci->CompleteName().str() : "(null)",
            (int)e->off);  }
        else
        {  tmp.sprintf(
            "  base[%u]={ TypeID=%d, off=%d }\n",
            (uint)i,(int)e->tid,(int)e->off);  }
        dump+=tmp;
    }
    for(uint32 i=0; i<membvar.n(); i++)
    {
        const MemberVarEntry *e=&membvar[i];
        tmp.sprintf(
            "  membvar[%u]={ vtype=%s, off=%d, name=%s }\n",
            (uint)i,e->vtype.TypeString().str(),(int)e->off,
            e->name ? e->name.str() : "(null)");
        dump+=tmp;
    }
    for(uint32 i=0; i<vtable.n(); i++)
    {
        const VTableEntry *e=&vtable[i];
        if(IDs_resolved)
        {  tmp.sprintf(
            "  vtable[%u]={ se=%s }\n",
            (uint)i,(e->se ? e->se->CompleteName().str() : "(null)"));  }
        else
        {  tmp.sprintf(
            "  vtable[%u]={ symref=%d }\n",
            (uint)i,(int)e->symref);  }
        dump+=tmp;
    }
    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();
    }
}


ClassInfo::ClassInfo(const TLString &name,TypeID _class_tid,
    NamespaceInfo *parent) : 
    NamespaceInfo(name,parent,NSClass),
    ClassInfoIE(_class_tid),
    base(),
    vtable(),
    membvar()
{
    size=0;
    nvirtuals=0;
    
    need_construct=0;
    need_cast=0;
}

ClassInfo::~ClassInfo()
{
    // base, vtable, membvar tidy up themselves. 
}

}  // end of namespace VM

---