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

Go to the documentation of this file.

/*
 * vm/input/tasm/tasm-scanner.h
 * 
 * VM plaintext assembly scanner (lexical analysis). 
 * 
 * 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_SCANNER_H_
#define _VM_INPUT_TASM_TASM_SCANNER_H_ 1

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

#include <lib/lex/location.h>
#include <lib/sourcepos/sparchive.h>
#include <vm/input/nspcinfo.h>
#include <vm/program.h>

#include <stdio.h>      /* because of FILE * (FIXME) */

#define PREFIX_FlexScannerBase TASM_FlexScannerBase
#include <lib/lex/scannerbase.h>
#undef PREFIX_FlexScannerBase


class TextAsmScanner : public TASM_FlexScannerBase
{
    friend int TASM_lex(void *);
    public:
        enum TokID
        {
            T_EOF=0,           
            // skip 0..255 for single char tokens
            T_pop=258,         
            T_symbols,         
            T_locations,       
            T_program,         
            T_info,            
            // For symbols: 
            TS_namespace,      
            TS_class,          
            TS_base,
            TS_baseent,
            TS_varent,         
            TS_size,
            TS_virtual,
            TS_vtable,         
            TS_symref,         
            TS_vglobal,        
            TS_pglobal,        
            TS_symbols,        
            TS_funcsym,        
            TS_varsym,         
            TS_globvar,        
            // For locations:
            // TL_*  (nothing currently)
            // For program:
            TP_slabel,         
            TP_mlabel,         
            TP_rlabel,         
            // For info section: 
            TI_abivers,        
        };
        
        static const char *TokID2String(TokID t);
        
        struct Token : TokenEntry
        {
            struct Type
            {
                // Note for TS_varent: 
                //  tid is the TYPEID specified with the pointer when 
                //      used like "p>TYPEID". In this case tchar[1]='>'. 
                //  tchar are the max 2 type chars; 1 normally, 2 for arrays. 
                VM::TypeID tid;
                char tchar[2];
            };
            
            union {
                struct { uint32 size; uint32 num_p,num_v; };
                struct { uint32 num; };
                struct {
                    union { Type t; VM::TypeID tid; char ftype; };
                    union { VM::Offset off; uint32 codemark; };
                    union { VM::SymRef symref; };
                };
            };
            char *str_val;
            
            bool MayBeCleared() const;
            void clear(bool force);
            
            Token() : TokenEntry(),str_val(NULL)  { }
            ~Token()  { clear(1); }
        };
        
    private:
        void reset();
        TokenEntry *AllocTokenEntry()
            {  return(new Token());  }
        
        char *_ParseNameStr(const char *str,const char *end);
        
        template<typename T>const char *_ParseInt(T *ret,const char *str,
            char prefix='\0');
        template<typename T>const char *_ParseInt0(T *ret,const char *str);
        
        template<typename T>const char *_ParseFloat(T *ret,const char *str);
        
        const char *_ParseTypeSpec(Token::Type *ts,const char *str);
        
        void _CheckInstAllowed_Failed();
        inline bool _CheckInstAllowed()
        {
            if(insn_storage)  return(1);
            _CheckInstAllowed_Failed();  return(0);
        }
        
        TextAsmScanner(const TextAsmScanner &);
        void operator=(const TextAsmScanner &);
    public:
        TextAsmScanner();
        ~TextAsmScanner();
        
        int NErrors() const
            {  return(n_errors);  }
        
        VM::ProgramStorage::Function *insn_storage;
        
        inline VM::InstructionStorage *InsnStorage()
            {  return(insn_storage);  }
};

#endif  /* _VM_INPUT_TASM_TASM_SCANNER_H_ */

---