SIDPlayer/src/prefs.cpp

/*
 *  prefs.cpp - Preferences handling
 *
 *  SIDPlayer (C) Copyright 1996-2001 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sys.h"

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

#include "prefs.h"


// Prefs items are stored in a linked list of these nodes
struct prefs_node {
        prefs_node *next;
        const char *name;
        prefs_type type;
        void *data;
        prefs_desc *desc;
};

// List of prefs nodes
static prefs_node *the_prefs = NULL;

// Prototypes
static prefs_desc *find_prefs_desc(const char *name);


/*
 *  Initialize preferences
 */

void PrefsInit(int &argc, char **&argv)
{
        // Set defaults
        AddPrefsDefaults();

        // Override prefs with command line options
        for (int i=1; i<argc; i++) {

                // Options are of the form '--keyword'
                const char *option = argv[i];
                if (strlen(option) < 3 || option[0] != '-' || option[1] != '-')
                        continue;
                const char *keyword = option + 2;

                // Find descriptor for keyword
                const prefs_desc *d = find_prefs_desc(keyword);
                if (d == NULL)
                        continue;
                argv[i] = NULL;

                // Get value
                i++;
                if (i >= argc) {
                        fprintf(stderr, "Option '%s' must be followed by a value\n", option);
                        continue;
                }
                const char *value = argv[i];
                argv[i] = NULL;

                // Add/replace prefs item
                switch (d->type) {
                        case TYPE_STRING:
                                if (d->multiple)
                                        PrefsAddString(keyword, value);
                                else
                                        PrefsReplaceString(keyword, value);
                                break;

                        case TYPE_BOOLEAN: {
                                if (!strcmp(value, "true") || !strcmp(value, "on") || !strcmp(value, "yes"))
                                        PrefsReplaceBool(keyword, true);
                                else if (!strcmp(value, "false") || !strcmp(value, "off") || !strcmp(value, "no"))
                                        PrefsReplaceBool(keyword, false);
                                else
                                        fprintf(stderr, "Value for option '%s' must be 'true' or 'false'\n", option);
                                break;
                        }

                        case TYPE_INT32:
                                PrefsReplaceInt32(keyword, atoi(value));
                                break;

                        default:
                                break;
                }
        }

        // Remove processed arguments
        for (int i=1; i<argc; i++) {
                int k;
                for (k=i; k<argc; k++)
                        if (argv[k] != NULL)
                                break;
                if (k > i) {
                        k -= i;
                        for (int j=i+k; j<argc; j++)
                                argv[j-k] = argv[j];
                        argc -= k;
                }
        }
}


/*
 *  Deinitialize preferences
 */

void PrefsExit(void)
{
        // Free prefs list
        prefs_node *p = the_prefs, *next;
        while (p) {
                next = p->next;
                free((void *)p->name);
                free(p->data);
                delete p;
                p = next;
        }
}


/*
 *  Print preferences options help
 */

static void print_options(const prefs_desc *list)
{
        while (list->type != TYPE_END) {
                if (list->help) {
                        const char *typestr, *defstr;
                        char numstr[32];
                        switch (list->type) {
                                case TYPE_STRING:
                                        typestr = "STRING";
                                        defstr = PrefsFindString(list->name);
                                        if (defstr == NULL)
                                                defstr = "none";
                                        break;
                                case TYPE_BOOLEAN:
                                        typestr = "BOOL";
                                        if (PrefsFindBool(list->name))
                                                defstr = "true";
                                        else
                                                defstr = "false";
                                        break;
                                case TYPE_INT32:
                                        typestr = "NUMBER";
                                        sprintf(numstr, "%d", PrefsFindInt32(list->name));
                                        defstr = numstr;
                                        break;
                                default:
                                        typestr = "<unknown>";
                                        defstr = "none";
                                        break;
                        }
                        printf("  --%s %s\n    %s [default=%s]\n", list->name, typestr, list->help, defstr);
                }
                list++;
        }
}

void PrefsPrintUsage(void)
{
        printf("\nGeneral options:\n");
        print_options(common_prefs_items);
        printf("\nBoolean options are specified as '--OPTION true|on|yes' or\n'--OPTION false|off|no'.\n");
}


/*
 *  Find preferences descriptor by keyword
 */

static prefs_desc *find_prefs_desc(const char *name, prefs_desc *list)
{
        while (list->type != TYPE_END) {
                if (strcmp(list->name, name) == 0)
                        return list;
                list++;
        }
        return NULL;
}

static prefs_desc *find_prefs_desc(const char *name)
{
        return find_prefs_desc(name, common_prefs_items);
}


/*
 *  Set prefs items
 */

static void add_data(const char *name, prefs_type type, void *data, int size)
{
        void *d = malloc(size);
        if (d == NULL)
                return;
        memcpy(d, data, size);
        prefs_node *p = new prefs_node;
        p->next = 0;
        p->name = strdup(name);
        p->type = type;
        p->data = d;
        p->desc = find_prefs_desc(p->name);
        if (the_prefs) {
                prefs_node *prev = the_prefs;
                while (prev->next)
                        prev = prev->next;
                prev->next = p;
        } else
                the_prefs = p;
}

void PrefsAddString(const char *name, const char *s)
{
        add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
}

void PrefsAddBool(const char *name, bool b)
{
        add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
}

void PrefsAddInt32(const char *name, int32 val)
{
        add_data(name, TYPE_INT32, &val, sizeof(int32));
}


/*
 *  Replace prefs items
 */

static prefs_node *find_node(const char *name, prefs_type type, int index = 0)
{
        prefs_node *p = the_prefs;
        int i = 0;
        while (p) {
                if ((type == TYPE_ANY || p->type == type) && !strcmp(p->name, name)) {
                        if (i == index)
                                return p;
                        else
                                i++;
                }
                p = p->next;
        }
        return NULL;
}

void PrefsReplaceString(const char *name, const char *s, int index)
{
        prefs_node *p = find_node(name, TYPE_STRING, index);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_string)(p->desc->func))(name, (const char *)p->data, s);
                free(p->data);
                p->data = strdup(s);
        } else
                add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
}

void PrefsReplaceBool(const char *name, bool b)
{
        prefs_node *p = find_node(name, TYPE_BOOLEAN);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_bool)(p->desc->func))(name, *(bool *)(p->data), b);
                *(bool *)(p->data) = b;
        } else
                add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
}

void PrefsReplaceInt32(const char *name, int32 val)
{
        prefs_node *p = find_node(name, TYPE_INT32);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_int32)(p->desc->func))(name, *(int32 *)(p->data), val);
                *(int32 *)(p->data) = val;
        } else
                add_data(name, TYPE_INT32, &val, sizeof(int32));
}


/*
 *  Get prefs items
 */

const char *PrefsFindString(const char *name, int index)
{
        prefs_node *p = find_node(name, TYPE_STRING, index);
        if (p)
                return (char *)(p->data);
        else
                return NULL;
}

bool PrefsFindBool(const char *name)
{
        prefs_node *p = find_node(name, TYPE_BOOLEAN, 0);
        if (p)
                return *(bool *)(p->data);
        else
                return false;
}

int32 PrefsFindInt32(const char *name)
{
        prefs_node *p = find_node(name, TYPE_INT32, 0);
        if (p)
                return *(int32 *)(p->data);
        else
                return 0;
}


/*
 *  Remove prefs items
 */

void PrefsRemoveItem(const char *name, int index)
{
        prefs_node *p = find_node(name, TYPE_ANY, index);
        if (p) {
                free((void *)p->name);
                free(p->data);
                prefs_node *q = the_prefs;
                if (q == p) {
                        the_prefs = NULL;
                        delete p;
                        return;
                }
                while (q) {
                        if (q->next == p) {
                                q->next = p->next;
                                delete p;
                                return;
                        }
                        q = q->next;
                }
        }
}


/*
 *  Set prefs change callback function
 */

static void set_callback(const char *name, prefs_func f)
{
        prefs_desc *d = find_prefs_desc(name);
        if (d == NULL)
                return;
        d->func = f;
}

void PrefsSetCallback(const char *name, prefs_func_string f)
{
        set_callback(name, (prefs_func)f);
}

void PrefsSetCallback(const char *name, prefs_func_bool f)
{
        set_callback(name, (prefs_func)f);
}

void PrefsSetCallback(const char *name, prefs_func_int32 f)
{
        set_callback(name, (prefs_func)f);
}
Revision:	1.5
Committed:	2001-04-01T12:13:49Z (23 years, 7 months ago) by cebix
Branch:	MAIN
Changes since 1.4:	+42 -48 lines
Log Message:	- PrefsInit() removes processed options - changes to command line argument handling
#	User	Rev	Content
1	cebix	1.1	/*
2			* prefs.cpp - Preferences handling
3			*
4	cebix	1.4	* SIDPlayer (C) Copyright 1996-2001 Christian Bauer
5	cebix	1.1	*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "sys.h"
22
23			#include <string.h>
24			#include <stdlib.h>
25			#include <stdio.h>
26			#include <ctype.h>
27
28			#include "prefs.h"
29
30
31	cebix	1.2	// Prefs items are stored in a linked list of these nodes
32	cebix	1.1	struct prefs_node {
33			prefs_node *next;
34			const char *name;
35			prefs_type type;
36			void *data;
37			prefs_desc *desc;
38			};
39
40			// List of prefs nodes
41	cebix	1.2	static prefs_node *the_prefs = NULL;
42
43			// Prototypes
44			static prefs_desc find_prefs_desc(const char name);
45	cebix	1.1
46
47			/*
48			* Initialize preferences
49			*/
50
51	cebix	1.5	void PrefsInit(int &argc, char **&argv)
52	cebix	1.1	{
53	cebix	1.2	// Set defaults
54			AddPrefsDefaults();
55
56	cebix	1.5	// Override prefs with command line options
57			for (int i=1; i<argc; i++) {
58	cebix	1.2
59	cebix	1.5	// Options are of the form '--keyword'
60			const char *option = argv[i];
61			if (strlen(option) < 3 \|\| option[0] != '-' \|\| option[1] != '-')
62	cebix	1.2	continue;
63	cebix	1.5	const char *keyword = option + 2;
64	cebix	1.3
65			// Find descriptor for keyword
66	cebix	1.2	const prefs_desc *d = find_prefs_desc(keyword);
67	cebix	1.5	if (d == NULL)
68			continue;
69			argv[i] = NULL;
70
71			// Get value
72			i++;
73			if (i >= argc) {
74			fprintf(stderr, "Option '%s' must be followed by a value\n", option);
75			continue;
76	cebix	1.2	}
77	cebix	1.5	const char *value = argv[i];
78			argv[i] = NULL;
79	cebix	1.1
80	cebix	1.2	// Add/replace prefs item
81			switch (d->type) {
82			case TYPE_STRING:
83			if (d->multiple)
84	cebix	1.5	PrefsAddString(keyword, value);
85	cebix	1.2	else
86	cebix	1.5	PrefsReplaceString(keyword, value);
87	cebix	1.2	break;
88
89	cebix	1.3	case TYPE_BOOLEAN: {
90	cebix	1.5	if (!strcmp(value, "true") \|\| !strcmp(value, "on") \|\| !strcmp(value, "yes"))
91			PrefsReplaceBool(keyword, true);
92			else if (!strcmp(value, "false") \|\| !strcmp(value, "off") \|\| !strcmp(value, "no"))
93			PrefsReplaceBool(keyword, false);
94			else
95			fprintf(stderr, "Value for option '%s' must be 'true' or 'false'\n", option);
96	cebix	1.2	break;
97	cebix	1.3	}
98	cebix	1.2
99			case TYPE_INT32:
100	cebix	1.5	PrefsReplaceInt32(keyword, atoi(value));
101	cebix	1.2	break;
102
103			default:
104			break;
105			}
106			}
107	cebix	1.5
108			// Remove processed arguments
109			for (int i=1; i<argc; i++) {
110			int k;
111			for (k=i; k<argc; k++)
112			if (argv[k] != NULL)
113			break;
114			if (k > i) {
115			k -= i;
116			for (int j=i+k; j<argc; j++)
117			argv[j-k] = argv[j];
118			argc -= k;
119			}
120			}
121	cebix	1.1	}
122
123
124			/*
125			* Deinitialize preferences
126			*/
127
128			void PrefsExit(void)
129			{
130			// Free prefs list
131			prefs_node p = the_prefs, next;
132			while (p) {
133			next = p->next;
134			free((void *)p->name);
135			free(p->data);
136			delete p;
137			p = next;
138			}
139			}
140
141
142			/*
143	cebix	1.3	* Print preferences options help
144			*/
145
146			static void print_options(const prefs_desc *list)
147			{
148			while (list->type != TYPE_END) {
149			if (list->help) {
150			const char typestr, defstr;
151			char numstr[32];
152			switch (list->type) {
153			case TYPE_STRING:
154			typestr = "STRING";
155			defstr = PrefsFindString(list->name);
156			if (defstr == NULL)
157			defstr = "none";
158			break;
159			case TYPE_BOOLEAN:
160			typestr = "BOOL";
161			if (PrefsFindBool(list->name))
162			defstr = "true";
163			else
164			defstr = "false";
165			break;
166			case TYPE_INT32:
167			typestr = "NUMBER";
168			sprintf(numstr, "%d", PrefsFindInt32(list->name));
169			defstr = numstr;
170			break;
171			default:
172			typestr = "<unknown>";
173			defstr = "none";
174			break;
175			}
176			printf(" --%s %s\n %s [default=%s]\n", list->name, typestr, list->help, defstr);
177			}
178			list++;
179			}
180			}
181
182			void PrefsPrintUsage(void)
183			{
184			printf("\nGeneral options:\n");
185			print_options(common_prefs_items);
186	cebix	1.5	printf("\nBoolean options are specified as '--OPTION true\|on\|yes' or\n'--OPTION false\|off\|no'.\n");
187	cebix	1.3	}
188
189
190			/*
191	cebix	1.1	* Find preferences descriptor by keyword
192			*/
193
194			static prefs_desc find_prefs_desc(const char name, prefs_desc *list)
195			{
196	cebix	1.3	while (list->type != TYPE_END) {
197	cebix	1.1	if (strcmp(list->name, name) == 0)
198			return list;
199			list++;
200			}
201			return NULL;
202			}
203
204	cebix	1.2	static prefs_desc find_prefs_desc(const char name)
205			{
206			return find_prefs_desc(name, common_prefs_items);
207			}
208
209	cebix	1.1
210			/*
211			* Set prefs items
212			*/
213
214			static void add_data(const char name, prefs_type type, void data, int size)
215			{
216			void *d = malloc(size);
217			if (d == NULL)
218			return;
219			memcpy(d, data, size);
220			prefs_node *p = new prefs_node;
221			p->next = 0;
222			p->name = strdup(name);
223			p->type = type;
224			p->data = d;
225	cebix	1.2	p->desc = find_prefs_desc(p->name);
226	cebix	1.1	if (the_prefs) {
227			prefs_node *prev = the_prefs;
228			while (prev->next)
229			prev = prev->next;
230			prev->next = p;
231			} else
232			the_prefs = p;
233			}
234
235			void PrefsAddString(const char name, const char s)
236			{
237			add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
238			}
239
240			void PrefsAddBool(const char *name, bool b)
241			{
242			add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
243			}
244
245			void PrefsAddInt32(const char *name, int32 val)
246			{
247			add_data(name, TYPE_INT32, &val, sizeof(int32));
248			}
249
250
251			/*
252			* Replace prefs items
253			*/
254
255			static prefs_node find_node(const char name, prefs_type type, int index = 0)
256			{
257			prefs_node *p = the_prefs;
258			int i = 0;
259			while (p) {
260			if ((type == TYPE_ANY \|\| p->type == type) && !strcmp(p->name, name)) {
261			if (i == index)
262			return p;
263			else
264			i++;
265			}
266			p = p->next;
267			}
268			return NULL;
269			}
270
271			void PrefsReplaceString(const char name, const char s, int index)
272			{
273			prefs_node *p = find_node(name, TYPE_STRING, index);
274			if (p) {
275			if (p->desc && p->desc->func)
276			((prefs_func_string)(p->desc->func))(name, (const char *)p->data, s);
277			free(p->data);
278			p->data = strdup(s);
279			} else
280			add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
281			}
282
283			void PrefsReplaceBool(const char *name, bool b)
284			{
285			prefs_node *p = find_node(name, TYPE_BOOLEAN);
286			if (p) {
287			if (p->desc && p->desc->func)
288			((prefs_func_bool)(p->desc->func))(name, (bool )(p->data), b);
289			(bool )(p->data) = b;
290			} else
291			add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
292			}
293
294			void PrefsReplaceInt32(const char *name, int32 val)
295			{
296			prefs_node *p = find_node(name, TYPE_INT32);
297			if (p) {
298			if (p->desc && p->desc->func)
299			((prefs_func_int32)(p->desc->func))(name, (int32 )(p->data), val);
300			(int32 )(p->data) = val;
301			} else
302			add_data(name, TYPE_INT32, &val, sizeof(int32));
303			}
304
305
306			/*
307			* Get prefs items
308			*/
309
310			const char PrefsFindString(const char name, int index)
311			{
312			prefs_node *p = find_node(name, TYPE_STRING, index);
313			if (p)
314			return (char *)(p->data);
315			else
316			return NULL;
317			}
318
319			bool PrefsFindBool(const char *name)
320			{
321			prefs_node *p = find_node(name, TYPE_BOOLEAN, 0);
322			if (p)
323			return (bool )(p->data);
324			else
325			return false;
326			}
327
328			int32 PrefsFindInt32(const char *name)
329			{
330			prefs_node *p = find_node(name, TYPE_INT32, 0);
331			if (p)
332			return (int32 )(p->data);
333			else
334			return 0;
335			}
336
337
338			/*
339			* Remove prefs items
340			*/
341
342			void PrefsRemoveItem(const char *name, int index)
343			{
344			prefs_node *p = find_node(name, TYPE_ANY, index);
345			if (p) {
346			free((void *)p->name);
347			free(p->data);
348			prefs_node *q = the_prefs;
349			if (q == p) {
350			the_prefs = NULL;
351			delete p;
352			return;
353			}
354			while (q) {
355			if (q->next == p) {
356			q->next = p->next;
357			delete p;
358			return;
359			}
360			q = q->next;
361			}
362			}
363			}
364
365
366			/*
367			* Set prefs change callback function
368			*/
369
370			static void set_callback(const char *name, prefs_func f)
371			{
372	cebix	1.2	prefs_desc *d = find_prefs_desc(name);
373	cebix	1.1	if (d == NULL)
374			return;
375			d->func = f;
376			}
377
378			void PrefsSetCallback(const char *name, prefs_func_string f)
379			{
380			set_callback(name, (prefs_func)f);
381			}
382
383			void PrefsSetCallback(const char *name, prefs_func_bool f)
384			{
385			set_callback(name, (prefs_func)f);
386			}
387
388			void PrefsSetCallback(const char *name, prefs_func_int32 f)
389			{
390			set_callback(name, (prefs_func)f);
391			}