trunk/src/settings.c

/*
 *  Copyright (C) 2006  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright  
 *     notice, this list of conditions and the following disclaimer in the 
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE   
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 *  SUCH DAMAGE.
 *
 *
 *  $Id: settings.c,v 1.7 2006/07/15 10:06:11 debug Exp $
 *
 *  A generic settings object. (This module should be 100% indepedent of GXemul
 *  and hence easily reusable.)  It is basically a tree structure of nodes,
 *  where each node has a name and a few properties. The main property is
 *  a pointer, which can either point to other settings ("sub-settings"),
 *  or to a variable in memory.
 *
 *  Appart from the pointer, the other properties are a definition of the
 *  type being pointed to (int, int32_t, int64_t, etc), how it should be
 *  presented (e.g. it may be an int value in memory, but it should be
 *  presented as a boolean "true/false" value), and a flag which tells us
 *  whether the setting is directly writable or not.
 *
 *  If UNSTABLE_DEVEL is defined, then warnings are printed when
 *  settings_destroy() is called if individual settings have not yet been
 *  deleted. (This is to help making sure that code which uses the settings
 *  subsystem correctly un-initializes stuff.)
 *
 *
 *  TODO:
 *      Remove a setting
 *      Read/write settings
 */

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

/*  Including misc.h should ONLY be necessary to work around the fact that
    many systems don't have PRIx64 etc defined.  */
#include "misc.h"

#include "settings.h"


struct settings {
        int                     n_settings;

        /*
         *  Each setting has a name, a writable flag, a storage type, a
         *  presentation format, and a pointer.
         *
         *  For subsettings, the pointer points to the subsettings object;
         *  for other settings, the pointer points to a variable.
         *
         *  These pointers point to simple linear arrays, containing n_settings
         *  entries each.
         */

        char                    **name;
        int                     *writable;
        int                     *storage_type;
        int                     *presentation_format;
        void                    **ptr;
};


/*
 *  settings_new():
 *
 *  Create a new settings object. Return value is a pointer to the newly
 *  created object. The function does not return on failure.
 */
struct settings *settings_new(void)
{
        struct settings *settings = malloc(sizeof(struct settings));

        if (settings == NULL) {
                fprintf(stderr, "settings_new(): out of memory\n");
                exit(1);
        }

        /*  No settings.  */
        memset(settings, 0, sizeof(struct settings));

        return settings;
}


/*
 *  settings_destroy():
 *
 *  Frees all resources occupied by a settings object.
 */
void settings_destroy(struct settings *settings)
{
        int i;

        if (settings == NULL) {
                fprintf(stderr, "settings_destroy(): internal error, "
                    "settings = NULL!\n");
                exit(1);
        }

#ifdef UNSTABLE_DEVEL
        if (settings->n_settings > 0)
                printf("settings_destroy(): there are remaining settings!\n");
#endif

        if (settings->name != NULL) {
                for (i=0; i<settings->n_settings; i++) {
                        if (settings->name[i] != NULL) {
#ifdef UNSTABLE_DEVEL
                                printf("settings_destroy(): setting '%s'"
                                    " was not properly deleted before "
                                    "exiting!\n", settings->name[i]);
#endif
                                free(settings->name[i]);
                        }
                }

                free(settings->name);
        } else if (settings->n_settings != 0) {
                fprintf(stderr, "settings_destroy(): internal error, "
                    "settings->name = NULL, but there were settings?"
                    " (n_settings = %i)\n", settings->n_settings);
                exit(1);
        }

        if (settings->writable != NULL)
                free(settings->writable);

        if (settings->storage_type != NULL)
                free(settings->storage_type);

        if (settings->presentation_format != NULL)
                free(settings->presentation_format);

        if (settings->ptr != NULL)
                free(settings->ptr);

        free(settings);
}


/*
 *  settings_debugdump():
 *
 *  Dump settings in a settings object to stdout.
 *  If recurse is non-zero, all subsetting objects are also dumped.
 */
void settings_debugdump(struct settings *settings, const char *prefix,
        int recurse)
{
        size_t name_buflen = strlen(prefix) + 100;
        char *name = malloc(name_buflen);
        int i;
        uint64_t value;

        for (i=0; i<settings->n_settings; i++) {
                snprintf(name, name_buflen, "%s.%s", prefix, settings->name[i]);

                if (settings->storage_type[i] == SETTINGS_TYPE_SUBSETTINGS) {
                        /*  Subsettings:  */
                        if (recurse)
                                settings_debugdump(settings->ptr[i], name, 1);
                } else {
                        /*  Normal value:  */
                        printf("%s = ", name);

                        switch (settings->storage_type[i]) {
                        case SETTINGS_TYPE_INT:
                                value = *((int *) settings->ptr[i]);
                                break;
                        case SETTINGS_TYPE_INT32:
                                value = *((int32_t *) settings->ptr[i]);
                                break;
                        case SETTINGS_TYPE_INT64:
                                value = *((int64_t *) settings->ptr[i]);
                                break;
                        default:printf("FATAL ERROR! Unknown storage type"
                                    ": %i\n", settings->storage_type[i]);
                                exit(1);
                        }

                        switch (settings->presentation_format[i]) {
                        case SETTINGS_FORMAT_DECIMAL:
                                printf("%"PRIi64, value);
                                break;
                        case SETTINGS_FORMAT_HEX:
                                printf("0x%"PRIx64, value);
                                break;
                        case SETTINGS_FORMAT_BOOL:
                                printf(value? "true" : "false");
                                break;
                        case SETTINGS_FORMAT_YESNO:
                                printf(value? "yes" : "no");
                                break;
                        default:printf("FATAL ERROR! Unknown presentation "
                                    "format: %i\n",
                                    settings->presentation_format[i]);
                                exit(1);
                        }

                        if (!settings->writable[i])
                                printf("  (Read-only)");

                        printf("\n");
                }
        }

        free(name);
}


/*
 *  settings_add():
 *
 *  Add a setting to a settings object.
 */
void settings_add(struct settings *settings, const char *name, int writable,
        int type, int format, void *ptr)
{
        settings->n_settings ++;

        if ((settings->name = realloc(settings->name, settings->n_settings
            * sizeof(char *))) == NULL)
                goto out_of_mem;
        if ((settings->writable = realloc(settings->writable,
            settings->n_settings * sizeof(int))) == NULL)
                goto out_of_mem;
        if ((settings->storage_type = realloc(settings->storage_type,
            settings->n_settings * sizeof(int))) == NULL)
                goto out_of_mem;
        if ((settings->presentation_format = realloc(settings->
            presentation_format, settings->n_settings * sizeof(int))) == NULL)
                goto out_of_mem;
        if ((settings->ptr = realloc(settings->ptr, settings->n_settings
            * sizeof(void *))) == NULL)
                goto out_of_mem;

        settings->name[settings->n_settings - 1] = strdup(name);
        settings->writable[settings->n_settings - 1] = writable;
        settings->storage_type[settings->n_settings - 1] = type;
        settings->presentation_format[settings->n_settings - 1] = format;
        settings->ptr[settings->n_settings - 1] = ptr;

        return;

out_of_mem:
        fprintf(stderr, "settings_add(): fatal error: out of memory\n");
        exit(1);
}


1	/*
2	* Copyright (C) 2006 Anders Gavare. All rights reserved.
3	*
4	* Redistribution and use in source and binary forms, with or without
5	* modification, are permitted provided that the following conditions are met:
6	*
7	* 1. Redistributions of source code must retain the above copyright
8	* notice, this list of conditions and the following disclaimer.
9	* 2. Redistributions in binary form must reproduce the above copyright
10	* notice, this list of conditions and the following disclaimer in the
11	* documentation and/or other materials provided with the distribution.
12	* 3. The name of the author may not be used to endorse or promote products
13	* derived from this software without specific prior written permission.
14	*
15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25	* SUCH DAMAGE.
26	*
27	*
28	* $Id: settings.c,v 1.7 2006/07/15 10:06:11 debug Exp $
29	*
30	* A generic settings object. (This module should be 100% indepedent of GXemul
31	* and hence easily reusable.) It is basically a tree structure of nodes,
32	* where each node has a name and a few properties. The main property is
33	* a pointer, which can either point to other settings ("sub-settings"),
34	* or to a variable in memory.
35	*
36	* Appart from the pointer, the other properties are a definition of the
37	* type being pointed to (int, int32_t, int64_t, etc), how it should be
38	* presented (e.g. it may be an int value in memory, but it should be
39	* presented as a boolean "true/false" value), and a flag which tells us
40	* whether the setting is directly writable or not.
41	*
42	* If UNSTABLE_DEVEL is defined, then warnings are printed when
43	* settings_destroy() is called if individual settings have not yet been
44	* deleted. (This is to help making sure that code which uses the settings
45	* subsystem correctly un-initializes stuff.)
46	*
47	*
48	* TODO:
49	* Remove a setting
50	* Read/write settings
51	*/
52
53	#include <stdio.h>
54	#include <stdlib.h>
55	#include <string.h>
56
57	/* Including misc.h should ONLY be necessary to work around the fact that
58	many systems don't have PRIx64 etc defined. */
59	#include "misc.h"
60
61	#include "settings.h"
62
63
64	struct settings {
65	int n_settings;
66
67	/*
68	* Each setting has a name, a writable flag, a storage type, a
69	* presentation format, and a pointer.
70	*
71	* For subsettings, the pointer points to the subsettings object;
72	* for other settings, the pointer points to a variable.
73	*
74	* These pointers point to simple linear arrays, containing n_settings
75	* entries each.
76	*/
77
78	char **name;
79	int *writable;
80	int *storage_type;
81	int *presentation_format;
82	void **ptr;
83	};
84
85
86	/*
87	* settings_new():
88	*
89	* Create a new settings object. Return value is a pointer to the newly
90	* created object. The function does not return on failure.
91	*/
92	struct settings *settings_new(void)
93	{
94	struct settings *settings = malloc(sizeof(struct settings));
95
96	if (settings == NULL) {
97	fprintf(stderr, "settings_new(): out of memory\n");
98	exit(1);
99	}
100
101	/* No settings. */
102	memset(settings, 0, sizeof(struct settings));
103
104	return settings;
105	}
106
107
108	/*
109	* settings_destroy():
110	*
111	* Frees all resources occupied by a settings object.
112	*/
113	void settings_destroy(struct settings *settings)
114	{
115	int i;
116
117	if (settings == NULL) {
118	fprintf(stderr, "settings_destroy(): internal error, "
119	"settings = NULL!\n");
120	exit(1);
121	}
122
123	#ifdef UNSTABLE_DEVEL
124	if (settings->n_settings > 0)
125	printf("settings_destroy(): there are remaining settings!\n");
126	#endif
127
128	if (settings->name != NULL) {
129	for (i=0; i<settings->n_settings; i++) {
130	if (settings->name[i] != NULL) {
131	#ifdef UNSTABLE_DEVEL
132	printf("settings_destroy(): setting '%s'"
133	" was not properly deleted before "
134	"exiting!\n", settings->name[i]);
135	#endif
136	free(settings->name[i]);
137	}
138	}
139
140	free(settings->name);
141	} else if (settings->n_settings != 0) {
142	fprintf(stderr, "settings_destroy(): internal error, "
143	"settings->name = NULL, but there were settings?"
144	" (n_settings = %i)\n", settings->n_settings);
145	exit(1);
146	}
147
148	if (settings->writable != NULL)
149	free(settings->writable);
150
151	if (settings->storage_type != NULL)
152	free(settings->storage_type);
153
154	if (settings->presentation_format != NULL)
155	free(settings->presentation_format);
156
157	if (settings->ptr != NULL)
158	free(settings->ptr);
159
160	free(settings);
161	}
162
163
164	/*
165	* settings_debugdump():
166	*
167	* Dump settings in a settings object to stdout.
168	* If recurse is non-zero, all subsetting objects are also dumped.
169	*/
170	void settings_debugdump(struct settings settings, const char prefix,
171	int recurse)
172	{
173	size_t name_buflen = strlen(prefix) + 100;
174	char *name = malloc(name_buflen);
175	int i;
176	uint64_t value;
177
178	for (i=0; i<settings->n_settings; i++) {
179	snprintf(name, name_buflen, "%s.%s", prefix, settings->name[i]);
180
181	if (settings->storage_type[i] == SETTINGS_TYPE_SUBSETTINGS) {
182	/* Subsettings: */
183	if (recurse)
184	settings_debugdump(settings->ptr[i], name, 1);
185	} else {
186	/* Normal value: */
187	printf("%s = ", name);
188
189	switch (settings->storage_type[i]) {
190	case SETTINGS_TYPE_INT:
191	value = ((int ) settings->ptr[i]);
192	break;
193	case SETTINGS_TYPE_INT32:
194	value = ((int32_t ) settings->ptr[i]);
195	break;
196	case SETTINGS_TYPE_INT64:
197	value = ((int64_t ) settings->ptr[i]);
198	break;
199	default:printf("FATAL ERROR! Unknown storage type"
200	": %i\n", settings->storage_type[i]);
201	exit(1);
202	}
203
204	switch (settings->presentation_format[i]) {
205	case SETTINGS_FORMAT_DECIMAL:
206	printf("%"PRIi64, value);
207	break;
208	case SETTINGS_FORMAT_HEX:
209	printf("0x%"PRIx64, value);
210	break;
211	case SETTINGS_FORMAT_BOOL:
212	printf(value? "true" : "false");
213	break;
214	case SETTINGS_FORMAT_YESNO:
215	printf(value? "yes" : "no");
216	break;
217	default:printf("FATAL ERROR! Unknown presentation "
218	"format: %i\n",
219	settings->presentation_format[i]);
220	exit(1);
221	}
222
223	if (!settings->writable[i])
224	printf(" (Read-only)");
225
226	printf("\n");
227	}
228	}
229
230	free(name);
231	}
232
233
234	/*
235	* settings_add():
236	*
237	* Add a setting to a settings object.
238	*/
239	void settings_add(struct settings settings, const char name, int writable,
240	int type, int format, void *ptr)
241	{
242	settings->n_settings ++;
243
244	if ((settings->name = realloc(settings->name, settings->n_settings
245	* sizeof(char *))) == NULL)
246	goto out_of_mem;
247	if ((settings->writable = realloc(settings->writable,
248	settings->n_settings * sizeof(int))) == NULL)
249	goto out_of_mem;
250	if ((settings->storage_type = realloc(settings->storage_type,
251	settings->n_settings * sizeof(int))) == NULL)
252	goto out_of_mem;
253	if ((settings->presentation_format = realloc(settings->
254	presentation_format, settings->n_settings * sizeof(int))) == NULL)
255	goto out_of_mem;
256	if ((settings->ptr = realloc(settings->ptr, settings->n_settings
257	* sizeof(void *))) == NULL)
258	goto out_of_mem;
259
260	settings->name[settings->n_settings - 1] = strdup(name);
261	settings->writable[settings->n_settings - 1] = writable;
262	settings->storage_type[settings->n_settings - 1] = type;
263	settings->presentation_format[settings->n_settings - 1] = format;
264	settings->ptr[settings->n_settings - 1] = ptr;
265
266	return;
267
268	out_of_mem:
269	fprintf(stderr, "settings_add(): fatal error: out of memory\n");
270	exit(1);
271	}
272
273