Make all the virtual function (except destructor) inline so there are

default implementations without taking up a ton of space in a .cpp file.

llvm-svn: 14603

llvm/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<unsigned>& 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<Constant*> ArgVec, ///< expression args
     Constant* C ///< The constant value
-  );
+  ) {}
 
   /// @brief Handle a constant array
   virtual void handleConstantArray( 
@@ -242,14 +242,14 @@ public:
     std::vector<Constant*>& 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<Constant*>& 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
-  );
+  ) {}
 /// @}
 
 };