/ray/src/vm/input/asmfile.h

Go to the documentation of this file.

/*
 * vm/input/asmfile.h
 * 
 * VM assembler input file. 
 * 
 * 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_ASSEMBLERFILE_H_
#define _VM_INPUT_ASSEMBLERFILE_H_ 1

#include <vm/vmconfig.h>    /* MUST be first */

#include <vm/maptable.h>
#include <vm/imaptable.h>
#include <vm/input/classinfo.h>
#include <lib/lex/location.h>
#include <vm/nrarray.h>
#include <vm/program.h>
#include <lib/tl/tllinearqueue.h>


namespace VM
{

// See <vm/input/linker.h>. 
class VMLinker;


class AssemblerFile
{
    friend class VMLinker;
    public:
        struct Config
        {
            bool read_non_pointer_members;
            bool read_member_var_names;
            bool emit_all_namespaces;
            bool emit_all_classinfo;
            
            Config();
            inline ~Config() {}
        };
        
        struct GlobalVarEntry
        {
            VarType vtype;  
            Offset off;     
            union {
                SymRef symref;
                NamespaceInfo::SymbolEntryE *se;
            };
            
            inline GlobalVarEntry() {}
            inline ~GlobalVarEntry() {}
        };
        
        struct ORD_SymRef_SE
        {
            static inline SymRef ord(const NamespaceInfo::SymbolEntryB *se)
                {  return(se->symref);  }
        };
        struct ORD_TypeID
        {
            static inline TypeID ord(const ClassInfo *ci)
                {  return(ci->ClassTID());  }
        };
        struct ORD_TypeID2
        {
            static inline TypeID ord(const ClassInfoIE *ci)
                {  return(ci->class_tid);  }
        };
        
        class InternalSymbolList
        {
            private:
                TLLinearQueue<NamespaceInfo::SymbolEntryB,
                    TLDefaultOperators_CDT<NamespaceInfo::SymbolEntryB> > 
                        sym_stor;
                
                ImplicitMapTable< NamespaceInfo::SymbolEntryB,SymRef,
                    ImplicitMapOperators<NamespaceInfo::SymbolEntryB,SymRef,
                        ORD_SymRef_SE> > sym_map;
                
                InternalSymbolList(const InternalSymbolList &);
                void operator=(const InternalSymbolList &);
            public:
                InternalSymbolList();
                inline ~InternalSymbolList()  {}
                
                NamespaceInfo::SymbolEntryB *LookupStore(SymRef symref);
        };
        
        class InternalClassList
        {
            private:
                TLLinearQueue<ClassInfoIE,TLDefaultOperators_CDT<ClassInfoIE> > 
                        class_stor;
                
                ImplicitMapTable< ClassInfoIE,SymRef,
                    ImplicitMapOperators<ClassInfoIE,SymRef,
                        ORD_TypeID2> > class_map;
                
                InternalClassList(const InternalClassList &);
                void operator=(const InternalClassList &);
            public:
                InternalClassList();
                inline ~InternalClassList()  {}
                
                ClassInfoIE *LookupStore(TypeID tid);
        };
        
    protected:
        Config cfg;
        
        SCLocation filename;
        
        uint32 file_num;
        
        TLString abi_version;
        
        NamespaceInfo *nspc_root;
        
        typedef TLLinearQueue<GlobalVarEntry,
                TLDefaultOperators_CDT<GlobalVarEntry> > GlobalVarList;
        struct _GlobVars {
            Offset size;
            GlobalVarList globvarq;
            
            inline _GlobVars() : size(0),globvarq(/*chunk_size=*/32) {}
            inline ~_GlobVars() {}
        } gvar_v,gvar_p;
        
        ProgramStorage program;
        
        ImplicitMapTable< ClassInfo,TypeID,
            ImplicitMapOperators<ClassInfo,TypeID,ORD_TypeID> > tid2classinfo;
        
        ImplicitMapTable< NamespaceInfo::SymbolEntryE,SymRef,
            ImplicitMapOperators<NamespaceInfo::SymbolEntryE,SymRef,
                ORD_SymRef_SE> > symref2symbol;
        
        InternalSymbolList internal_symbols;
        InternalClassList internal_classes;
        
        // NOTE: canNOT be replaced by an ImplicitMapTable<>. 
        IDMapTable<SymRef,ProgramStorage::Function*> symref2function;
        // NOTE: canNOT be replaced by an ImplicitMapTable<>. 
        IDMapTable<SymRef,GlobalVarEntry*> symref2globvar;
        
        struct SLabelInfo
        {
            ProgramStorage::Function *pfunc;
            NamespaceInfo::SymbolEntryE se;
        } slabel_init,slabel_start;
        
    private:
        int _ResolveIDsNamespaceLocal_Recursive(NamespaceInfo *root);
        int _ResolveSymrefsInGlobal(_GlobVars *gvar);
    
    private:
        AssemblerFile(const AssemblerFile &);
        void operator=(const AssemblerFile &);
    protected:
        AssemblerFile();
    public:
        virtual ~AssemblerFile();
        
        virtual int ParseFile(const TLString &fname,SError &error,
            uint32 file_num);
        
        int ResolveIDsNamespaceLocal();
        
        virtual int WriteFile(const TLString &fname,SError &error);
};

}  // end of namespace VM

#endif  /* _VM_INPUT_ASSEMBLERFILE_H_ */

---