/// getBytecodeModuleProvider - lazy function-at-a-time loading from a file
///
-AbstractModuleProvider*
-getBytecodeModuleProvider(const std::string &Filename);
+ModuleProvider *getBytecodeModuleProvider(const std::string &Filename);
/// getBytecodeBufferModuleProvider - lazy function-at-a-time loading from a
/// buffer
///
-AbstractModuleProvider*
-getBytecodeBufferModuleProvider(const unsigned char *Buffer,
- unsigned BufferSize,
- const std::string &ModuleID = "");
+ModuleProvider *getBytecodeBufferModuleProvider(const unsigned char *Buffer,
+ unsigned BufferSize,
+ const std::string &ModuleID="");
/// ParseBytecodeFile - Parse the given bytecode file
///
class Function;
class Module;
-class AbstractModuleProvider {
+class ModuleProvider {
protected:
Module *TheModule;
- AbstractModuleProvider();
+ ModuleProvider();
public:
- virtual ~AbstractModuleProvider();
+ virtual ~ModuleProvider();
/// getModule - returns the module this provider is encapsulating.
///
unsigned FunctionSlot;
};
-class BytecodeParser : public AbstractModuleProvider {
+class BytecodeParser : public ModuleProvider {
BytecodeParser(const BytecodeParser &); // DO NOT IMPLEMENT
void operator=(const BytecodeParser &); // DO NOT IMPLEMENT
public:
/// getBytecodeBufferModuleProvider - lazy function-at-a-time loading from a
/// buffer
-AbstractModuleProvider*
+ModuleProvider*
getBytecodeBufferModuleProvider(const unsigned char *Buffer, unsigned Length,
const std::string &ModuleID) {
return new BytecodeBufferReader(Buffer, Length, ModuleID);
Module *ParseBytecodeBuffer(const unsigned char *Buffer, unsigned Length,
const std::string &ModuleID, std::string *ErrorStr){
try {
- std::auto_ptr<AbstractModuleProvider>
+ std::auto_ptr<ModuleProvider>
AMP(getBytecodeBufferModuleProvider(Buffer, Length, ModuleID));
return AMP->releaseModule();
} catch (std::string &err) {
/// getBytecodeModuleProvider - lazy function-at-a-time loading from a file
///
-AbstractModuleProvider*
-getBytecodeModuleProvider(const std::string &Filename) {
+ModuleProvider *getBytecodeModuleProvider(const std::string &Filename) {
if (Filename != std::string("-")) // Read from a file...
return new BytecodeFileReader(Filename);
else // Read from stdin
///
Module *ParseBytecodeFile(const std::string &Filename, std::string *ErrorStr) {
try {
- std::auto_ptr<AbstractModuleProvider>
- AMP(getBytecodeModuleProvider(Filename));
+ std::auto_ptr<ModuleProvider> AMP(getBytecodeModuleProvider(Filename));
return AMP->releaseModule();
} catch (std::string &err) {
if (ErrorStr) *ErrorStr = err;
/// ctor - always have a valid Module
///
-AbstractModuleProvider::AbstractModuleProvider() : TheModule(0) { }
+ModuleProvider::ModuleProvider() : TheModule(0) { }
/// dtor - when we leave, we take our Module with us
///
-AbstractModuleProvider::~AbstractModuleProvider() {
+ModuleProvider::~ModuleProvider() {
delete TheModule;
}
/// materializeFunction - make sure the given function is fully read.
///
-void AbstractModuleProvider::materializeModule() {
+void ModuleProvider::materializeModule() {
if (!TheModule) return;
for (Module::iterator i = TheModule->begin(), e = TheModule->end();