/ray/src/vm/input/nspcinfo.h

Go to the documentation of this file.

/*
 * vm/input/nspcinfo.h
 * 
 * VM namespace information node. 
 * 
 * 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.
 * 
 */

#ifndef _VM_INPUT_NSPCINFO_H_
#define _VM_INPUT_NSPCINFO_H_ 1

#include <vm/vmconfig.h>    /* MUST be first */
#include <vm/vartype.h>
#include <vm/functype.h>
#include <lib/tl/tlstring.h>
#include <lib/tl/linkedlist.h>
#include <lib/tl/tllinearqueue.h>
#include <lib/tl/tlbtree.h>
#include <vm/nrarray.h>
#include <lib/lex/location.h>


// See lib/lex/strtreedump.h. 
class StringTreeDump;

namespace VM
{

class NamespaceInfo : public LinkedListBase<NamespaceInfo>
{
    // Friends used for parsing. 
    friend class AssemblerFile;
    friend class AssemblerFile_Plaintext;
    // Friend for linking. 
    friend class VMLinker;
    
    public:
        template<typename T>struct PtrListOperators : 
            TLDefaultOperators_Construct_PDT<T*>,
            TLDefaultOperators_Allocation
        {
            static const bool pdt=1;
            
            static inline bool lt(T const *a,T const *b)
                {  return(a->name<b->name);   }
            static inline bool gt(T const *a,T const *b)
                {  return(a->name>b->name);   }
            
            static inline bool le(T const *a,T const *b)
                {  return(a==b || a->name<=b->name);  }
            static inline bool eq(T const *a,T const *b)
                {  return(a==b || a->name==b->name);  }
            
            static inline bool lt(T const *a,TLString const &b)
                {  return(a->name<b);   }
            static inline bool gt(T const *a,TLString const &b)
                {  return(a->name>b);   }
            static inline bool eq(T const *a,TLString const &b)
                {  return(a->name==b);  }
            
            template<typename I>static inline T* &idx(
                T **array,I i)
                {  return(array[i]);  }
        };
        
    public:
        enum NSType
        {
            NSNamespace,
            NSClass
        };
        
        static const char *NSType2String(NSType t);
        
        // See below. 
        struct SymbolEntryE;
        
        struct SymbolEntryB
        {
            SymRef symref;
            
            inline SymbolEntryB() : symref(0) {}
            inline ~SymbolEntryB() {}
            

            inline SymbolEntryE *ep();
            inline const SymbolEntryE *ep() const;
            
            TLString CompleteName() const;
            
            bool CompareTo(const SymbolEntryB &e) const;
            
            public:
                inline SymbolEntryB(const SymbolEntryB &b) : symref(b.symref) {}
            private:
                void operator=(const SymbolEntryB &);
        };
        struct SymbolEntryE : SymbolEntryB
        {
            enum ExtID
            {
                ExtUnknown=0,   
                ExtFunction,    
                ExtVariable,    
            };
            
            static const char *ExtID2String(ExtID e);
            
            ExtID extid;     
            // Should use a union for these but cannot because they are 
            // "C++-safe" classes. Oh well, they are 2 bytes each...
            FuncType ftype;  
            VarType vtype;   
            TLString name;   
            NamespaceInfo *nspc; 


            SymbolEntryE *linked;
            
            SymbolEntryE(NamespaceInfo *_nspc=NULL);
            inline ~SymbolEntryE()  { nspc=NULL; linked=NULL; }
            
            SymbolEntryE(const SymbolEntryE &se);
            SymbolEntryE &operator=(const SymbolEntryE &se);
        };
        
    protected:
        NamespaceInfo *parent;           
        LinkedList<NamespaceInfo> down;  
        TLString name;                   
        NSType nstype;                   
        
        SCLocation asm_loc;
        
        NamespaceInfo *linked;
        uint16 link_info_set : 1;
        uint16 recursion_flag : 1;
        
        typedef TLLinearQueue<SymbolEntryE,TLDefaultOperators_CDT<SymbolEntryE> > 
            SymbolList;
        SymbolList symbol;
        
        TLBTree<NamespaceInfo*,PtrListOperators<NamespaceInfo> > map_name2child;
        
        TLBTree< SymbolEntryE*,PtrListOperators<SymbolEntryE> > map_name2symbol;
        
        struct _Operators
        {
            static inline bool le(NamespaceInfo const &a,
                NamespaceInfo const &b)
                {  return(a.name<=b.name);  }
        };
        
        void _AddChild(NamespaceInfo *child);
        void _DelChild(NamespaceInfo *child);
        
    private:
        NamespaceInfo(const NamespaceInfo &);
        void operator=(const NamespaceInfo &);
    public:
        NamespaceInfo(const TLString &name,NamespaceInfo *parent=NULL,
            NSType nstype=NSNamespace);
        virtual ~NamespaceInfo();
        
        void SortNamespaceTree();
        
        void AddChild(NamespaceInfo *child);
        
        virtual TLString CompleteName() const;
        
        virtual void DumpTree(StringTreeDump &dump,bool IDs_resolved,
            bool recurse=1) const;
};

// Must be placed here below SymbolEntryE definition. 
inline NamespaceInfo::SymbolEntryE *NamespaceInfo::SymbolEntryB::ep()
    {  return(symref<0 ? NULL : static_cast<SymbolEntryE*>(this));  }
inline const NamespaceInfo::SymbolEntryE *NamespaceInfo::SymbolEntryB::ep() 
    const
    {  return(symref<0 ? NULL : static_cast<const SymbolEntryE*>(this));  }

// See classinfo.h: 
struct ClassInfo;

}  // end of namespace VM

#endif  /* _VM_INPUT_NSPCINFO_H_ */

---