Ticket #8917: defaultsearchmanager.patch

File defaultsearchmanager.patch, 22.9 KB (added by peres, 13 years ago)

Search manager for middleware.

  • base/main.cpp

     
    3939
    4040#include "common/config-manager.h"
    4141#include "common/events.h"
    42 #include "common/file.h"
     42#include "common/archive.h"
    4343#include "common/fs.h"
    4444#include "common/system.h"
    4545#include "gui/newgui.h"
     
    156156        }
    157157
    158158        // Add the game path to the directory search list
    159         Common::File::addDefaultDirectory(path);
     159        SearchMan.addDirectory(path);
    160160
    161         // Add extrapath (if any) to the directory search list
    162         if (ConfMan.hasKey("extrapath"))
    163                 Common::File::addDefaultDirectoryRecursive(ConfMan.get("extrapath"));
    164 
    165         // If a second extrapath is specified on the app domain level, add that as well.
    166         if (ConfMan.hasKey("extrapath", Common::ConfigManager::kApplicationDomain))
    167                 Common::File::addDefaultDirectoryRecursive(ConfMan.get("extrapath", Common::ConfigManager::kApplicationDomain));
    168 
    169 #ifdef DATA_PATH
    170         // Add the global DATA_PATH to the directory search list
    171         Common::File::addDefaultDirectoryRecursive(DATA_PATH);
    172 #endif
    173 
    174161        // On creation the engine should've set up all debug levels so we can use
    175162        // the command line arugments here
    176163        Common::enableSpecialDebugLevelList(edebuglevels);
     
    198185        // Free up memory
    199186        delete engine;
    200187
    201         // Reset the file/directory mappings
    202         Common::File::resetDefaultDirectories();
    203 
    204188        // Return result (== 0 means no error)
    205189        return result;
    206190}
     
    229213                ConfMan.loadDefaultConfigFile();
    230214        }
    231215
     216        // Add extrapath (if any) to the directory search list
     217        if (ConfMan.hasKey("extrapath"))
     218                SearchMan.addDirectoryRecursive(ConfMan.get("extrapath"));
     219
     220        // If a second extrapath is specified on the app domain level, add that as well.
     221        if (ConfMan.hasKey("extrapath", Common::ConfigManager::kApplicationDomain))
     222                SearchMan.addDirectoryRecursive(ConfMan.get("extrapath", Common::ConfigManager::kApplicationDomain));
     223
     224#ifdef DATA_PATH
     225        // Add the global DATA_PATH to the directory search list
     226        SearchMan.addDirectoryRecursive(DATA_PATH);
     227#endif
     228
    232229        // Update the config file
    233230        ConfMan.set("versioninfo", gScummVMVersion, Common::ConfigManager::kApplicationDomain);
    234231
     
    285282
    286283                        // Try to run the game
    287284                        int result = runGame(plugin, system, specialDebug);
    288                        
     285
    289286                        // Did an error occur ?
    290287                        if (result != 0) {
    291288                                // TODO: Show an informative error dialog if starting the selected game failed.
    292289                        }
    293                        
     290
    294291                        // Quit unless an error occurred, or Return to launcher was requested
    295292                        if (result == 0 && !g_system->getEventManager()->shouldRTL())
    296293                                break;
     
    319316        PluginManager::destroy();
    320317        Common::ConfigManager::destroy();
    321318        GUI::NewGui::destroy();
     319        Common::DefaultSearchManager::destroy();
    322320
    323321        return 0;
    324322}
  • common/advancedDetector.cpp

     
    2525
    2626#include "base/plugins.h"
    2727
     28#include "common/archive.h"
    2829#include "common/util.h"
    2930#include "common/hash-str.h"
    30 #include "common/file.h"
    3131#include "common/md5.h"
    3232#include "common/advancedDetector.h"
    3333#include "common/config-manager.h"
     
    362362
    363363                debug(3, "> %s: %s", fname.c_str(), md5str);
    364364
    365                 File testFile;
    366                 if (testFile.open(allFiles[fname])) {
    367                         filesSize[fname] = (int32)testFile.size();
    368                         testFile.close();
     365                SeekableReadStream *testFile = SearchMan.openFile(allFiles[fname]);
     366                if (testFile) {
     367                        filesSize[fname] = (int32)testFile->size();
     368                        delete testFile;
    369369                }
    370370        }
    371371
     
    449449        if (matched.empty()) {
    450450                if (!filesMD5.empty())
    451451                        reportUnknown(filesMD5, filesSize);
    452        
     452
    453453                // Filename based fallback
    454454                if (params.fileBasedFallback != 0)
    455455                        matched = detectGameFilebased(allFiles, params);
     
    488488
    489489                if (!fileMissing) {
    490490                        debug(4, "Matched: %s", agdesc->gameid);
    491        
     491
    492492                        if (numMatchedFiles > maxNumMatchedFiles) {
    493493                                matchedDesc = agdesc;
    494494                                maxNumMatchedFiles = numMatchedFiles;
    495        
     495
    496496                                debug(4, "and overriden");
    497497                        }
    498498                }
  • common/archive.cpp

     
    2525
    2626#include "common/archive.h"
    2727#include "common/fs.h"
    28 #include "common/file.h"
    2928#include "common/util.h"
    3029
    3130namespace Common {
     
    285284}
    286285
    287286
     287
     288DECLARE_SINGLETON(DefaultSearchManager);
     289
     290void DefaultSearchManager::addArchive(const String &name, ArchivePtr archive) {
     291        _searchSet.add(name, archive);
     292}
     293
     294void DefaultSearchManager::addDirectory(const String &directory) {
     295        addDirectoryRecursive(directory, 1);
     296}
     297
     298void DefaultSearchManager::addDirectoryRecursive(const String &directory, int depth) {
     299        _searchSet.add(directory, SharedPtr<FSDirectory>(new FSDirectory(directory, depth)));
     300}
     301
     302void DefaultSearchManager::clear() {
     303        _searchSet.clear();
     304}
     305
     306bool DefaultSearchManager::hasFile(const String &name) {
     307        return _searchSet.hasFile(name);
     308}
     309
     310int DefaultSearchManager::matchPattern(StringList &list, const String &pattern) {
     311        return _searchSet.matchPattern(list, pattern);
     312}
     313
     314SeekableReadStream *DefaultSearchManager::openFile(const String &name) {
     315        return _searchSet.openFile(name);
     316}
     317
     318
    288319} // namespace Common
  • common/archive.h

     
    3131#include "common/hash-str.h"
    3232#include "common/list.h"
    3333#include "common/ptr.h"
     34#include "common/singleton.h"
    3435#include "common/stream.h"
    3536
    3637namespace Common {
     
    144145};
    145146
    146147
    147 
    148148/**
    149149 * SearchSet enables access to a group of Archives through the Archive interface.
    150150 * Its intended usage is a situation in which there are no name clashes among names in the
     
    200200        virtual SeekableReadStream *openFile(const String &name);
    201201};
    202202
     203
     204class DefaultSearchManager : public Singleton<DefaultSearchManager>, public Archive {
     205
     206        SearchSet       _searchSet;
     207
     208public:
     209        /**
     210         *      Add an existing Archive. This is meant to support searching in system-specific
     211         *  archives, namely the MACOSX/IPHONE bundles.
     212         */
     213        void addArchive(const String &name, ArchivePtr archive);
     214
     215        /**
     216         *      Create and add a FSDirectory by name
     217         */
     218        void addDirectory(const String &directory);
     219
     220        /**
     221         *      Create and add a FSDirectory and its subdirectories by name
     222         */
     223        void addDirectoryRecursive(const String &directory, int depth = 4);
     224
     225        /**
     226         *      Clears the archive
     227         */
     228        void clear();
     229
     230
     231        virtual bool hasFile(const String &name);
     232        virtual int matchPattern(StringList &list, const String &pattern);
     233
     234        /**
     235         * Implements openFile from Archive base class. The current policy is
     236         * opening the first file encountered that matches the name.
     237         */
     238        virtual SeekableReadStream *openFile(const String &name);
     239};
     240
     241/** Shortcut for accessing the configuration manager. */
     242#define SearchMan               Common::DefaultSearchManager::instance()
     243
    203244} // namespace Common
    204245
    205246#endif
  • common/config-file.cpp

     
    2323 *
    2424 */
    2525
     26#include "common/archive.h"
     27#include "common/file.h"                        // included for DumpFile
    2628#include "common/config-file.h"
    27 #include "common/file.h"
    2829#include "common/savefile.h"
    2930#include "common/system.h"
    3031#include "common/util.h"
     
    5758}
    5859
    5960bool ConfigFile::loadFromFile(const String &filename) {
    60         File file;
    61         if (file.open(filename))
    62                 return loadFromStream(file);
    63         else
    64                 return false;
     61        SeekableReadStream *file = SearchMan.openFile(filename);
     62        bool result = false;
     63
     64        if (file)
     65                result = loadFromStream(*file);
     66
     67        delete file;
     68        return result;
    6569}
    6670
    6771bool ConfigFile::loadFromSaveFile(const char *filename) {
     
    135139                        assert(isValidName(section.name));
    136140                } else {
    137141                        // This line should be a line with a 'key=value' pair, or an empty one.
    138                        
     142
    139143                        // Skip leading whitespaces
    140144                        const char *t = line.c_str();
    141145                        while (isspace(*t))
     
    158162                        // Extract the key/value pair
    159163                        kv.key = String(t, p);
    160164                        kv.value = String(p + 1);
    161                        
     165
    162166                        // Trim of spaces
    163167                        kv.key.trim();
    164168                        kv.value.trim();
  • common/config-manager.cpp

     
    2323 *
    2424 */
    2525
     26#include "common/archive.h"
     27#include "common/file.h"                // included for DumpFile
    2628#include "common/config-manager.h"
    27 #include "common/file.h"
    2829#include "common/util.h"
    2930#include "common/system.h"
    3031
     
    6768        // ... load it, if available ...
    6869        if (stream)
    6970                loadFromStream(*stream);
    70        
     71
    7172        // ... and close it again.
    7273        delete stream;
    7374
     
    7778void ConfigManager::loadConfigFile(const String &filename) {
    7879        _filename = filename;
    7980
    80         File cfg_file;
    81         if (!cfg_file.open(filename)) {
     81        SeekableReadStream *cfg_file = SearchMan.openFile(filename);
     82        if (!cfg_file) {
    8283                printf("Creating configuration file: %s\n", filename.c_str());
    8384        } else {
    8485                printf("Using configuration file: %s\n", _filename.c_str());
    85                 loadFromStream(cfg_file);
     86                loadFromStream(*cfg_file);
    8687        }
     88        delete cfg_file;
    8789}
    8890
    8991void ConfigManager::loadFromStream(SeekableReadStream &stream) {
     
    140142                        _domainSaveOrder.push_back(domain);
    141143                } else {
    142144                        // This line should be a line with a 'key=value' pair, or an empty one.
    143                        
     145
    144146                        // Skip leading whitespaces
    145147                        const char *t = line.c_str();
    146148                        while (isspace(*t))
     
    163165                        // Extract the key/value pair
    164166                        String key(t, p);
    165167                        String value(p + 1);
    166                        
     168
    167169                        // Trim of spaces
    168170                        key.trim();
    169171                        value.trim();
     
    200202                        delete dump;
    201203                        return;
    202204                }
    203                
     205
    204206                stream = dump;
    205207        }
    206208
  • common/file.cpp

     
    2323 *
    2424 */
    2525
    26 #include "common/file.h"
     26#include "common/file.h"                // this is file.cpp!
    2727#include "common/fs.h"
    2828#include "common/hashmap.h"
    2929#include "common/util.h"
     
    485485
    486486        String fname(filename);
    487487        fname.toLowercase();
    488        
     488
    489489        _handle = fopenNoCase(filename, "", "wb");
    490490
    491491        if (_handle == NULL)
  • common/md5.cpp

     
    2828 * this program is licensed under the GPL.
    2929 */
    3030
    31 #include "common/file.h"
     31#include "common/archive.h"
    3232#include "common/fs.h"
    3333#include "common/md5.h"
    3434#include "common/util.h"
     
    262262}
    263263
    264264bool md5_file(const char *name, uint8 digest[16], uint32 length) {
    265         File f;
     265        SeekableReadStream *f = SearchMan.openFile(name);
    266266
    267         f.open(name);
    268         if (!f.isOpen()) {
     267        if (!f) {
    269268                warning("md5_file couldn't open '%s'", name);
    270269                return false;
    271270        }
    272271
    273         return md5_file(f, digest, length);
     272        bool result = md5_file(*f, digest, length);
     273        delete f;
     274        return result;
    274275}
    275276
    276277
  • common/system.cpp

     
    126126 Port specific variants should be pushed into the respective ports.
    127127
    128128 Ideally, the default OSystem::openConfigFileForReading/Writing methods
    129  should be removed completely. 
     129 should be removed completely.
    130130*/
    131131
    132 #include "common/file.h"
    133132
    134133#ifdef __PLAYSTATION2__
    135134#include "backends/platform/ps2/systemps2.h"
  • common/unzip.cpp

     
    2929*/
    3030
    3131#include "common/scummsys.h"
     32#include "common/stream.h"
    3233
    3334#ifdef USE_ZLIB
    3435
     
    4344#endif
    4445
    4546#include "common/unzip.h"
    46 #include "common/file.h"
    4747
    4848#ifdef STDC
    4949#  include <stddef.h>
     
    131131        uLong crc32_wait;           /* crc32 we must obtain after decompress all */
    132132        uLong rest_read_compressed; /* number of byte to be decompressed */
    133133        uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
    134         Common::File *file;                 /* io structore of the zipfile */
     134        Common::SeekableReadStream *file;                 /* io structore of the zipfile */
    135135        uLong compression_method;   /* compression method (0==store) */
    136136        uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
    137137} file_in_zip_read_info_s;
     
    141141*/
    142142typedef struct
    143143{
    144         Common::File file;                              /* io structore of the zipfile */
     144        Common::SeekableReadStream *file;                               /* io structore of the zipfile */
    145145        unz_global_info gi;                             /* public global information */
    146146        uLong byte_before_the_zipfile;  /* byte before the zipfile, (>0 for sfx)*/
    147147        uLong num_file;                                 /* number of the current file in the zipfile*/
     
    166166*/
    167167
    168168
    169 /*local int unzlocal_getByte(Common::File &fin, int *pi)
     169/*local int unzlocal_getByte(SeekableReadStream &fin, int *pi)
    170170{
    171171    unsigned char c = fin.readByte();
    172172      *pi = (int)c;
     
    185185/* ===========================================================================
    186186   Reads a long in LSB order from the given gz_stream. Sets
    187187*/
    188 local int unzlocal_getShort (Common::File &fin, uLong *pX)
     188local int unzlocal_getShort (Common::SeekableReadStream &fin, uLong *pX)
    189189{
    190190        *pX = fin.readUint16LE();
    191191        return UNZ_OK;
    192192}
    193193
    194 local int unzlocal_getLong (Common::File &fin, uLong *pX)
     194local int unzlocal_getLong (Common::SeekableReadStream &fin, uLong *pX)
    195195{
    196196        *pX = fin.readUint32LE();
    197197        return UNZ_OK;
     
    255255  Locate the Central directory of a zipfile (at the end, just before
    256256    the global comment)
    257257*/
    258 local uLong unzlocal_SearchCentralDir(Common::File &fin)
     258local uLong unzlocal_SearchCentralDir(Common::SeekableReadStream &fin)
    259259{
    260260        unsigned char* buf;
    261261        uLong uSizeFile;
     
    333333
    334334        int err=UNZ_OK;
    335335
     336
    336337        if (!us->file.open(path)) {
    337338                delete us;
    338339                return NULL;
  • engines/engine.cpp

     
    3131
    3232#include "engines/engine.h"
    3333#include "common/config-manager.h"
    34 #include "common/file.h"
    3534#include "common/timer.h"
    3635#include "common/savefile.h"
    3736#include "common/system.h"
     
    7675
    7776Engine::~Engine() {
    7877        _mixer->stopAll();
    79        
     78
    8079        delete _mainMenuDialog;
    8180        g_engine = NULL;
    8281}
     
    135134        // if it's running from CD.
    136135
    137136#ifdef USE_VORBIS
    138         if (Common::File::exists("track1.ogg"))
     137        if (SearchMan.hasFile("track1.ogg"))
    139138                return;
    140139#endif
    141140#ifdef USE_FLAC
    142         if (Common::File::exists("track1.fla") || Common::File::exists("track1.flac"))
     141        if (SearchMan.hasFile("track1.fla") || SearchMan.hasFile("track1.flac"))
    143142                return;
    144143#endif
    145144#ifdef USE_MAD
    146         if (Common::File::exists("track1.mp3"))
     145        if (SearchMan.hasFile("track1.mp3"))
    147146                return;
    148147#endif
    149148
     
    224223}
    225224
    226225int Engine::runDialog(Dialog &dialog) {
    227        
     226
    228227        pauseEngine(true);
    229228
    230229        int result = dialog.runModal();
     
    258257        Common::String gameid = ConfMan.get("gameid");
    259258        gameid.toLowercase();
    260259        EngineMan.findGame(gameid, &plugin);
    261        
     260
    262261        return ( (*plugin)->hasFeature((MetaEngine::MetaEngineFeature)f) );
    263262}
    264263
  • graphics/font.cpp

     
    2323 */
    2424
    2525#include "common/stream.h"
    26 #include "common/file.h"
     26#include "common/file.h"                // included for DumpFile
    2727#include "common/endian.h"
    2828#include "graphics/font.h"
    2929
  • gui/theme.cpp

     
    2525#include "gui/theme.h"
    2626#include "gui/eval.h"
    2727
     28#include "common/archive.h"
    2829#include "common/unzip.h"
    2930
    3031namespace GUI {
     
    3435        _defaultConfig.loadFromStream(s);
    3536
    3637        _evaluator = new Eval();
     38
     39        // FIXME: should path be added in runGame()?
     40        if (ConfMan.hasKey("themepath"))
     41                SearchMan.addDirectory(ConfMan.get("themepath"));
    3742}
    3843
    3944Theme::~Theme() {
     
    5964const Graphics::Font *Theme::loadFont(const char *filename) {
    6065        const Graphics::NewFont *font = 0;
    6166        Common::String cacheFilename = genCacheFilename(filename);
    62         Common::File fontFile;
     67        Common::SeekableReadStream *fontFile;
    6368
    6469        if (!cacheFilename.empty()) {
    65                 if (fontFile.open(cacheFilename))
    66                         font = Graphics::NewFont::loadFromCache(fontFile);
     70                fontFile = SearchMan.openFile(cacheFilename);
     71                if (fontFile) {
     72                        font = Graphics::NewFont::loadFromCache(*fontFile);
     73                        delete fontFile;
     74                }
    6775                if (font)
    6876                        return font;
    6977
     
    92100        }
    93101
    94102        // normal open
    95         if (fontFile.open(filename)) {
    96                 font = Graphics::NewFont::loadFont(fontFile);
     103        fontFile = SearchMan.openFile(filename);
     104        if (fontFile) {
     105                font = Graphics::NewFont::loadFont(*fontFile);
     106                delete fontFile;
    97107        }
    98108
    99109#ifdef USE_ZLIB
     
    147157}
    148158
    149159bool Theme::loadConfigFile(const Common::String &stylefile) {
    150         if (ConfMan.hasKey("themepath"))
    151                 Common::File::addDefaultDirectory(ConfMan.get("themepath"));
    152 
    153 #ifdef DATA_PATH
    154         Common::File::addDefaultDirectoryRecursive(DATA_PATH);
    155 #endif
    156 
    157         if (ConfMan.hasKey("extrapath"))
    158                 Common::File::addDefaultDirectoryRecursive(ConfMan.get("extrapath"));
    159 
    160160        if (!_configFile.loadFromFile(stylefile + ".ini")) {
    161161#ifdef USE_ZLIB
    162162                // Maybe find a nicer solution to this
     
    191191}
    192192
    193193bool Theme::themeConfigUseable(const Common::String &stylefile, const Common::String &style, Common::String *cStyle, Common::ConfigFile *cfg) {
    194         if (ConfMan.hasKey("themepath"))
    195                 Common::File::addDefaultDirectory(ConfMan.get("themepath"));
    196 
    197 #ifdef DATA_PATH
    198         Common::File::addDefaultDirectoryRecursive(DATA_PATH);
    199 #endif
    200 
    201         if (ConfMan.hasKey("extrapath"))
    202                 Common::File::addDefaultDirectoryRecursive(ConfMan.get("extrapath"));
    203 
    204         Common::File file;
     194        Common::SeekableReadStream *file;
    205195        Common::ConfigFile configFile;
    206196        if (!cfg && (cStyle || !style.empty()))
    207197                cfg = &configFile;
    208198
    209         if (!file.open(stylefile + ".ini")) {
     199        file = SearchMan.openFile(stylefile + ".ini");
     200        if (!file) {
    210201#ifdef USE_ZLIB
    211202                // Maybe find a nicer solution to this
    212203                unzFile zipFile = unzOpen((stylefile + ".zip").c_str());
     
    239230        }
    240231
    241232        if (!style.empty() || cStyle || cfg) {
    242                 if (file.isOpen()) {
    243                         if (!cfg->loadFromStream(file))
     233                if (file) {
     234                        if (!cfg->loadFromStream(*file))
    244235                                return false;
    245                         file.close();
     236                        delete file;
    246237                }
    247238
    248239                Common::String temp;
  • gui/theme.h

     
    2828#include "common/system.h"
    2929#include "common/rect.h"
    3030#include "common/str.h"
    31 #include "common/file.h"
    3231#include "common/config-file.h"
    3332
    3433#include "graphics/surface.h"
  • gui/ThemeModern.cpp

     
    3333#include "graphics/cursorman.h"
    3434
    3535#include "common/config-manager.h"
    36 #include "common/file.h"
    3736
    3837#define kShadowTr0 8
    3938#define kShadowTr1 16
  • sound/audiocd.cpp

     
    2929#include "sound/vorbis.h"
    3030#include "sound/flac.h"
    3131#include "engines/engine.h"
    32 #include "common/file.h"
    3332#include "common/util.h"
    3433#include "common/system.h"
    3534
  • sound/flac.cpp

     
    2727
    2828#ifdef USE_FLAC
    2929
    30 #include "common/file.h"
     30#include "common/stream.h"
    3131#include "common/util.h"
    3232
    3333#include "sound/audiostream.h"
  • sound/mixer.cpp

     
    2323 *
    2424 */
    2525
    26 #include "common/file.h"
    2726#include "common/util.h"
    2827#include "common/system.h"
    2928
     
    208207        assert(samples);
    209208
    210209        Common::StackLock lock(_mutex);
    211        
     210
    212211        int16 *buf = (int16 *)samples;
    213212        len >>= 2;
    214213
  • sound/mp3.cpp

     
    2727
    2828#ifdef USE_MAD
    2929
    30 #include "common/file.h"
     30#include "common/stream.h"
    3131#include "common/util.h"
    3232
    3333#include "sound/audiocd.h"
     
    117117        // Calculate play time
    118118        mad_timer_t length;
    119119
    120         mad_timer_set(&length, 0, 0, 1000);     
     120        mad_timer_set(&length, 0, 0, 1000);
    121121        mad_timer_add(&length, start);
    122122        mad_timer_negate(&length);
    123123
     
    175175        }
    176176
    177177        _totalPlayTime = mad_timer_count(length, MAD_UNITS_MILLISECONDS);
    178        
     178
    179179        if (numLoops && mad_timer_sign(length) >= 0)
    180180                _totalPlayTime *= numLoops;
    181181        else
  • sound/softsynth/mt32.cpp

     
    3434
    3535#include "common/config-manager.h"
    3636#include "common/events.h"
    37 #include "common/file.h"
    3837#include "common/system.h"
    3938#include "common/util.h"
    4039
     
    8079};
    8180
    8281class MT32File : public MT32Emu::File {
    83         Common::File _in;
     82        Common::SeekableReadStream *_in;
    8483        Common::DumpFile _out;
    8584public:
     85        MT32File() : _in(0) { }
     86        ~MT32File() { close(); }
    8687        bool open(const char *filename, OpenMode mode) {
    8788                if (mode == OpenMode_read)
    88                         return _in.open(filename);
     89                        return (_in = SearchMan.openFile(filename));
    8990                else
    9091                        return _out.open(filename);
    9192        }
    9293        void close() {
    93                 _in.close();
     94                delete _in; _in = 0;
    9495                _out.close();
    9596        }
    9697        size_t read(void *in, size_t size) {
    97                 return _in.read(in, size);
     98                return _in->read(in, size);
    9899        }
    99100        bool readBit8u(MT32Emu::Bit8u *in) {
    100                 byte b = _in.readByte();
    101                 if (_in.eof())
     101                byte b = _in->readByte();
     102                if (_in->eof())
    102103                        return false;
    103104                *in = b;
    104105                return true;
     
    111112                return !_out.ioFailed();
    112113        }
    113114        bool isEOF() {
    114                 return _in.isOpen() ? _in.eof() : _out.eof();
     115                return _in ? _in->eof() : _out.eof();
    115116        }
    116117};
    117118
     
    511512}
    512513
    513514MidiDriver *MidiDriver_MT32_create(Audio::Mixer *mixer) {
    514         // HACK: It will stay here until engine plugin loader overhaul
    515         if (ConfMan.hasKey("extrapath"))
    516                 Common::File::addDefaultDirectory(ConfMan.get("extrapath"));
    517 
    518515        MidiDriver *mididriver;
    519516
    520517        MT32EmuMusicPlugin p;
  • sound/vorbis.cpp

     
    2727
    2828#ifdef USE_VORBIS
    2929
    30 #include "common/file.h"
     30#include "common/stream.h"
    3131#include "common/util.h"
    3232
    3333#include "sound/audiostream.h"