1

/* $Id$ */

     2

     3

/** @file fileio.cpp Standard In/Out file operations */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "fileio.h"

     8

#include "functions.h"

     9

#include "string.h"

    10

#include "macros.h"

    11

#include "variables.h"

    12

#include "debug.h"

    13

    14

/*************************************************/

    15

/* FILE IO ROUTINES ******************************/

    16

/*************************************************/

    17

    18

#define FIO_BUFFER_SIZE 512

    19

#define MAX_HANDLES 64

    20

    21

typedef struct {

    22

	byte *buffer, *buffer_end;          ///< position pointer in local buffer and last valid byte of buffer

    23

	uint32 pos;                         ///< current (system) position in file

    24

	FILE *cur_fh;                       ///< current file handle

    25

	FILE *handles[MAX_HANDLES];         ///< array of file handles we can have open

    26

	byte buffer_start[FIO_BUFFER_SIZE]; ///< local buffer when read from file

    27

#if defined(LIMITED_FDS)

    28

	uint open_handles;                  ///< current amount of open handles

    29

	const char *filename[MAX_HANDLES];  ///< array of filenames we (should) have open

    30

	uint usage_count[MAX_HANDLES];      ///< count how many times this file has been opened

    31

#endif /* LIMITED_FDS */

    32

} Fio;

    33

    34

static Fio _fio;

    35

    36

/* Get current position in file */

    37

uint32 FioGetPos(void)

    38

{

    39

	return _fio.pos + (_fio.buffer - _fio.buffer_start) - FIO_BUFFER_SIZE;

    40

}

    41

    42

void FioSeekTo(uint32 pos, int mode)

    43

{

    44

	if (mode == SEEK_CUR) pos += FioGetPos();

    45

	_fio.buffer = _fio.buffer_end = _fio.buffer_start + FIO_BUFFER_SIZE;

    46

	_fio.pos = pos;

    47

	fseek(_fio.cur_fh, _fio.pos, SEEK_SET);

    48

}

    49

    50

#if defined(LIMITED_FDS)

    51

static void FioRestoreFile(int slot)

    52

{

    53

	/* Do we still have the file open, or should we reopen it? */

    54

	if (_fio.handles[slot] == NULL) {

    55

		DEBUG(misc, 6, "Restoring file '%s' in slot '%d' from disk", _fio.filename[slot], slot);

    56

		FioOpenFile(slot, _fio.filename[slot]);

    57

	}

    58

	_fio.usage_count[slot]++;

    59

}

    60

#endif /* LIMITED_FDS */

    61

    62

/* Seek to a file and a position */

    63

void FioSeekToFile(uint32 pos)

    64

{

    65

	FILE *f;

    66

#if defined(LIMITED_FDS)

    67

	/* Make sure we have this file open */

    68

	FioRestoreFile(pos >> 24);

    69

#endif /* LIMITED_FDS */

    70

	f = _fio.handles[pos >> 24];

    71

	assert(f != NULL);

    72

	_fio.cur_fh = f;

    73

	FioSeekTo(GB(pos, 0, 24), SEEK_SET);

    74

}

    75

    76

byte FioReadByte(void)

    77

{

    78

	if (_fio.buffer == _fio.buffer_end) {

    79

		_fio.pos += FIO_BUFFER_SIZE;

    80

		fread(_fio.buffer = _fio.buffer_start, 1, FIO_BUFFER_SIZE, _fio.cur_fh);

    81

	}

    82

	return *_fio.buffer++;

    83

}

    84

    85

void FioSkipBytes(int n)

    86

{

    87

	for (;;) {

    88

		int m = min(_fio.buffer_end - _fio.buffer, n);

    89

		_fio.buffer += m;

    90

		n -= m;

    91

		if (n == 0) break;

    92

		FioReadByte();

    93

		n--;

    94

	}

    95

}

    96

    97

uint16 FioReadWord(void)

    98

{

    99

	byte b = FioReadByte();

   100

	return (FioReadByte() << 8) | b;

   101

}

   102

   103

uint32 FioReadDword(void)

   104

{

   105

	uint b = FioReadWord();

   106

	return (FioReadWord() << 16) | b;

   107

}

   108

   109

void FioReadBlock(void *ptr, uint size)

   110

{

   111

	FioSeekTo(FioGetPos(), SEEK_SET);

   112

	_fio.pos += size;

   113

	fread(ptr, 1, size, _fio.cur_fh);

   114

}

   115

   116

static inline void FioCloseFile(int slot)

   117

{

   118

	if (_fio.handles[slot] != NULL) {

   119

		fclose(_fio.handles[slot]);

   120

		_fio.handles[slot] = NULL;

   121

#if defined(LIMITED_FDS)

   122

		_fio.open_handles--;

   123

#endif /* LIMITED_FDS */

   124

	}

   125

}

   126

   127

void FioCloseAll(void)

   128

{

   129

	int i;

   130

   131

	for (i = 0; i != lengthof(_fio.handles); i++)

   132

		FioCloseFile(i);

   133

}

   134

   135

bool FioCheckFileExists(const char *filename)

   136

{

   137

	FILE *f = FioFOpenFile(filename);

   138

	if (f == NULL) return false;

   139

   140

	fclose(f);

   141

	return true;

   142

}

   143

   144

#if defined(LIMITED_FDS)

   145

static void FioFreeHandle()

   146

{

   147

	/* If we are about to open a file that will exceed the limit, close a file */

   148

	if (_fio.open_handles + 1 == LIMITED_FDS) {

   149

		uint i, count;

   150

		int slot;

   151

   152

		count = UINT_MAX;

   153

		slot = -1;

   154

		/* Find the file that is used the least */

   155

		for (i = 0; i < lengthof(_fio.handles); i++) {

   156

			if (_fio.handles[i] != NULL && _fio.usage_count[i] < count) {

   157

				count = _fio.usage_count[i];

   158

				slot  = i;

   159

			}

   160

		}

   161

		assert(slot != -1);

   162

		DEBUG(misc, 6, "Closing filehandler '%s' in slot '%d' because of fd-limit", _fio.filename[slot], slot);

   163

		FioCloseFile(slot);

   164

	}

   165

}

   166

#endif /* LIMITED_FDS */

   167

   168

FILE *FioFOpenFile(const char *filename)

   169

{

   170

	FILE *f;

   171

	char buf[MAX_PATH];

   172

   173

	snprintf(buf, lengthof(buf), "%s%s", _paths.data_dir, filename);

   174

   175

	f = fopen(buf, "rb");

   176

#if !defined(WIN32)

   177

	if (f == NULL) {

   178

		strtolower(buf + strlen(_paths.data_dir) - 1);

   179

		f = fopen(buf, "rb");

   180

   181

#if defined SECOND_DATA_DIR

   182

		/* tries in the 2nd data directory */

   183

		if (f == NULL) {

   184

			snprintf(buf, lengthof(buf), "%s%s", _paths.second_data_dir, filename);

   185

			strtolower(buf + strlen(_paths.second_data_dir) - 1);

   186

			f = fopen(buf, "rb");

   187

		}

   188

#endif

   189

	}

   190

#endif

   191

   192

	return f;

   193

}

   194

   195

void FioOpenFile(int slot, const char *filename)

   196

{

   197

	FILE *f;

   198

   199

#if defined(LIMITED_FDS)

   200

	FioFreeHandle();

   201

#endif /* LIMITED_FDS */

   202

	f = FioFOpenFile(filename);

   203

	if (f == NULL) error("Cannot open file '%s%s'", _paths.data_dir, filename);

   204

   205

	FioCloseFile(slot); // if file was opened before, close it

   206

	_fio.handles[slot] = f;

   207

#if defined(LIMITED_FDS)

   208

	_fio.filename[slot] = filename;

   209

	_fio.usage_count[slot] = 0;

   210

	_fio.open_handles++;

   211

#endif /* LIMITED_FDS */

   212

	FioSeekToFile(slot << 24);

   213

}