SIDPlayer/src/prefs.cpp

/*
 *  prefs.cpp - Preferences handling
 *
 *  SIDPlayer (C) Copyright 1996-2000 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 arguments
        argc--; argv++;
        for (; argc>0; argc--, argv++) {

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

                // Find descriptor for keyword
                const prefs_desc *d = find_prefs_desc(keyword);
                bool negated_bool = false;
                if (d == NULL) {
                        // We also accept boolean arguments in the form '--nokeyword'
                        if (strncmp(keyword, "no", 2) == 0) {
                                negated_bool = true;
                                keyword += 2;
                                d = find_prefs_desc(keyword);
                        }
                        if (d == NULL) {
                                printf("WARNING: Unrecognized argument '%s'\n", *argv);
                                continue;
                        }
                }

                // Add/replace prefs item
                switch (d->type) {
                        case TYPE_STRING:
                                if (argc < 2) {
                                        printf("WARNING: Argument '%s' must be followed by value\n", *argv);
                                        break;
                                }
                                argc--; argv++;
                                if (d->multiple)
                                        PrefsAddString(keyword, *argv);
                                else
                                        PrefsReplaceString(keyword, *argv);
                                break;

                        case TYPE_BOOLEAN: {
                                bool new_value;
                                if (negated_bool)
                                        new_value = false;
                                else if (argc > 1 && argv[1][0] != '-') {
                                        if (!strcmp(argv[1], "true") || !strcmp(argv[1], "on") || !strcmp(argv[1], "yes")) {
                                                new_value = true;
                                                argc--; argv++;
                                        } else if (!strcmp(argv[1], "false") || !strcmp(argv[1], "off") || !strcmp(argv[1], "no")) {
                                                new_value = false;
                                                argc--; argv++;
                                        } else
                                                new_value = true;
                                } else
                                        new_value = true;
                                PrefsReplaceBool(keyword, new_value);
                                break;
                        }

                        case TYPE_INT32:
                                if (argc < 2) {
                                        printf("WARNING: Argument '%s' must be followed by value\n", *argv);
                                        break;
                                }
                                argc--; argv++;
                                PrefsReplaceInt32(keyword, atoi(*argv));
                                break;

                        default:
                                break;
                }
        }
}


/*
 *  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 can be specified as '--OPTION true|on|yes' and\n'--OPTION false|off|no', or as '--OPTION' and '--noOPTION'.\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.3
Committed:	2001-01-16T16:53:26Z (23 years, 10 months ago) by cebix
Branch:	MAIN
Changes since 1.2:	+78 -8 lines
Log Message:	added options help screen for command line version
#	User	Rev	Content
1	cebix	1.1	/*
2			* prefs.cpp - Preferences handling
3			*
4			* SIDPlayer (C) Copyright 1996-2000 Christian Bauer
5			*
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			void PrefsInit(int argc, char **argv)
52			{
53	cebix	1.2	// Set defaults
54			AddPrefsDefaults();
55
56			// Override prefs with command line arguments
57			argc--; argv++;
58			for (; argc>0; argc--, argv++) {
59
60			// Arguments are of the form '--keyword'
61			if (strlen(*argv) < 3 \|\| argv[0][0] != '-' \|\| argv[0][1] != '-')
62			continue;
63			const char keyword = argv + 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.3	bool negated_bool = false;
68	cebix	1.2	if (d == NULL) {
69	cebix	1.3	// We also accept boolean arguments in the form '--nokeyword'
70			if (strncmp(keyword, "no", 2) == 0) {
71			negated_bool = true;
72			keyword += 2;
73			d = find_prefs_desc(keyword);
74			}
75			if (d == NULL) {
76			printf("WARNING: Unrecognized argument '%s'\n", *argv);
77			continue;
78			}
79	cebix	1.2	}
80	cebix	1.1
81	cebix	1.2	// Add/replace prefs item
82			switch (d->type) {
83			case TYPE_STRING:
84			if (argc < 2) {
85			printf("WARNING: Argument '%s' must be followed by value\n", *argv);
86			break;
87			}
88			argc--; argv++;
89			if (d->multiple)
90			PrefsAddString(keyword, *argv);
91			else
92			PrefsReplaceString(keyword, *argv);
93			break;
94
95	cebix	1.3	case TYPE_BOOLEAN: {
96			bool new_value;
97			if (negated_bool)
98			new_value = false;
99			else if (argc > 1 && argv[1][0] != '-') {
100			if (!strcmp(argv[1], "true") \|\| !strcmp(argv[1], "on") \|\| !strcmp(argv[1], "yes")) {
101			new_value = true;
102			argc--; argv++;
103			} else if (!strcmp(argv[1], "false") \|\| !strcmp(argv[1], "off") \|\| !strcmp(argv[1], "no")) {
104			new_value = false;
105			argc--; argv++;
106			} else
107			new_value = true;
108	cebix	1.2	} else
109	cebix	1.3	new_value = true;
110			PrefsReplaceBool(keyword, new_value);
111	cebix	1.2	break;
112	cebix	1.3	}
113	cebix	1.2
114			case TYPE_INT32:
115			if (argc < 2) {
116			printf("WARNING: Argument '%s' must be followed by value\n", *argv);
117			break;
118			}
119			argc--; argv++;
120			PrefsReplaceInt32(keyword, atoi(*argv));
121			break;
122
123			default:
124			break;
125			}
126			}
127	cebix	1.1	}
128
129
130			/*
131			* Deinitialize preferences
132			*/
133
134			void PrefsExit(void)
135			{
136			// Free prefs list
137			prefs_node p = the_prefs, next;
138			while (p) {
139			next = p->next;
140			free((void *)p->name);
141			free(p->data);
142			delete p;
143			p = next;
144			}
145			}
146
147
148			/*
149	cebix	1.3	* Print preferences options help
150			*/
151
152			static void print_options(const prefs_desc *list)
153			{
154			while (list->type != TYPE_END) {
155			if (list->help) {
156			const char typestr, defstr;
157			char numstr[32];
158			switch (list->type) {
159			case TYPE_STRING:
160			typestr = "STRING";
161			defstr = PrefsFindString(list->name);
162			if (defstr == NULL)
163			defstr = "none";
164			break;
165			case TYPE_BOOLEAN:
166			typestr = "BOOL";
167			if (PrefsFindBool(list->name))
168			defstr = "true";
169			else
170			defstr = "false";
171			break;
172			case TYPE_INT32:
173			typestr = "NUMBER";
174			sprintf(numstr, "%d", PrefsFindInt32(list->name));
175			defstr = numstr;
176			break;
177			default:
178			typestr = "<unknown>";
179			defstr = "none";
180			break;
181			}
182			printf(" --%s %s\n %s [default=%s]\n", list->name, typestr, list->help, defstr);
183			}
184			list++;
185			}
186			}
187
188			void PrefsPrintUsage(void)
189			{
190			printf("\nGeneral options:\n");
191			print_options(common_prefs_items);
192			printf("\nBoolean options can be specified as '--OPTION true\|on\|yes' and\n'--OPTION false\|off\|no', or as '--OPTION' and '--noOPTION'.\n");
193			}
194
195
196			/*
197	cebix	1.1	* Find preferences descriptor by keyword
198			*/
199
200			static prefs_desc find_prefs_desc(const char name, prefs_desc *list)
201			{
202	cebix	1.3	while (list->type != TYPE_END) {
203	cebix	1.1	if (strcmp(list->name, name) == 0)
204			return list;
205			list++;
206			}
207			return NULL;
208			}
209
210	cebix	1.2	static prefs_desc find_prefs_desc(const char name)
211			{
212			return find_prefs_desc(name, common_prefs_items);
213			}
214
215	cebix	1.1
216			/*
217			* Set prefs items
218			*/
219
220			static void add_data(const char name, prefs_type type, void data, int size)
221			{
222			void *d = malloc(size);
223			if (d == NULL)
224			return;
225			memcpy(d, data, size);
226			prefs_node *p = new prefs_node;
227			p->next = 0;
228			p->name = strdup(name);
229			p->type = type;
230			p->data = d;
231	cebix	1.2	p->desc = find_prefs_desc(p->name);
232	cebix	1.1	if (the_prefs) {
233			prefs_node *prev = the_prefs;
234			while (prev->next)
235			prev = prev->next;
236			prev->next = p;
237			} else
238			the_prefs = p;
239			}
240
241			void PrefsAddString(const char name, const char s)
242			{
243			add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
244			}
245
246			void PrefsAddBool(const char *name, bool b)
247			{
248			add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
249			}
250
251			void PrefsAddInt32(const char *name, int32 val)
252			{
253			add_data(name, TYPE_INT32, &val, sizeof(int32));
254			}
255
256
257			/*
258			* Replace prefs items
259			*/
260
261			static prefs_node find_node(const char name, prefs_type type, int index = 0)
262			{
263			prefs_node *p = the_prefs;
264			int i = 0;
265			while (p) {
266			if ((type == TYPE_ANY \|\| p->type == type) && !strcmp(p->name, name)) {
267			if (i == index)
268			return p;
269			else
270			i++;
271			}
272			p = p->next;
273			}
274			return NULL;
275			}
276
277			void PrefsReplaceString(const char name, const char s, int index)
278			{
279			prefs_node *p = find_node(name, TYPE_STRING, index);
280			if (p) {
281			if (p->desc && p->desc->func)
282			((prefs_func_string)(p->desc->func))(name, (const char *)p->data, s);
283			free(p->data);
284			p->data = strdup(s);
285			} else
286			add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
287			}
288
289			void PrefsReplaceBool(const char *name, bool b)
290			{
291			prefs_node *p = find_node(name, TYPE_BOOLEAN);
292			if (p) {
293			if (p->desc && p->desc->func)
294			((prefs_func_bool)(p->desc->func))(name, (bool )(p->data), b);
295			(bool )(p->data) = b;
296			} else
297			add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
298			}
299
300			void PrefsReplaceInt32(const char *name, int32 val)
301			{
302			prefs_node *p = find_node(name, TYPE_INT32);
303			if (p) {
304			if (p->desc && p->desc->func)
305			((prefs_func_int32)(p->desc->func))(name, (int32 )(p->data), val);
306			(int32 )(p->data) = val;
307			} else
308			add_data(name, TYPE_INT32, &val, sizeof(int32));
309			}
310
311
312			/*
313			* Get prefs items
314			*/
315
316			const char PrefsFindString(const char name, int index)
317			{
318			prefs_node *p = find_node(name, TYPE_STRING, index);
319			if (p)
320			return (char *)(p->data);
321			else
322			return NULL;
323			}
324
325			bool PrefsFindBool(const char *name)
326			{
327			prefs_node *p = find_node(name, TYPE_BOOLEAN, 0);
328			if (p)
329			return (bool )(p->data);
330			else
331			return false;
332			}
333
334			int32 PrefsFindInt32(const char *name)
335			{
336			prefs_node *p = find_node(name, TYPE_INT32, 0);
337			if (p)
338			return (int32 )(p->data);
339			else
340			return 0;
341			}
342
343
344			/*
345			* Remove prefs items
346			*/
347
348			void PrefsRemoveItem(const char *name, int index)
349			{
350			prefs_node *p = find_node(name, TYPE_ANY, index);
351			if (p) {
352			free((void *)p->name);
353			free(p->data);
354			prefs_node *q = the_prefs;
355			if (q == p) {
356			the_prefs = NULL;
357			delete p;
358			return;
359			}
360			while (q) {
361			if (q->next == p) {
362			q->next = p->next;
363			delete p;
364			return;
365			}
366			q = q->next;
367			}
368			}
369			}
370
371
372			/*
373			* Set prefs change callback function
374			*/
375
376			static void set_callback(const char *name, prefs_func f)
377			{
378	cebix	1.2	prefs_desc *d = find_prefs_desc(name);
379	cebix	1.1	if (d == NULL)
380			return;
381			d->func = f;
382			}
383
384			void PrefsSetCallback(const char *name, prefs_func_string f)
385			{
386			set_callback(name, (prefs_func)f);
387			}
388
389			void PrefsSetCallback(const char *name, prefs_func_bool f)
390			{
391			set_callback(name, (prefs_func)f);
392			}
393
394			void PrefsSetCallback(const char *name, prefs_func_int32 f)
395			{
396			set_callback(name, (prefs_func)f);
397			}