![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cfgopts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src|
Return to cfgopts.c CVS log | Up to [Previous NeXT emulator] / previous / src |
1.1 root 1: /*
2: * Hatari - cfgopts.c
3: *
4: * The functions in this file are used to load and save the ASCII
5: * configuration file.
6: * Original information text follows:
7: */
8: /*<<---------------[ cfgopts.c ]------------------------/
9: / /
10: / Functional /
11: / Description: Configuration file I/O /
12: / /
13: / Input : Configuration file name /
14: / Configuration parameters in a structure /
15: / /
16: / Process : Interpret information by parameter and read or /
17: / write back to the configuration file. /
18: / /
19: / Ouput : updated configuration file or updated structure. /
20: / /
21: / Programmer : Jeffry J. Brickley /
22: / /
23: / /
24: /---------------------------------------------------------------------*/
25:
26: /*---------------------------------------------------------------------/
27: /
28: / Description: CfgOpts is based on GETOPTS by Bob Stout. It will
29: / process a configuration file based one words and
30: / store it in a structure pointing to physical data
31: / area for each storage item.
32: / i.e. ???.CFG:
33: / Port=1
34: / work_space=C:\temp
35: / menus=TRUE
36: / user=Jeffry Brickley
37: / will write to the following structure:
38: / struct Config_Tag configs[] = {
39: / {"port", Int_Tag, &port_number},
40: / {"work_space", String_Tag, &work_space},
41: / {"menus", Bool_Tag, &menu_flag},
42: / {"user", String_Tag, &User_name},
43: / {NULL, Error_Tag, NULL}
44: / };
45: / Note that the structure must always be terminated by a NULL row as
46: / was the same with GETOPTS. This however is slightly more
47: / complicated than scaning the command line (but not by much) for
48: / data as there can be more variety in words than letters and an
49: / number of data items limited only by memory.
50: /
51: / Like the original code from which this was taken, this is released
52: / to the Public Domain. I cannot make any guarentees other than these
53: / work for me and I find them usefull. Feel free to pass these on to
54: / a friend, but please do not charge him....
55: /
56: /---------------------------------------------------------------------*/
57: const char CfgOpts_fileid[] = "Hatari cfgopts.c : " __DATE__ " " __TIME__;
58:
59: #include <stdio.h>
60: #include <stdlib.h>
61: #include <unistd.h>
62:
63: #include "main.h"
64: #include "cfgopts.h"
65: #include "str.h"
66:
67:
68: /**
69: * ---------------------------------------------------------------------/
70: * / reads from an input configuration (INI) file.
71: * /---------------------------------------------------------------------
72: * >>------[ input_config() ]-------------[ 08-02-95 14:02PM ]------/
73: * / return value:
74: * / int ; number of records read or -1 on error
75: * / parameters:
76: * / char *filename ; filename of INI style file
77: * / struct Config_Tag configs[]; Configuration structure
78: * / char *header ; INI header name (i.e. "[TEST]")
79: * /-------------------------------------------------------------------<<
80: */
81: int input_config(const char *filename, const struct Config_Tag configs[], const char *header)
82: {
83: const struct Config_Tag *ptr;
84: int count=0, lineno=0;
85: FILE *file;
86: char *fptr,*tok,*next;
87: char line[1024];
88:
89: file = fopen(filename,"r");
90: if (file == NULL)
91: return -1; /* return error designation. */
92:
93: if (header != NULL)
94: {
95: do
96: {
97: fptr = Str_Trim(fgets(line, sizeof(line), file)); /* get input line */
98: }
99: while ( memcmp(line,header,strlen(header)) && !feof(file));
100: }
101:
102: if ( !feof(file) )
103: do
104: {
105: fptr = Str_Trim(fgets(line, sizeof(line), file)); /* get input line */
106: if (fptr == NULL)
107: continue;
108: lineno++;
109: if (line[0] == '#')
110: continue; /* skip comments */
111: if (line[0] == '[')
112: continue; /* skip next header */
113: tok = Str_Trim(strtok(line, "=\n\r")); /* get first token */
114: if (tok != NULL)
115: {
116: next = Str_Trim(strtok(NULL, "=\n\r")); /* get actual config information */
117: for (ptr = configs; ptr->buf; ++ptr) /* scan for token */
118: {
119: if (!strcmp(tok, ptr->code)) /* got a match? */
120: {
121: switch (ptr->type) /* check type */
122: {
123: case Bool_Tag:
124: if (!strcasecmp(next,"FALSE"))
125: *((bool *)(ptr->buf)) = false;
126: else if (!strcasecmp(next,"TRUE"))
127: *((bool *)(ptr->buf)) = true;
128: ++count;
129: break;
130:
131: case Char_Tag:
132: sscanf(next, "%c", (char *)(ptr->buf));
133: ++count;
134: break;
135:
136: case Short_Tag:
137: sscanf(next, "%hd", (short *)(ptr->buf));
138: ++count;
139: break;
140:
141: case Int_Tag:
142: sscanf(next, "%d", (int *)(ptr->buf));
143: ++count;
144: break;
145:
146: case Long_Tag:
147: sscanf(next, "%ld", (long *)(ptr->buf));
148: ++count;
149: break;
150:
151: case Float_Tag:
152: sscanf(next, "%g", (float *)ptr->buf);
153: ++count;
154: break;
155:
156: case Double_Tag:
157: sscanf(next, "%lg", (double *)ptr->buf);
158: ++count;
159: break;
160:
161: case String_Tag:
162: if(next)
163: strcpy((char *)ptr->buf, next);
164: else
165: *(char *)ptr->buf = 0;
166: ++count;
167: break;
168:
169: case Error_Tag:
170: default:
171: printf("Error in Config file %s on line %d\n", filename, lineno);
172: break;
173: }
174: }
175:
176: }
177: }
178: }
179: while ( fptr!=NULL && line[0]!='[');
180:
181: fclose(file);
182: return count;
183: }
184:
185:
186: /**
187: * Write out an settings line
188: */
189: static int write_token(FILE *outfile, const struct Config_Tag *ptr)
190: {
191: fprintf(outfile,"%s = ",ptr->code);
192:
193: switch (ptr->type) /* check type */
194: {
195: case Bool_Tag:
196: fprintf(outfile,"%s\n", *((bool *)(ptr->buf)) ? "TRUE" : "FALSE");
197: break;
198:
199: case Char_Tag:
200: fprintf(outfile, "%c\n", *((char *)(ptr->buf)));
201: break;
202:
203: case Short_Tag:
204: fprintf(outfile, "%hd\n", *((short *)(ptr->buf)));
205: break;
206:
207: case Int_Tag:
208: fprintf(outfile, "%d\n", *((int *)(ptr->buf)));
209: break;
210:
211: case Long_Tag:
212: fprintf(outfile, "%ld\n", *((long *)(ptr->buf)));
213: break;
214:
215: case Float_Tag:
216: fprintf(outfile, "%g\n", *((float *)ptr->buf));
217: break;
218:
219: case Double_Tag:
220: fprintf(outfile, "%g\n", *((double *)ptr->buf));
221: break;
222:
223: case String_Tag:
224: fprintf(outfile, "%s\n",(char *)ptr->buf);
225: break;
226:
227: case Error_Tag:
228: default:
229: fprintf(stderr, "Error in Config structure (Contact author).\n");
230: return -1;
231: }
232:
233: return 0;
234: }
235:
236:
237: /**
238: * Write given section header and tokens for that
239: * Return number of written tokens
240: */
241: static int write_header_tokens(FILE *fp, const struct Config_Tag *ptr, const char *header)
242: {
243: int count = 0;
244:
245: if (header != NULL)
246: {
247: fprintf(fp, "%s\n", header);
248: }
249:
250: for (; ptr->buf; ++ptr) /* scan for token */
251: {
252: if (write_token(fp, ptr) == 0)
253: ++count;
254: }
255:
256: fprintf(fp, "\n");
257:
258: return count;
259: }
260:
261:
262: /**
263: * ---------------------------------------------------------------------/
264: * / updates an input configuration (INI) file from a structure.
265: * /---------------------------------------------------------------------
266: * >>------[ update_config() ]-------------[ 08-02-95 14:02PM ]------/
267: * / return value:
268: * / int ; Number of records read & updated
269: * / parameters:
270: * / char *filename ; filename of INI file
271: * / struct Config_Tag configs[]; Configuration structure
272: * / char *header ; INI header name (i.e. "[TEST]")
273: * /-------------------------------------------------------------------<<
274: */
275: int update_config(const char *filename, const struct Config_Tag configs[], const char *header)
276: {
277: const struct Config_Tag *ptr;
278: int count=0, lineno=0, retval;
279: FILE *cfgfile, *tempfile;
280: char *fptr, *tok, *next;
281: char line[1024];
282: bool bUseTempCfg = false;
283: const char *sTempCfgName = "_temp_.cfg";
284:
285: cfgfile = fopen(filename, "r");
286:
287: /* If the cfg file does not yet exists, we can create it directly: */
288: if (cfgfile == NULL)
289: {
290: cfgfile = fopen(filename, "w");
291: if (cfgfile == NULL)
292: return -1; /* return error designation. */
293: count = write_header_tokens(cfgfile, configs, header);
294: fclose(cfgfile);
295: return count;
296: }
297:
298: tempfile = tmpfile(); /* Open a temporary file for output */
299: if (tempfile == NULL)
300: {
301: /* tmpfile() failed, let's try a normal open */
302: tempfile = fopen(sTempCfgName, "w+");
303: bUseTempCfg = true;
304: }
305: if (tempfile == NULL)
306: {
307: perror("update_config");
308: fclose(cfgfile);
309: return -1; /* return error designation. */
310: }
311:
312: if (header != NULL)
313: {
314: int headerlen = strlen(header);
315: do
316: {
317: fptr = Str_Trim(fgets(line, sizeof(line), cfgfile)); /* get input line */
318: if (feof(cfgfile))
319: break;
320: fprintf(tempfile, "%s\n", line);
321: }
322: while(memcmp(line, header, headerlen));
323: }
324:
325: if (feof(cfgfile))
326: {
327: count += write_header_tokens(tempfile, configs, header);
328: }
329: else
330: {
331: char *savedtokenflags = NULL; /* Array to log the saved tokens */
332: int numtokens = 0; /* Total number of tokens to save */
333:
334: /* Find total number of tokens: */
335: for (ptr=configs; ptr->buf; ++ptr)
336: {
337: numtokens += 1;
338: }
339: if (numtokens)
340: {
341: savedtokenflags = malloc(numtokens * sizeof(char));
342: if (savedtokenflags)
343: memset(savedtokenflags, 0, numtokens * sizeof(char));
344: }
345:
346: for(;;)
347: {
348: fptr = Str_Trim(fgets(line, sizeof(line), cfgfile)); /* get input line */
349: if (fptr == NULL)
350: break;
351: lineno++;
352: if (line[0] == '#')
353: {
354: fprintf(tempfile, "%s\n", line);
355: continue; /* skip comments */
356: }
357: if (line[0] == '[' || feof(cfgfile))
358: {
359: break;
360: }
361:
362: tok = Str_Trim(strtok(line, "=\n\r")); /* get first token */
363: if (tok != NULL)
364: {
365: int i = 0;
366: next = strtok(line, "=\n\r"); /* get actual config information */
367: for (ptr = configs; ptr->buf; ++ptr, i++) /* scan for token */
368: {
369: if (!strcmp(tok, ptr->code)) /* got a match? */
370: {
371: if (write_token(tempfile, ptr) == 0)
372: {
373: if (savedtokenflags)
374: savedtokenflags[i] = true;
375: count += 1;
376: }
377: }
378: }
379: }
380: }
381:
382: /* Write remaining (new?) tokens that were not in the configuration file, yet */
383: if (count != numtokens && savedtokenflags != NULL)
384: {
385: int i;
386: for (ptr = configs, i = 0; ptr->buf; ++ptr, i++)
387: {
388: if (!savedtokenflags[i])
389: {
390: if (write_token(tempfile, ptr) == 0)
391: {
392: count += 1;
393: fprintf(stderr, "Wrote new token %s -> %s \n", header, ptr->code);
394: }
395: }
396: }
397: }
398:
399: if (savedtokenflags)
400: {
401: free(savedtokenflags);
402: savedtokenflags = NULL;
403: }
404:
405: if (!feof(cfgfile) && fptr != NULL)
406: fprintf(tempfile, "\n%s\n", line);
407:
408: for(;;)
409: {
410: fptr = Str_Trim(fgets(line, sizeof(line), cfgfile)); /* get input line */
411: if (feof(cfgfile))
412: break;
413: fprintf(tempfile, "%s\n", line);
414: }
415: }
416:
417:
418: /* Re-open the config file for writing: */
419: fclose(cfgfile);
420: cfgfile = fopen(filename, "wb");
421: if (cfgfile == NULL || fseek(tempfile, 0, SEEK_SET) != 0)
422: {
423: retval = -1;
424: goto cleanup;
425: }
426:
427: /* Now copy the temporary file to the configuration file: */
428: retval = count;
429: while(!(feof(tempfile) || ferror(cfgfile)))
430: {
431: size_t copycount;
432: copycount = fread(line, sizeof(char), sizeof(line), tempfile);
433: if (copycount == 0)
434: break;
435: if (fwrite(line, sizeof(char), copycount, cfgfile) != copycount)
436: {
437: retval = -1;
438: break;
439: }
440: }
441: cleanup:
442: if (cfgfile)
443: {
444: if (ferror(cfgfile))
445: perror("update_config");
446: fclose(cfgfile);
447: }
448: if (tempfile)
449: {
450: /* tmpfile() is removed automatically on close */
451: fclose(tempfile);
452: if (bUseTempCfg)
453: unlink(sTempCfgName);
454: }
455: return retval;
456: }
457:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.