SIDPlayer/src/prefs.cpp

/*
 *  prefs.cpp - Preferences handling
 *
 *  SIDPlayer (C) Copyright 1996-2003 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()
{
        // 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()
{
        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.7
Committed:	2003-10-21T16:56:19Z (21 years ago) by cebix
Branch:	MAIN
Changes since 1.6:	+2 -2 lines
Log Message:	- play_adr is updated from the IRQ vector every time before the replay routine is called if it was 0 in the PSID header (this makes some tunes play correctly now) - f(void) -> f() (this is C++, dammit!)
#	Content
1	/*
2	* prefs.cpp - Preferences handling
3	*
4	* SIDPlayer (C) Copyright 1996-2003 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	// Prefs items are stored in a linked list of these nodes
32	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	static prefs_node *the_prefs = NULL;
42
43	// Prototypes
44	static prefs_desc find_prefs_desc(const char name);
45
46
47	/*
48	* Initialize preferences
49	*/
50
51	void PrefsInit(int &argc, char **&argv)
52	{
53	// Set defaults
54	AddPrefsDefaults();
55
56	// Override prefs with command line options
57	for (int i=1; i<argc; i++) {
58
59	// Options are of the form '--keyword'
60	const char *option = argv[i];
61	if (strlen(option) < 3 \|\| option[0] != '-' \|\| option[1] != '-')
62	continue;
63	const char *keyword = option + 2;
64
65	// Find descriptor for keyword
66	const prefs_desc *d = find_prefs_desc(keyword);
67	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	}
77	const char *value = argv[i];
78	argv[i] = NULL;
79
80	// Add/replace prefs item
81	switch (d->type) {
82	case TYPE_STRING:
83	if (d->multiple)
84	PrefsAddString(keyword, value);
85	else
86	PrefsReplaceString(keyword, value);
87	break;
88
89	case TYPE_BOOLEAN: {
90	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	break;
97	}
98
99	case TYPE_INT32:
100	PrefsReplaceInt32(keyword, atoi(value));
101	break;
102
103	default:
104	break;
105	}
106	}
107
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	}
122
123
124	/*
125	* Deinitialize preferences
126	*/
127
128	void PrefsExit()
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	* 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()
183	{
184	printf("\nGeneral options:\n");
185	print_options(common_prefs_items);
186	printf("\nBoolean options are specified as '--OPTION true\|on\|yes' or\n'--OPTION false\|off\|no'.\n");
187	}
188
189
190	/*
191	* Find preferences descriptor by keyword
192	*/
193
194	static prefs_desc find_prefs_desc(const char name, prefs_desc *list)
195	{
196	while (list->type != TYPE_END) {
197	if (strcmp(list->name, name) == 0)
198	return list;
199	list++;
200	}
201	return NULL;
202	}
203
204	static prefs_desc find_prefs_desc(const char name)
205	{
206	return find_prefs_desc(name, common_prefs_items);
207	}
208
209
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	p->desc = find_prefs_desc(p->name);
226	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	prefs_desc *d = find_prefs_desc(name);
373	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	}