1

/* $Id$ */

     2

     3

/** @file ini.cpp Definition of the IniItem class, related to reading/writing '*.ini' files. */

     4

     5

#include "stdafx.h"

     6

#include "core/alloc_func.hpp"

     7

#include "core/math_func.hpp"

     8

#include "debug.h"

     9

#include "ini_type.h"

    10

#include "string_func.h"

    11

#include "fileio_func.h"

    12

    13

IniItem::IniItem(IniGroup *parent, const char *name, size_t len) : next(NULL), value(NULL), comment(NULL)

    14

{

    15

	if (len == 0) len = strlen(name);

    16

    17

	this->name = strndup(name, len);

    18

	*parent->last_item = this;

    19

	parent->last_item = &this->next;

    20

}

    21

    22

IniItem::~IniItem()

    23

{

    24

	free(this->name);

    25

	free(this->value);

    26

	free(this->comment);

    27

    28

	delete this->next;

    29

}

    30

    31

void IniItem::SetValue(const char *value)

    32

{

    33

	free(this->value);

    34

	this->value = strdup(value);

    35

}

    36

    37

IniGroup::IniGroup(IniFile *parent, const char *name, size_t len) : next(NULL), type(IGT_VARIABLES), item(NULL), comment(NULL)

    38

{

    39

	if (len == 0) len = strlen(name);

    40

    41

	this->name = strndup(name, len);

    42

	this->last_item = &this->item;

    43

	*parent->last_group = this;

    44

	parent->last_group = &this->next;

    45

    46

	if (parent->list_group_names == NULL) return;

    47

    48

	for (uint i = 0; parent->list_group_names[i] != NULL; i++) {

    49

		if (strcmp(this->name, parent->list_group_names[i]) == 0) {

    50

			this->type = IGT_LIST;

    51

			return;

    52

		}

    53

	}

    54

}

    55

    56

IniGroup::~IniGroup()

    57

{

    58

	free(this->name);

    59

	free(this->comment);

    60

    61

	delete this->item;

    62

	delete this->next;

    63

}

    64

    65

IniItem *IniGroup::GetItem(const char *name, bool create)

    66

{

    67

	IniItem *item;

    68

	size_t len = strlen(name);

    69

    70

	for (item = this->item; item != NULL; item = item->next) {

    71

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

    72

	}

    73

    74

	if (!create) return NULL;

    75

    76

	/* otherwise make a new one */

    77

	return new IniItem(this, name, len);

    78

}

    79

    80

IniFile::IniFile(const char **list_group_names) : group(NULL), comment(NULL), list_group_names(list_group_names)

    81

{

    82

	this->last_group = &this->group;

    83

}

    84

    85

IniFile::~IniFile()

    86

{

    87

	free(this->comment);

    88

	delete this->group;

    89

}

    90

    91

IniGroup *IniFile::GetGroup(const char *name, size_t len)

    92

{

    93

	IniGroup *group;

    94

    95

	if (len == 0) len = strlen(name);

    96

    97

	/* does it exist already? */

    98

	for (group = this->group; group != NULL; group = group->next) {

    99

		if (!memcmp(group->name, name, len) && group->name[len] == 0) {

   100

			return group;

   101

		}

   102

	}

   103

   104

	/* otherwise make a new one */

   105

	group = new IniGroup(this, name, len);

   106

	group->comment = strdup("\n");

   107

	return group;

   108

}

   109

   110

void IniFile::RemoveGroup(const char *name)

   111

{

   112

	size_t len = strlen(name);

   113

	IniGroup *prev = NULL;

   114

	IniGroup *group;

   115

   116

	/* does it exist already? */

   117

	for (group = this->group; group != NULL; prev = group, group = group->next) {

   118

		if (memcmp(group->name, name, len) == 0) {

   119

			break;

   120

		}

   121

	}

   122

   123

	if (group == NULL) return;

   124

   125

	if (prev != NULL) {

   126

		prev->next = prev->next->next;

   127

		if (this->last_group == &group->next) this->last_group = &prev->next;

   128

	} else {

   129

		this->group = this->group->next;

   130

		if (this->last_group == &group->next) this->last_group = &this->group;

   131

	}

   132

   133

	group->next = NULL;

   134

	delete group;

   135

}

   136

   137

void IniFile::LoadFromDisk(const char *filename)

   138

{

   139

	assert(this->last_group == &this->group);

   140

   141

	char buffer[1024], c, *s, *t, *e;

   142

	IniGroup *group = NULL;

   143

	IniItem *item = NULL;

   144

   145

	char *comment = NULL;

   146

	uint comment_size = 0;

   147

	uint comment_alloc = 0;

   148

   149

	size_t end;

   150

	/*

   151

	 * Now we are going to open a file that contains no more than simple

   152

	 * plain text. That would raise the question: "why open the file as

   153

	 * if it is a binary file?". That's simple... Microsoft, in all

   154

	 * their greatness and wisdom decided it would be useful if ftell

   155

	 * is aware of '\r\n' and "sees" that as a single character. The

   156

	 * easiest way to test for that situation is by searching for '\n'

   157

	 * and decrease the value every time you encounter a '\n'. This will

   158

	 * thus also make ftell "see" the '\r' when it is not there, so the

   159

	 * result of ftell will be highly unreliable. So to work around this

   160

	 * marvel of wisdom we have to open in as a binary file.

   161

	 */

   162

	FILE *in = FioFOpenFile(filename, "rb", DATA_DIR, &end);

   163

	if (in == NULL) return;

   164

   165

	end += ftell(in);

   166

   167

	/* for each line in the file */

   168

	while ((size_t)ftell(in) < end && fgets(buffer, sizeof(buffer), in)) {

   169

		/* trim whitespace from the left side */

   170

		for (s = buffer; *s == ' ' || *s == '\t'; s++) {}

   171

   172

		/* trim whitespace from right side. */

   173

		e = s + strlen(s);

   174

		while (e > s && ((c = e[-1]) == '\n' || c == '\r' || c == ' ' || c == '\t')) e--;

   175

		*e = '\0';

   176

   177

		/* skip comments and empty lines */

   178

		if (*s == '#' || *s == ';' || *s == '\0') {

   179

			uint ns = comment_size + (e - s + 1);

   180

			uint a = comment_alloc;

   181

			uint pos;

   182

			/* add to comment */

   183

			if (ns > a) {

   184

				a = max(a, 128U);

   185

				do a *= 2; while (a < ns);

   186

				comment = ReallocT(comment, comment_alloc = a);

   187

			}

   188

			pos = comment_size;

   189

			comment_size += (e - s + 1);

   190

			comment[pos + e - s] = '\n'; // comment newline

   191

			memcpy(comment + pos, s, e - s); // copy comment contents

   192

			continue;

   193

		}

   194

   195

		/* it's a group? */

   196

		if (s[0] == '[') {

   197

			if (e[-1] != ']') {

   198

				ShowInfoF("ini: invalid group name '%s'", buffer);

   199

			} else {

   200

				e--;

   201

			}

   202

			s++; // skip [

   203

			group = new IniGroup(this, s, e - s);

   204

			if (comment_size) {

   205

				group->comment = strndup(comment, comment_size);

   206

				comment_size = 0;

   207

			}

   208

		} else if (group) {

   209

			/* find end of keyname */

   210

			if (*s == '\"') {

   211

				s++;

   212

				for (t = s; *t != '\0' && *t != '\"'; t++) {}

   213

				if (*t == '\"') *t = ' ';

   214

			} else {

   215

				for (t = s; *t != '\0' && *t != '=' && *t != '\t' && *t != ' '; t++) {}

   216

			}

   217

   218

			/* it's an item in an existing group */

   219

			item = new IniItem(group, s, t-s);

   220

			if (comment_size) {

   221

				item->comment = strndup(comment, comment_size);

   222

				comment_size = 0;

   223

			}

   224

   225

			/* find start of parameter */

   226

			while (*t == '=' || *t == ' ' || *t == '\t') t++;

   227

   228

   229

			/* remove starting quotation marks */

   230

			if (*t == '\"') t++;

   231

			/* remove ending quotation marks */

   232

			e = t + strlen(t);

   233

			if (e > t && e[-1] == '\"') e--;

   234

			*e = '\0';

   235

   236

			item->value = strndup(t, e - t);

   237

		} else {

   238

			/* it's an orphan item */

   239

			ShowInfoF("ini: '%s' outside of group", buffer);

   240

		}

   241

	}

   242

   243

	if (comment_size > 0) {

   244

		this->comment = strndup(comment, comment_size);

   245

		comment_size = 0;

   246

	}

   247

   248

	free(comment);

   249

	fclose(in);

   250

}

   251

   252

bool IniFile::SaveToDisk(const char *filename)

   253

{

   254

	FILE *f;

   255

	IniGroup *group;

   256

	IniItem *item;

   257

   258

	f = fopen(filename, "w");

   259

	if (f == NULL) return false;

   260

   261

	for (group = this->group; group != NULL; group = group->next) {

   262

		if (group->comment) fputs(group->comment, f);

   263

		fprintf(f, "[%s]\n", group->name);

   264

		for (item = group->item; item != NULL; item = item->next) {

   265

			assert(item->value != NULL);

   266

			if (item->comment != NULL) fputs(item->comment, f);

   267

   268

			/* protect item->name with quotes if needed */

   269

			if (strchr(item->name, ' ') != NULL) {

   270

				fprintf(f, "\"%s\"", item->name);

   271

			} else {

   272

				fprintf(f, "%s", item->name);

   273

			}

   274

   275

			fprintf(f, " = %s\n", item->value);

   276

		}

   277

	}

   278

	if (this->comment) fputs(this->comment, f);

   279

   280

	fclose(f);

   281

	return true;

   282

}