[Buildroot] [PATCH 1/1] package/xenomai: fix build with gcc 10
Fabrice Fontaine
fontaine.fabrice at gmail.com
Tue Jan 19 17:31:19 UTC 2021
Fixes:
- http://autobuild.buildroot.org/results/551228bcc7152d5e835f3cced6329269b6bad651
Signed-off-by: Fabrice Fontaine <fontaine.fabrice at gmail.com>
---
...Allow-building-with-GCC-10-2-2020101.patch | 1721 +++++++++++++++++
1 file changed, 1721 insertions(+)
create mode 100644 package/xenomai/0001-lib-boilerplate-iniparser-Allow-building-with-GCC-10-2-2020101.patch
diff --git a/package/xenomai/0001-lib-boilerplate-iniparser-Allow-building-with-GCC-10-2-2020101.patch b/package/xenomai/0001-lib-boilerplate-iniparser-Allow-building-with-GCC-10-2-2020101.patch
new file mode 100644
index 0000000000..e4addea856
--- /dev/null
+++ b/package/xenomai/0001-lib-boilerplate-iniparser-Allow-building-with-GCC-10-2-2020101.patch
@@ -0,0 +1,1721 @@
+From 8acdbd718b7828b5d8903a6254b2fa198b866491 Mon Sep 17 00:00:00 2001
+From: Florian Bezdeka <florian.bezdeka at siemens.com>
+Date: Thu, 12 Nov 2020 11:45:28 +0000
+Subject: [PATCH] lib/boilerplate/iniparser: Allow building with GCC 10.2
+ 2020101
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Updating to upstream revision f858275f7f307eecba84c2f5429483f9f28007f8.
+Upstream repository is located at [1].
+
+The reason for updating was the following compiler error when trying
+to compile with GCC 10.2 10.2.1 20201016. As it turned out the problem
+was already addressed upstream:
+
+iniparser/iniparser.c: In function ‘iniparser_load’:
+iniparser/iniparser.c:616:13: error: ‘sprintf’ arguments 3, 4 may
+overlap destination object ‘buf’ [-Werror=restrict]
+ 616 | sprintf(tmp, "%s:%s", section, key);
+ | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+I reviewed especially the API changes. Most of them are cleanups only
+but two things should be pointed out:
+
+ - The type of the size field of struct _dictionary_ changed from int
+ to ssize_t. The only user of this struct is
+ lib/analogy/calibration.c which uses this structure for internal
+ things only. It is never exposed to any public API so updating is
+ OK and fully backward compatible.
+
+ - dictionary_new changed its signature
+ from dictionary_new(int size)
+ to dictionary_new(size_t size).
+ This function is not part of any public API. So updating does not
+ break backward compatibility.
+
+[1] https://github.com/ndevilla/iniparser
+
+Signed-off-by: Florian Bezdeka <florian.bezdeka at siemens.com>
+Signed-off-by: Jan Kiszka <jan.kiszka at siemens.com>
+
+[Retrieved from:
+https://gitlab.denx.de/Xenomai/xenomai/-/commit/8acdbd718b7828b5d8903a6254b2fa198b866491]
+Signed-off-by: Fabrice Fontaine <fontaine.fabrice at gmail.com>
+---
+ lib/boilerplate/iniparser/dictionary.c | 409 ++++++++++----------
+ lib/boilerplate/iniparser/dictionary.h | 43 ++-
+ lib/boilerplate/iniparser/iniparser.c | 491 +++++++++++++++++--------
+ lib/boilerplate/iniparser/iniparser.h | 131 +++++--
+ 4 files changed, 646 insertions(+), 428 deletions(-)
+
+diff --git a/lib/boilerplate/iniparser/dictionary.c b/lib/boilerplate/iniparser/dictionary.c
+index 5299b77ed..cb7ccd49e 100644
+--- a/lib/boilerplate/iniparser/dictionary.c
++++ b/lib/boilerplate/iniparser/dictionary.c
+@@ -1,10 +1,8 @@
+ /*-------------------------------------------------------------------------*/
+ /**
+- @file dictionary.c
+- @author N. Devillard
+- @date Sep 2007
+- @version $Revision: 1.27 $
+- @brief Implements a dictionary for string variables.
++ @file dictionary.c
++ @author N. Devillard
++ @brief Implements a dictionary for string variables.
+
+ This module implements a simple dictionary object, i.e. a list
+ of string/string associations. This object is useful to store e.g.
+@@ -12,12 +10,8 @@
+ */
+ /*--------------------------------------------------------------------------*/
+
+-/*
+- $Id: dictionary.c,v 1.27 2007-11-23 21:39:18 ndevilla Exp $
+- $Revision: 1.27 $
+-*/
+ /*---------------------------------------------------------------------------
+- Includes
++ Includes
+ ---------------------------------------------------------------------------*/
+ #include "dictionary.h"
+
+@@ -27,33 +21,18 @@
+ #include <unistd.h>
+
+ /** Maximum value size for integers and doubles. */
+-#define MAXVALSZ 1024
++#define MAXVALSZ 1024
+
+ /** Minimal allocated number of entries in a dictionary */
+-#define DICTMINSZ 128
++#define DICTMINSZ 128
+
+ /** Invalid key token */
+ #define DICT_INVALID_KEY ((char*)-1)
+
+ /*---------------------------------------------------------------------------
+- Private functions
++ Private functions
+ ---------------------------------------------------------------------------*/
+
+-/* Doubles the allocated size associated to a pointer */
+-/* 'size' is the current allocated size. */
+-static void * mem_double(void * ptr, int size)
+-{
+- void * newptr ;
+-
+- newptr = calloc(2*size, 1);
+- if (newptr==NULL) {
+- return NULL ;
+- }
+- memcpy(newptr, ptr, size);
+- free(ptr);
+- return newptr ;
+-}
+-
+ /*-------------------------------------------------------------------------*/
+ /**
+ @brief Duplicate a string
+@@ -67,23 +46,68 @@ static void * mem_double(void * ptr, int size)
+ static char * xstrdup(const char * s)
+ {
+ char * t ;
++ size_t len ;
+ if (!s)
+ return NULL ;
+- t = malloc(strlen(s)+1) ;
++
++ len = strlen(s) + 1 ;
++ t = (char*) malloc(len) ;
+ if (t) {
+- strcpy(t,s);
++ memcpy(t, s, len) ;
+ }
+ return t ;
+ }
+
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Double the size of the dictionary
++ @param d Dictionary to grow
++ @return This function returns non-zero in case of failure
++ */
++/*--------------------------------------------------------------------------*/
++static int dictionary_grow(dictionary * d)
++{
++ char ** new_val ;
++ char ** new_key ;
++ unsigned * new_hash ;
++
++ new_val = (char**) calloc(d->size * 2, sizeof *d->val);
++ new_key = (char**) calloc(d->size * 2, sizeof *d->key);
++ new_hash = (unsigned*) calloc(d->size * 2, sizeof *d->hash);
++ if (!new_val || !new_key || !new_hash) {
++ /* An allocation failed, leave the dictionary unchanged */
++ if (new_val)
++ free(new_val);
++ if (new_key)
++ free(new_key);
++ if (new_hash)
++ free(new_hash);
++ return -1 ;
++ }
++ /* Initialize the newly allocated space */
++ memcpy(new_val, d->val, d->size * sizeof(char *));
++ memcpy(new_key, d->key, d->size * sizeof(char *));
++ memcpy(new_hash, d->hash, d->size * sizeof(unsigned));
++ /* Delete previous data */
++ free(d->val);
++ free(d->key);
++ free(d->hash);
++ /* Actually update the dictionary */
++ d->size *= 2 ;
++ d->val = new_val;
++ d->key = new_key;
++ d->hash = new_hash;
++ return 0 ;
++}
++
+ /*---------------------------------------------------------------------------
+- Function codes
++ Function codes
+ ---------------------------------------------------------------------------*/
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Compute the hash key for a string.
+- @param key Character string to use for key.
+- @return 1 unsigned int on at least 32 bits.
++ @brief Compute the hash key for a string.
++ @param key Character string to use for key.
++ @return 1 unsigned int on at least 32 bits.
+
+ This hash function has been taken from an Article in Dr Dobbs Journal.
+ This is normally a collision-free function, distributing keys evenly.
+@@ -93,84 +117,88 @@ static char * xstrdup(const char * s)
+ /*--------------------------------------------------------------------------*/
+ unsigned dictionary_hash(const char * key)
+ {
+- int len ;
+- unsigned hash ;
+- int i ;
+-
+- len = strlen(key);
+- for (hash=0, i=0 ; i<len ; i++) {
+- hash += (unsigned)key[i] ;
+- hash += (hash<<10);
+- hash ^= (hash>>6) ;
+- }
+- hash += (hash <<3);
+- hash ^= (hash >>11);
+- hash += (hash <<15);
+- return hash ;
++ size_t len ;
++ unsigned hash ;
++ size_t i ;
++
++ if (!key)
++ return 0 ;
++
++ len = strlen(key);
++ for (hash=0, i=0 ; i<len ; i++) {
++ hash += (unsigned)key[i] ;
++ hash += (hash<<10);
++ hash ^= (hash>>6) ;
++ }
++ hash += (hash <<3);
++ hash ^= (hash >>11);
++ hash += (hash <<15);
++ return hash ;
+ }
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Create a new dictionary object.
+- @param size Optional initial size of the dictionary.
+- @return 1 newly allocated dictionary objet.
++ @brief Create a new dictionary object.
++ @param size Optional initial size of the dictionary.
++ @return 1 newly allocated dictionary objet.
+
+ This function allocates a new dictionary object of given size and returns
+ it. If you do not know in advance (roughly) the number of entries in the
+ dictionary, give size=0.
+ */
+-/*--------------------------------------------------------------------------*/
+-dictionary * dictionary_new(int size)
++/*-------------------------------------------------------------------------*/
++dictionary * dictionary_new(size_t size)
+ {
+- dictionary * d ;
+-
+- /* If no size was specified, allocate space for DICTMINSZ */
+- if (size<DICTMINSZ) size=DICTMINSZ ;
+-
+- if (!(d = (dictionary *)calloc(1, sizeof(dictionary)))) {
+- return NULL;
+- }
+- d->size = size ;
+- d->val = (char **)calloc(size, sizeof(char*));
+- d->key = (char **)calloc(size, sizeof(char*));
+- d->hash = (unsigned int *)calloc(size, sizeof(unsigned));
+- return d ;
++ dictionary * d ;
++
++ /* If no size was specified, allocate space for DICTMINSZ */
++ if (size<DICTMINSZ) size=DICTMINSZ ;
++
++ d = (dictionary*) calloc(1, sizeof *d) ;
++
++ if (d) {
++ d->size = size ;
++ d->val = (char**) calloc(size, sizeof *d->val);
++ d->key = (char**) calloc(size, sizeof *d->key);
++ d->hash = (unsigned*) calloc(size, sizeof *d->hash);
++ }
++ return d ;
+ }
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Delete a dictionary object
+- @param d dictionary object to deallocate.
+- @return void
++ @brief Delete a dictionary object
++ @param d dictionary object to deallocate.
++ @return void
+
+ Deallocate a dictionary object and all memory associated to it.
+ */
+ /*--------------------------------------------------------------------------*/
+ void dictionary_del(dictionary * d)
+ {
+- int i ;
+-
+- if (d==NULL) return ;
+- for (i=0 ; i<d->size ; i++) {
+- if (d->key[i]!=NULL)
+- free(d->key[i]);
+- if (d->val[i]!=NULL)
+- free(d->val[i]);
+- }
+- free(d->val);
+- free(d->key);
+- free(d->hash);
+- free(d);
+- return ;
++ ssize_t i ;
++
++ if (d==NULL) return ;
++ for (i=0 ; i<d->size ; i++) {
++ if (d->key[i]!=NULL)
++ free(d->key[i]);
++ if (d->val[i]!=NULL)
++ free(d->val[i]);
++ }
++ free(d->val);
++ free(d->key);
++ free(d->hash);
++ free(d);
++ return ;
+ }
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Get a value from a dictionary.
+- @param d dictionary object to search.
+- @param key Key to look for in the dictionary.
++ @brief Get a value from a dictionary.
++ @param d dictionary object to search.
++ @param key Key to look for in the dictionary.
+ @param def Default value to return if key not found.
+- @return 1 pointer to internally allocated character string.
++ @return 1 pointer to internally allocated character string.
+
+ This function locates a key in a dictionary and returns a pointer to its
+ value, or the passed 'def' pointer if no such key can be found in
+@@ -178,24 +206,24 @@ void dictionary_del(dictionary * d)
+ dictionary object, you should not try to free it or modify it.
+ */
+ /*--------------------------------------------------------------------------*/
+-const char * dictionary_get(dictionary * d, const char * key, const char * def)
++const char * dictionary_get(const dictionary * d, const char * key, const char * def)
+ {
+- unsigned hash ;
+- int i ;
++ unsigned hash ;
++ ssize_t i ;
+
+- hash = dictionary_hash(key);
+- for (i=0 ; i<d->size ; i++) {
++ hash = dictionary_hash(key);
++ for (i=0 ; i<d->size ; i++) {
+ if (d->key[i]==NULL)
+ continue ;
+ /* Compare hash */
+- if (hash==d->hash[i]) {
++ if (hash==d->hash[i]) {
+ /* Compare string, to avoid hash collisions */
+ if (!strcmp(key, d->key[i])) {
+- return d->val[i] ;
+- }
+- }
+- }
+- return def ;
++ return d->val[i] ;
++ }
++ }
++ }
++ return def ;
+ }
+
+ /*-------------------------------------------------------------------------*/
+@@ -226,66 +254,57 @@ const char * dictionary_get(dictionary * d, const char * key, const char * def)
+ /*--------------------------------------------------------------------------*/
+ int dictionary_set(dictionary * d, const char * key, const char * val)
+ {
+- int i ;
+- unsigned hash ;
+-
+- if (d==NULL || key==NULL) return -1 ;
+-
+- /* Compute hash for this key */
+- hash = dictionary_hash(key) ;
+- /* Find if value is already in dictionary */
+- if (d->n>0) {
+- for (i=0 ; i<d->size ; i++) {
++ ssize_t i ;
++ unsigned hash ;
++
++ if (d==NULL || key==NULL) return -1 ;
++
++ /* Compute hash for this key */
++ hash = dictionary_hash(key) ;
++ /* Find if value is already in dictionary */
++ if (d->n>0) {
++ for (i=0 ; i<d->size ; i++) {
+ if (d->key[i]==NULL)
+ continue ;
+- if (hash==d->hash[i]) { /* Same hash value */
+- if (!strcmp(key, d->key[i])) { /* Same key */
+- /* Found a value: modify and return */
+- if (d->val[i]!=NULL)
+- free(d->val[i]);
+- d->val[i] = val ? xstrdup(val) : NULL ;
++ if (hash==d->hash[i]) { /* Same hash value */
++ if (!strcmp(key, d->key[i])) { /* Same key */
++ /* Found a value: modify and return */
++ if (d->val[i]!=NULL)
++ free(d->val[i]);
++ d->val[i] = (val ? xstrdup(val) : NULL);
+ /* Value has been modified: return */
+- return 0 ;
+- }
+- }
+- }
+- }
+- /* Add a new value */
+- /* See if dictionary needs to grow */
+- if (d->n==d->size) {
+-
+- /* Reached maximum size: reallocate dictionary */
+- d->val = (char **)mem_double(d->val, d->size * sizeof(char*)) ;
+- d->key = (char **)mem_double(d->key, d->size * sizeof(char*)) ;
+- d->hash = (unsigned int *)mem_double(d->hash, d->size * sizeof(unsigned)) ;
+- if ((d->val==NULL) || (d->key==NULL) || (d->hash==NULL)) {
+- /* Cannot grow dictionary */
+- return -1 ;
++ return 0 ;
++ }
++ }
+ }
+- /* Double size */
+- d->size *= 2 ;
+- }
++ }
++ /* Add a new value */
++ /* See if dictionary needs to grow */
++ if (d->n==d->size) {
++ /* Reached maximum size: reallocate dictionary */
++ if (dictionary_grow(d) != 0)
++ return -1;
++ }
+
+- /* Insert key in the first empty slot */
+- for (i=0 ; i<d->size ; i++) {
+- if (d->key[i]==NULL) {
+- /* Add key here */
+- break ;
+- }
++ /* Insert key in the first empty slot. Start at d->n and wrap at
++ d->size. Because d->n < d->size this will necessarily
++ terminate. */
++ for (i=d->n ; d->key[i] ; ) {
++ if(++i == d->size) i = 0;
+ }
+- /* Copy key */
+- d->key[i] = xstrdup(key);
+- d->val[i] = val ? xstrdup(val) : NULL ;
+- d->hash[i] = hash;
+- d->n ++ ;
+- return 0 ;
++ /* Copy key */
++ d->key[i] = xstrdup(key);
++ d->val[i] = (val ? xstrdup(val) : NULL) ;
++ d->hash[i] = hash;
++ d->n ++ ;
++ return 0 ;
+ }
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Delete a key in a dictionary
+- @param d dictionary object to modify.
+- @param key Key to remove.
++ @brief Delete a key in a dictionary
++ @param d dictionary object to modify.
++ @param key Key to remove.
+ @return void
+
+ This function deletes a key in a dictionary. Nothing is done if the
+@@ -294,26 +313,26 @@ int dictionary_set(dictionary * d, const char * key, const char * val)
+ /*--------------------------------------------------------------------------*/
+ void dictionary_unset(dictionary * d, const char * key)
+ {
+- unsigned hash ;
+- int i ;
++ unsigned hash ;
++ ssize_t i ;
+
+- if (key == NULL) {
+- return;
+- }
++ if (key == NULL || d == NULL) {
++ return;
++ }
+
+- hash = dictionary_hash(key);
+- for (i=0 ; i<d->size ; i++) {
++ hash = dictionary_hash(key);
++ for (i=0 ; i<d->size ; i++) {
+ if (d->key[i]==NULL)
+ continue ;
+ /* Compare hash */
+- if (hash==d->hash[i]) {
++ if (hash==d->hash[i]) {
+ /* Compare string, to avoid hash collisions */
+ if (!strcmp(key, d->key[i])) {
+ /* Found key */
+ break ;
+- }
+- }
+- }
++ }
++ }
++ }
+ if (i>=d->size)
+ /* Key not found */
+ return ;
+@@ -331,75 +350,31 @@ void dictionary_unset(dictionary * d, const char * key)
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Dump a dictionary to an opened file pointer.
+- @param d Dictionary to dump
+- @param out Opened file pointer.
+- @return void
++ @brief Dump a dictionary to an opened file pointer.
++ @param d Dictionary to dump
++ @param f Opened file pointer.
++ @return void
+
+ Dumps a dictionary onto an opened file pointer. Key pairs are printed out
+ as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as
+ output file pointers.
+ */
+ /*--------------------------------------------------------------------------*/
+-void dictionary_dump(dictionary * d, FILE * out)
++void dictionary_dump(const dictionary * d, FILE * out)
+ {
+- int i ;
+-
+- if (d==NULL || out==NULL) return ;
+- if (d->n<1) {
+- fprintf(out, "empty dictionary\n");
+- return ;
+- }
+- for (i=0 ; i<d->size ; i++) {
++ ssize_t i ;
++
++ if (d==NULL || out==NULL) return ;
++ if (d->n<1) {
++ fprintf(out, "empty dictionary\n");
++ return ;
++ }
++ for (i=0 ; i<d->size ; i++) {
+ if (d->key[i]) {
+ fprintf(out, "%20s\t[%s]\n",
+ d->key[i],
+ d->val[i] ? d->val[i] : "UNDEF");
+ }
+- }
+- return ;
+-}
+-
+-
+-/* Test code */
+-#ifdef TESTDIC
+-#define NVALS 20000
+-int main(int argc, char *argv[])
+-{
+- dictionary * d ;
+- char * val ;
+- int i ;
+- char cval[90] ;
+-
+- /* Allocate dictionary */
+- printf("allocating...\n");
+- d = dictionary_new(0);
+-
+- /* Set values in dictionary */
+- printf("setting %d values...\n", NVALS);
+- for (i=0 ; i<NVALS ; i++) {
+- sprintf(cval, "%04d", i);
+- dictionary_set(d, cval, "salut");
+- }
+- printf("getting %d values...\n", NVALS);
+- for (i=0 ; i<NVALS ; i++) {
+- sprintf(cval, "%04d", i);
+- val = dictionary_get(d, cval, DICT_INVALID_KEY);
+- if (val==DICT_INVALID_KEY) {
+- printf("cannot get value for key [%s]\n", cval);
+- }
+- }
+- printf("unsetting %d values...\n", NVALS);
+- for (i=0 ; i<NVALS ; i++) {
+- sprintf(cval, "%04d", i);
+- dictionary_unset(d, cval);
+- }
+- if (d->n != 0) {
+- printf("error deleting values\n");
+ }
+- printf("deallocating...\n");
+- dictionary_del(d);
+- return 0 ;
++ return ;
+ }
+-#endif
+-/* vim: set ts=4 et sw=4 tw=75 */
+diff --git a/lib/boilerplate/iniparser/dictionary.h b/lib/boilerplate/iniparser/dictionary.h
+index fa4dcb727..d04b6ce71 100644
+--- a/lib/boilerplate/iniparser/dictionary.h
++++ b/lib/boilerplate/iniparser/dictionary.h
+@@ -3,8 +3,6 @@
+ /**
+ @file dictionary.h
+ @author N. Devillard
+- @date Sep 2007
+- @version $Revision: 1.12 $
+ @brief Implements a dictionary for string variables.
+
+ This module implements a simple dictionary object, i.e. a list
+@@ -13,18 +11,11 @@
+ */
+ /*--------------------------------------------------------------------------*/
+
+-/*
+- $Id: dictionary.h,v 1.12 2007-11-23 21:37:00 ndevilla Exp $
+- $Author: ndevilla $
+- $Date: 2007-11-23 21:37:00 $
+- $Revision: 1.12 $
+-*/
+-
+ #ifndef _DICTIONARY_H_
+ #define _DICTIONARY_H_
+
+ /*---------------------------------------------------------------------------
+- Includes
++ Includes
+ ---------------------------------------------------------------------------*/
+
+ #include <stdio.h>
+@@ -32,14 +23,18 @@
+ #include <string.h>
+ #include <unistd.h>
+
++#ifdef __cplusplus
++extern "C" {
++#endif
++
+ /*---------------------------------------------------------------------------
+- New types
++ New types
+ ---------------------------------------------------------------------------*/
+
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Dictionary object
++ @brief Dictionary object
+
+ This object contains a list of string/string associations. Each
+ association is identified by a unique string key. Looking up values
+@@ -48,16 +43,16 @@
+ */
+ /*-------------------------------------------------------------------------*/
+ typedef struct _dictionary_ {
+- int n ; /** Number of entries in dictionary */
+- int size ; /** Storage size */
+- char ** val ; /** List of string values */
+- char ** key ; /** List of string keys */
+- unsigned * hash ; /** List of hash values for keys */
++ int n ; /** Number of entries in dictionary */
++ ssize_t size ; /** Storage size */
++ char ** val ; /** List of string values */
++ char ** key ; /** List of string keys */
++ unsigned * hash ; /** List of hash values for keys */
+ } dictionary ;
+
+
+ /*---------------------------------------------------------------------------
+- Function prototypes
++ Function prototypes
+ ---------------------------------------------------------------------------*/
+
+ /*-------------------------------------------------------------------------*/
+@@ -85,7 +80,7 @@ unsigned dictionary_hash(const char * key);
+ dictionary, give size=0.
+ */
+ /*--------------------------------------------------------------------------*/
+-dictionary * dictionary_new(int size);
++dictionary * dictionary_new(size_t size);
+
+ /*-------------------------------------------------------------------------*/
+ /**
+@@ -112,7 +107,7 @@ void dictionary_del(dictionary * vd);
+ dictionary object, you should not try to free it or modify it.
+ */
+ /*--------------------------------------------------------------------------*/
+-const char * dictionary_get(dictionary * d, const char * key, const char * def);
++const char * dictionary_get(const dictionary * d, const char * key, const char * def);
+
+
+ /*-------------------------------------------------------------------------*/
+@@ -161,7 +156,7 @@ void dictionary_unset(dictionary * d, const char * key);
+ /**
+ @brief Dump a dictionary to an opened file pointer.
+ @param d Dictionary to dump
+- @param out Opened file pointer.
++ @param f Opened file pointer.
+ @return void
+
+ Dumps a dictionary onto an opened file pointer. Key pairs are printed out
+@@ -169,6 +164,10 @@ void dictionary_unset(dictionary * d, const char * key);
+ output file pointers.
+ */
+ /*--------------------------------------------------------------------------*/
+-void dictionary_dump(dictionary * d, FILE * out);
++void dictionary_dump(const dictionary * d, FILE * out);
++
++#ifdef __cplusplus
++}
++#endif
+
+ #endif
+diff --git a/lib/boilerplate/iniparser/iniparser.c b/lib/boilerplate/iniparser/iniparser.c
+index 5b2094a00..f1d165896 100644
+--- a/lib/boilerplate/iniparser/iniparser.c
++++ b/lib/boilerplate/iniparser/iniparser.c
+@@ -3,19 +3,12 @@
+ /**
+ @file iniparser.c
+ @author N. Devillard
+- @date Sep 2007
+- @version 3.0
+ @brief Parser for ini files.
+ */
+ /*--------------------------------------------------------------------------*/
+-/*
+- $Id: iniparser.c,v 2.18 2008-01-03 18:35:39 ndevilla Exp $
+- $Revision: 2.18 $
+- $Date: 2008-01-03 18:35:39 $
+-*/
+ /*---------------------------- Includes ------------------------------------*/
+ #include <ctype.h>
+-#include <errno.h>
++#include <stdarg.h>
+ #include "iniparser.h"
+
+ /*---------------------------- Defines -------------------------------------*/
+@@ -39,65 +32,115 @@ typedef enum _line_status_ {
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Convert a string to lowercase.
+- @param s String to convert.
+- @return ptr to statically allocated string.
+-
+- This function returns a pointer to a statically allocated string
+- containing a lowercased version of the input string. Do not free
+- or modify the returned string! Since the returned string is statically
+- allocated, it will be modified at each function call (not re-entrant).
++ @brief Convert a string to lowercase.
++ @param in String to convert.
++ @param out Output buffer.
++ @param len Size of the out buffer.
++ @return ptr to the out buffer or NULL if an error occured.
++
++ This function convert a string into lowercase.
++ At most len - 1 elements of the input string will be converted.
+ */
+ /*--------------------------------------------------------------------------*/
+-
+-static char strbuf[ASCIILINESZ+1];
+-
+-static char * strlwc(const char * s)
++static const char * strlwc(const char * in, char *out, unsigned len)
+ {
+- int i ;
++ unsigned i ;
+
+- if (s==NULL) return NULL ;
+- memset(strbuf, 0, ASCIILINESZ+1);
++ if (in==NULL || out == NULL || len==0) return NULL ;
+ i=0 ;
+- while (s[i] && i<ASCIILINESZ) {
+- strbuf[i] = (char)tolower((int)s[i]);
++ while (in[i] != '\0' && i < len-1) {
++ out[i] = (char)tolower((int)in[i]);
+ i++ ;
+ }
+- strbuf[ASCIILINESZ]=(char)0;
+- return strbuf ;
++ out[i] = '\0';
++ return out ;
++}
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Duplicate a string
++ @param s String to duplicate
++ @return Pointer to a newly allocated string, to be freed with free()
++
++ This is a replacement for strdup(). This implementation is provided
++ for systems that do not have it.
++ */
++/*--------------------------------------------------------------------------*/
++static char * xstrdup(const char * s)
++{
++ char * t ;
++ size_t len ;
++ if (!s)
++ return NULL ;
++
++ len = strlen(s) + 1 ;
++ t = (char*) malloc(len) ;
++ if (t) {
++ memcpy(t, s, len) ;
++ }
++ return t ;
++}
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Remove blanks at the beginning and the end of a string.
++ @param str String to parse and alter.
++ @return unsigned New size of the string.
++ */
++/*--------------------------------------------------------------------------*/
++static unsigned strstrip(char * s)
++{
++ char *last = NULL ;
++ char *dest = s;
++
++ if (s==NULL) return 0;
++
++ last = s + strlen(s);
++ while (isspace((int)*s) && *s) s++;
++ while (last > s) {
++ if (!isspace((int)*(last-1)))
++ break ;
++ last -- ;
++ }
++ *last = (char)0;
++
++ memmove(dest,s,last - s + 1);
++ return last - s;
++}
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Default error callback for iniparser: wraps `fprintf(stderr, ...)`.
++ */
++/*--------------------------------------------------------------------------*/
++static int default_error_callback(const char *format, ...)
++{
++ int ret;
++ va_list argptr;
++ va_start(argptr, format);
++ ret = vfprintf(stderr, format, argptr);
++ va_end(argptr);
++ return ret;
+ }
+
++static int (*iniparser_error_callback)(const char*, ...) = default_error_callback;
++
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Remove blanks at the beginning and the end of a string.
+- @param s String to parse.
+- @return ptr to statically allocated string.
+-
+- This function returns a pointer to a statically allocated string,
+- which is identical to the input string, except that all blank
+- characters at the end and the beg. of the string have been removed.
+- Do not free or modify the returned string! Since the returned string
+- is statically allocated, it will be modified at each function call
+- (not re-entrant).
++ @brief Configure a function to receive the error messages.
++ @param errback Function to call.
++
++ By default, the error will be printed on stderr. If a null pointer is passed
++ as errback the error callback will be switched back to default.
+ */
+ /*--------------------------------------------------------------------------*/
+-static char * strstrip(const char * s)
++void iniparser_set_error_callback(int (*errback)(const char *, ...))
+ {
+- char * last ;
+-
+- if (s==NULL) return NULL ;
+-
+- while (isspace((int)*s) && *s) s++;
+- memset(strbuf, 0, ASCIILINESZ+1);
+- strcpy(strbuf, s);
+- last = strbuf + strlen(strbuf);
+- while (last > strbuf) {
+- if (!isspace((int)*(last-1)))
+- break ;
+- last -- ;
+- }
+- *last = (char)0;
+- return (char*)strbuf ;
++ if (errback) {
++ iniparser_error_callback = errback;
++ } else {
++ iniparser_error_callback = default_error_callback;
++ }
+ }
+
+ /*-------------------------------------------------------------------------*/
+@@ -118,7 +161,7 @@ static char * strstrip(const char * s)
+ This function returns -1 in case of error.
+ */
+ /*--------------------------------------------------------------------------*/
+-int iniparser_getnsec(dictionary * d)
++int iniparser_getnsec(const dictionary * d)
+ {
+ int i ;
+ int nsec ;
+@@ -149,7 +192,7 @@ int iniparser_getnsec(dictionary * d)
+ This function returns NULL in case of error.
+ */
+ /*--------------------------------------------------------------------------*/
+-const char * iniparser_getsecname(dictionary * d, int n)
++const char * iniparser_getsecname(const dictionary * d, int n)
+ {
+ int i ;
+ int foundsec ;
+@@ -184,7 +227,7 @@ const char * iniparser_getsecname(dictionary * d, int n)
+ purposes mostly.
+ */
+ /*--------------------------------------------------------------------------*/
+-void iniparser_dump(dictionary * d, FILE * f)
++void iniparser_dump(const dictionary * d, FILE * f)
+ {
+ int i ;
+
+@@ -212,13 +255,11 @@ void iniparser_dump(dictionary * d, FILE * f)
+ It is Ok to specify @c stderr or @c stdout as output files.
+ */
+ /*--------------------------------------------------------------------------*/
+-void iniparser_dump_ini(dictionary * d, FILE * f)
++void iniparser_dump_ini(const dictionary * d, FILE * f)
+ {
+- int i, j ;
+- char keym[ASCIILINESZ+1];
+- int nsec ;
+- const char * secname ;
+- int seclen ;
++ int i ;
++ int nsec ;
++ const char * secname ;
+
+ if (d==NULL || f==NULL) return ;
+
+@@ -234,24 +275,126 @@ void iniparser_dump_ini(dictionary * d, FILE * f)
+ }
+ for (i=0 ; i<nsec ; i++) {
+ secname = iniparser_getsecname(d, i) ;
+- seclen = (int)strlen(secname);
+- fprintf(f, "\n[%s]\n", secname);
+- sprintf(keym, "%s:", secname);
+- for (j=0 ; j<d->size ; j++) {
+- if (d->key[j]==NULL)
+- continue ;
+- if (!strncmp(d->key[j], keym, seclen+1)) {
+- fprintf(f,
+- "%-30s = %s\n",
+- d->key[j]+seclen+1,
+- d->val[j] ? d->val[j] : "");
+- }
++ iniparser_dumpsection_ini(d, secname, f);
++ }
++ fprintf(f, "\n");
++ return ;
++}
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Save a dictionary section to a loadable ini file
++ @param d Dictionary to dump
++ @param s Section name of dictionary to dump
++ @param f Opened file pointer to dump to
++ @return void
++
++ This function dumps a given section of a given dictionary into a loadable ini
++ file. It is Ok to specify @c stderr or @c stdout as output files.
++ */
++/*--------------------------------------------------------------------------*/
++void iniparser_dumpsection_ini(const dictionary * d, const char * s, FILE * f)
++{
++ int j ;
++ char keym[ASCIILINESZ+1];
++ int seclen ;
++
++ if (d==NULL || f==NULL) return ;
++ if (! iniparser_find_entry(d, s)) return ;
++
++ seclen = (int)strlen(s);
++ fprintf(f, "\n[%s]\n", s);
++ sprintf(keym, "%s:", s);
++ for (j=0 ; j<d->size ; j++) {
++ if (d->key[j]==NULL)
++ continue ;
++ if (!strncmp(d->key[j], keym, seclen+1)) {
++ fprintf(f,
++ "%-30s = %s\n",
++ d->key[j]+seclen+1,
++ d->val[j] ? d->val[j] : "");
+ }
+ }
+ fprintf(f, "\n");
+ return ;
+ }
+
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Get the number of keys in a section of a dictionary.
++ @param d Dictionary to examine
++ @param s Section name of dictionary to examine
++ @return Number of keys in section
++ */
++/*--------------------------------------------------------------------------*/
++int iniparser_getsecnkeys(const dictionary * d, const char * s)
++{
++ int seclen, nkeys ;
++ char keym[ASCIILINESZ+1];
++ int j ;
++
++ nkeys = 0;
++
++ if (d==NULL) return nkeys;
++ if (! iniparser_find_entry(d, s)) return nkeys;
++
++ seclen = (int)strlen(s);
++ strlwc(s, keym, sizeof(keym));
++ keym[seclen] = ':';
++
++ for (j=0 ; j<d->size ; j++) {
++ if (d->key[j]==NULL)
++ continue ;
++ if (!strncmp(d->key[j], keym, seclen+1))
++ nkeys++;
++ }
++
++ return nkeys;
++
++}
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Get the number of keys in a section of a dictionary.
++ @param d Dictionary to examine
++ @param s Section name of dictionary to examine
++ @param keys Already allocated array to store the keys in
++ @return The pointer passed as `keys` argument or NULL in case of error
++
++ This function queries a dictionary and finds all keys in a given section.
++ The keys argument should be an array of pointers which size has been
++ determined by calling `iniparser_getsecnkeys` function prior to this one.
++
++ Each pointer in the returned char pointer-to-pointer is pointing to
++ a string allocated in the dictionary; do not free or modify them.
++ */
++/*--------------------------------------------------------------------------*/
++const char ** iniparser_getseckeys(const dictionary * d, const char * s, const char ** keys)
++{
++ int i, j, seclen ;
++ char keym[ASCIILINESZ+1];
++
++ if (d==NULL || keys==NULL) return NULL;
++ if (! iniparser_find_entry(d, s)) return NULL;
++
++ seclen = (int)strlen(s);
++ strlwc(s, keym, sizeof(keym));
++ keym[seclen] = ':';
++
++ i = 0;
++
++ for (j=0 ; j<d->size ; j++) {
++ if (d->key[j]==NULL)
++ continue ;
++ if (!strncmp(d->key[j], keym, seclen+1)) {
++ keys[i] = d->key[j];
++ i++;
++ }
++ }
++
++ return keys;
++}
++
+ /*-------------------------------------------------------------------------*/
+ /**
+ @brief Get the string associated to a key
+@@ -267,24 +410,27 @@ void iniparser_dump_ini(dictionary * d, FILE * f)
+ the dictionary, do not free or modify it.
+ */
+ /*--------------------------------------------------------------------------*/
+-const char * iniparser_getstring(dictionary * d, const char * key, const char * def)
++const char * iniparser_getstring(const dictionary * d, const char * key, const char * def)
+ {
+- char * lc_key ;
++ const char * lc_key ;
++ const char * sval ;
++ char tmp_str[ASCIILINESZ+1];
+
+ if (d==NULL || key==NULL)
+ return def ;
+
+- lc_key = strlwc(key);
+- return dictionary_get(d, lc_key, def);
++ lc_key = strlwc(key, tmp_str, sizeof(tmp_str));
++ sval = dictionary_get(d, lc_key, def);
++ return sval ;
+ }
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Get the string associated to a key, convert to an int
++ @brief Get the string associated to a key, convert to an long int
+ @param d Dictionary to search
+ @param key Key string to look for
+ @param notfound Value to return in case of error
+- @return integer
++ @return long integer
+
+ This function queries a dictionary for a key. A key as read from an
+ ini file is given as "section:key". If the key cannot be found,
+@@ -305,13 +451,46 @@ const char * iniparser_getstring(dictionary * d, const char * key, const char *
+ Credits: Thanks to A. Becker for suggesting strtol()
+ */
+ /*--------------------------------------------------------------------------*/
+-int iniparser_getint(dictionary * d, const char * key, int notfound)
++long int iniparser_getlongint(const dictionary * d, const char * key, long int notfound)
+ {
+- const char * str ;
++ const char * str ;
+
+ str = iniparser_getstring(d, key, INI_INVALID_KEY);
+ if (str==INI_INVALID_KEY) return notfound ;
+- return (int)strtol(str, NULL, 0);
++ return strtol(str, NULL, 0);
++}
++
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Get the string associated to a key, convert to an int
++ @param d Dictionary to search
++ @param key Key string to look for
++ @param notfound Value to return in case of error
++ @return integer
++
++ This function queries a dictionary for a key. A key as read from an
++ ini file is given as "section:key". If the key cannot be found,
++ the notfound value is returned.
++
++ Supported values for integers include the usual C notation
++ so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
++ are supported. Examples:
++
++ "42" -> 42
++ "042" -> 34 (octal -> decimal)
++ "0x42" -> 66 (hexa -> decimal)
++
++ Warning: the conversion may overflow in various ways. Conversion is
++ totally outsourced to strtol(), see the associated man page for overflow
++ handling.
++
++ Credits: Thanks to A. Becker for suggesting strtol()
++ */
++/*--------------------------------------------------------------------------*/
++int iniparser_getint(const dictionary * d, const char * key, int notfound)
++{
++ return (int)iniparser_getlongint(d, key, notfound);
+ }
+
+ /*-------------------------------------------------------------------------*/
+@@ -327,9 +506,9 @@ int iniparser_getint(dictionary * d, const char * key, int notfound)
+ the notfound value is returned.
+ */
+ /*--------------------------------------------------------------------------*/
+-double iniparser_getdouble(dictionary * d, const char * key, double notfound)
++double iniparser_getdouble(const dictionary * d, const char * key, double notfound)
+ {
+- const char * str ;
++ const char * str ;
+
+ str = iniparser_getstring(d, key, INI_INVALID_KEY);
+ if (str==INI_INVALID_KEY) return notfound ;
+@@ -368,10 +547,10 @@ double iniparser_getdouble(dictionary * d, const char * key, double notfound)
+ necessarily have to be 0 or 1.
+ */
+ /*--------------------------------------------------------------------------*/
+-int iniparser_getboolean(dictionary * d, const char * key, int notfound)
++int iniparser_getboolean(const dictionary * d, const char * key, int notfound)
+ {
+- const char * c ;
+- int ret ;
++ int ret ;
++ const char * c ;
+
+ c = iniparser_getstring(d, key, INI_INVALID_KEY);
+ if (c==INI_INVALID_KEY) return notfound ;
+@@ -397,10 +576,7 @@ int iniparser_getboolean(dictionary * d, const char * key, int notfound)
+ of querying for the presence of sections in a dictionary.
+ */
+ /*--------------------------------------------------------------------------*/
+-int iniparser_find_entry(
+- dictionary * ini,
+- const char * entry
+-)
++int iniparser_find_entry(const dictionary * ini, const char * entry)
+ {
+ int found=0 ;
+ if (iniparser_getstring(ini, entry, INI_INVALID_KEY)!=INI_INVALID_KEY) {
+@@ -418,13 +594,14 @@ int iniparser_find_entry(
+ @return int 0 if Ok, -1 otherwise.
+
+ If the given entry can be found in the dictionary, it is modified to
+- contain the provided value. If it cannot be found, -1 is returned.
++ contain the provided value. If it cannot be found, the entry is created.
+ It is Ok to set val to NULL.
+ */
+ /*--------------------------------------------------------------------------*/
+ int iniparser_set(dictionary * ini, const char * entry, const char * val)
+ {
+- return dictionary_set(ini, strlwc(entry), val) ;
++ char tmp_str[ASCIILINESZ+1];
++ return dictionary_set(ini, strlwc(entry, tmp_str, sizeof(tmp_str)), val) ;
+ }
+
+ /*-------------------------------------------------------------------------*/
+@@ -439,12 +616,13 @@ int iniparser_set(dictionary * ini, const char * entry, const char * val)
+ /*--------------------------------------------------------------------------*/
+ void iniparser_unset(dictionary * ini, const char * entry)
+ {
+- dictionary_unset(ini, strlwc(entry));
++ char tmp_str[ASCIILINESZ+1];
++ dictionary_unset(ini, strlwc(entry, tmp_str, sizeof(tmp_str)));
+ }
+
+ /*-------------------------------------------------------------------------*/
+ /**
+- @brief Load a single line from an INI file
++ @brief Load a single line from an INI file
+ @param input_line Input line, may be concatenated multi-line input
+ @param section Output space to store section
+ @param key Output space to store key
+@@ -457,34 +635,39 @@ static line_status iniparser_line(
+ char * section,
+ char * key,
+ char * value)
+-{
++{
+ line_status sta ;
+- char line[ASCIILINESZ+1];
+- int len ;
++ char * line = NULL;
++ size_t len ;
+
+- strcpy(line, strstrip(input_line));
+- len = (int)strlen(line);
++ line = xstrdup(input_line);
++ len = strstrip(line);
+
+ sta = LINE_UNPROCESSED ;
+ if (len<1) {
+ /* Empty line */
+ sta = LINE_EMPTY ;
+- } else if (line[0]=='#') {
++ } else if (line[0]=='#' || line[0]==';') {
+ /* Comment line */
+- sta = LINE_COMMENT ;
++ sta = LINE_COMMENT ;
+ } else if (line[0]=='[' && line[len-1]==']') {
+ /* Section name */
+ sscanf(line, "[%[^]]", section);
+- strcpy(section, strstrip(section));
+- strcpy(section, strlwc(section));
++ strstrip(section);
++ strlwc(section, section, len);
+ sta = LINE_SECTION ;
+ } else if (sscanf (line, "%[^=] = \"%[^\"]\"", key, value) == 2
+- || sscanf (line, "%[^=] = '%[^\']'", key, value) == 2
+- || sscanf (line, "%[^=] = %[^;#]", key, value) == 2) {
+- /* Usual key=value, with or without comments */
+- strcpy(key, strstrip(key));
+- strcpy(key, strlwc(key));
+- strcpy(value, strstrip(value));
++ || sscanf (line, "%[^=] = '%[^\']'", key, value) == 2) {
++ /* Usual key=value with quotes, with or without comments */
++ strstrip(key);
++ strlwc(key, key, len);
++ /* Don't strip spaces from values surrounded with quotes */
++ sta = LINE_VALUE ;
++ } else if (sscanf (line, "%[^=] = %[^;#]", key, value) == 2) {
++ /* Usual key=value without quotes, with or without comments */
++ strstrip(key);
++ strlwc(key, key, len);
++ strstrip(value);
+ /*
+ * sscanf cannot handle '' or "" as empty values
+ * this is done here
+@@ -501,14 +684,16 @@ static line_status iniparser_line(
+ * key=;
+ * key=#
+ */
+- strcpy(key, strstrip(key));
+- strcpy(key, strlwc(key));
++ strstrip(key);
++ strlwc(key, key, len);
+ value[0]=0 ;
+ sta = LINE_VALUE ;
+ } else {
+ /* Generate syntax error */
+ sta = LINE_ERROR ;
+ }
++
++ free(line);
+ return sta ;
+ }
+
+@@ -528,44 +713,33 @@ static line_status iniparser_line(
+ /*--------------------------------------------------------------------------*/
+ dictionary * iniparser_load(const char * ininame)
+ {
+- char *buf;
+ FILE * in ;
+
+- char *line;
+- char *section;
+- char *key;
+- char *tmp;
+- char *val;
++ char line [ASCIILINESZ+1] ;
++ char section [ASCIILINESZ+1] ;
++ char key [ASCIILINESZ+1] ;
++ char tmp [(ASCIILINESZ * 2) + 2] ;
++ char val [ASCIILINESZ+1] ;
+
+ int last=0 ;
+ int len ;
+ int lineno=0 ;
+ int errs=0;
+- int ret;
++ int mem_err=0;
+
+ dictionary * dict ;
+
+- if ((in=fopen(ininame, "r"))==NULL)
++ if ((in=fopen(ininame, "r"))==NULL) {
++ iniparser_error_callback("iniparser: cannot open %s\n", ininame);
+ return NULL ;
++ }
+
+ dict = dictionary_new(0) ;
+ if (!dict) {
+ fclose(in);
+- errno = ENOMEM;
+ return NULL ;
+ }
+
+- buf = malloc((ASCIILINESZ+1) * 5);
+- if (buf == NULL) {
+- errno = -ENOMEM;
+- return NULL;
+- }
+- line = buf;
+- section = line + ASCIILINESZ + 1;
+- key = section + ASCIILINESZ + 1;
+- tmp = key + ASCIILINESZ + 1;
+- val = tmp + ASCIILINESZ + 1;
+-
+ memset(line, 0, ASCIILINESZ);
+ memset(section, 0, ASCIILINESZ);
+ memset(key, 0, ASCIILINESZ);
+@@ -575,18 +749,16 @@ dictionary * iniparser_load(const char * ininame)
+ while (fgets(line+last, ASCIILINESZ-last, in)!=NULL) {
+ lineno++ ;
+ len = (int)strlen(line)-1;
++ if (len<=0)
++ continue;
+ /* Safety check against buffer overflows */
+- if (last > 0 && line[len]!='\n') {
+-#if 0
+- warning(anon_scope,
+- "iniparser: input line too long in %s (%d)\n",
+- ininame,
+- lineno);
+-#endif
++ if (line[len]!='\n' && !feof(in)) {
++ iniparser_error_callback(
++ "iniparser: input line too long in %s (%d)\n",
++ ininame,
++ lineno);
+ dictionary_del(dict);
+ fclose(in);
+- free(buf);
+- errno = EINVAL;
+ return NULL ;
+ }
+ /* Get rid of \n and spaces at end of line */
+@@ -595,8 +767,11 @@ dictionary * iniparser_load(const char * ininame)
+ line[len]=0 ;
+ len-- ;
+ }
++ if (len < 0) { /* Line was entirely \n and/or spaces */
++ len = 0;
++ }
+ /* Detect multi-line */
+- if (len >= 0 && line[len]=='\\') {
++ if (line[len]=='\\') {
+ /* Multi-line value */
+ last=len ;
+ continue ;
+@@ -609,24 +784,20 @@ dictionary * iniparser_load(const char * ininame)
+ break ;
+
+ case LINE_SECTION:
+- errs = dictionary_set(dict, section, NULL);
++ mem_err = dictionary_set(dict, section, NULL);
+ break ;
+
+ case LINE_VALUE:
+ sprintf(tmp, "%s:%s", section, key);
+- errs = dictionary_set(dict, tmp, val) ;
++ mem_err = dictionary_set(dict, tmp, val);
+ break ;
+
+- case LINE_ERROR:
+-#if 0
+- printf("iniparser: syntax error in %s (%d):\n",
+- ininame,
+- lineno);
+- printf( "-> %s\n", line);
+-
+-#endif
+-
+- ret = EINVAL;
++ case LINE_ERROR:
++ iniparser_error_callback(
++ "iniparser: syntax error in %s (%d):\n-> %s\n",
++ ininame,
++ lineno,
++ line);
+ errs++ ;
+ break;
+
+@@ -635,18 +806,16 @@ dictionary * iniparser_load(const char * ininame)
+ }
+ memset(line, 0, ASCIILINESZ);
+ last=0;
+- if (errs<0) {
+- ret = ENOMEM;
++ if (mem_err<0) {
++ iniparser_error_callback("iniparser: memory allocation failure\n");
+ break ;
+ }
+ }
+- fclose(in);
+- free(buf);
+ if (errs) {
+ dictionary_del(dict);
+ dict = NULL ;
+- errno = ret;
+ }
++ fclose(in);
+ return dict ;
+ }
+
+@@ -665,5 +834,3 @@ void iniparser_freedict(dictionary * d)
+ {
+ dictionary_del(d);
+ }
+-
+-/* vim: set ts=4 et sw=4 tw=75 */
+diff --git a/lib/boilerplate/iniparser/iniparser.h b/lib/boilerplate/iniparser/iniparser.h
+index d454cef34..37ff7b71b 100644
+--- a/lib/boilerplate/iniparser/iniparser.h
++++ b/lib/boilerplate/iniparser/iniparser.h
+@@ -3,22 +3,15 @@
+ /**
+ @file iniparser.h
+ @author N. Devillard
+- @date Sep 2007
+- @version 3.0
+ @brief Parser for ini files.
+ */
+ /*--------------------------------------------------------------------------*/
+
+-/*
+- $Id: iniparser.h,v 1.24 2007-11-23 21:38:19 ndevilla Exp $
+- $Revision: 1.24 $
+-*/
+-
+ #ifndef _INIPARSER_H_
+ #define _INIPARSER_H_
+
+ /*---------------------------------------------------------------------------
+- Includes
++ Includes
+ ---------------------------------------------------------------------------*/
+
+ #include <stdio.h>
+@@ -34,12 +27,21 @@
+
+ #include "dictionary.h"
+
+-/*---------------------------------------------------------------------------
+- Macros
+- ---------------------------------------------------------------------------*/
+-/** For backwards compatibility only */
+-#define iniparser_getstr(d, k) iniparser_getstring(d, k, NULL)
+-#define iniparser_setstr iniparser_setstring
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Configure a function to receive the error messages.
++ @param errback Function to call.
++
++ By default, the error will be printed on stderr. If a null pointer is passed
++ as errback the error callback will be switched back to default.
++ */
++/*--------------------------------------------------------------------------*/
++
++void iniparser_set_error_callback(int (*errback)(const char *, ...));
+
+ /*-------------------------------------------------------------------------*/
+ /**
+@@ -60,7 +62,7 @@
+ */
+ /*--------------------------------------------------------------------------*/
+
+-int iniparser_getnsec(dictionary * d);
++int iniparser_getnsec(const dictionary * d);
+
+
+ /*-------------------------------------------------------------------------*/
+@@ -78,7 +80,7 @@ int iniparser_getnsec(dictionary * d);
+ */
+ /*--------------------------------------------------------------------------*/
+
+-const char * iniparser_getsecname(dictionary * d, int n);
++const char * iniparser_getsecname(const dictionary * d, int n);
+
+
+ /*-------------------------------------------------------------------------*/
+@@ -93,7 +95,22 @@ const char * iniparser_getsecname(dictionary * d, int n);
+ */
+ /*--------------------------------------------------------------------------*/
+
+-void iniparser_dump_ini(dictionary * d, FILE * f);
++void iniparser_dump_ini(const dictionary * d, FILE * f);
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Save a dictionary section to a loadable ini file
++ @param d Dictionary to dump
++ @param s Section name of dictionary to dump
++ @param f Opened file pointer to dump to
++ @return void
++
++ This function dumps a given section of a given dictionary into a loadable ini
++ file. It is Ok to specify @c stderr or @c stdout as output files.
++ */
++/*--------------------------------------------------------------------------*/
++
++void iniparser_dumpsection_ini(const dictionary * d, const char * s, FILE * f);
+
+ /*-------------------------------------------------------------------------*/
+ /**
+@@ -108,7 +125,36 @@ void iniparser_dump_ini(dictionary * d, FILE * f);
+ purposes mostly.
+ */
+ /*--------------------------------------------------------------------------*/
+-void iniparser_dump(dictionary * d, FILE * f);
++void iniparser_dump(const dictionary * d, FILE * f);
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Get the number of keys in a section of a dictionary.
++ @param d Dictionary to examine
++ @param s Section name of dictionary to examine
++ @return Number of keys in section
++ */
++/*--------------------------------------------------------------------------*/
++int iniparser_getsecnkeys(const dictionary * d, const char * s);
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Get the number of keys in a section of a dictionary.
++ @param d Dictionary to examine
++ @param s Section name of dictionary to examine
++ @param keys Already allocated array to store the keys in
++ @return The pointer passed as `keys` argument or NULL in case of error
++
++ This function queries a dictionary and finds all keys in a given section.
++ The keys argument should be an array of pointers which size has been
++ determined by calling `iniparser_getsecnkeys` function prior to this one.
++
++ Each pointer in the returned char pointer-to-pointer is pointing to
++ a string allocated in the dictionary; do not free or modify them.
++ */
++/*--------------------------------------------------------------------------*/
++const char ** iniparser_getseckeys(const dictionary * d, const char * s, const char ** keys);
++
+
+ /*-------------------------------------------------------------------------*/
+ /**
+@@ -125,7 +171,7 @@ void iniparser_dump(dictionary * d, FILE * f);
+ the dictionary, do not free or modify it.
+ */
+ /*--------------------------------------------------------------------------*/
+-const char * iniparser_getstring(dictionary * d, const char * key, const char * def);
++const char * iniparser_getstring(const dictionary * d, const char * key, const char * def);
+
+ /*-------------------------------------------------------------------------*/
+ /**
+@@ -154,7 +200,35 @@ const char * iniparser_getstring(dictionary * d, const char * key, const char *
+ Credits: Thanks to A. Becker for suggesting strtol()
+ */
+ /*--------------------------------------------------------------------------*/
+-int iniparser_getint(dictionary * d, const char * key, int notfound);
++int iniparser_getint(const dictionary * d, const char * key, int notfound);
++
++/*-------------------------------------------------------------------------*/
++/**
++ @brief Get the string associated to a key, convert to an long int
++ @param d Dictionary to search
++ @param key Key string to look for
++ @param notfound Value to return in case of error
++ @return integer
++
++ This function queries a dictionary for a key. A key as read from an
++ ini file is given as "section:key". If the key cannot be found,
++ the notfound value is returned.
++
++ Supported values for integers include the usual C notation
++ so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
++ are supported. Examples:
++
++ - "42" -> 42
++ - "042" -> 34 (octal -> decimal)
++ - "0x42" -> 66 (hexa -> decimal)
++
++ Warning: the conversion may overflow in various ways. Conversion is
++ totally outsourced to strtol(), see the associated man page for overflow
++ handling.
++ */
++/*--------------------------------------------------------------------------*/
++long int iniparser_getlongint(const dictionary * d, const char * key, long int notfound);
++
+
+ /*-------------------------------------------------------------------------*/
+ /**
+@@ -169,7 +243,7 @@ int iniparser_getint(dictionary * d, const char * key, int notfound);
+ the notfound value is returned.
+ */
+ /*--------------------------------------------------------------------------*/
+-double iniparser_getdouble(dictionary * d, const char * key, double notfound);
++double iniparser_getdouble(const dictionary * d, const char * key, double notfound);
+
+ /*-------------------------------------------------------------------------*/
+ /**
+@@ -203,7 +277,7 @@ double iniparser_getdouble(dictionary * d, const char * key, double notfound);
+ necessarily have to be 0 or 1.
+ */
+ /*--------------------------------------------------------------------------*/
+-int iniparser_getboolean(dictionary * d, const char * key, int notfound);
++int iniparser_getboolean(const dictionary * d, const char * key, int notfound);
+
+
+ /*-------------------------------------------------------------------------*/
+@@ -212,17 +286,16 @@ int iniparser_getboolean(dictionary * d, const char * key, int notfound);
+ @param ini Dictionary to modify.
+ @param entry Entry to modify (entry name)
+ @param val New value to associate to the entry.
+- @return int 0 if Ok, -1 otherwise.
++ @return int 0 if Ok, -1 otherwise.
+
+ If the given entry can be found in the dictionary, it is modified to
+- contain the provided value. If it cannot be found, -1 is returned.
++ contain the provided value. If it cannot be found, the entry is created.
+ It is Ok to set val to NULL.
+ */
+ /*--------------------------------------------------------------------------*/
+-int iniparser_setstring(dictionary * ini, const char * entry, const char * val);
+-
+ int iniparser_set(dictionary * ini, const char * entry, const char * val);
+
++
+ /*-------------------------------------------------------------------------*/
+ /**
+ @brief Delete an entry in a dictionary
+@@ -247,7 +320,7 @@ void iniparser_unset(dictionary * ini, const char * entry);
+ of querying for the presence of sections in a dictionary.
+ */
+ /*--------------------------------------------------------------------------*/
+-int iniparser_find_entry(dictionary * ini, const char * entry) ;
++int iniparser_find_entry(const dictionary * ini, const char * entry) ;
+
+ /*-------------------------------------------------------------------------*/
+ /**
+@@ -278,4 +351,8 @@ dictionary * iniparser_load(const char * ininame);
+ /*--------------------------------------------------------------------------*/
+ void iniparser_freedict(dictionary * d);
+
++#ifdef __cplusplus
++}
++#endif
++
+ #endif
+--
+GitLab
+
--
2.29.2
More information about the buildroot
mailing list