0.4.0.1/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.5 2006/05/16 03:15:14 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.
 */

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

        if (settings->name != NULL) {
                for (i=0; i<settings->n_settings; i++) {
                        if (settings->name[i] != NULL)
                                free(settings->name[i]);
                }

                free(settings->name);
        }

        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.5 2006/05/16 03:15:14 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
43	#include <stdio.h>
44	#include <stdlib.h>
45	#include <string.h>
46
47	/* Including misc.h should ONLY be necessary to work around the fact that
48	many systems don't have PRIx64 etc defined. */
49	#include "misc.h"
50
51	#include "settings.h"
52
53
54	struct settings {
55	int n_settings;
56
57	/*
58	* Each setting has a name, a writable flag, a storage type, a
59	* presentation format, and a pointer.
60	*
61	* For subsettings, the pointer points to the subsettings object;
62	* for other settings, the pointer points to a variable.
63	*
64	* These pointers point to simple linear arrays, containing n_settings
65	* entries each.
66	*/
67
68	char **name;
69	int *writable;
70	int *storage_type;
71	int *presentation_format;
72	void **ptr;
73	};
74
75
76	/*
77	* settings_new():
78	*
79	* Create a new settings object. Return value is a pointer to the newly
80	* created object. The function does not return on failure.
81	*/
82	struct settings *settings_new(void)
83	{
84	struct settings *settings = malloc(sizeof(struct settings));
85
86	if (settings == NULL) {
87	fprintf(stderr, "settings_new(): out of memory\n");
88	exit(1);
89	}
90
91	/* No settings. */
92	memset(settings, 0, sizeof(struct settings));
93
94	return settings;
95	}
96
97
98	/*
99	* settings_destroy():
100	*
101	* Frees all resources occupied by a settings object.
102	*/
103	void settings_destroy(struct settings *settings)
104	{
105	int i;
106
107	if (settings == NULL) {
108	fprintf(stderr, "settings_destroy(): internal error, "
109	"settings = NULL!\n");
110	exit(1);
111	}
112
113	if (settings->name != NULL) {
114	for (i=0; i<settings->n_settings; i++) {
115	if (settings->name[i] != NULL)
116	free(settings->name[i]);
117	}
118
119	free(settings->name);
120	}
121
122	if (settings->writable != NULL)
123	free(settings->writable);
124
125	if (settings->storage_type != NULL)
126	free(settings->storage_type);
127
128	if (settings->presentation_format != NULL)
129	free(settings->presentation_format);
130
131	if (settings->ptr != NULL)
132	free(settings->ptr);
133
134	free(settings);
135	}
136
137
138	/*
139	* settings_debugdump():
140	*
141	* Dump settings in a settings object to stdout.
142	* If recurse is non-zero, all subsetting objects are also dumped.
143	*/
144	void settings_debugdump(struct settings settings, const char prefix,
145	int recurse)
146	{
147	size_t name_buflen = strlen(prefix) + 100;
148	char *name = malloc(name_buflen);
149	int i;
150	uint64_t value;
151
152	for (i=0; i<settings->n_settings; i++) {
153	snprintf(name, name_buflen, "%s.%s", prefix, settings->name[i]);
154
155	if (settings->storage_type[i] == SETTINGS_TYPE_SUBSETTINGS) {
156	/* Subsettings: */
157	if (recurse)
158	settings_debugdump(settings->ptr[i], name, 1);
159	} else {
160	/* Normal value: */
161	printf("%s = ", name);
162
163	switch (settings->storage_type[i]) {
164	case SETTINGS_TYPE_INT:
165	value = ((int ) settings->ptr[i]);
166	break;
167	case SETTINGS_TYPE_INT32:
168	value = ((int32_t ) settings->ptr[i]);
169	break;
170	case SETTINGS_TYPE_INT64:
171	value = ((int64_t ) settings->ptr[i]);
172	break;
173	default:printf("FATAL ERROR! Unknown storage type"
174	": %i\n", settings->storage_type[i]);
175	exit(1);
176	}
177
178	switch (settings->presentation_format[i]) {
179	case SETTINGS_FORMAT_DECIMAL:
180	printf("%"PRIi64, value);
181	break;
182	case SETTINGS_FORMAT_HEX:
183	printf("0x%"PRIx64, value);
184	break;
185	case SETTINGS_FORMAT_BOOL:
186	printf(value? "true" : "false");
187	break;
188	case SETTINGS_FORMAT_YESNO:
189	printf(value? "yes" : "no");
190	break;
191	default:printf("FATAL ERROR! Unknown presentation "
192	"format: %i\n",
193	settings->presentation_format[i]);
194	exit(1);
195	}
196
197	if (!settings->writable[i])
198	printf(" (Read-only)");
199
200	printf("\n");
201	}
202	}
203
204	free(name);
205	}
206
207
208	/*
209	* settings_add():
210	*
211	* Add a setting to a settings object.
212	*/
213	void settings_add(struct settings settings, const char name, int writable,
214	int type, int format, void *ptr)
215	{
216	settings->n_settings ++;
217
218	if ((settings->name = realloc(settings->name, settings->n_settings
219	* sizeof(char *))) == NULL)
220	goto out_of_mem;
221	if ((settings->writable = realloc(settings->writable,
222	settings->n_settings * sizeof(int))) == NULL)
223	goto out_of_mem;
224	if ((settings->storage_type = realloc(settings->storage_type,
225	settings->n_settings * sizeof(int))) == NULL)
226	goto out_of_mem;
227	if ((settings->presentation_format = realloc(settings->
228	presentation_format, settings->n_settings * sizeof(int))) == NULL)
229	goto out_of_mem;
230	if ((settings->ptr = realloc(settings->ptr, settings->n_settings
231	* sizeof(void *))) == NULL)
232	goto out_of_mem;
233
234	settings->name[settings->n_settings - 1] = strdup(name);
235	settings->writable[settings->n_settings - 1] = writable;
236	settings->storage_type[settings->n_settings - 1] = type;
237	settings->presentation_format[settings->n_settings - 1] = format;
238	settings->ptr[settings->n_settings - 1] = ptr;
239
240	return;
241
242	out_of_mem:
243	fprintf(stderr, "settings_add(): fatal error: out of memory\n");
244	exit(1);
245	}
246
247