/ray/src/vm/input/linker.h

Go to the documentation of this file.

/*
 * vm/input/linker.h
 * 
 * VM (assembler) linker. 
 * 
 * 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_LINKER_H_
#define _VM_INPUT_LINKER_H_ 1

#include <vm/vmconfig.h>    /* MUST be first */
#include <vm/input/asmfile.h>
#include <lib/tl/tlbtree.h>


namespace VM
{

class VMLinker
{
    public:
        struct FileNode : LinkedListBase<FileNode>
        {
            AssemblerFile *f;        
            bool needed;             
            
            inline FileNode(AssemblerFile *_f) : f(_f),needed(0)  {}
            inline ~FileNode()  {  DELETE(f);  }
        };
        
        struct Config
        {
            bool ignore_simple_type_missing;
            bool abandon_out_maps;
            
            Config();
            inline ~Config() {}
        };
        
        static inline NamespaceInfo *SPM_ORD(NamespaceInfo::SymbolEntryE *se)
            {  return(se->nspc->linked);  }
        
        template<typename T>struct ProvideMapOP : 
            TLDefaultOperators_Construct_PDT<T>,
            TLDefaultOperators_Allocation
        {
            static inline int _cmp_name(T const &a,T const &b)
            {  return(a->name.compare(b->name));  }
            
            // First name, then linked namespace pointer. 
            static inline bool lt(T const &a,T const &b)
            {
                int rv=_cmp_name(a,b);
                return(rv ? rv<0 : SPM_ORD(a)<SPM_ORD(b));
            }
            static inline bool le(T const &a,T const &b)
            {
                int rv=_cmp_name(a,b);
                return(rv ? rv<0 : SPM_ORD(a)<=SPM_ORD(b));
            }
            static inline bool gt(T const &a,T const &b)
                {  return(lt(b,a));  }
            static inline bool ge(T const &a,T const &b)
                {  return(le(b,a));  }
            
            static inline bool eq(T const &a,T const &b)
            {  return(SPM_ORD(a)==SPM_ORD(b) && _cmp_name(a,b)==0);  }
            static inline bool ne(T const &a,T const &b)
            {  return(SPM_ORD(a)!=SPM_ORD(b) || _cmp_name(a,b)!=0);  }
        };
        
        struct LSymbol
        {
            NamespaceInfo::SymbolEntryE *se; 
            SymRef symref;                   

            NamespaceInfo::SymbolEntryB **update_se;
            enum SFlag
            {
                SNone=0,   
                SStart,    
            } sflag;
            
            inline LSymbol() : se(NULL),symref(0),update_se(NULL),
                sflag(SNone)  {}
            inline LSymbol(NamespaceInfo::SymbolEntryE *_se,SymRef _symref,
                NamespaceInfo::SymbolEntryB **_update_se,SFlag _sflag) : 
                se(_se),symref(_symref),update_se(_update_se),sflag(_sflag)  {}
            inline ~LSymbol()  {}
            
            //inline bool operator<(const LSymbol &b) const { return(se<b.se); }
            //inline bool operator>(const LSymbol &b) const { return(se>b.se); }
            //inline bool operator==(const LSymbol &b) const { return(se==b.se); }
            //inline bool operator!=(const LSymbol &b) const { return(se!=b.se); }
            typedef ProvideMapOP<NamespaceInfo::SymbolEntryE*> PMOP;
            inline bool operator<(const LSymbol &b) const
                {  return(PMOP::lt(se,b.se));  }
            inline bool operator>(const LSymbol &b) const
                {  return(PMOP::gt(se,b.se));  }
            inline bool operator==(const LSymbol &b) const
                {  return(PMOP::eq(se,b.se));  }
            inline bool operator!=(const LSymbol &b) const
                {  return(PMOP::ne(se,b.se));  }
        };
        
        typedef TLBTree< LSymbol,TLDefaultOperators_CDT<LSymbol> > SymbolQueue;
        
        class SymbolProvideMap
        {
            private:
                TLBTree< NamespaceInfo::SymbolEntryE*,
                    ProvideMapOP<NamespaceInfo::SymbolEntryE*> > map;
                
                SymbolProvideMap(const SymbolProvideMap &);
                void operator=(const SymbolProvideMap &);
            public:
                inline SymbolProvideMap() : map() {}
                inline ~SymbolProvideMap() {}
                
                NamespaceInfo::SymbolEntryE *AddNode(
                    NamespaceInfo::SymbolEntryE *s);
        
                NamespaceInfo::SymbolEntryE *lookup(
                    NamespaceInfo::SymbolEntryE *symb)
                {
                    NamespaceInfo::SymbolEntryE **found=map.search(symb);
                    return(found ? *found : NULL);
                }
                
                inline void clear()
                    {  map.clear();  }
        };
        
    private:
        Config cfg;
        
        LinkedList<FileNode> flist;
        
        int n_errors;
        
        SymbolQueue sq;
        
        TypeID master_TypeID_cnt;
        
        SymRef master_SymRef_cnt;
        
        SymbolProvideMap symbol_provide_map;
        
        AssemblerFile *out;
        
        void _MergeNamespaceAndVTableInfo();
        NamespaceInfo *_MergeNamespaceInfo_Recursive(NamespaceInfo **head_list,
            uint nheads);
        void _CheckNamespaceInfo_Recursive(FileNode *fn,NamespaceInfo *ni);
        
        void _LinkFunction(FileNode *fn,ProgramStorage::Function *psf,
            NamespaceInfo::SymbolEntryE *se_linked);
        
        void _LinkGlobalStorage(FileNode *fn,AssemblerFile::_GlobVars *gvar,
            AssemblerFile::_GlobVars *dest,char which);
        
        void _LinkerFileNeeded(FileNode *fn);
        
        void _LinkerNeedClassConstruct(ClassInfo *ci);
        
        int _CheckBaseRecursion(ClassInfo *cni);
        
        void _CheckBaseRecursion_Recursive(FileNode *fn,NamespaceInfo *ni);
        
        void _PropagateUseFlags_Recursive(NamespaceInfo *ni);
        void _DoPropagateUseFlags(ClassInfo *from,ClassInfo *cni);
        
        void _GenerateSymbolProvideMap();
        void _GenerateSymbolProvideMap_AddGlobal(FileNode *fn,
            AssemblerFile::_GlobVars *gvar);
        
        void _CreateInitFunction();
        
        FileNode *_GetDefinitionFile(NamespaceInfo *from_here);
        
        SymRef _SQPush(NamespaceInfo::SymbolEntryE *,
            NamespaceInfo::SymbolEntryB **update_se=NULL,
            LSymbol::SFlag sflag=LSymbol::SNone);
        SymRef _SQQuery(NamespaceInfo::SymbolEntryE *ni);
        void _SQPop();
        bool _SQPeek(LSymbol &ls);
        
        VMLinker(const VMLinker &);
        void operator=(const VMLinker &);
    public:
        VMLinker();
        ~VMLinker();
        
        int AddFile(AssemblerFile *afile);
        
        int LinkAll(AssemblerFile *out);
};

}  // end of namespace VM

#endif  /* _VM_INPUT_LINKER_H_ */

---