0.4.3/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.14 2006/09/21 11:53:26 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	dpavlin	24	/*
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	dpavlin	32	* $Id: settings.c,v 1.14 2006/09/21 11:53:26 debug Exp $
29	dpavlin	24	*
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	dpavlin	32	* type being pointed to (int, int32_t, int64_t, char*, etc), how it should be
38	dpavlin	24	* 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	dpavlin	28	*
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	dpavlin	24	*/
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	dpavlin	32	struct settings *parent;
61			char *name_in_parent;
62
63	dpavlin	24	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	dpavlin	32	* Frees all resources occupied by a settings object. Also, if this settings
110			* object has a parent, then remove it from the parent.
111	dpavlin	24	*/
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	dpavlin	28	#ifdef UNSTABLE_DEVEL
123			if (settings->n_settings > 0)
124			printf("settings_destroy(): there are remaining settings!\n");
125			#endif
126
127	dpavlin	24	if (settings->name != NULL) {
128			for (i=0; i<settings->n_settings; i++) {
129	dpavlin	28	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	dpavlin	24	free(settings->name[i]);
136	dpavlin	28	}
137	dpavlin	24	}
138
139			free(settings->name);
140	dpavlin	28	} 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	dpavlin	24	}
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	dpavlin	32	if (settings->parent != NULL) {
160			settings_remove(settings->parent, settings->name_in_parent);
161			free(settings->name_in_parent);
162			}
163
164	dpavlin	24	free(settings);
165			}
166
167
168			/*
169	dpavlin	32	* 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	dpavlin	24	* 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	dpavlin	32	uint64_t value = 0;
278	dpavlin	24
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	dpavlin	32	settings_read(settings, i, &value);
291	dpavlin	24
292			switch (settings->presentation_format[i]) {
293			case SETTINGS_FORMAT_DECIMAL:
294			printf("%"PRIi64, value);
295			break;
296	dpavlin	32	case SETTINGS_FORMAT_HEX8:
297			printf("0x%02"PRIx8, (int8_t) value);
298	dpavlin	24	break;
299	dpavlin	32	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	dpavlin	24	case SETTINGS_FORMAT_BOOL:
309			printf(value? "true" : "false");
310			break;
311			case SETTINGS_FORMAT_YESNO:
312			printf(value? "yes" : "no");
313			break;
314	dpavlin	32	case SETTINGS_FORMAT_STRING:
315			printf("\"%s\"", ((char *)settings->ptr[i]));
316			break;
317	dpavlin	24	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	dpavlin	32	printf(" (R/O)");
325	dpavlin	24
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	dpavlin	32	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	dpavlin	24	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	dpavlin	32	if (settings->name[settings->n_settings - 1] == NULL)
375			goto out_of_mem;
376	dpavlin	24	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	dpavlin	32	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	dpavlin	24	return;
389
390			out_of_mem:
391			fprintf(stderr, "settings_add(): fatal error: out of memory\n");
392			exit(1);
393			}
394
395
396	dpavlin	32	/*
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