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	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	28	* $Id: settings.c,v 1.7 2006/07/15 10:06:11 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			* 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	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			*
47			*
48			* TODO:
49			* Remove a setting
50			* Read/write settings
51	dpavlin	24	*/
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	dpavlin	28	#ifdef UNSTABLE_DEVEL
124			if (settings->n_settings > 0)
125			printf("settings_destroy(): there are remaining settings!\n");
126			#endif
127
128	dpavlin	24	if (settings->name != NULL) {
129			for (i=0; i<settings->n_settings; i++) {
130	dpavlin	28	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	dpavlin	24	free(settings->name[i]);
137	dpavlin	28	}
138	dpavlin	24	}
139
140			free(settings->name);
141	dpavlin	28	} 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	dpavlin	24	}
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