/ray/src/vm/input/tasm/tasm-file.h

Go to the documentation of this file.

/*
 * vm/input/tasm/tasm-file.h
 * 
 * VM plaintext assembly 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_TASM_TASM_FILE_H_
#define _VM_INPUT_TASM_TASM_FILE_H_ 1

#include <vm/vmconfig.h>    /* MUST be first */
#include <vm/input/asmfile.h>
#include <vm/input/tasm/tasm-scanner.h>
#include <lib/tl/tlarrayheap.h>

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


namespace VM
{

// See <vm/input/classinfo.h>: 
class ClassInfo;


class AssemblerFile_Plaintext : public AssemblerFile
{
    public:
        struct RJumpEntry
        {
            PrgAdr adr;      
            CodeMark cmark;  
            
            static inline PrgAdr ord(const RJumpEntry &e)
                {  return(e.adr);  }
            
            inline RJumpEntry() {}
            inline RJumpEntry(PrgAdr _adr,CodeMark _cmark) : adr(_adr),
                cmark(_cmark)  {}
            inline ~RJumpEntry() {}
        };
        
        struct RJumpEntry_Operators : 
            TLDefaultOperators_OrdRel2_Rev<RJumpEntry,RJumpEntry,RJumpEntry,
                RJumpEntry>,
            TLDefaultOperators_Construct_CDT<RJumpEntry>,
            TLDefaultOperators_Index<RJumpEntry>,
            TLDefaultOperators_Allocation
        {
        };
        
    protected:
        TextAsmScanner scan;
        int n_errors;
        
        IDMapTable<CodeMark,PrgAdr> codemark2prgadr;
        
        TLArrayHeap<RJumpEntry,RJumpEntry_Operators> *prgadr2codemark;
        
        TextAsmScanner::Token *tok;
        
        inline void _LexNextToken()
        {
            // Mark old token as used. 
            if(tok && tok->str_val)  *tok->str_val='\0';
            tok=(TextAsmScanner::Token*)scan.LexNextToken();
        }
        
        inline TextAsmScanner::TokID _CurrTokID()
            {  return((TextAsmScanner::TokID)
                (tok ? tok->token : TextAsmScanner::T_EOF));  }
        
        void _ExpectError(const char *str);
        void _AlreadySetError();
        void _LocFirstDefError(const SCLocation &loc);
        
        VarType _ParseVarType(const TextAsmScanner::Token::Type *t);
        FuncType _ParseFuncType(char ftype);
        
        void _SkipUntilPop(uint32 num,TextAsmScanner::TokID skip_a,
            TextAsmScanner::TokID skip_b=TextAsmScanner::T_EOF);
        
        NamespaceInfo *_CheckNspcNameKnown(NamespaceInfo *parent,
            const TLString &name);
        
        void _ParseInfoSection();
        void _ParseSymbolSection();
        void _ParseLocationSection();
        void _ParseProgramSection();
        
        void _ParseSymbols_Namespace(NamespaceInfo *parent);
        void _ParseSymbols_Class(NamespaceInfo *parent);
        void _ParseSymbols_Symbols(NamespaceInfo *parent);
        void _ParseSymbols_Global();
        void _ParseSymbols_Class_Base(ClassInfo *parent);
        void _ParseSymbols_Class_VTable(ClassInfo *parent);
        void _ParseSymbols_Class_Size(ClassInfo *parent);
        
        void _ParseProgram_Label();
        
        void _ParseProgram_FinishFunction();
        
        int _WriteFunctionProgram(FILE *fp,ProgramStorage::Function *pfunc);
        int _WriteSymbolSectionContent(FILE *fp);
        int _WriteSymbols_Recursive(StringTreeDump &out,NamespaceInfo *ni);
        int _WriteSymbols_Global(StringTreeDump &out,_GlobVars *gvar,
            char which);
            
        int _MustDumpNamespace(NamespaceInfo *ni);
        
    private:
        AssemblerFile_Plaintext(const AssemblerFile_Plaintext &);
        void operator=(const AssemblerFile_Plaintext &);
    public:
        AssemblerFile_Plaintext();
        ~AssemblerFile_Plaintext();
        
        int ParseFile(const TLString &fname,SError &error,uint32 file_num);
        
        int WriteFile(const TLString &fname,SError &error);
        
        int WriteFunctionProgram(FILE *fp,ProgramStorage::Function *pfunc)
            {  return(_WriteFunctionProgram(fp,pfunc));  }
};

}  // end of namespace VM

#endif  /* _VM_INPUT_TASM_TASM_FILE_H_ */

---