so://phie

blob: e8392a0fcf93f7f6aac1c5dc4c5bf99b7c9f6688 (14075 bytes)[doc][blame][raw]

  1/* inih -- simple .INI file parser
  2
  3SPDX-License-Identifier: BSD-3-Clause
  4
  5Copyright (C) 2009-2020, Ben Hoyt
  6
  7inih is released under the New BSD license (see LICENSE.txt). Go to the project
  8home page for more info:
  9
 10https://github.com/benhoyt/inih
 11
 12*/
 13
 14#ifndef INI_H
 15#define INI_H
 16
 17/* Make this header file easier to include in C++ code */
 18#ifdef __cplusplus
 19extern "C" {
 20#endif
 21
 22#include <stdio.h>
 23
 24/* Nonzero if ini_handler callback should accept lineno parameter. */
 25#ifndef INI_HANDLER_LINENO
 26#define INI_HANDLER_LINENO 0
 27#endif
 28
 29/* Visibility symbols, required for Windows DLLs */
 30#ifndef INI_API
 31#if defined _WIN32 || defined __CYGWIN__
 32#	ifdef INI_SHARED_LIB
 33#		ifdef INI_SHARED_LIB_BUILDING
 34#			define INI_API __declspec(dllexport)
 35#		else
 36#			define INI_API __declspec(dllimport)
 37#		endif
 38#	else
 39#		define INI_API
 40#	endif
 41#else
 42#	if defined(__GNUC__) && __GNUC__ >= 4
 43#		define INI_API __attribute__ ((visibility ("default")))
 44#	else
 45#		define INI_API
 46#	endif
 47#endif
 48#endif
 49
 50/* Typedef for prototype of handler function. */
 51#if INI_HANDLER_LINENO
 52typedef int (*ini_handler)(void* user, const char* section,
 53                           const char* name, const char* value,
 54                           int lineno);
 55#else
 56typedef int (*ini_handler)(void* user, const char* section,
 57                           const char* name, const char* value);
 58#endif
 59
 60/* Typedef for prototype of fgets-style reader function. */
 61typedef char* (*ini_reader)(char* str, int num, void* stream);
 62
 63/* Parse given INI-style file. May have [section]s, name=value pairs
 64   (whitespace stripped), and comments starting with ';' (semicolon). Section
 65   is "" if name=value pair parsed before any section heading. name:value
 66   pairs are also supported as a concession to Python's configparser.
 67
 68   For each name=value pair parsed, call handler function with given user
 69   pointer as well as section, name, and value (data only valid for duration
 70   of handler call). Handler should return nonzero on success, zero on error.
 71
 72   Returns 0 on success, line number of first error on parse error (doesn't
 73   stop on first error), -1 on file open error, or -2 on memory allocation
 74   error (only when INI_USE_STACK is zero).
 75*/
 76INI_API int ini_parse(const char* filename, ini_handler handler, void* user);
 77
 78/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
 79   close the file when it's finished -- the caller must do that. */
 80INI_API int ini_parse_file(FILE* file, ini_handler handler, void* user);
 81
 82/* Same as ini_parse(), but takes an ini_reader function pointer instead of
 83   filename. Used for implementing custom or string-based I/O (see also
 84   ini_parse_string). */
 85INI_API int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
 86                     void* user);
 87
 88/* Same as ini_parse(), but takes a zero-terminated string with the INI data
 89instead of a file. Useful for parsing INI data from a network socket or
 90already in memory. */
 91INI_API int ini_parse_string(const char* string, ini_handler handler, void* user);
 92
 93/* Nonzero to allow multi-line value parsing, in the style of Python's
 94   configparser. If allowed, ini_parse() will call the handler with the same
 95   name for each subsequent line parsed. */
 96#ifndef INI_ALLOW_MULTILINE
 97#define INI_ALLOW_MULTILINE 1
 98#endif
 99
100/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
101   the file. See https://github.com/benhoyt/inih/issues/21 */
102#ifndef INI_ALLOW_BOM
103#define INI_ALLOW_BOM 1
104#endif
105
106/* Chars that begin a start-of-line comment. Per Python configparser, allow
107   both ; and # comments at the start of a line by default. */
108#ifndef INI_START_COMMENT_PREFIXES
109#define INI_START_COMMENT_PREFIXES ";#"
110#endif
111
112/* Nonzero to allow inline comments (with valid inline comment characters
113   specified by INI_INLINE_COMMENT_PREFIXES). Set to 0 to turn off and match
114   Python 3.2+ configparser behaviour. */
115#ifndef INI_ALLOW_INLINE_COMMENTS
116#define INI_ALLOW_INLINE_COMMENTS 1
117#endif
118#ifndef INI_INLINE_COMMENT_PREFIXES
119#define INI_INLINE_COMMENT_PREFIXES ";"
120#endif
121
122/* Nonzero to use stack for line buffer, zero to use heap (malloc/free). */
123#ifndef INI_USE_STACK
124#define INI_USE_STACK 1
125#endif
126
127/* Maximum line length for any line in INI file (stack or heap). Note that
128   this must be 3 more than the longest line (due to '\r', '\n', and '\0'). */
129#ifndef INI_MAX_LINE
130#define INI_MAX_LINE 200
131#endif
132
133/* Nonzero to allow heap line buffer to grow via realloc(), zero for a
134   fixed-size buffer of INI_MAX_LINE bytes. Only applies if INI_USE_STACK is
135   zero. */
136#ifndef INI_ALLOW_REALLOC
137#define INI_ALLOW_REALLOC 0
138#endif
139
140/* Initial size in bytes for heap line buffer. Only applies if INI_USE_STACK
141   is zero. */
142#ifndef INI_INITIAL_ALLOC
143#define INI_INITIAL_ALLOC 200
144#endif
145
146/* Stop parsing on first error (default is to keep parsing). */
147#ifndef INI_STOP_ON_FIRST_ERROR
148#define INI_STOP_ON_FIRST_ERROR 0
149#endif
150
151/* Nonzero to call the handler at the start of each new section (with
152   name and value NULL). Default is to only call the handler on
153   each name=value pair. */
154#ifndef INI_CALL_HANDLER_ON_NEW_SECTION
155#define INI_CALL_HANDLER_ON_NEW_SECTION 0
156#endif
157
158/* Nonzero to allow a name without a value (no '=' or ':' on the line) and
159   call the handler with value NULL in this case. Default is to treat
160   no-value lines as an error. */
161#ifndef INI_ALLOW_NO_VALUE
162#define INI_ALLOW_NO_VALUE 0
163#endif
164
165/* Nonzero to use custom ini_malloc, ini_free, and ini_realloc memory
166   allocation functions (INI_USE_STACK must also be 0). These functions must
167   have the same signatures as malloc/free/realloc and behave in a similar
168   way. ini_realloc is only needed if INI_ALLOW_REALLOC is set. */
169#ifndef INI_CUSTOM_ALLOCATOR
170#define INI_CUSTOM_ALLOCATOR 0
171#endif
172
173
174#ifdef __cplusplus
175}
176#endif
177
178#ifdef INI_IMPL
179
180#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
181#define _CRT_SECURE_NO_WARNINGS
182#endif
183
184#include <stdio.h>
185#include <ctype.h>
186#include <string.h>
187
188#include "ini.h"
189
190#if !INI_USE_STACK
191#if INI_CUSTOM_ALLOCATOR
192#include <stddef.h>
193void* ini_malloc(size_t size);
194void ini_free(void* ptr);
195void* ini_realloc(void* ptr, size_t size);
196#else
197#include <stdlib.h>
198#define ini_malloc malloc
199#define ini_free free
200#define ini_realloc realloc
201#endif
202#endif
203
204#define MAX_SECTION 50
205#define MAX_NAME 50
206
207/* Used by ini_parse_string() to keep track of string parsing state. */
208typedef struct {
209    const char* ptr;
210    size_t num_left;
211} ini_parse_string_ctx;
212
213/* Strip whitespace chars off end of given string, in place. Return s. */
214static char* ini_rstrip(char* s)
215{
216    char* p = s + strlen(s);
217    while (p > s && isspace((unsigned char)(*--p)))
218        *p = '\0';
219    return s;
220}
221
222/* Return pointer to first non-whitespace char in given string. */
223static char* ini_lskip(const char* s)
224{
225    while (*s && isspace((unsigned char)(*s)))
226        s++;
227    return (char*)s;
228}
229
230/* Return pointer to first char (of chars) or inline comment in given string,
231   or pointer to NUL at end of string if neither found. Inline comment must
232   be prefixed by a whitespace character to register as a comment. */
233static char* ini_find_chars_or_comment(const char* s, const char* chars)
234{
235#if INI_ALLOW_INLINE_COMMENTS
236    int was_space = 0;
237    while (*s && (!chars || !strchr(chars, *s)) &&
238           !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
239        was_space = isspace((unsigned char)(*s));
240        s++;
241    }
242#else
243    while (*s && (!chars || !strchr(chars, *s))) {
244        s++;
245    }
246#endif
247    return (char*)s;
248}
249
250/* Similar to strncpy, but ensures dest (size bytes) is
251   NUL-terminated, and doesn't pad with NULs. */
252static char* ini_strncpy0(char* dest, const char* src, size_t size)
253{
254    /* Could use strncpy internally, but it causes gcc warnings (see issue #91) */
255    size_t i;
256    for (i = 0; i < size - 1 && src[i]; i++)
257        dest[i] = src[i];
258    dest[i] = '\0';
259    return dest;
260}
261
262/* See documentation in header file. */
263int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
264                     void* user)
265{
266    /* Uses a fair bit of stack (use heap instead if you need to) */
267#if INI_USE_STACK
268    char line[INI_MAX_LINE];
269    size_t max_line = INI_MAX_LINE;
270#else
271    char* line;
272    size_t max_line = INI_INITIAL_ALLOC;
273#endif
274#if INI_ALLOW_REALLOC && !INI_USE_STACK
275    char* new_line;
276    size_t offset;
277#endif
278    char section[MAX_SECTION] = "";
279#if INI_ALLOW_MULTILINE
280    char prev_name[MAX_NAME] = "";
281#endif
282
283    char* start;
284    char* end;
285    char* name;
286    char* value;
287    int lineno = 0;
288    int error = 0;
289
290#if !INI_USE_STACK
291    line = (char*)ini_malloc(INI_INITIAL_ALLOC);
292    if (!line) {
293        return -2;
294    }
295#endif
296
297#if INI_HANDLER_LINENO
298#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
299#else
300#define HANDLER(u, s, n, v) handler(u, s, n, v)
301#endif
302
303    /* Scan through stream line by line */
304    while (reader(line, (int)max_line, stream) != NULL) {
305#if INI_ALLOW_REALLOC && !INI_USE_STACK
306        offset = strlen(line);
307        while (offset == max_line - 1 && line[offset - 1] != '\n') {
308            max_line *= 2;
309            if (max_line > INI_MAX_LINE)
310                max_line = INI_MAX_LINE;
311            new_line = ini_realloc(line, max_line);
312            if (!new_line) {
313                ini_free(line);
314                return -2;
315            }
316            line = new_line;
317            if (reader(line + offset, (int)(max_line - offset), stream) == NULL)
318                break;
319            if (max_line >= INI_MAX_LINE)
320                break;
321            offset += strlen(line + offset);
322        }
323#endif
324
325        lineno++;
326
327        start = line;
328#if INI_ALLOW_BOM
329        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
330                           (unsigned char)start[1] == 0xBB &&
331                           (unsigned char)start[2] == 0xBF) {
332            start += 3;
333        }
334#endif
335        start = ini_rstrip(ini_lskip(start));
336
337        if (strchr(INI_START_COMMENT_PREFIXES, *start)) {
338            /* Start-of-line comment */
339        }
340#if INI_ALLOW_MULTILINE
341        else if (*prev_name && *start && start > line) {
342#if INI_ALLOW_INLINE_COMMENTS
343            end = ini_find_chars_or_comment(start, NULL);
344            if (*end)
345                *end = '\0';
346            ini_rstrip(start);
347#endif
348            /* Non-blank line with leading whitespace, treat as continuation
349               of previous name's value (as per Python configparser). */
350            if (!HANDLER(user, section, prev_name, start) && !error)
351                error = lineno;
352        }
353#endif
354        else if (*start == '[') {
355            /* A "[section]" line */
356            end = ini_find_chars_or_comment(start + 1, "]");
357            if (*end == ']') {
358                *end = '\0';
359                ini_strncpy0(section, start + 1, sizeof(section));
360#if INI_ALLOW_MULTILINE
361                *prev_name = '\0';
362#endif
363#if INI_CALL_HANDLER_ON_NEW_SECTION
364                if (!HANDLER(user, section, NULL, NULL) && !error)
365                    error = lineno;
366#endif
367            }
368            else if (!error) {
369                /* No ']' found on section line */
370                error = lineno;
371            }
372        }
373        else if (*start) {
374            /* Not a comment, must be a name[=:]value pair */
375            end = ini_find_chars_or_comment(start, "=:");
376            if (*end == '=' || *end == ':') {
377                *end = '\0';
378                name = ini_rstrip(start);
379                value = end + 1;
380#if INI_ALLOW_INLINE_COMMENTS
381                end = ini_find_chars_or_comment(value, NULL);
382                if (*end)
383                    *end = '\0';
384#endif
385                value = ini_lskip(value);
386                ini_rstrip(value);
387
388#if INI_ALLOW_MULTILINE
389                ini_strncpy0(prev_name, name, sizeof(prev_name));
390#endif
391                /* Valid name[=:]value pair found, call handler */
392                if (!HANDLER(user, section, name, value) && !error)
393                    error = lineno;
394            }
395            else if (!error) {
396                /* No '=' or ':' found on name[=:]value line */
397#if INI_ALLOW_NO_VALUE
398                *end = '\0';
399                name = ini_rstrip(start);
400                if (!HANDLER(user, section, name, NULL) && !error)
401                    error = lineno;
402#else
403                error = lineno;
404#endif
405            }
406        }
407
408#if INI_STOP_ON_FIRST_ERROR
409        if (error)
410            break;
411#endif
412    }
413
414#if !INI_USE_STACK
415    ini_free(line);
416#endif
417
418    return error;
419}
420
421/* See documentation in header file. */
422int ini_parse_file(FILE* file, ini_handler handler, void* user)
423{
424    return ini_parse_stream((ini_reader)fgets, file, handler, user);
425}
426
427/* See documentation in header file. */
428int ini_parse(const char* filename, ini_handler handler, void* user)
429{
430    FILE* file;
431    int error;
432
433    file = fopen(filename, "r");
434    if (!file)
435        return -1;
436    error = ini_parse_file(file, handler, user);
437    fclose(file);
438    return error;
439}
440
441/* An ini_reader function to read the next line from a string buffer. This
442   is the fgets() equivalent used by ini_parse_string(). */
443static char* ini_reader_string(char* str, int num, void* stream) {
444    ini_parse_string_ctx* ctx = (ini_parse_string_ctx*)stream;
445    const char* ctx_ptr = ctx->ptr;
446    size_t ctx_num_left = ctx->num_left;
447    char* strp = str;
448    char c;
449
450    if (ctx_num_left == 0 || num < 2)
451        return NULL;
452
453    while (num > 1 && ctx_num_left != 0) {
454        c = *ctx_ptr++;
455        ctx_num_left--;
456        *strp++ = c;
457        if (c == '\n')
458            break;
459        num--;
460    }
461
462    *strp = '\0';
463    ctx->ptr = ctx_ptr;
464    ctx->num_left = ctx_num_left;
465    return str;
466}
467
468/* See documentation in header file. */
469int ini_parse_string(const char* string, ini_handler handler, void* user) {
470    ini_parse_string_ctx ctx;
471
472    ctx.ptr = string;
473    ctx.num_left = strlen(string);
474    return ini_parse_stream((ini_reader)ini_reader_string, &ctx, handler,
475                            user);
476}
477
478#endif /* INI_IMPL */
479#endif /* INI_H */