1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "driver.h"

     6

#include "functions.h"

     7

#include "hal.h"

     8

#include "string.h"

     9

    10

typedef struct {

    11

	const DriverDesc *descs;

    12

	const char *name;

    13

	void *var;

    14

} DriverClass;

    15

    16

static DriverClass _driver_classes[] = {

    17

	{_video_driver_descs, "video", &_video_driver},

    18

	{_sound_driver_descs, "sound", &_sound_driver},

    19

	{_music_driver_descs, "music", &_music_driver},

    20

};

    21

    22

enum {

    23

	DF_PRIORITY_MASK = 0xF,

    24

};

    25

    26

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

    27

{

    28

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

    29

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

    30

	}

    31

	return NULL;

    32

}

    33

    34

static const DriverDesc* ChooseDefaultDriver(const DriverDesc* dd)

    35

{

    36

	byte os_version = GetOSVersion();

    37

	const DriverDesc *best = NULL;

    38

	int best_pri = -1;

    39

    40

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

    41

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

    42

			best_pri = dd->flags & DF_PRIORITY_MASK;

    43

			best = dd;

    44

		}

    45

	}

    46

	return best;

    47

}

    48

    49

void LoadDriver(int driver, const char *name)

    50

{

    51

	const DriverClass *dc = &_driver_classes[driver];

    52

	const DriverDesc *dd;

    53

	const void **var;

    54

	const void *drv;

    55

	const char *err;

    56

	char *parm;

    57

	char buffer[256];

    58

	const char *parms[32];

    59

    60

	parms[0] = NULL;

    61

    62

	if (!*name) {

    63

		dd = ChooseDefaultDriver(dc->descs);

    64

	} else {

    65

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

    66

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

    67

		parm = strchr(buffer, ':');

    68

		if (parm) {

    69

			uint np = 0;

    70

			// Tokenize the parm.

    71

			do {

    72

				*parm++ = 0;

    73

				if (np < lengthof(parms) - 1)

    74

					parms[np++] = parm;

    75

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

    76

					parm++;

    77

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

    78

			parms[np] = NULL;

    79

		}

    80

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

    81

		if (dd == NULL)

    82

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

    83

	}

    84

	var = dc->var;

    85

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

    86

	*var = NULL;

    87

	drv = dd->drv;

    88

    89

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

    90

	if (err != NULL)

    91

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

    92

	*var = drv;

    93

}

    94

    95

    96

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

    97

{

    98

	uint len = strlen(name);

    99

   100

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

   101

		const char* p = *parm;

   102

   103

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

   104

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

   105

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

   106

		}

   107

	}

   108

	return NULL;

   109

}

   110

   111

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

   112

{

   113

	return GetDriverParam(parm, name) != NULL;

   114

}

   115

   116

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

   117

{

   118

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

   119

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

   120

}

   121

   122

   123

void GetDriverList(char* p)

   124

{

   125

	const DriverClass* dc;

   126

   127

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

   128

		const DriverDesc* dd;

   129

   130

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

   131

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

   132

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

   133

		}

   134

	}

   135

}