trunk/src/settings.c

/*
 *  Copyright (C) 2006-2007  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.15 2006/12/30 13:30:52 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, char*, 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.)
 */

#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 {
        struct settings         *parent;
        char                    *name_in_parent;

        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. Also, if this settings
 *  object has a parent, then remove it from the parent.
 */
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);

        if (settings->parent != NULL) {
                settings_remove(settings->parent, settings->name_in_parent);
                free(settings->name_in_parent);
        }

        free(settings);
}


/*
 *  settings_read():
 *
 *  Used internally by settings_access() and settings_debugdump().
 */
static int settings_read(struct settings *settings, int i, uint64_t *valuep)
{
        *valuep = 0;

        switch (settings->storage_type[i]) {
        case SETTINGS_TYPE_INT:
                *valuep = *((int *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_INT8:
                *valuep = *((int8_t *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_INT16:
                *valuep = *((int16_t *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_INT32:
                *valuep = *((int32_t *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_INT64:
                *valuep = *((int64_t *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_UINT:
                *valuep = *((uint *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_UINT8:
                *valuep = *((uint8_t *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_UINT16:
                *valuep = *((uint16_t *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_UINT32:
                *valuep = *((uint32_t *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_UINT64:
                *valuep = *((uint64_t *) settings->ptr[i]);
                break;
        case SETTINGS_TYPE_STRING:
                /*  Note: Strings cannot be read like this.  */
                break;
        default:printf("settings_read(): FATAL ERROR! Unknown storage type"
                    ": %i\n", settings->storage_type[i]);
                exit(1);
        }

        return SETTINGS_OK;
}


/*
 *  settings_write():
 *
 *  Used internally by settings_access().
 */
static int settings_write(struct settings *settings, int i, uint64_t *valuep)
{
        if (!settings->writable[i])
                return SETTINGS_READONLY;

        switch (settings->storage_type[i]) {
        case SETTINGS_TYPE_INT:
        case SETTINGS_TYPE_UINT:
                *((int *) settings->ptr[i]) = *valuep;
                break;
        case SETTINGS_TYPE_INT8:
        case SETTINGS_TYPE_UINT8:
                *((int8_t *) settings->ptr[i]) = *valuep;
                break;
        case SETTINGS_TYPE_INT16:
        case SETTINGS_TYPE_UINT16:
                *((int16_t *) settings->ptr[i]) = *valuep;
                break;
        case SETTINGS_TYPE_INT32:
        case SETTINGS_TYPE_UINT32:
                *((int32_t *) settings->ptr[i]) = *valuep;
                break;
        case SETTINGS_TYPE_INT64:
        case SETTINGS_TYPE_UINT64:
                *((int64_t *) settings->ptr[i]) = *valuep;
                break;
        case SETTINGS_TYPE_STRING:
                /*  Note: Strings cannot be read like this.  */
                printf("settings_write(): ERROR! Strings cannot be "
                    "written like this.\n");
                break;
        default:printf("settings_read(): FATAL ERROR! Unknown storage type"
                    ": %i\n", settings->storage_type[i]);
                exit(1);
        }

        return SETTINGS_OK;
}


/*
 *  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 = 0;

        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);

                        settings_read(settings, i, &value);

                        switch (settings->presentation_format[i]) {
                        case SETTINGS_FORMAT_DECIMAL:
                                printf("%"PRIi64, value);
                                break;
                        case SETTINGS_FORMAT_HEX8:
                                printf("0x%02"PRIx8, (int8_t) value);
                                break;
                        case SETTINGS_FORMAT_HEX16:
                                printf("0x%04"PRIx16, (int16_t) value);
                                break;
                        case SETTINGS_FORMAT_HEX32:
                                printf("0x%08"PRIx32, (int32_t) value);
                                break;
                        case SETTINGS_FORMAT_HEX64:
                                printf("0x%016"PRIx64, (int64_t) value);
                                break;
                        case SETTINGS_FORMAT_BOOL:
                                printf(value? "true" : "false");
                                break;
                        case SETTINGS_FORMAT_YESNO:
                                printf(value? "yes" : "no");
                                break;
                        case SETTINGS_FORMAT_STRING:
                                printf("\"%s\"", *((char **)settings->ptr[i]));
                                break;
                        default:printf("FATAL ERROR! Unknown presentation "
                                    "format: %i\n",
                                    settings->presentation_format[i]);
                                exit(1);
                        }

                        if (!settings->writable[i])
                                printf("  (R/O)");

                        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)
{
        int i;

        for (i=0; i<settings->n_settings; i++) {
                if (strcmp(settings->name[i], name) == 0)
                        break;
        }

        if (i < settings->n_settings) {
                fprintf(stderr, "settings_add(): name '%s' is already"
                    " in use\n", name);
                exit(1);
        }

        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);
        if (settings->name[settings->n_settings - 1] == NULL)
                goto out_of_mem;
        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;

        if (type == SETTINGS_TYPE_SUBSETTINGS) {
                ((struct settings *)ptr)->parent = settings;
                ((struct settings *)ptr)->name_in_parent = strdup(name);
                if (((struct settings *)ptr)->name_in_parent == NULL)
                        goto out_of_mem;
        }

        return;

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


/*
 *  settings_remove():
 *
 *  Remove a setting from a settings object.
 */
void settings_remove(struct settings *settings, const char *name)
{
        int i, m;

        for (i=0; i<settings->n_settings; i++) {
                if (strcmp(settings->name[i], name) == 0)
                        break;
        }

        if (i >= settings->n_settings) {
#ifdef UNSTABLE_DEVEL
                fprintf(stderr, "settings_remove(): attempting to remove"
                    " non-existant setting '%s'\n", name);
#endif
                return;
        }

        /*  Check subsettings specifically:  */
        if (settings->storage_type[i] == SETTINGS_TYPE_SUBSETTINGS &&
            settings->ptr[i] != NULL) {
                struct settings *subsettings = settings->ptr[i];
                if (subsettings->n_settings != 0) {
                        fprintf(stderr, "settings_remove(): attempting to "
                            "remove non-emtpy setting '%s'\n", name);
                        fprintf(stderr, "Remaining settings are:\n");
                        for (i=0; i<subsettings->n_settings; i++)
                                fprintf(stderr, "\t%s\n", subsettings->name[i]);
                        exit(1);
                }
        }

        settings->n_settings --;
        free(settings->name[i]);

        m = settings->n_settings - i;
        if (m == 0)
                return;

        memmove(&settings->name[i], &settings->name[i+1],
            m * sizeof(settings->name[0]));
        memmove(&settings->writable[i], &settings->writable[i+1],
            m * sizeof(settings->writable[0]));
        memmove(&settings->storage_type[i], &settings->storage_type[i+1],
            m * sizeof(settings->storage_type[0]));
        memmove(&settings->presentation_format[i],
            &settings->presentation_format[i+1],
            m * sizeof(settings->presentation_format[0]));
        memmove(&settings->ptr[i], &settings->ptr[i+1],
            m * sizeof(settings->ptr[0]));
}


/*
 *  settings_remove_all():
 *
 *  Remove all (level-1) settings from a settings object. By level-1, I mean
 *  all settings that do not contain subsettings.
 */
void settings_remove_all(struct settings *settings)
{
        while (settings->n_settings > 0)
                settings_remove(settings, settings->name[0]);
}


/*
 *  settings_access():
 *
 *  Read or write a setting. fullname may be something like "settings.x.y".
 *  When writing a value, valuebuf should point to a uint64_t containing the
 *  new value (note: always a uint64_t). When reading a value, valuebuf should
 *  point to a uint64_t where the value will be stored.
 *
 *  The return value is one of the following:
 *
 *      SETTINGS_OK
 *              The value was read or written.
 *
 *      SETTINGS_NAME_NOT_FOUND
 *              The name was not found in the settings object.
 *
 *      SETTINGS_READONLY
 *              The name was found, but it was marked as read-only, and
 *              an attempt was made to write to it.
 */
int settings_access(struct settings *settings, const char *fullname,
        int writeflag, uint64_t *valuep)
{
        int i;

        /*  printf("settings_access(fullname='%s')\n", fullname);  */

        if (strncmp(fullname, GLOBAL_SETTINGS_NAME".",
            strlen(GLOBAL_SETTINGS_NAME) + 1) == 0)
                fullname += strlen(GLOBAL_SETTINGS_NAME) + 1;

        for (i=0; i<settings->n_settings; i++) {
                size_t settings_name_len = strlen(settings->name[i]);

                if (strncmp(fullname, settings->name[i],
                    settings_name_len) != 0)
                        continue;

                /*  Found the correct setting?  */
                if (fullname[settings_name_len] == '\0') {
                        if (writeflag)
                                return settings_write(settings, i, valuep);
                        else
                                return settings_read(settings, i, valuep);
                }

                /*  Found a setting which has sub-settings?  */
                if (fullname[settings_name_len] == '.') {
                        /*  Recursive search:  */
                        return settings_access(
                            (struct settings *)settings->ptr[i],
                            fullname + settings_name_len + 1,
                            writeflag, valuep);
                }
        }

        return SETTINGS_NAME_NOT_FOUND;
}

1	/*
2	* Copyright (C) 2006-2007 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.15 2006/12/30 13:30:52 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, char*, 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	#include <stdio.h>
49	#include <stdlib.h>
50	#include <string.h>
51
52	/* Including misc.h should ONLY be necessary to work around the fact that
53	many systems don't have PRIx64 etc defined. */
54	#include "misc.h"
55
56	#include "settings.h"
57
58
59	struct settings {
60	struct settings *parent;
61	char *name_in_parent;
62
63	int n_settings;
64
65	/*
66	* Each setting has a name, a writable flag, a storage type, a
67	* presentation format, and a pointer.
68	*
69	* For subsettings, the pointer points to the subsettings object;
70	* for other settings, the pointer points to a variable.
71	*
72	* These pointers point to simple linear arrays, containing n_settings
73	* entries each.
74	*/
75
76	char **name;
77	int *writable;
78	int *storage_type;
79	int *presentation_format;
80	void **ptr;
81	};
82
83
84	/*
85	* settings_new():
86	*
87	* Create a new settings object. Return value is a pointer to the newly
88	* created object. The function does not return on failure.
89	*/
90	struct settings *settings_new(void)
91	{
92	struct settings *settings = malloc(sizeof(struct settings));
93
94	if (settings == NULL) {
95	fprintf(stderr, "settings_new(): out of memory\n");
96	exit(1);
97	}
98
99	/* No settings. */
100	memset(settings, 0, sizeof(struct settings));
101
102	return settings;
103	}
104
105
106	/*
107	* settings_destroy():
108	*
109	* Frees all resources occupied by a settings object. Also, if this settings
110	* object has a parent, then remove it from the parent.
111	*/
112	void settings_destroy(struct settings *settings)
113	{
114	int i;
115
116	if (settings == NULL) {
117	fprintf(stderr, "settings_destroy(): internal error, "
118	"settings = NULL!\n");
119	exit(1);
120	}
121
122	#ifdef UNSTABLE_DEVEL
123	if (settings->n_settings > 0)
124	printf("settings_destroy(): there are remaining settings!\n");
125	#endif
126
127	if (settings->name != NULL) {
128	for (i=0; i<settings->n_settings; i++) {
129	if (settings->name[i] != NULL) {
130	#ifdef UNSTABLE_DEVEL
131	printf("settings_destroy(): setting '%s'"
132	" was not properly deleted before "
133	"exiting!\n", settings->name[i]);
134	#endif
135	free(settings->name[i]);
136	}
137	}
138
139	free(settings->name);
140	} else if (settings->n_settings != 0) {
141	fprintf(stderr, "settings_destroy(): internal error, "
142	"settings->name = NULL, but there were settings?"
143	" (n_settings = %i)\n", settings->n_settings);
144	exit(1);
145	}
146
147	if (settings->writable != NULL)
148	free(settings->writable);
149
150	if (settings->storage_type != NULL)
151	free(settings->storage_type);
152
153	if (settings->presentation_format != NULL)
154	free(settings->presentation_format);
155
156	if (settings->ptr != NULL)
157	free(settings->ptr);
158
159	if (settings->parent != NULL) {
160	settings_remove(settings->parent, settings->name_in_parent);
161	free(settings->name_in_parent);
162	}
163
164	free(settings);
165	}
166
167
168	/*
169	* settings_read():
170	*
171	* Used internally by settings_access() and settings_debugdump().
172	*/
173	static int settings_read(struct settings settings, int i, uint64_t valuep)
174	{
175	*valuep = 0;
176
177	switch (settings->storage_type[i]) {
178	case SETTINGS_TYPE_INT:
179	valuep = ((int *) settings->ptr[i]);
180	break;
181	case SETTINGS_TYPE_INT8:
182	valuep = ((int8_t *) settings->ptr[i]);
183	break;
184	case SETTINGS_TYPE_INT16:
185	valuep = ((int16_t *) settings->ptr[i]);
186	break;
187	case SETTINGS_TYPE_INT32:
188	valuep = ((int32_t *) settings->ptr[i]);
189	break;
190	case SETTINGS_TYPE_INT64:
191	valuep = ((int64_t *) settings->ptr[i]);
192	break;
193	case SETTINGS_TYPE_UINT:
194	valuep = ((uint *) settings->ptr[i]);
195	break;
196	case SETTINGS_TYPE_UINT8:
197	valuep = ((uint8_t *) settings->ptr[i]);
198	break;
199	case SETTINGS_TYPE_UINT16:
200	valuep = ((uint16_t *) settings->ptr[i]);
201	break;
202	case SETTINGS_TYPE_UINT32:
203	valuep = ((uint32_t *) settings->ptr[i]);
204	break;
205	case SETTINGS_TYPE_UINT64:
206	valuep = ((uint64_t *) settings->ptr[i]);
207	break;
208	case SETTINGS_TYPE_STRING:
209	/* Note: Strings cannot be read like this. */
210	break;
211	default:printf("settings_read(): FATAL ERROR! Unknown storage type"
212	": %i\n", settings->storage_type[i]);
213	exit(1);
214	}
215
216	return SETTINGS_OK;
217	}
218
219
220	/*
221	* settings_write():
222	*
223	* Used internally by settings_access().
224	*/
225	static int settings_write(struct settings settings, int i, uint64_t valuep)
226	{
227	if (!settings->writable[i])
228	return SETTINGS_READONLY;
229
230	switch (settings->storage_type[i]) {
231	case SETTINGS_TYPE_INT:
232	case SETTINGS_TYPE_UINT:
233	((int ) settings->ptr[i]) = *valuep;
234	break;
235	case SETTINGS_TYPE_INT8:
236	case SETTINGS_TYPE_UINT8:
237	((int8_t ) settings->ptr[i]) = *valuep;
238	break;
239	case SETTINGS_TYPE_INT16:
240	case SETTINGS_TYPE_UINT16:
241	((int16_t ) settings->ptr[i]) = *valuep;
242	break;
243	case SETTINGS_TYPE_INT32:
244	case SETTINGS_TYPE_UINT32:
245	((int32_t ) settings->ptr[i]) = *valuep;
246	break;
247	case SETTINGS_TYPE_INT64:
248	case SETTINGS_TYPE_UINT64:
249	((int64_t ) settings->ptr[i]) = *valuep;
250	break;
251	case SETTINGS_TYPE_STRING:
252	/* Note: Strings cannot be read like this. */
253	printf("settings_write(): ERROR! Strings cannot be "
254	"written like this.\n");
255	break;
256	default:printf("settings_read(): FATAL ERROR! Unknown storage type"
257	": %i\n", settings->storage_type[i]);
258	exit(1);
259	}
260
261	return SETTINGS_OK;
262	}
263
264
265	/*
266	* settings_debugdump():
267	*
268	* Dump settings in a settings object to stdout.
269	* If recurse is non-zero, all subsetting objects are also dumped.
270	*/
271	void settings_debugdump(struct settings settings, const char prefix,
272	int recurse)
273	{
274	size_t name_buflen = strlen(prefix) + 100;
275	char *name = malloc(name_buflen);
276	int i;
277	uint64_t value = 0;
278
279	for (i=0; i<settings->n_settings; i++) {
280	snprintf(name, name_buflen, "%s.%s", prefix, settings->name[i]);
281
282	if (settings->storage_type[i] == SETTINGS_TYPE_SUBSETTINGS) {
283	/* Subsettings: */
284	if (recurse)
285	settings_debugdump(settings->ptr[i], name, 1);
286	} else {
287	/* Normal value: */
288	printf("%s = ", name);
289
290	settings_read(settings, i, &value);
291
292	switch (settings->presentation_format[i]) {
293	case SETTINGS_FORMAT_DECIMAL:
294	printf("%"PRIi64, value);
295	break;
296	case SETTINGS_FORMAT_HEX8:
297	printf("0x%02"PRIx8, (int8_t) value);
298	break;
299	case SETTINGS_FORMAT_HEX16:
300	printf("0x%04"PRIx16, (int16_t) value);
301	break;
302	case SETTINGS_FORMAT_HEX32:
303	printf("0x%08"PRIx32, (int32_t) value);
304	break;
305	case SETTINGS_FORMAT_HEX64:
306	printf("0x%016"PRIx64, (int64_t) value);
307	break;
308	case SETTINGS_FORMAT_BOOL:
309	printf(value? "true" : "false");
310	break;
311	case SETTINGS_FORMAT_YESNO:
312	printf(value? "yes" : "no");
313	break;
314	case SETTINGS_FORMAT_STRING:
315	printf("\"%s\"", ((char *)settings->ptr[i]));
316	break;
317	default:printf("FATAL ERROR! Unknown presentation "
318	"format: %i\n",
319	settings->presentation_format[i]);
320	exit(1);
321	}
322
323	if (!settings->writable[i])
324	printf(" (R/O)");
325
326	printf("\n");
327	}
328	}
329
330	free(name);
331	}
332
333
334	/*
335	* settings_add():
336	*
337	* Add a setting to a settings object.
338	*/
339	void settings_add(struct settings settings, const char name, int writable,
340	int type, int format, void *ptr)
341	{
342	int i;
343
344	for (i=0; i<settings->n_settings; i++) {
345	if (strcmp(settings->name[i], name) == 0)
346	break;
347	}
348
349	if (i < settings->n_settings) {
350	fprintf(stderr, "settings_add(): name '%s' is already"
351	" in use\n", name);
352	exit(1);
353	}
354
355	settings->n_settings ++;
356
357	if ((settings->name = realloc(settings->name, settings->n_settings
358	* sizeof(char *))) == NULL)
359	goto out_of_mem;
360	if ((settings->writable = realloc(settings->writable,
361	settings->n_settings * sizeof(int))) == NULL)
362	goto out_of_mem;
363	if ((settings->storage_type = realloc(settings->storage_type,
364	settings->n_settings * sizeof(int))) == NULL)
365	goto out_of_mem;
366	if ((settings->presentation_format = realloc(settings->
367	presentation_format, settings->n_settings * sizeof(int))) == NULL)
368	goto out_of_mem;
369	if ((settings->ptr = realloc(settings->ptr, settings->n_settings
370	* sizeof(void *))) == NULL)
371	goto out_of_mem;
372
373	settings->name[settings->n_settings - 1] = strdup(name);
374	if (settings->name[settings->n_settings - 1] == NULL)
375	goto out_of_mem;
376	settings->writable[settings->n_settings - 1] = writable;
377	settings->storage_type[settings->n_settings - 1] = type;
378	settings->presentation_format[settings->n_settings - 1] = format;
379	settings->ptr[settings->n_settings - 1] = ptr;
380
381	if (type == SETTINGS_TYPE_SUBSETTINGS) {
382	((struct settings *)ptr)->parent = settings;
383	((struct settings *)ptr)->name_in_parent = strdup(name);
384	if (((struct settings *)ptr)->name_in_parent == NULL)
385	goto out_of_mem;
386	}
387
388	return;
389
390	out_of_mem:
391	fprintf(stderr, "settings_add(): fatal error: out of memory\n");
392	exit(1);
393	}
394
395
396	/*
397	* settings_remove():
398	*
399	* Remove a setting from a settings object.
400	*/
401	void settings_remove(struct settings settings, const char name)
402	{
403	int i, m;
404
405	for (i=0; i<settings->n_settings; i++) {
406	if (strcmp(settings->name[i], name) == 0)
407	break;
408	}
409
410	if (i >= settings->n_settings) {
411	#ifdef UNSTABLE_DEVEL
412	fprintf(stderr, "settings_remove(): attempting to remove"
413	" non-existant setting '%s'\n", name);
414	#endif
415	return;
416	}
417
418	/* Check subsettings specifically: */
419	if (settings->storage_type[i] == SETTINGS_TYPE_SUBSETTINGS &&
420	settings->ptr[i] != NULL) {
421	struct settings *subsettings = settings->ptr[i];
422	if (subsettings->n_settings != 0) {
423	fprintf(stderr, "settings_remove(): attempting to "
424	"remove non-emtpy setting '%s'\n", name);
425	fprintf(stderr, "Remaining settings are:\n");
426	for (i=0; i<subsettings->n_settings; i++)
427	fprintf(stderr, "\t%s\n", subsettings->name[i]);
428	exit(1);
429	}
430	}
431
432	settings->n_settings --;
433	free(settings->name[i]);
434
435	m = settings->n_settings - i;
436	if (m == 0)
437	return;
438
439	memmove(&settings->name[i], &settings->name[i+1],
440	m * sizeof(settings->name[0]));
441	memmove(&settings->writable[i], &settings->writable[i+1],
442	m * sizeof(settings->writable[0]));
443	memmove(&settings->storage_type[i], &settings->storage_type[i+1],
444	m * sizeof(settings->storage_type[0]));
445	memmove(&settings->presentation_format[i],
446	&settings->presentation_format[i+1],
447	m * sizeof(settings->presentation_format[0]));
448	memmove(&settings->ptr[i], &settings->ptr[i+1],
449	m * sizeof(settings->ptr[0]));
450	}
451
452
453	/*
454	* settings_remove_all():
455	*
456	* Remove all (level-1) settings from a settings object. By level-1, I mean
457	* all settings that do not contain subsettings.
458	*/
459	void settings_remove_all(struct settings *settings)
460	{
461	while (settings->n_settings > 0)
462	settings_remove(settings, settings->name[0]);
463	}
464
465
466	/*
467	* settings_access():
468	*
469	* Read or write a setting. fullname may be something like "settings.x.y".
470	* When writing a value, valuebuf should point to a uint64_t containing the
471	* new value (note: always a uint64_t). When reading a value, valuebuf should
472	* point to a uint64_t where the value will be stored.
473	*
474	* The return value is one of the following:
475	*
476	* SETTINGS_OK
477	* The value was read or written.
478	*
479	* SETTINGS_NAME_NOT_FOUND
480	* The name was not found in the settings object.
481	*
482	* SETTINGS_READONLY
483	* The name was found, but it was marked as read-only, and
484	* an attempt was made to write to it.
485	*/
486	int settings_access(struct settings settings, const char fullname,
487	int writeflag, uint64_t *valuep)
488	{
489	int i;
490
491	/* printf("settings_access(fullname='%s')\n", fullname); */
492
493	if (strncmp(fullname, GLOBAL_SETTINGS_NAME".",
494	strlen(GLOBAL_SETTINGS_NAME) + 1) == 0)
495	fullname += strlen(GLOBAL_SETTINGS_NAME) + 1;
496
497	for (i=0; i<settings->n_settings; i++) {
498	size_t settings_name_len = strlen(settings->name[i]);
499
500	if (strncmp(fullname, settings->name[i],
501	settings_name_len) != 0)
502	continue;
503
504	/* Found the correct setting? */
505	if (fullname[settings_name_len] == '\0') {
506	if (writeflag)
507	return settings_write(settings, i, valuep);
508	else
509	return settings_read(settings, i, valuep);
510	}
511
512	/* Found a setting which has sub-settings? */
513	if (fullname[settings_name_len] == '.') {
514	/* Recursive search: */
515	return settings_access(
516	(struct settings *)settings->ptr[i],
517	fullname + settings_name_len + 1,
518	writeflag, valuep);
519	}
520	}
521
522	return SETTINGS_NAME_NOT_FOUND;
523	}
524