1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "driver.h"

     4

#include "functions.h"

     5

#include "hal.h"

     6

#include "string.h"

     7

     8

typedef struct {

     9

	const DriverDesc *descs;

    10

	const char *name;

    11

	void *var;

    12

} DriverClass;

    13

    14

static DriverClass _driver_classes[] = {

    15

	{_video_driver_descs, "video", &_video_driver},

    16

	{_sound_driver_descs, "sound", &_sound_driver},

    17

	{_music_driver_descs, "music", &_music_driver},

    18

};

    19

    20

enum {

    21

	DF_PRIORITY_MASK = 0xF,

    22

};

    23

    24

static const DriverDesc* GetDriverByName(const DriverDesc* dd, const char* name)

    25

{

    26

	for (; dd->name != NULL; dd++) {

    27

		if (strcmp(dd->name, name) == 0) return dd;

    28

	}

    29

	return NULL;

    30

}

    31

    32

static const DriverDesc* ChooseDefaultDriver(const DriverDesc* dd)

    33

{

    34

	byte os_version = GetOSVersion();

    35

	const DriverDesc *best = NULL;

    36

	int best_pri = -1;

    37

    38

	for (; dd->name != NULL; dd++) {

    39

		if ((int)(dd->flags & DF_PRIORITY_MASK) > best_pri && os_version >= (byte)dd->flags) {

    40

			best_pri = dd->flags & DF_PRIORITY_MASK;

    41

			best = dd;

    42

		}

    43

	}

    44

	return best;

    45

}

    46

    47

void LoadDriver(int driver, const char *name)

    48

{

    49

	const DriverClass *dc = &_driver_classes[driver];

    50

	const DriverDesc *dd;

    51

	const void **var;

    52

	const void *drv;

    53

	const char *err;

    54

	char *parm;

    55

	char buffer[256];

    56

	const char *parms[32];

    57

    58

	parms[0] = NULL;

    59

    60

	if (!*name) {

    61

		dd = ChooseDefaultDriver(dc->descs);

    62

	} else {

    63

		// Extract the driver name and put parameter list in parm

    64

		ttd_strlcpy(buffer, name, sizeof(buffer));

    65

		parm = strchr(buffer, ':');

    66

		if (parm) {

    67

			uint np = 0;

    68

			// Tokenize the parm.

    69

			do {

    70

				*parm++ = 0;

    71

				if (np < lengthof(parms) - 1)

    72

					parms[np++] = parm;

    73

				while (*parm != 0 && *parm != ',')

    74

					parm++;

    75

			} while (*parm == ',');

    76

			parms[np] = NULL;

    77

		}

    78

		dd = GetDriverByName(dc->descs, buffer);

    79

		if (dd == NULL)

    80

			error("No such %s driver: %s\n", dc->name, buffer);

    81

	}

    82

	var = dc->var;

    83

	if (*var != NULL) ((const HalCommonDriver*)*var)->stop();

    84

	*var = NULL;

    85

	drv = dd->drv;

    86

    87

	err = ((const HalCommonDriver*)drv)->start(parms);

    88

	if (err != NULL)

    89

		error("Unable to load driver %s(%s). The error was: %s\n", dd->name, dd->longname, err);

    90

	*var = drv;

    91

}

    92

    93

    94

static const char* GetDriverParam(const char* const* parm, const char* name)

    95

{

    96

	uint len = strlen(name);

    97

    98

	for (; *parm != NULL; parm++) {

    99

		const char* p = *parm;

   100

   101

		if (strncmp(p, name, len) == 0) {

   102

			if (p[len] == '=')  return p + len + 1;

   103

			if (p[len] == '\0') return p + len;

   104

		}

   105

	}

   106

	return NULL;

   107

}

   108

   109

bool GetDriverParamBool(const char* const* parm, const char* name)

   110

{

   111

	return GetDriverParam(parm, name) != NULL;

   112

}

   113

   114

int GetDriverParamInt(const char* const* parm, const char* name, int def)

   115

{

   116

	const char* p = GetDriverParam(parm, name);

   117

	return p != NULL ? atoi(p) : def;

   118

}

   119

   120

   121

void GetDriverList(char* p)

   122

{

   123

	const DriverClass* dc;

   124

   125

	for (dc = _driver_classes; dc != endof(_driver_classes); dc++) {

   126

		const DriverDesc* dd;

   127

   128

		p += sprintf(p, "List of %s drivers:\n", dc->name);

   129

		for (dd = dc->descs; dd->name != NULL; dd++) {

   130

			p += sprintf(p, "%10s: %s\n", dd->name, dd->longname);

   131

		}

   132

	}

   133

}