From 1847444e0c23e49013c561219540b1a779fbab29 Mon Sep 17 00:00:00 2001 From: Reid Spencer Date: Sun, 4 Jul 2004 11:29:56 +0000 Subject: [PATCH] Make all the virtual function (except destructor) inline so there are default implementations without taking up a ton of space in a .cpp file. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14603 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Bytecode/BytecodeHandler.h | 82 ++++++++++++------------- 1 file changed, 41 insertions(+), 41 deletions(-) diff --git a/include/llvm/Bytecode/BytecodeHandler.h b/include/llvm/Bytecode/BytecodeHandler.h index 3550d22636b..71446127103 100644 --- a/include/llvm/Bytecode/BytecodeHandler.h +++ b/include/llvm/Bytecode/BytecodeHandler.h @@ -66,29 +66,29 @@ public: /// with the error message before the parser throws an exception to /// terminate the parsing. /// @brief Handle parsing errors. - virtual void handleError(const std::string& str ); + virtual void handleError(const std::string& str ) {} /// This method is called at the beginning of a parse before anything is /// read in order to give the handler a chance to initialize. /// @brief Handle the start of a bytecode parse - virtual void handleStart( Module* Mod, unsigned byteSize ); + virtual void handleStart( Module* Mod, unsigned byteSize ) {} /// This method is called at the end of a parse after everything has been /// read in order to give the handler a chance to terminate. /// @brief Handle the end of a bytecode parse - virtual void handleFinish(); + virtual void handleFinish() {} /// This method is called at the start of a module to indicate that a /// module is being parsed. /// @brief Handle the start of a module. - virtual void handleModuleBegin(const std::string& moduleId); + virtual void handleModuleBegin(const std::string& moduleId) {} /// This method is called at the end of a module to indicate that the module /// previously being parsed has concluded. /// @brief Handle the end of a module. virtual void handleModuleEnd( const std::string& moduleId ///< An identifier for the module - ); + ) {} /// This method is called once the version information has been parsed. It /// provides the information about the version of the bytecode file being @@ -98,11 +98,11 @@ public: unsigned char RevisionNum, ///< Byte code revision number Module::Endianness Endianness, ///< Endianness indicator Module::PointerSize PointerSize ///< PointerSize indicator - ); + ) {} /// This method is called at the start of a module globals block which /// contains the global variables and the function placeholders - virtual void handleModuleGlobalsBegin(); + virtual void handleModuleGlobalsBegin() {} /// This method is called when a non-initialized global variable is /// recognized. Its type, constness, and linkage type are provided. @@ -113,46 +113,46 @@ public: GlobalValue::LinkageTypes,///< The linkage type of the GV unsigned SlotNum, ///< Slot number of GV unsigned initSlot ///< Slot number of GV's initializer (0 if none) - ); + ) {} /// This method is called when a new type is recognized. The type is /// converted from the bytecode and passed to this method. /// @brief Handle a type virtual void handleType( const Type* Ty ///< The type that was just recognized - ); + ) {} /// This method is called when the function prototype for a function is /// encountered in the module globals block. virtual void handleFunctionDeclaration( Function* Func ///< The function being declared - ); + ) {} /// This method is called when a global variable is initialized with /// its constant value. Because of forward referencing, etc. this is /// done towards the end of the module globals block - virtual void handleGlobalInitializer(GlobalVariable*, Constant* ); + virtual void handleGlobalInitializer(GlobalVariable*, Constant* ) {} /// This method is called at the end of the module globals block. /// @brief Handle end of module globals block. - virtual void handleModuleGlobalsEnd(); + virtual void handleModuleGlobalsEnd() {} /// This method is called at the beginning of a compaction table. /// @brief Handle start of compaction table. - virtual void handleCompactionTableBegin(); + virtual void handleCompactionTableBegin() {} /// @brief Handle start of a compaction table plane virtual void handleCompactionTablePlane( unsigned Ty, ///< The type of the plane (slot number) unsigned NumEntries ///< The number of entries in the plane - ); + ) {} /// @brief Handle a type entry in the compaction table virtual void handleCompactionTableType( unsigned i, ///< Index in the plane of this type unsigned TypSlot, ///< Slot number for this type const Type* ///< The type referenced by this slot - ); + ) {} /// @brief Handle a value entry in the compaction table virtual void handleCompactionTableValue( @@ -160,56 +160,56 @@ public: unsigned TypSlot, ///< The slot (plane) of the type of this value unsigned ValSlot, ///< The global value slot of the value const Type* ///< The resolved type of the value. - ); + ) {} /// @brief Handle end of a compaction table - virtual void handleCompactionTableEnd(); + virtual void handleCompactionTableEnd() {} /// @brief Handle start of a symbol table virtual void handleSymbolTableBegin( Function* Func, ///< The function to which the ST belongs SymbolTable* ST ///< The symbol table being filled - ); + ) {} /// @brief Handle start of a symbol table plane virtual void handleSymbolTablePlane( - unsigned Ty, ///< The slotnum of the type plane + unsigned TySlot, ///< The slotnum of the type plane unsigned NumEntries, ///< Number of entries in the plane - const Type* Ty ///< The type of this type plane - ); + const Type* Typ ///< The type of this type plane + ) {} /// @brief Handle a named type in the symbol table virtual void handleSymbolTableType( unsigned i, ///< The index of the type in this plane unsigned slot, ///< Slot number of the named type const std::string& name ///< Name of the type - ); + ) {} /// @brief Handle a named value in the symbol table virtual void handleSymbolTableValue( unsigned i, ///< The index of the value in this plane unsigned slot, ///< Slot number of the named value const std::string& name ///< Name of the value. - ); + ) {} /// @brief Handle the end of a symbol table - virtual void handleSymbolTableEnd(); + virtual void handleSymbolTableEnd() {} /// @brief Handle the beginning of a function body virtual void handleFunctionBegin( Function* Func, ///< The function being defined unsigned Size ///< The size (in bytes) of the function's bytecode - ); + ) {} /// @brief Handle the end of a function body virtual void handleFunctionEnd( Function* Func ///< The function whose definition has just finished. - ); + ) {} /// @brief Handle the beginning of a basic block virtual void handleBasicBlockBegin( unsigned blocknum ///< The block number of the block - ); + ) {} /// This method is called for each instruction that is parsed. /// @returns true if the instruction is a block terminating instruction @@ -219,22 +219,22 @@ public: const Type* iType, ///< Instruction type std::vector& Operands, ///< Vector of slot # operands unsigned Length ///< Length of instruction in bc bytes - ); + ) { return false; } /// @brief Handle the end of a basic block virtual void handleBasicBlockEnd( unsigned blocknum ///< The block number of the block just finished - ); + ) {} /// @brief Handle start of global constants block. - virtual void handleGlobalConstantsBegin(); + virtual void handleGlobalConstantsBegin() {} /// @brief Handle a constant expression virtual void handleConstantExpression( unsigned Opcode, ///< Opcode of primary expression operator std::vector ArgVec, ///< expression args Constant* C ///< The constant value - ); + ) {} /// @brief Handle a constant array virtual void handleConstantArray( @@ -242,14 +242,14 @@ public: std::vector& ElementSlots,///< Slot nums for array values unsigned TypeSlot, ///< Slot # of type Constant* Val ///< The constant value - ); + ) {} /// @brief Handle a constant structure virtual void handleConstantStruct( const StructType* ST, ///< Type of the struct std::vector& ElementSlots,///< Slot nums for struct values Constant* Val ///< The constant value - ); + ) {} /// @brief Handle a constant pointer virtual void handleConstantPointer( @@ -257,42 +257,42 @@ public: unsigned Slot, ///< Slot num of initializer value GlobalValue* GV, ///< Referenced global value Constant* Val ///< Value of constant - ); + ) {} /// @brief Handle a constant strings (array special case) virtual void handleConstantString( const ConstantArray* CA ///< Type of the string array - ); + ) {} /// @brief Handle a primitive constant value virtual void handleConstantValue( Constant * c ///< The constant just defined - ); + ) {} /// @brief Handle the end of the global constants - virtual void handleGlobalConstantsEnd(); + virtual void handleGlobalConstantsEnd() {} /// @brief Handle an alignment event virtual void handleAlignment( unsigned numBytes ///< The number of bytes added for alignment - ); + ) {} /// @brief Handle a bytecode block virtual void handleBlock( unsigned BType, ///< The type of block const unsigned char* StartPtr, ///< The start of the block unsigned Size ///< The size of the block - ); + ) {} /// @brief Handle a variable bit rate 32 bit unsigned virtual void handleVBR32( unsigned Size ///< Number of bytes the vbr_uint took up - ); + ) {} /// @brief Handle a variable bit rate 64 bit unsigned virtual void handleVBR64( unsigned Size ///< Number of byte sthe vbr_uint64 took up - ); + ) {} /// @} };