LCOV - code coverage report
Current view: top level - build directory/src/include - kdberrors.h (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 780 1482 52.6 %
Date: 2019-09-12 12:28:41 Functions: 36 52 69.2 %

          Line data    Source code
       1             : /*This is an auto-generated file generated by exporterrors. Do not modify it.*/
       2             : 
       3             : #ifndef KDBERRORS_H
       4             : #define KDBERRORS_H
       5             : 
       6             : #include <kdb.h>
       7             : #include <kdbhelper.h>
       8             : #include <kdblogger.h>
       9             : #include <kdbmacros.h>
      10             : #include <string.h>
      11             : 
      12             : #ifdef __cplusplus
      13             : using namespace ckdb;
      14             : #endif
      15             : 
      16             : 
      17             : #define ELEKTRA_SET_RESOURCE_ERROR(key, text) \
      18             :         do { ELEKTRA_LOG ("Add Error C01100: %s", text); elektraSetErrorC01100(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      19             : #define ELEKTRA_SET_RESOURCE_ERRORF(key, text, ...) \
      20             :         do { ELEKTRA_LOG ("Add Error C01100: " text, __VA_ARGS__); elektraSetErrorfC01100(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      21             : #define ELEKTRA_ADD_RESOURCE_WARNING(key, text) \
      22             :         do { ELEKTRA_LOG ("Add Warning C01100: %s", text); elektraAddWarningC01100(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      23             : #define ELEKTRA_ADD_RESOURCE_WARNINGF(key, text, ...) \
      24             :         do { ELEKTRA_LOG ("Add Warning C01100: " text, __VA_ARGS__); elektraAddWarningfC01100(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      25             : 
      26             : #define ELEKTRA_SET_OUT_OF_MEMORY_ERROR(key, text) \
      27             :         do { ELEKTRA_LOG ("Add Error C01110: %s", text); elektraSetErrorC01110(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      28             : #define ELEKTRA_SET_OUT_OF_MEMORY_ERRORF(key, text, ...) \
      29             :         do { ELEKTRA_LOG ("Add Error C01110: " text, __VA_ARGS__); elektraSetErrorfC01110(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      30             : #define ELEKTRA_ADD_OUT_OF_MEMORY_WARNING(key, text) \
      31             :         do { ELEKTRA_LOG ("Add Warning C01110: %s", text); elektraAddWarningC01110(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      32             : #define ELEKTRA_ADD_OUT_OF_MEMORY_WARNINGF(key, text, ...) \
      33             :         do { ELEKTRA_LOG ("Add Warning C01110: " text, __VA_ARGS__); elektraAddWarningfC01110(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      34             : 
      35             : #define ELEKTRA_SET_INSTALLATION_ERROR(key, text) \
      36             :         do { ELEKTRA_LOG ("Add Error C01200: %s", text); elektraSetErrorC01200(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      37             : #define ELEKTRA_SET_INSTALLATION_ERRORF(key, text, ...) \
      38             :         do { ELEKTRA_LOG ("Add Error C01200: " text, __VA_ARGS__); elektraSetErrorfC01200(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      39             : #define ELEKTRA_ADD_INSTALLATION_WARNING(key, text) \
      40             :         do { ELEKTRA_LOG ("Add Warning C01200: %s", text); elektraAddWarningC01200(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      41             : #define ELEKTRA_ADD_INSTALLATION_WARNINGF(key, text, ...) \
      42             :         do { ELEKTRA_LOG ("Add Warning C01200: " text, __VA_ARGS__); elektraAddWarningfC01200(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      43             : 
      44             : #define ELEKTRA_SET_INTERNAL_ERROR(key, text) \
      45             :         do { ELEKTRA_LOG ("Add Error C01310: %s", text); elektraSetErrorC01310(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      46             : #define ELEKTRA_SET_INTERNAL_ERRORF(key, text, ...) \
      47             :         do { ELEKTRA_LOG ("Add Error C01310: " text, __VA_ARGS__); elektraSetErrorfC01310(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      48             : #define ELEKTRA_ADD_INTERNAL_WARNING(key, text) \
      49             :         do { ELEKTRA_LOG ("Add Warning C01310: %s", text); elektraAddWarningC01310(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      50             : #define ELEKTRA_ADD_INTERNAL_WARNINGF(key, text, ...) \
      51             :         do { ELEKTRA_LOG ("Add Warning C01310: " text, __VA_ARGS__); elektraAddWarningfC01310(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      52             : 
      53             : #define ELEKTRA_SET_INTERFACE_ERROR(key, text) \
      54             :         do { ELEKTRA_LOG ("Add Error C01320: %s", text); elektraSetErrorC01320(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      55             : #define ELEKTRA_SET_INTERFACE_ERRORF(key, text, ...) \
      56             :         do { ELEKTRA_LOG ("Add Error C01320: " text, __VA_ARGS__); elektraSetErrorfC01320(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      57             : #define ELEKTRA_ADD_INTERFACE_WARNING(key, text) \
      58             :         do { ELEKTRA_LOG ("Add Warning C01320: %s", text); elektraAddWarningC01320(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      59             : #define ELEKTRA_ADD_INTERFACE_WARNINGF(key, text, ...) \
      60             :         do { ELEKTRA_LOG ("Add Warning C01320: " text, __VA_ARGS__); elektraAddWarningfC01320(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      61             : 
      62             : #define ELEKTRA_SET_PLUGIN_MISBEHAVIOR_ERROR(key, text) \
      63             :         do { ELEKTRA_LOG ("Add Error C01330: %s", text); elektraSetErrorC01330(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      64             : #define ELEKTRA_SET_PLUGIN_MISBEHAVIOR_ERRORF(key, text, ...) \
      65             :         do { ELEKTRA_LOG ("Add Error C01330: " text, __VA_ARGS__); elektraSetErrorfC01330(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      66             : #define ELEKTRA_ADD_PLUGIN_MISBEHAVIOR_WARNING(key, text) \
      67             :         do { ELEKTRA_LOG ("Add Warning C01330: %s", text); elektraAddWarningC01330(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      68             : #define ELEKTRA_ADD_PLUGIN_MISBEHAVIOR_WARNINGF(key, text, ...) \
      69             :         do { ELEKTRA_LOG ("Add Warning C01330: " text, __VA_ARGS__); elektraAddWarningfC01330(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      70             : 
      71             : #define ELEKTRA_SET_CONFLICTING_STATE_ERROR(key, text) \
      72             :         do { ELEKTRA_LOG ("Add Error C02000: %s", text); elektraSetErrorC02000(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      73             : #define ELEKTRA_SET_CONFLICTING_STATE_ERRORF(key, text, ...) \
      74             :         do { ELEKTRA_LOG ("Add Error C02000: " text, __VA_ARGS__); elektraSetErrorfC02000(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      75             : #define ELEKTRA_ADD_CONFLICTING_STATE_WARNING(key, text) \
      76             :         do { ELEKTRA_LOG ("Add Warning C02000: %s", text); elektraAddWarningC02000(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      77             : #define ELEKTRA_ADD_CONFLICTING_STATE_WARNINGF(key, text, ...) \
      78             :         do { ELEKTRA_LOG ("Add Warning C02000: " text, __VA_ARGS__); elektraAddWarningfC02000(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      79             : 
      80             : #define ELEKTRA_SET_VALIDATION_SYNTACTIC_ERROR(key, text) \
      81             :         do { ELEKTRA_LOG ("Add Error C03100: %s", text); elektraSetErrorC03100(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      82             : #define ELEKTRA_SET_VALIDATION_SYNTACTIC_ERRORF(key, text, ...) \
      83             :         do { ELEKTRA_LOG ("Add Error C03100: " text, __VA_ARGS__); elektraSetErrorfC03100(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      84             : #define ELEKTRA_ADD_VALIDATION_SYNTACTIC_WARNING(key, text) \
      85             :         do { ELEKTRA_LOG ("Add Warning C03100: %s", text); elektraAddWarningC03100(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      86             : #define ELEKTRA_ADD_VALIDATION_SYNTACTIC_WARNINGF(key, text, ...) \
      87             :         do { ELEKTRA_LOG ("Add Warning C03100: " text, __VA_ARGS__); elektraAddWarningfC03100(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      88             : 
      89             : #define ELEKTRA_SET_VALIDATION_SEMANTIC_ERROR(key, text) \
      90             :         do { ELEKTRA_LOG ("Add Error C03200: %s", text); elektraSetErrorC03200(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      91             : #define ELEKTRA_SET_VALIDATION_SEMANTIC_ERRORF(key, text, ...) \
      92             :         do { ELEKTRA_LOG ("Add Error C03200: " text, __VA_ARGS__); elektraSetErrorfC03200(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      93             : #define ELEKTRA_ADD_VALIDATION_SEMANTIC_WARNING(key, text) \
      94             :         do { ELEKTRA_LOG ("Add Warning C03200: %s", text); elektraAddWarningC03200(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME)); } while (0)
      95             : #define ELEKTRA_ADD_VALIDATION_SEMANTIC_WARNINGF(key, text, ...) \
      96             :         do { ELEKTRA_LOG ("Add Warning C03200: " text, __VA_ARGS__); elektraAddWarningfC03200(key, text, __FILE__, ELEKTRA_STRINGIFY(__LINE__), ELEKTRA_STRINGIFY(ELEKTRA_MODULE_NAME), __VA_ARGS__); } while (0)
      97             : 
      98             : 
      99             : #define ELEKTRA_WARNING_RESOURCE "C01100"
     100             : #define ELEKTRA_ERROR_RESOURCE "C01100"
     101             : #define ELEKTRA_WARNING_OUT_OF_MEMORY "C01110"
     102             : #define ELEKTRA_ERROR_OUT_OF_MEMORY "C01110"
     103             : #define ELEKTRA_WARNING_INSTALLATION "C01200"
     104             : #define ELEKTRA_ERROR_INSTALLATION "C01200"
     105             : #define ELEKTRA_WARNING_INTERNAL "C01310"
     106             : #define ELEKTRA_ERROR_INTERNAL "C01310"
     107             : #define ELEKTRA_WARNING_INTERFACE "C01320"
     108             : #define ELEKTRA_ERROR_INTERFACE "C01320"
     109             : #define ELEKTRA_WARNING_PLUGIN_MISBEHAVIOR "C01330"
     110             : #define ELEKTRA_ERROR_PLUGIN_MISBEHAVIOR "C01330"
     111             : #define ELEKTRA_WARNING_CONFLICTING_STATE "C02000"
     112             : #define ELEKTRA_ERROR_CONFLICTING_STATE "C02000"
     113             : #define ELEKTRA_WARNING_VALIDATION_SYNTACTIC "C03100"
     114             : #define ELEKTRA_ERROR_VALIDATION_SYNTACTIC "C03100"
     115             : #define ELEKTRA_WARNING_VALIDATION_SEMANTIC "C03200"
     116             : #define ELEKTRA_ERROR_VALIDATION_SEMANTIC "C03200"
     117             : 
     118             : 
     119             : static inline void elektraAddWarningfC01100(Key *warningKey, const char *reason,
     120             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     121          48 : static inline void elektraAddWarningfC01100(Key *warningKey, const char *reason,
     122             :         const char *file, const char *line, const char *module, ...)
     123             : {
     124          48 :         if (!warningKey) return;
     125             : 
     126          48 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     127          48 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     128          48 :         if (meta)
     129             :         {
     130          44 :                 buffer[10] = keyString(meta)[0];
     131          44 :                 buffer[11] = keyString(meta)[1];
     132          44 :                 buffer[11]++;
     133          44 :                 if (buffer[11] > '9')
     134             :                 {
     135           2 :                         buffer[11] = '0';
     136           2 :                         buffer[10]++;
     137           2 :                         if (buffer[10] > '9') buffer[10] = '0';
     138             :                 }
     139          44 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     140           4 :         } else  keySetMeta(warningKey, "warnings", "00");
     141             : 
     142          48 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     143          48 :         strcat(buffer, "/number" );
     144          48 :         keySetMeta(warningKey, buffer, "C01100");
     145          48 :         buffer[12] = '\0'; strcat(buffer, "/description");
     146          48 :         keySetMeta(warningKey, buffer, "Resource");
     147          48 :         buffer[12] = '\0'; strcat(buffer, "/module");
     148          48 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     149          48 :         keySetMeta(warningKey, buffer, module);
     150          48 :         buffer[12] = '\0'; strcat(buffer, "/file");
     151          48 :         keySetMeta(warningKey, buffer, file);
     152          48 :         buffer[12] = '\0'; strcat(buffer, "/line");
     153          48 :         keySetMeta(warningKey, buffer, line);
     154          48 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     155          48 :         keySetMeta(warningKey, buffer, keyName(warningKey));
     156          48 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
     157          48 :         keySetMeta(warningKey, buffer, keyString(warningKey));
     158          48 :         buffer[12] = '\0'; strcat(buffer, "/reason");
     159             :         va_list arg;
     160          48 :         va_start(arg, module);
     161          48 :         char * r = elektraVFormat(reason, arg);
     162          48 :         keySetMeta(warningKey, buffer, r);
     163          48 :         elektraFree(r);
     164          48 :         va_end(arg);
     165             : }
     166             : 
     167          14 : static inline void elektraAddWarningC01100(Key *warningKey, const char *reason,
     168             :         const char *file, const char *line, const char *module)
     169             : {
     170          28 :         if (!warningKey) return;
     171             : 
     172           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     173           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     174           0 :         if (meta)
     175             :         {
     176           0 :                 buffer[10] = keyString(meta)[0];
     177           0 :                 buffer[11] = keyString(meta)[1];
     178           0 :                 buffer[11]++;
     179           0 :                 if (buffer[11] > '9')
     180             :                 {
     181           0 :                         buffer[11] = '0';
     182           0 :                         buffer[10]++;
     183           0 :                         if (buffer[10] > '9') buffer[10] = '0';
     184             :                 }
     185           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     186           0 :         } else  keySetMeta(warningKey, "warnings", "00");
     187             : 
     188           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     189           0 :         strcat(buffer, "/number" );
     190           0 :         keySetMeta(warningKey, buffer, "C01100");
     191           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
     192           0 :         keySetMeta(warningKey, buffer, "Resource");
     193           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
     194           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     195           0 :         keySetMeta(warningKey, buffer, module);
     196           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
     197           0 :         keySetMeta(warningKey, buffer, file);
     198           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
     199           0 :         keySetMeta(warningKey, buffer, line);
     200           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     201           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
     202           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
     203           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
     204           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
     205           0 :         keySetMeta(warningKey, buffer, reason);
     206             : }
     207             : 
     208             : static inline void elektraSetErrorfC01100(Key *errorKey, const char *reason,
     209             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     210          14 : static inline void elektraSetErrorfC01100(Key *errorKey, const char *reason,
     211             :         const char *file, const char *line, const char *module, ...)
     212             : {
     213          14 :         if (!errorKey) return;
     214          14 :         char buffer[25] = "warnings/#00";
     215          14 :         const Key *meta = keyGetMeta(errorKey, "error");
     216          14 :         if (meta)
     217             :         {
     218           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
     219           0 :                 if (warningMeta)
     220             :                 {
     221           0 :                         buffer[10] = keyString(warningMeta)[0];
     222           0 :                         buffer[11] = keyString(warningMeta)[1];
     223           0 :                         buffer[11]++;
     224           0 :                         if (buffer[11] > '9')
     225             :                         {
     226           0 :                                 buffer[11] = '0';
     227           0 :                                 buffer[10]++;
     228           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
     229             :                         }
     230           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
     231           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
     232           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
     233           0 :                 strcat(buffer, "/number" );
     234           0 :                 keySetMeta(errorKey, buffer, "C01100");
     235           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
     236           0 :                 keySetMeta(errorKey, buffer, "Resource");
     237           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
     238           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     239           0 :                 keySetMeta(errorKey, buffer, module);
     240           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
     241           0 :                 keySetMeta(errorKey, buffer, file);
     242           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
     243           0 :                 keySetMeta(errorKey, buffer, line);
     244           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     245           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
     246           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
     247           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
     248           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
     249             :         }
     250             :         else
     251             :         {
     252          14 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
     253          14 :                 keySetMeta(errorKey, "error/number", "C01100");
     254          14 :                 keySetMeta(errorKey, "error/description", "Resource");
     255          14 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     256          14 :                 keySetMeta(errorKey, "error/module", module);
     257          14 :                 keySetMeta(errorKey, "error/file", file);
     258          14 :                 keySetMeta(errorKey, "error/line", line);
     259          14 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
     260          14 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
     261             :         }
     262             :         va_list arg;
     263          14 :         va_start(arg, module);
     264          14 :         char * r = elektraVFormat(reason, arg);
     265          14 :         if (meta)
     266           0 :                         keySetMeta(errorKey, buffer, r);
     267             :         else
     268          14 :                         keySetMeta(errorKey, "error/reason", r);
     269          14 :         elektraFree(r);
     270          14 :         va_end(arg);
     271             : }
     272             : 
     273          14 : static inline void elektraSetErrorC01100(Key *errorKey, const char *reason,
     274             :         const char *file, const char *line, const char *module)
     275             : {
     276          14 :         if (!errorKey) return;
     277          14 :         char buffer[25] = "warnings/#00";
     278          14 :         const Key *meta = keyGetMeta(errorKey, "error");
     279          14 :         if (meta)
     280             :         {
     281           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
     282           0 :                 if (warningMeta)
     283             :                 {
     284           0 :                         buffer[10] = keyString(warningMeta)[0];
     285           0 :                         buffer[11] = keyString(warningMeta)[1];
     286           0 :                         buffer[11]++;
     287           0 :                         if (buffer[11] > '9')
     288             :                         {
     289           0 :                                 buffer[11] = '0';
     290           0 :                                 buffer[10]++;
     291           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
     292             :                         }
     293           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
     294           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
     295           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
     296           0 :                 strcat(buffer, "/number" );
     297           0 :                 keySetMeta(errorKey, buffer, "C01100");
     298           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
     299           0 :                 keySetMeta(errorKey, buffer, "Resource");
     300           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
     301           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     302           0 :                 keySetMeta(errorKey, buffer, module);
     303           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
     304           0 :                 keySetMeta(errorKey, buffer, file);
     305           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
     306           0 :                 keySetMeta(errorKey, buffer, line);
     307           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     308           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
     309           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
     310           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
     311           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
     312             :         }
     313             :         else
     314             :         {
     315          14 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
     316          14 :                 keySetMeta(errorKey, "error/number", "C01100");
     317          14 :                 keySetMeta(errorKey, "error/description", "Resource");
     318          14 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     319          14 :                 keySetMeta(errorKey, "error/module", module);
     320          14 :                 keySetMeta(errorKey, "error/file", file);
     321          14 :                 keySetMeta(errorKey, "error/line", line);
     322          14 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
     323          14 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
     324             :         }
     325          14 :         if (meta)
     326           0 :                         keySetMeta(errorKey, buffer, reason);
     327             :         else
     328          14 :                         keySetMeta(errorKey, "error/reason", reason);
     329             : }
     330             : 
     331             : static inline void elektraAddWarningfC01110(Key *warningKey, const char *reason,
     332             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     333           0 : static inline void elektraAddWarningfC01110(Key *warningKey, const char *reason,
     334             :         const char *file, const char *line, const char *module, ...)
     335             : {
     336           0 :         if (!warningKey) return;
     337             : 
     338           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     339           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     340           0 :         if (meta)
     341             :         {
     342           0 :                 buffer[10] = keyString(meta)[0];
     343           0 :                 buffer[11] = keyString(meta)[1];
     344           0 :                 buffer[11]++;
     345           0 :                 if (buffer[11] > '9')
     346             :                 {
     347           0 :                         buffer[11] = '0';
     348           0 :                         buffer[10]++;
     349           0 :                         if (buffer[10] > '9') buffer[10] = '0';
     350             :                 }
     351           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     352           0 :         } else  keySetMeta(warningKey, "warnings", "00");
     353             : 
     354           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     355           0 :         strcat(buffer, "/number" );
     356           0 :         keySetMeta(warningKey, buffer, "C01110");
     357           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
     358           0 :         keySetMeta(warningKey, buffer, "Out of Memory");
     359           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
     360           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     361           0 :         keySetMeta(warningKey, buffer, module);
     362           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
     363           0 :         keySetMeta(warningKey, buffer, file);
     364           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
     365           0 :         keySetMeta(warningKey, buffer, line);
     366           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     367           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
     368           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
     369           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
     370           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
     371             :         va_list arg;
     372           0 :         va_start(arg, module);
     373           0 :         char * r = elektraVFormat(reason, arg);
     374           0 :         keySetMeta(warningKey, buffer, r);
     375           0 :         elektraFree(r);
     376           0 :         va_end(arg);
     377             : }
     378             : 
     379           0 : static inline void elektraAddWarningC01110(Key *warningKey, const char *reason,
     380             :         const char *file, const char *line, const char *module)
     381             : {
     382           0 :         if (!warningKey) return;
     383             : 
     384           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     385           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     386           0 :         if (meta)
     387             :         {
     388           0 :                 buffer[10] = keyString(meta)[0];
     389           0 :                 buffer[11] = keyString(meta)[1];
     390           0 :                 buffer[11]++;
     391           0 :                 if (buffer[11] > '9')
     392             :                 {
     393           0 :                         buffer[11] = '0';
     394           0 :                         buffer[10]++;
     395           0 :                         if (buffer[10] > '9') buffer[10] = '0';
     396             :                 }
     397           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     398           0 :         } else  keySetMeta(warningKey, "warnings", "00");
     399             : 
     400           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     401           0 :         strcat(buffer, "/number" );
     402           0 :         keySetMeta(warningKey, buffer, "C01110");
     403           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
     404           0 :         keySetMeta(warningKey, buffer, "Out of Memory");
     405           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
     406           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     407           0 :         keySetMeta(warningKey, buffer, module);
     408           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
     409           0 :         keySetMeta(warningKey, buffer, file);
     410           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
     411           0 :         keySetMeta(warningKey, buffer, line);
     412           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     413           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
     414           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
     415           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
     416           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
     417           0 :         keySetMeta(warningKey, buffer, reason);
     418             : }
     419             : 
     420             : static inline void elektraSetErrorfC01110(Key *errorKey, const char *reason,
     421             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     422           0 : static inline void elektraSetErrorfC01110(Key *errorKey, const char *reason,
     423             :         const char *file, const char *line, const char *module, ...)
     424             : {
     425           0 :         if (!errorKey) return;
     426           0 :         char buffer[25] = "warnings/#00";
     427           0 :         const Key *meta = keyGetMeta(errorKey, "error");
     428           0 :         if (meta)
     429             :         {
     430           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
     431           0 :                 if (warningMeta)
     432             :                 {
     433           0 :                         buffer[10] = keyString(warningMeta)[0];
     434           0 :                         buffer[11] = keyString(warningMeta)[1];
     435           0 :                         buffer[11]++;
     436           0 :                         if (buffer[11] > '9')
     437             :                         {
     438           0 :                                 buffer[11] = '0';
     439           0 :                                 buffer[10]++;
     440           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
     441             :                         }
     442           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
     443           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
     444           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
     445           0 :                 strcat(buffer, "/number" );
     446           0 :                 keySetMeta(errorKey, buffer, "C01110");
     447           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
     448           0 :                 keySetMeta(errorKey, buffer, "Out of Memory");
     449           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
     450           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     451           0 :                 keySetMeta(errorKey, buffer, module);
     452           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
     453           0 :                 keySetMeta(errorKey, buffer, file);
     454           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
     455           0 :                 keySetMeta(errorKey, buffer, line);
     456           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     457           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
     458           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
     459           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
     460           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
     461             :         }
     462             :         else
     463             :         {
     464           0 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
     465           0 :                 keySetMeta(errorKey, "error/number", "C01110");
     466           0 :                 keySetMeta(errorKey, "error/description", "Out of Memory");
     467           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     468           0 :                 keySetMeta(errorKey, "error/module", module);
     469           0 :                 keySetMeta(errorKey, "error/file", file);
     470           0 :                 keySetMeta(errorKey, "error/line", line);
     471           0 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
     472           0 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
     473             :         }
     474             :         va_list arg;
     475           0 :         va_start(arg, module);
     476           0 :         char * r = elektraVFormat(reason, arg);
     477           0 :         if (meta)
     478           0 :                         keySetMeta(errorKey, buffer, r);
     479             :         else
     480           0 :                         keySetMeta(errorKey, "error/reason", r);
     481           0 :         elektraFree(r);
     482           0 :         va_end(arg);
     483             : }
     484             : 
     485           6 : static inline void elektraSetErrorC01110(Key *errorKey, const char *reason,
     486             :         const char *file, const char *line, const char *module)
     487             : {
     488           6 :         if (!errorKey) return;
     489           6 :         char buffer[25] = "warnings/#00";
     490           6 :         const Key *meta = keyGetMeta(errorKey, "error");
     491           6 :         if (meta)
     492             :         {
     493           2 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
     494           2 :                 if (warningMeta)
     495             :                 {
     496           0 :                         buffer[10] = keyString(warningMeta)[0];
     497           0 :                         buffer[11] = keyString(warningMeta)[1];
     498           0 :                         buffer[11]++;
     499           0 :                         if (buffer[11] > '9')
     500             :                         {
     501           0 :                                 buffer[11] = '0';
     502           0 :                                 buffer[10]++;
     503           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
     504             :                         }
     505           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
     506           2 :                 } else  keySetMeta(errorKey, "warnings", "00");
     507           2 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
     508           2 :                 strcat(buffer, "/number" );
     509           2 :                 keySetMeta(errorKey, buffer, "C01110");
     510           2 :                 buffer[12] = '\0'; strcat(buffer, "/description");
     511           2 :                 keySetMeta(errorKey, buffer, "Out of Memory");
     512           2 :                 buffer[12] = '\0'; strcat(buffer, "/module");
     513           2 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     514           2 :                 keySetMeta(errorKey, buffer, module);
     515           2 :                 buffer[12] = '\0'; strcat(buffer, "/file");
     516           2 :                 keySetMeta(errorKey, buffer, file);
     517           2 :                 buffer[12] = '\0'; strcat(buffer, "/line");
     518           2 :                 keySetMeta(errorKey, buffer, line);
     519           2 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     520           2 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
     521           2 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
     522           2 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
     523           2 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
     524             :         }
     525             :         else
     526             :         {
     527           4 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
     528           4 :                 keySetMeta(errorKey, "error/number", "C01110");
     529           4 :                 keySetMeta(errorKey, "error/description", "Out of Memory");
     530           4 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     531           4 :                 keySetMeta(errorKey, "error/module", module);
     532           4 :                 keySetMeta(errorKey, "error/file", file);
     533           4 :                 keySetMeta(errorKey, "error/line", line);
     534           4 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
     535           4 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
     536             :         }
     537           6 :         if (meta)
     538           2 :                         keySetMeta(errorKey, buffer, reason);
     539             :         else
     540           4 :                         keySetMeta(errorKey, "error/reason", reason);
     541             : }
     542             : 
     543             : static inline void elektraAddWarningfC01200(Key *warningKey, const char *reason,
     544             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     545       20975 : static inline void elektraAddWarningfC01200(Key *warningKey, const char *reason,
     546             :         const char *file, const char *line, const char *module, ...)
     547             : {
     548       20979 :         if (!warningKey) return;
     549             : 
     550       20971 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     551       20971 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     552       20971 :         if (meta)
     553             :         {
     554           0 :                 buffer[10] = keyString(meta)[0];
     555           0 :                 buffer[11] = keyString(meta)[1];
     556           0 :                 buffer[11]++;
     557           0 :                 if (buffer[11] > '9')
     558             :                 {
     559           0 :                         buffer[11] = '0';
     560           0 :                         buffer[10]++;
     561           0 :                         if (buffer[10] > '9') buffer[10] = '0';
     562             :                 }
     563           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     564       20971 :         } else  keySetMeta(warningKey, "warnings", "00");
     565             : 
     566       20971 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     567       20971 :         strcat(buffer, "/number" );
     568       20971 :         keySetMeta(warningKey, buffer, "C01200");
     569       20971 :         buffer[12] = '\0'; strcat(buffer, "/description");
     570       20971 :         keySetMeta(warningKey, buffer, "Installation");
     571       20971 :         buffer[12] = '\0'; strcat(buffer, "/module");
     572       20971 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     573       20971 :         keySetMeta(warningKey, buffer, module);
     574       20971 :         buffer[12] = '\0'; strcat(buffer, "/file");
     575       20971 :         keySetMeta(warningKey, buffer, file);
     576       20971 :         buffer[12] = '\0'; strcat(buffer, "/line");
     577       20971 :         keySetMeta(warningKey, buffer, line);
     578       20971 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     579       20971 :         keySetMeta(warningKey, buffer, keyName(warningKey));
     580       20971 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
     581       20971 :         keySetMeta(warningKey, buffer, keyString(warningKey));
     582       20971 :         buffer[12] = '\0'; strcat(buffer, "/reason");
     583             :         va_list arg;
     584       20971 :         va_start(arg, module);
     585       20971 :         char * r = elektraVFormat(reason, arg);
     586       20971 :         keySetMeta(warningKey, buffer, r);
     587       20971 :         elektraFree(r);
     588       20971 :         va_end(arg);
     589             : }
     590             : 
     591         490 : static inline void elektraAddWarningC01200(Key *warningKey, const char *reason,
     592             :         const char *file, const char *line, const char *module)
     593             : {
     594         490 :         if (!warningKey) return;
     595             : 
     596         490 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     597         490 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     598         490 :         if (meta)
     599             :         {
     600         288 :                 buffer[10] = keyString(meta)[0];
     601         288 :                 buffer[11] = keyString(meta)[1];
     602         288 :                 buffer[11]++;
     603         288 :                 if (buffer[11] > '9')
     604             :                 {
     605           0 :                         buffer[11] = '0';
     606           0 :                         buffer[10]++;
     607           0 :                         if (buffer[10] > '9') buffer[10] = '0';
     608             :                 }
     609         288 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     610         202 :         } else  keySetMeta(warningKey, "warnings", "00");
     611             : 
     612         490 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     613         490 :         strcat(buffer, "/number" );
     614         490 :         keySetMeta(warningKey, buffer, "C01200");
     615         490 :         buffer[12] = '\0'; strcat(buffer, "/description");
     616         490 :         keySetMeta(warningKey, buffer, "Installation");
     617         490 :         buffer[12] = '\0'; strcat(buffer, "/module");
     618         490 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     619         490 :         keySetMeta(warningKey, buffer, module);
     620         490 :         buffer[12] = '\0'; strcat(buffer, "/file");
     621         490 :         keySetMeta(warningKey, buffer, file);
     622         490 :         buffer[12] = '\0'; strcat(buffer, "/line");
     623         490 :         keySetMeta(warningKey, buffer, line);
     624         490 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     625         490 :         keySetMeta(warningKey, buffer, keyName(warningKey));
     626         490 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
     627         490 :         keySetMeta(warningKey, buffer, keyString(warningKey));
     628         490 :         buffer[12] = '\0'; strcat(buffer, "/reason");
     629         490 :         keySetMeta(warningKey, buffer, reason);
     630             : }
     631             : 
     632             : static inline void elektraSetErrorfC01200(Key *errorKey, const char *reason,
     633             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     634           1 : static inline void elektraSetErrorfC01200(Key *errorKey, const char *reason,
     635             :         const char *file, const char *line, const char *module, ...)
     636             : {
     637           1 :         if (!errorKey) return;
     638           1 :         char buffer[25] = "warnings/#00";
     639           1 :         const Key *meta = keyGetMeta(errorKey, "error");
     640           1 :         if (meta)
     641             :         {
     642           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
     643           0 :                 if (warningMeta)
     644             :                 {
     645           0 :                         buffer[10] = keyString(warningMeta)[0];
     646           0 :                         buffer[11] = keyString(warningMeta)[1];
     647           0 :                         buffer[11]++;
     648           0 :                         if (buffer[11] > '9')
     649             :                         {
     650           0 :                                 buffer[11] = '0';
     651           0 :                                 buffer[10]++;
     652           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
     653             :                         }
     654           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
     655           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
     656           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
     657           0 :                 strcat(buffer, "/number" );
     658           0 :                 keySetMeta(errorKey, buffer, "C01200");
     659           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
     660           0 :                 keySetMeta(errorKey, buffer, "Installation");
     661           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
     662           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     663           0 :                 keySetMeta(errorKey, buffer, module);
     664           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
     665           0 :                 keySetMeta(errorKey, buffer, file);
     666           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
     667           0 :                 keySetMeta(errorKey, buffer, line);
     668           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     669           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
     670           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
     671           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
     672           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
     673             :         }
     674             :         else
     675             :         {
     676           1 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
     677           1 :                 keySetMeta(errorKey, "error/number", "C01200");
     678           1 :                 keySetMeta(errorKey, "error/description", "Installation");
     679           1 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     680           1 :                 keySetMeta(errorKey, "error/module", module);
     681           1 :                 keySetMeta(errorKey, "error/file", file);
     682           1 :                 keySetMeta(errorKey, "error/line", line);
     683           1 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
     684           1 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
     685             :         }
     686             :         va_list arg;
     687           1 :         va_start(arg, module);
     688           1 :         char * r = elektraVFormat(reason, arg);
     689           1 :         if (meta)
     690           0 :                         keySetMeta(errorKey, buffer, r);
     691             :         else
     692           1 :                         keySetMeta(errorKey, "error/reason", r);
     693           1 :         elektraFree(r);
     694           1 :         va_end(arg);
     695             : }
     696             : 
     697           8 : static inline void elektraSetErrorC01200(Key *errorKey, const char *reason,
     698             :         const char *file, const char *line, const char *module)
     699             : {
     700           8 :         if (!errorKey) return;
     701           8 :         char buffer[25] = "warnings/#00";
     702           8 :         const Key *meta = keyGetMeta(errorKey, "error");
     703           8 :         if (meta)
     704             :         {
     705           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
     706           0 :                 if (warningMeta)
     707             :                 {
     708           0 :                         buffer[10] = keyString(warningMeta)[0];
     709           0 :                         buffer[11] = keyString(warningMeta)[1];
     710           0 :                         buffer[11]++;
     711           0 :                         if (buffer[11] > '9')
     712             :                         {
     713           0 :                                 buffer[11] = '0';
     714           0 :                                 buffer[10]++;
     715           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
     716             :                         }
     717           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
     718           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
     719           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
     720           0 :                 strcat(buffer, "/number" );
     721           0 :                 keySetMeta(errorKey, buffer, "C01200");
     722           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
     723           0 :                 keySetMeta(errorKey, buffer, "Installation");
     724           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
     725           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     726           0 :                 keySetMeta(errorKey, buffer, module);
     727           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
     728           0 :                 keySetMeta(errorKey, buffer, file);
     729           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
     730           0 :                 keySetMeta(errorKey, buffer, line);
     731           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     732           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
     733           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
     734           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
     735           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
     736             :         }
     737             :         else
     738             :         {
     739           8 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
     740           8 :                 keySetMeta(errorKey, "error/number", "C01200");
     741           8 :                 keySetMeta(errorKey, "error/description", "Installation");
     742           8 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     743           8 :                 keySetMeta(errorKey, "error/module", module);
     744           8 :                 keySetMeta(errorKey, "error/file", file);
     745           8 :                 keySetMeta(errorKey, "error/line", line);
     746           8 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
     747           8 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
     748             :         }
     749           8 :         if (meta)
     750           0 :                         keySetMeta(errorKey, buffer, reason);
     751             :         else
     752           8 :                         keySetMeta(errorKey, "error/reason", reason);
     753             : }
     754             : 
     755             : static inline void elektraAddWarningfC01310(Key *warningKey, const char *reason,
     756             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     757          12 : static inline void elektraAddWarningfC01310(Key *warningKey, const char *reason,
     758             :         const char *file, const char *line, const char *module, ...)
     759             : {
     760          12 :         if (!warningKey) return;
     761             : 
     762          12 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     763          12 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     764          12 :         if (meta)
     765             :         {
     766           0 :                 buffer[10] = keyString(meta)[0];
     767           0 :                 buffer[11] = keyString(meta)[1];
     768           0 :                 buffer[11]++;
     769           0 :                 if (buffer[11] > '9')
     770             :                 {
     771           0 :                         buffer[11] = '0';
     772           0 :                         buffer[10]++;
     773           0 :                         if (buffer[10] > '9') buffer[10] = '0';
     774             :                 }
     775           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     776          12 :         } else  keySetMeta(warningKey, "warnings", "00");
     777             : 
     778          12 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     779          12 :         strcat(buffer, "/number" );
     780          12 :         keySetMeta(warningKey, buffer, "C01310");
     781          12 :         buffer[12] = '\0'; strcat(buffer, "/description");
     782          12 :         keySetMeta(warningKey, buffer, "Internal");
     783          12 :         buffer[12] = '\0'; strcat(buffer, "/module");
     784          12 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     785          12 :         keySetMeta(warningKey, buffer, module);
     786          12 :         buffer[12] = '\0'; strcat(buffer, "/file");
     787          12 :         keySetMeta(warningKey, buffer, file);
     788          12 :         buffer[12] = '\0'; strcat(buffer, "/line");
     789          12 :         keySetMeta(warningKey, buffer, line);
     790          12 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     791          12 :         keySetMeta(warningKey, buffer, keyName(warningKey));
     792          12 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
     793          12 :         keySetMeta(warningKey, buffer, keyString(warningKey));
     794          12 :         buffer[12] = '\0'; strcat(buffer, "/reason");
     795             :         va_list arg;
     796          12 :         va_start(arg, module);
     797          12 :         char * r = elektraVFormat(reason, arg);
     798          12 :         keySetMeta(warningKey, buffer, r);
     799          12 :         elektraFree(r);
     800          12 :         va_end(arg);
     801             : }
     802             : 
     803           0 : static inline void elektraAddWarningC01310(Key *warningKey, const char *reason,
     804             :         const char *file, const char *line, const char *module)
     805             : {
     806           0 :         if (!warningKey) return;
     807             : 
     808           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     809           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     810           0 :         if (meta)
     811             :         {
     812           0 :                 buffer[10] = keyString(meta)[0];
     813           0 :                 buffer[11] = keyString(meta)[1];
     814           0 :                 buffer[11]++;
     815           0 :                 if (buffer[11] > '9')
     816             :                 {
     817           0 :                         buffer[11] = '0';
     818           0 :                         buffer[10]++;
     819           0 :                         if (buffer[10] > '9') buffer[10] = '0';
     820             :                 }
     821           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     822           0 :         } else  keySetMeta(warningKey, "warnings", "00");
     823             : 
     824           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     825           0 :         strcat(buffer, "/number" );
     826           0 :         keySetMeta(warningKey, buffer, "C01310");
     827           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
     828           0 :         keySetMeta(warningKey, buffer, "Internal");
     829           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
     830           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     831           0 :         keySetMeta(warningKey, buffer, module);
     832           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
     833           0 :         keySetMeta(warningKey, buffer, file);
     834           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
     835           0 :         keySetMeta(warningKey, buffer, line);
     836           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     837           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
     838           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
     839           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
     840           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
     841           0 :         keySetMeta(warningKey, buffer, reason);
     842             : }
     843             : 
     844             : static inline void elektraSetErrorfC01310(Key *errorKey, const char *reason,
     845             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     846           6 : static inline void elektraSetErrorfC01310(Key *errorKey, const char *reason,
     847             :         const char *file, const char *line, const char *module, ...)
     848             : {
     849           6 :         if (!errorKey) return;
     850           6 :         char buffer[25] = "warnings/#00";
     851           6 :         const Key *meta = keyGetMeta(errorKey, "error");
     852           6 :         if (meta)
     853             :         {
     854           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
     855           0 :                 if (warningMeta)
     856             :                 {
     857           0 :                         buffer[10] = keyString(warningMeta)[0];
     858           0 :                         buffer[11] = keyString(warningMeta)[1];
     859           0 :                         buffer[11]++;
     860           0 :                         if (buffer[11] > '9')
     861             :                         {
     862           0 :                                 buffer[11] = '0';
     863           0 :                                 buffer[10]++;
     864           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
     865             :                         }
     866           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
     867           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
     868           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
     869           0 :                 strcat(buffer, "/number" );
     870           0 :                 keySetMeta(errorKey, buffer, "C01310");
     871           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
     872           0 :                 keySetMeta(errorKey, buffer, "Internal");
     873           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
     874           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     875           0 :                 keySetMeta(errorKey, buffer, module);
     876           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
     877           0 :                 keySetMeta(errorKey, buffer, file);
     878           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
     879           0 :                 keySetMeta(errorKey, buffer, line);
     880           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     881           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
     882           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
     883           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
     884           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
     885             :         }
     886             :         else
     887             :         {
     888           6 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
     889           6 :                 keySetMeta(errorKey, "error/number", "C01310");
     890           6 :                 keySetMeta(errorKey, "error/description", "Internal");
     891           6 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     892           6 :                 keySetMeta(errorKey, "error/module", module);
     893           6 :                 keySetMeta(errorKey, "error/file", file);
     894           6 :                 keySetMeta(errorKey, "error/line", line);
     895           6 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
     896           6 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
     897             :         }
     898             :         va_list arg;
     899           6 :         va_start(arg, module);
     900           6 :         char * r = elektraVFormat(reason, arg);
     901           6 :         if (meta)
     902           0 :                         keySetMeta(errorKey, buffer, r);
     903             :         else
     904           6 :                         keySetMeta(errorKey, "error/reason", r);
     905           6 :         elektraFree(r);
     906           6 :         va_end(arg);
     907             : }
     908             : 
     909         139 : static inline void elektraSetErrorC01310(Key *errorKey, const char *reason,
     910             :         const char *file, const char *line, const char *module)
     911             : {
     912         139 :         if (!errorKey) return;
     913         139 :         char buffer[25] = "warnings/#00";
     914         139 :         const Key *meta = keyGetMeta(errorKey, "error");
     915         139 :         if (meta)
     916             :         {
     917          76 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
     918          76 :                 if (warningMeta)
     919             :                 {
     920          32 :                         buffer[10] = keyString(warningMeta)[0];
     921          32 :                         buffer[11] = keyString(warningMeta)[1];
     922          32 :                         buffer[11]++;
     923          32 :                         if (buffer[11] > '9')
     924             :                         {
     925           0 :                                 buffer[11] = '0';
     926           0 :                                 buffer[10]++;
     927           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
     928             :                         }
     929          32 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
     930          44 :                 } else  keySetMeta(errorKey, "warnings", "00");
     931          76 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
     932          76 :                 strcat(buffer, "/number" );
     933          76 :                 keySetMeta(errorKey, buffer, "C01310");
     934          76 :                 buffer[12] = '\0'; strcat(buffer, "/description");
     935          76 :                 keySetMeta(errorKey, buffer, "Internal");
     936          76 :                 buffer[12] = '\0'; strcat(buffer, "/module");
     937          76 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     938          76 :                 keySetMeta(errorKey, buffer, module);
     939          76 :                 buffer[12] = '\0'; strcat(buffer, "/file");
     940          76 :                 keySetMeta(errorKey, buffer, file);
     941          76 :                 buffer[12] = '\0'; strcat(buffer, "/line");
     942          76 :                 keySetMeta(errorKey, buffer, line);
     943          76 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
     944          76 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
     945          76 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
     946          76 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
     947          76 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
     948             :         }
     949             :         else
     950             :         {
     951          63 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
     952          63 :                 keySetMeta(errorKey, "error/number", "C01310");
     953          63 :                 keySetMeta(errorKey, "error/description", "Internal");
     954          63 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     955          63 :                 keySetMeta(errorKey, "error/module", module);
     956          63 :                 keySetMeta(errorKey, "error/file", file);
     957          63 :                 keySetMeta(errorKey, "error/line", line);
     958          63 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
     959          63 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
     960             :         }
     961         139 :         if (meta)
     962          76 :                         keySetMeta(errorKey, buffer, reason);
     963             :         else
     964          63 :                         keySetMeta(errorKey, "error/reason", reason);
     965             : }
     966             : 
     967             : static inline void elektraAddWarningfC01320(Key *warningKey, const char *reason,
     968             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
     969           6 : static inline void elektraAddWarningfC01320(Key *warningKey, const char *reason,
     970             :         const char *file, const char *line, const char *module, ...)
     971             : {
     972           6 :         if (!warningKey) return;
     973             : 
     974           6 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
     975           6 :         const Key *meta = keyGetMeta(warningKey, "warnings");
     976           6 :         if (meta)
     977             :         {
     978           0 :                 buffer[10] = keyString(meta)[0];
     979           0 :                 buffer[11] = keyString(meta)[1];
     980           0 :                 buffer[11]++;
     981           0 :                 if (buffer[11] > '9')
     982             :                 {
     983           0 :                         buffer[11] = '0';
     984           0 :                         buffer[10]++;
     985           0 :                         if (buffer[10] > '9') buffer[10] = '0';
     986             :                 }
     987           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
     988           6 :         } else  keySetMeta(warningKey, "warnings", "00");
     989             : 
     990           6 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
     991           6 :         strcat(buffer, "/number" );
     992           6 :         keySetMeta(warningKey, buffer, "C01320");
     993           6 :         buffer[12] = '\0'; strcat(buffer, "/description");
     994           6 :         keySetMeta(warningKey, buffer, "Interface");
     995           6 :         buffer[12] = '\0'; strcat(buffer, "/module");
     996           6 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
     997           6 :         keySetMeta(warningKey, buffer, module);
     998           6 :         buffer[12] = '\0'; strcat(buffer, "/file");
     999           6 :         keySetMeta(warningKey, buffer, file);
    1000           6 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1001           6 :         keySetMeta(warningKey, buffer, line);
    1002           6 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1003           6 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1004           6 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1005           6 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1006           6 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1007             :         va_list arg;
    1008           6 :         va_start(arg, module);
    1009           6 :         char * r = elektraVFormat(reason, arg);
    1010           6 :         keySetMeta(warningKey, buffer, r);
    1011           6 :         elektraFree(r);
    1012           6 :         va_end(arg);
    1013             : }
    1014             : 
    1015          54 : static inline void elektraAddWarningC01320(Key *warningKey, const char *reason,
    1016             :         const char *file, const char *line, const char *module)
    1017             : {
    1018         108 :         if (!warningKey) return;
    1019             : 
    1020           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1021           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1022           0 :         if (meta)
    1023             :         {
    1024           0 :                 buffer[10] = keyString(meta)[0];
    1025           0 :                 buffer[11] = keyString(meta)[1];
    1026           0 :                 buffer[11]++;
    1027           0 :                 if (buffer[11] > '9')
    1028             :                 {
    1029           0 :                         buffer[11] = '0';
    1030           0 :                         buffer[10]++;
    1031           0 :                         if (buffer[10] > '9') buffer[10] = '0';
    1032             :                 }
    1033           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1034           0 :         } else  keySetMeta(warningKey, "warnings", "00");
    1035             : 
    1036           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1037           0 :         strcat(buffer, "/number" );
    1038           0 :         keySetMeta(warningKey, buffer, "C01320");
    1039           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
    1040           0 :         keySetMeta(warningKey, buffer, "Interface");
    1041           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
    1042           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1043           0 :         keySetMeta(warningKey, buffer, module);
    1044           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
    1045           0 :         keySetMeta(warningKey, buffer, file);
    1046           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1047           0 :         keySetMeta(warningKey, buffer, line);
    1048           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1049           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1050           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1051           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1052           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1053           0 :         keySetMeta(warningKey, buffer, reason);
    1054             : }
    1055             : 
    1056             : static inline void elektraSetErrorfC01320(Key *errorKey, const char *reason,
    1057             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1058           6 : static inline void elektraSetErrorfC01320(Key *errorKey, const char *reason,
    1059             :         const char *file, const char *line, const char *module, ...)
    1060             : {
    1061           6 :         if (!errorKey) return;
    1062           6 :         char buffer[25] = "warnings/#00";
    1063           6 :         const Key *meta = keyGetMeta(errorKey, "error");
    1064           6 :         if (meta)
    1065             :         {
    1066           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1067           0 :                 if (warningMeta)
    1068             :                 {
    1069           0 :                         buffer[10] = keyString(warningMeta)[0];
    1070           0 :                         buffer[11] = keyString(warningMeta)[1];
    1071           0 :                         buffer[11]++;
    1072           0 :                         if (buffer[11] > '9')
    1073             :                         {
    1074           0 :                                 buffer[11] = '0';
    1075           0 :                                 buffer[10]++;
    1076           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1077             :                         }
    1078           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1079           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1080           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1081           0 :                 strcat(buffer, "/number" );
    1082           0 :                 keySetMeta(errorKey, buffer, "C01320");
    1083           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1084           0 :                 keySetMeta(errorKey, buffer, "Interface");
    1085           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1086           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1087           0 :                 keySetMeta(errorKey, buffer, module);
    1088           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1089           0 :                 keySetMeta(errorKey, buffer, file);
    1090           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1091           0 :                 keySetMeta(errorKey, buffer, line);
    1092           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1093           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1094           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1095           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1096           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1097             :         }
    1098             :         else
    1099             :         {
    1100           6 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1101           6 :                 keySetMeta(errorKey, "error/number", "C01320");
    1102           6 :                 keySetMeta(errorKey, "error/description", "Interface");
    1103           6 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1104           6 :                 keySetMeta(errorKey, "error/module", module);
    1105           6 :                 keySetMeta(errorKey, "error/file", file);
    1106           6 :                 keySetMeta(errorKey, "error/line", line);
    1107           6 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1108           6 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1109             :         }
    1110             :         va_list arg;
    1111           6 :         va_start(arg, module);
    1112           6 :         char * r = elektraVFormat(reason, arg);
    1113           6 :         if (meta)
    1114           0 :                         keySetMeta(errorKey, buffer, r);
    1115             :         else
    1116           6 :                         keySetMeta(errorKey, "error/reason", r);
    1117           6 :         elektraFree(r);
    1118           6 :         va_end(arg);
    1119             : }
    1120             : 
    1121          14 : static inline void elektraSetErrorC01320(Key *errorKey, const char *reason,
    1122             :         const char *file, const char *line, const char *module)
    1123             : {
    1124          14 :         if (!errorKey) return;
    1125          14 :         char buffer[25] = "warnings/#00";
    1126          14 :         const Key *meta = keyGetMeta(errorKey, "error");
    1127          14 :         if (meta)
    1128             :         {
    1129           4 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1130           4 :                 if (warningMeta)
    1131             :                 {
    1132           2 :                         buffer[10] = keyString(warningMeta)[0];
    1133           2 :                         buffer[11] = keyString(warningMeta)[1];
    1134           2 :                         buffer[11]++;
    1135           2 :                         if (buffer[11] > '9')
    1136             :                         {
    1137           0 :                                 buffer[11] = '0';
    1138           0 :                                 buffer[10]++;
    1139           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1140             :                         }
    1141           2 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1142           2 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1143           4 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1144           4 :                 strcat(buffer, "/number" );
    1145           4 :                 keySetMeta(errorKey, buffer, "C01320");
    1146           4 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1147           4 :                 keySetMeta(errorKey, buffer, "Interface");
    1148           4 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1149           4 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1150           4 :                 keySetMeta(errorKey, buffer, module);
    1151           4 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1152           4 :                 keySetMeta(errorKey, buffer, file);
    1153           4 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1154           4 :                 keySetMeta(errorKey, buffer, line);
    1155           4 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1156           4 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1157           4 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1158           4 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1159           4 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1160             :         }
    1161             :         else
    1162             :         {
    1163          10 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1164          10 :                 keySetMeta(errorKey, "error/number", "C01320");
    1165          10 :                 keySetMeta(errorKey, "error/description", "Interface");
    1166          10 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1167          10 :                 keySetMeta(errorKey, "error/module", module);
    1168          10 :                 keySetMeta(errorKey, "error/file", file);
    1169          10 :                 keySetMeta(errorKey, "error/line", line);
    1170          10 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1171          10 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1172             :         }
    1173          14 :         if (meta)
    1174           4 :                         keySetMeta(errorKey, buffer, reason);
    1175             :         else
    1176          10 :                         keySetMeta(errorKey, "error/reason", reason);
    1177             : }
    1178             : 
    1179             : static inline void elektraAddWarningfC01330(Key *warningKey, const char *reason,
    1180             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1181          15 : static inline void elektraAddWarningfC01330(Key *warningKey, const char *reason,
    1182             :         const char *file, const char *line, const char *module, ...)
    1183             : {
    1184          15 :         if (!warningKey) return;
    1185             : 
    1186          15 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1187          15 :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1188          15 :         if (meta)
    1189             :         {
    1190           2 :                 buffer[10] = keyString(meta)[0];
    1191           2 :                 buffer[11] = keyString(meta)[1];
    1192           2 :                 buffer[11]++;
    1193           2 :                 if (buffer[11] > '9')
    1194             :                 {
    1195           0 :                         buffer[11] = '0';
    1196           0 :                         buffer[10]++;
    1197           0 :                         if (buffer[10] > '9') buffer[10] = '0';
    1198             :                 }
    1199           2 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1200          13 :         } else  keySetMeta(warningKey, "warnings", "00");
    1201             : 
    1202          15 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1203          15 :         strcat(buffer, "/number" );
    1204          15 :         keySetMeta(warningKey, buffer, "C01330");
    1205          15 :         buffer[12] = '\0'; strcat(buffer, "/description");
    1206          15 :         keySetMeta(warningKey, buffer, "Plugin Misbehavior");
    1207          15 :         buffer[12] = '\0'; strcat(buffer, "/module");
    1208          15 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1209          15 :         keySetMeta(warningKey, buffer, module);
    1210          15 :         buffer[12] = '\0'; strcat(buffer, "/file");
    1211          15 :         keySetMeta(warningKey, buffer, file);
    1212          15 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1213          15 :         keySetMeta(warningKey, buffer, line);
    1214          15 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1215          15 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1216          15 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1217          15 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1218          15 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1219             :         va_list arg;
    1220          15 :         va_start(arg, module);
    1221          15 :         char * r = elektraVFormat(reason, arg);
    1222          15 :         keySetMeta(warningKey, buffer, r);
    1223          15 :         elektraFree(r);
    1224          15 :         va_end(arg);
    1225             : }
    1226             : 
    1227           3 : static inline void elektraAddWarningC01330(Key *warningKey, const char *reason,
    1228             :         const char *file, const char *line, const char *module)
    1229             : {
    1230           3 :         if (!warningKey) return;
    1231             : 
    1232           3 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1233           3 :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1234           3 :         if (meta)
    1235             :         {
    1236           0 :                 buffer[10] = keyString(meta)[0];
    1237           0 :                 buffer[11] = keyString(meta)[1];
    1238           0 :                 buffer[11]++;
    1239           0 :                 if (buffer[11] > '9')
    1240             :                 {
    1241           0 :                         buffer[11] = '0';
    1242           0 :                         buffer[10]++;
    1243           0 :                         if (buffer[10] > '9') buffer[10] = '0';
    1244             :                 }
    1245           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1246           3 :         } else  keySetMeta(warningKey, "warnings", "00");
    1247             : 
    1248           3 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1249           3 :         strcat(buffer, "/number" );
    1250           3 :         keySetMeta(warningKey, buffer, "C01330");
    1251           3 :         buffer[12] = '\0'; strcat(buffer, "/description");
    1252           3 :         keySetMeta(warningKey, buffer, "Plugin Misbehavior");
    1253           3 :         buffer[12] = '\0'; strcat(buffer, "/module");
    1254           3 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1255           3 :         keySetMeta(warningKey, buffer, module);
    1256           3 :         buffer[12] = '\0'; strcat(buffer, "/file");
    1257           3 :         keySetMeta(warningKey, buffer, file);
    1258           3 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1259           3 :         keySetMeta(warningKey, buffer, line);
    1260           3 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1261           3 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1262           3 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1263           3 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1264           3 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1265           3 :         keySetMeta(warningKey, buffer, reason);
    1266             : }
    1267             : 
    1268             : static inline void elektraSetErrorfC01330(Key *errorKey, const char *reason,
    1269             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1270           4 : static inline void elektraSetErrorfC01330(Key *errorKey, const char *reason,
    1271             :         const char *file, const char *line, const char *module, ...)
    1272             : {
    1273           4 :         if (!errorKey) return;
    1274           4 :         char buffer[25] = "warnings/#00";
    1275           4 :         const Key *meta = keyGetMeta(errorKey, "error");
    1276           4 :         if (meta)
    1277             :         {
    1278           2 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1279           2 :                 if (warningMeta)
    1280             :                 {
    1281           0 :                         buffer[10] = keyString(warningMeta)[0];
    1282           0 :                         buffer[11] = keyString(warningMeta)[1];
    1283           0 :                         buffer[11]++;
    1284           0 :                         if (buffer[11] > '9')
    1285             :                         {
    1286           0 :                                 buffer[11] = '0';
    1287           0 :                                 buffer[10]++;
    1288           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1289             :                         }
    1290           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1291           2 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1292           2 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1293           2 :                 strcat(buffer, "/number" );
    1294           2 :                 keySetMeta(errorKey, buffer, "C01330");
    1295           2 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1296           2 :                 keySetMeta(errorKey, buffer, "Plugin Misbehavior");
    1297           2 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1298           2 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1299           2 :                 keySetMeta(errorKey, buffer, module);
    1300           2 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1301           2 :                 keySetMeta(errorKey, buffer, file);
    1302           2 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1303           2 :                 keySetMeta(errorKey, buffer, line);
    1304           2 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1305           2 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1306           2 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1307           2 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1308           2 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1309             :         }
    1310             :         else
    1311             :         {
    1312           2 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1313           2 :                 keySetMeta(errorKey, "error/number", "C01330");
    1314           2 :                 keySetMeta(errorKey, "error/description", "Plugin Misbehavior");
    1315           2 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1316           2 :                 keySetMeta(errorKey, "error/module", module);
    1317           2 :                 keySetMeta(errorKey, "error/file", file);
    1318           2 :                 keySetMeta(errorKey, "error/line", line);
    1319           2 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1320           2 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1321             :         }
    1322             :         va_list arg;
    1323           4 :         va_start(arg, module);
    1324           4 :         char * r = elektraVFormat(reason, arg);
    1325           4 :         if (meta)
    1326           2 :                         keySetMeta(errorKey, buffer, r);
    1327             :         else
    1328           2 :                         keySetMeta(errorKey, "error/reason", r);
    1329           4 :         elektraFree(r);
    1330           4 :         va_end(arg);
    1331             : }
    1332             : 
    1333           3 : static inline void elektraSetErrorC01330(Key *errorKey, const char *reason,
    1334             :         const char *file, const char *line, const char *module)
    1335             : {
    1336           3 :         if (!errorKey) return;
    1337           3 :         char buffer[25] = "warnings/#00";
    1338           3 :         const Key *meta = keyGetMeta(errorKey, "error");
    1339           3 :         if (meta)
    1340             :         {
    1341           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1342           0 :                 if (warningMeta)
    1343             :                 {
    1344           0 :                         buffer[10] = keyString(warningMeta)[0];
    1345           0 :                         buffer[11] = keyString(warningMeta)[1];
    1346           0 :                         buffer[11]++;
    1347           0 :                         if (buffer[11] > '9')
    1348             :                         {
    1349           0 :                                 buffer[11] = '0';
    1350           0 :                                 buffer[10]++;
    1351           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1352             :                         }
    1353           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1354           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1355           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1356           0 :                 strcat(buffer, "/number" );
    1357           0 :                 keySetMeta(errorKey, buffer, "C01330");
    1358           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1359           0 :                 keySetMeta(errorKey, buffer, "Plugin Misbehavior");
    1360           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1361           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1362           0 :                 keySetMeta(errorKey, buffer, module);
    1363           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1364           0 :                 keySetMeta(errorKey, buffer, file);
    1365           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1366           0 :                 keySetMeta(errorKey, buffer, line);
    1367           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1368           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1369           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1370           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1371           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1372             :         }
    1373             :         else
    1374             :         {
    1375           3 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1376           3 :                 keySetMeta(errorKey, "error/number", "C01330");
    1377           3 :                 keySetMeta(errorKey, "error/description", "Plugin Misbehavior");
    1378           3 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1379           3 :                 keySetMeta(errorKey, "error/module", module);
    1380           3 :                 keySetMeta(errorKey, "error/file", file);
    1381           3 :                 keySetMeta(errorKey, "error/line", line);
    1382           3 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1383           3 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1384             :         }
    1385           3 :         if (meta)
    1386           0 :                         keySetMeta(errorKey, buffer, reason);
    1387             :         else
    1388           3 :                         keySetMeta(errorKey, "error/reason", reason);
    1389             : }
    1390             : 
    1391             : static inline void elektraAddWarningfC02000(Key *warningKey, const char *reason,
    1392             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1393             : static inline void elektraAddWarningfC02000(Key *warningKey, const char *reason,
    1394             :         const char *file, const char *line, const char *module, ...)
    1395             : {
    1396             :         if (!warningKey) return;
    1397             : 
    1398             :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1399             :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1400             :         if (meta)
    1401             :         {
    1402             :                 buffer[10] = keyString(meta)[0];
    1403             :                 buffer[11] = keyString(meta)[1];
    1404             :                 buffer[11]++;
    1405             :                 if (buffer[11] > '9')
    1406             :                 {
    1407             :                         buffer[11] = '0';
    1408             :                         buffer[10]++;
    1409             :                         if (buffer[10] > '9') buffer[10] = '0';
    1410             :                 }
    1411             :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1412             :         } else  keySetMeta(warningKey, "warnings", "00");
    1413             : 
    1414             :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1415             :         strcat(buffer, "/number" );
    1416             :         keySetMeta(warningKey, buffer, "C02000");
    1417             :         buffer[12] = '\0'; strcat(buffer, "/description");
    1418             :         keySetMeta(warningKey, buffer, "Conflict");
    1419             :         buffer[12] = '\0'; strcat(buffer, "/module");
    1420             :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1421             :         keySetMeta(warningKey, buffer, module);
    1422             :         buffer[12] = '\0'; strcat(buffer, "/file");
    1423             :         keySetMeta(warningKey, buffer, file);
    1424             :         buffer[12] = '\0'; strcat(buffer, "/line");
    1425             :         keySetMeta(warningKey, buffer, line);
    1426             :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1427             :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1428             :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1429             :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1430             :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1431             :         va_list arg;
    1432             :         va_start(arg, module);
    1433             :         char * r = elektraVFormat(reason, arg);
    1434             :         keySetMeta(warningKey, buffer, r);
    1435             :         elektraFree(r);
    1436             :         va_end(arg);
    1437             : }
    1438             : 
    1439           0 : static inline void elektraAddWarningC02000(Key *warningKey, const char *reason,
    1440             :         const char *file, const char *line, const char *module)
    1441             : {
    1442           0 :         if (!warningKey) return;
    1443             : 
    1444           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1445           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1446           0 :         if (meta)
    1447             :         {
    1448           0 :                 buffer[10] = keyString(meta)[0];
    1449           0 :                 buffer[11] = keyString(meta)[1];
    1450           0 :                 buffer[11]++;
    1451           0 :                 if (buffer[11] > '9')
    1452             :                 {
    1453           0 :                         buffer[11] = '0';
    1454           0 :                         buffer[10]++;
    1455           0 :                         if (buffer[10] > '9') buffer[10] = '0';
    1456             :                 }
    1457           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1458           0 :         } else  keySetMeta(warningKey, "warnings", "00");
    1459             : 
    1460           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1461           0 :         strcat(buffer, "/number" );
    1462           0 :         keySetMeta(warningKey, buffer, "C02000");
    1463           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
    1464           0 :         keySetMeta(warningKey, buffer, "Conflict");
    1465           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
    1466           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1467           0 :         keySetMeta(warningKey, buffer, module);
    1468           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
    1469           0 :         keySetMeta(warningKey, buffer, file);
    1470           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1471           0 :         keySetMeta(warningKey, buffer, line);
    1472           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1473           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1474           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1475           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1476           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1477           0 :         keySetMeta(warningKey, buffer, reason);
    1478             : }
    1479             : 
    1480             : static inline void elektraSetErrorfC02000(Key *errorKey, const char *reason,
    1481             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1482          13 : static inline void elektraSetErrorfC02000(Key *errorKey, const char *reason,
    1483             :         const char *file, const char *line, const char *module, ...)
    1484             : {
    1485          13 :         if (!errorKey) return;
    1486          13 :         char buffer[25] = "warnings/#00";
    1487          13 :         const Key *meta = keyGetMeta(errorKey, "error");
    1488          13 :         if (meta)
    1489             :         {
    1490           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1491           0 :                 if (warningMeta)
    1492             :                 {
    1493           0 :                         buffer[10] = keyString(warningMeta)[0];
    1494           0 :                         buffer[11] = keyString(warningMeta)[1];
    1495           0 :                         buffer[11]++;
    1496           0 :                         if (buffer[11] > '9')
    1497             :                         {
    1498           0 :                                 buffer[11] = '0';
    1499           0 :                                 buffer[10]++;
    1500           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1501             :                         }
    1502           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1503           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1504           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1505           0 :                 strcat(buffer, "/number" );
    1506           0 :                 keySetMeta(errorKey, buffer, "C02000");
    1507           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1508           0 :                 keySetMeta(errorKey, buffer, "Conflict");
    1509           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1510           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1511           0 :                 keySetMeta(errorKey, buffer, module);
    1512           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1513           0 :                 keySetMeta(errorKey, buffer, file);
    1514           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1515           0 :                 keySetMeta(errorKey, buffer, line);
    1516           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1517           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1518           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1519           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1520           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1521             :         }
    1522             :         else
    1523             :         {
    1524          13 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1525          13 :                 keySetMeta(errorKey, "error/number", "C02000");
    1526          13 :                 keySetMeta(errorKey, "error/description", "Conflict");
    1527          13 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1528          13 :                 keySetMeta(errorKey, "error/module", module);
    1529          13 :                 keySetMeta(errorKey, "error/file", file);
    1530          13 :                 keySetMeta(errorKey, "error/line", line);
    1531          13 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1532          13 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1533             :         }
    1534             :         va_list arg;
    1535          13 :         va_start(arg, module);
    1536          13 :         char * r = elektraVFormat(reason, arg);
    1537          13 :         if (meta)
    1538           0 :                         keySetMeta(errorKey, buffer, r);
    1539             :         else
    1540          13 :                         keySetMeta(errorKey, "error/reason", r);
    1541          13 :         elektraFree(r);
    1542          13 :         va_end(arg);
    1543             : }
    1544             : 
    1545           2 : static inline void elektraSetErrorC02000(Key *errorKey, const char *reason,
    1546             :         const char *file, const char *line, const char *module)
    1547             : {
    1548           2 :         if (!errorKey) return;
    1549           2 :         char buffer[25] = "warnings/#00";
    1550           2 :         const Key *meta = keyGetMeta(errorKey, "error");
    1551           2 :         if (meta)
    1552             :         {
    1553           0 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1554           0 :                 if (warningMeta)
    1555             :                 {
    1556           0 :                         buffer[10] = keyString(warningMeta)[0];
    1557           0 :                         buffer[11] = keyString(warningMeta)[1];
    1558           0 :                         buffer[11]++;
    1559           0 :                         if (buffer[11] > '9')
    1560             :                         {
    1561           0 :                                 buffer[11] = '0';
    1562           0 :                                 buffer[10]++;
    1563           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1564             :                         }
    1565           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1566           0 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1567           0 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1568           0 :                 strcat(buffer, "/number" );
    1569           0 :                 keySetMeta(errorKey, buffer, "C02000");
    1570           0 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1571           0 :                 keySetMeta(errorKey, buffer, "Conflict");
    1572           0 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1573           0 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1574           0 :                 keySetMeta(errorKey, buffer, module);
    1575           0 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1576           0 :                 keySetMeta(errorKey, buffer, file);
    1577           0 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1578           0 :                 keySetMeta(errorKey, buffer, line);
    1579           0 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1580           0 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1581           0 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1582           0 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1583           0 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1584             :         }
    1585             :         else
    1586             :         {
    1587           2 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1588           2 :                 keySetMeta(errorKey, "error/number", "C02000");
    1589           2 :                 keySetMeta(errorKey, "error/description", "Conflict");
    1590           2 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1591           2 :                 keySetMeta(errorKey, "error/module", module);
    1592           2 :                 keySetMeta(errorKey, "error/file", file);
    1593           2 :                 keySetMeta(errorKey, "error/line", line);
    1594           2 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1595           2 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1596             :         }
    1597           2 :         if (meta)
    1598           0 :                         keySetMeta(errorKey, buffer, reason);
    1599             :         else
    1600           2 :                         keySetMeta(errorKey, "error/reason", reason);
    1601             : }
    1602             : 
    1603             : static inline void elektraAddWarningfC03100(Key *warningKey, const char *reason,
    1604             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1605          23 : static inline void elektraAddWarningfC03100(Key *warningKey, const char *reason,
    1606             :         const char *file, const char *line, const char *module, ...)
    1607             : {
    1608          23 :         if (!warningKey) return;
    1609             : 
    1610          23 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1611          23 :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1612          23 :         if (meta)
    1613             :         {
    1614           6 :                 buffer[10] = keyString(meta)[0];
    1615           6 :                 buffer[11] = keyString(meta)[1];
    1616           6 :                 buffer[11]++;
    1617           6 :                 if (buffer[11] > '9')
    1618             :                 {
    1619           0 :                         buffer[11] = '0';
    1620           0 :                         buffer[10]++;
    1621           0 :                         if (buffer[10] > '9') buffer[10] = '0';
    1622             :                 }
    1623           6 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1624          17 :         } else  keySetMeta(warningKey, "warnings", "00");
    1625             : 
    1626          23 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1627          23 :         strcat(buffer, "/number" );
    1628          23 :         keySetMeta(warningKey, buffer, "C03100");
    1629          23 :         buffer[12] = '\0'; strcat(buffer, "/description");
    1630          23 :         keySetMeta(warningKey, buffer, "Validation Syntactic");
    1631          23 :         buffer[12] = '\0'; strcat(buffer, "/module");
    1632          23 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1633          23 :         keySetMeta(warningKey, buffer, module);
    1634          23 :         buffer[12] = '\0'; strcat(buffer, "/file");
    1635          23 :         keySetMeta(warningKey, buffer, file);
    1636          23 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1637          23 :         keySetMeta(warningKey, buffer, line);
    1638          23 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1639          23 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1640          23 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1641          23 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1642          23 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1643             :         va_list arg;
    1644          23 :         va_start(arg, module);
    1645          23 :         char * r = elektraVFormat(reason, arg);
    1646          23 :         keySetMeta(warningKey, buffer, r);
    1647          23 :         elektraFree(r);
    1648          23 :         va_end(arg);
    1649             : }
    1650             : 
    1651           0 : static inline void elektraAddWarningC03100(Key *warningKey, const char *reason,
    1652             :         const char *file, const char *line, const char *module)
    1653             : {
    1654           0 :         if (!warningKey) return;
    1655             : 
    1656           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1657           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1658           0 :         if (meta)
    1659             :         {
    1660           0 :                 buffer[10] = keyString(meta)[0];
    1661           0 :                 buffer[11] = keyString(meta)[1];
    1662           0 :                 buffer[11]++;
    1663           0 :                 if (buffer[11] > '9')
    1664             :                 {
    1665           0 :                         buffer[11] = '0';
    1666           0 :                         buffer[10]++;
    1667           0 :                         if (buffer[10] > '9') buffer[10] = '0';
    1668             :                 }
    1669           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1670           0 :         } else  keySetMeta(warningKey, "warnings", "00");
    1671             : 
    1672           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1673           0 :         strcat(buffer, "/number" );
    1674           0 :         keySetMeta(warningKey, buffer, "C03100");
    1675           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
    1676           0 :         keySetMeta(warningKey, buffer, "Validation Syntactic");
    1677           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
    1678           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1679           0 :         keySetMeta(warningKey, buffer, module);
    1680           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
    1681           0 :         keySetMeta(warningKey, buffer, file);
    1682           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1683           0 :         keySetMeta(warningKey, buffer, line);
    1684           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1685           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1686           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1687           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1688           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1689           0 :         keySetMeta(warningKey, buffer, reason);
    1690             : }
    1691             : 
    1692             : static inline void elektraSetErrorfC03100(Key *errorKey, const char *reason,
    1693             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1694         125 : static inline void elektraSetErrorfC03100(Key *errorKey, const char *reason,
    1695             :         const char *file, const char *line, const char *module, ...)
    1696             : {
    1697         125 :         if (!errorKey) return;
    1698         125 :         char buffer[25] = "warnings/#00";
    1699         125 :         const Key *meta = keyGetMeta(errorKey, "error");
    1700         125 :         if (meta)
    1701             :         {
    1702          22 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1703          22 :                 if (warningMeta)
    1704             :                 {
    1705           0 :                         buffer[10] = keyString(warningMeta)[0];
    1706           0 :                         buffer[11] = keyString(warningMeta)[1];
    1707           0 :                         buffer[11]++;
    1708           0 :                         if (buffer[11] > '9')
    1709             :                         {
    1710           0 :                                 buffer[11] = '0';
    1711           0 :                                 buffer[10]++;
    1712           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1713             :                         }
    1714           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1715          22 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1716          22 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1717          22 :                 strcat(buffer, "/number" );
    1718          22 :                 keySetMeta(errorKey, buffer, "C03100");
    1719          22 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1720          22 :                 keySetMeta(errorKey, buffer, "Validation Syntactic");
    1721          22 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1722          22 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1723          22 :                 keySetMeta(errorKey, buffer, module);
    1724          22 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1725          22 :                 keySetMeta(errorKey, buffer, file);
    1726          22 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1727          22 :                 keySetMeta(errorKey, buffer, line);
    1728          22 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1729          22 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1730          22 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1731          22 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1732          22 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1733             :         }
    1734             :         else
    1735             :         {
    1736         103 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1737         103 :                 keySetMeta(errorKey, "error/number", "C03100");
    1738         103 :                 keySetMeta(errorKey, "error/description", "Validation Syntactic");
    1739         103 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1740         103 :                 keySetMeta(errorKey, "error/module", module);
    1741         103 :                 keySetMeta(errorKey, "error/file", file);
    1742         103 :                 keySetMeta(errorKey, "error/line", line);
    1743         103 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1744         103 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1745             :         }
    1746             :         va_list arg;
    1747         125 :         va_start(arg, module);
    1748         125 :         char * r = elektraVFormat(reason, arg);
    1749         125 :         if (meta)
    1750          22 :                         keySetMeta(errorKey, buffer, r);
    1751             :         else
    1752         103 :                         keySetMeta(errorKey, "error/reason", r);
    1753         125 :         elektraFree(r);
    1754         125 :         va_end(arg);
    1755             : }
    1756             : 
    1757          28 : static inline void elektraSetErrorC03100(Key *errorKey, const char *reason,
    1758             :         const char *file, const char *line, const char *module)
    1759             : {
    1760          28 :         if (!errorKey) return;
    1761          28 :         char buffer[25] = "warnings/#00";
    1762          28 :         const Key *meta = keyGetMeta(errorKey, "error");
    1763          28 :         if (meta)
    1764             :         {
    1765           1 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1766           1 :                 if (warningMeta)
    1767             :                 {
    1768           0 :                         buffer[10] = keyString(warningMeta)[0];
    1769           0 :                         buffer[11] = keyString(warningMeta)[1];
    1770           0 :                         buffer[11]++;
    1771           0 :                         if (buffer[11] > '9')
    1772             :                         {
    1773           0 :                                 buffer[11] = '0';
    1774           0 :                                 buffer[10]++;
    1775           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1776             :                         }
    1777           0 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1778           1 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1779           1 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1780           1 :                 strcat(buffer, "/number" );
    1781           1 :                 keySetMeta(errorKey, buffer, "C03100");
    1782           1 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1783           1 :                 keySetMeta(errorKey, buffer, "Validation Syntactic");
    1784           1 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1785           1 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1786           1 :                 keySetMeta(errorKey, buffer, module);
    1787           1 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1788           1 :                 keySetMeta(errorKey, buffer, file);
    1789           1 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1790           1 :                 keySetMeta(errorKey, buffer, line);
    1791           1 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1792           1 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1793           1 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1794           1 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1795           1 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1796             :         }
    1797             :         else
    1798             :         {
    1799          27 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1800          27 :                 keySetMeta(errorKey, "error/number", "C03100");
    1801          27 :                 keySetMeta(errorKey, "error/description", "Validation Syntactic");
    1802          27 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1803          27 :                 keySetMeta(errorKey, "error/module", module);
    1804          27 :                 keySetMeta(errorKey, "error/file", file);
    1805          27 :                 keySetMeta(errorKey, "error/line", line);
    1806          27 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1807          27 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1808             :         }
    1809          28 :         if (meta)
    1810           1 :                         keySetMeta(errorKey, buffer, reason);
    1811             :         else
    1812          27 :                         keySetMeta(errorKey, "error/reason", reason);
    1813             : }
    1814             : 
    1815             : static inline void elektraAddWarningfC03200(Key *warningKey, const char *reason,
    1816             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1817           0 : static inline void elektraAddWarningfC03200(Key *warningKey, const char *reason,
    1818             :         const char *file, const char *line, const char *module, ...)
    1819             : {
    1820           0 :         if (!warningKey) return;
    1821             : 
    1822           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1823           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1824           0 :         if (meta)
    1825             :         {
    1826           0 :                 buffer[10] = keyString(meta)[0];
    1827           0 :                 buffer[11] = keyString(meta)[1];
    1828           0 :                 buffer[11]++;
    1829           0 :                 if (buffer[11] > '9')
    1830             :                 {
    1831           0 :                         buffer[11] = '0';
    1832           0 :                         buffer[10]++;
    1833           0 :                         if (buffer[10] > '9') buffer[10] = '0';
    1834             :                 }
    1835           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1836           0 :         } else  keySetMeta(warningKey, "warnings", "00");
    1837             : 
    1838           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1839           0 :         strcat(buffer, "/number" );
    1840           0 :         keySetMeta(warningKey, buffer, "C03200");
    1841           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
    1842           0 :         keySetMeta(warningKey, buffer, "Validation Semantic");
    1843           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
    1844           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1845           0 :         keySetMeta(warningKey, buffer, module);
    1846           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
    1847           0 :         keySetMeta(warningKey, buffer, file);
    1848           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1849           0 :         keySetMeta(warningKey, buffer, line);
    1850           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1851           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1852           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1853           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1854           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1855             :         va_list arg;
    1856           0 :         va_start(arg, module);
    1857           0 :         char * r = elektraVFormat(reason, arg);
    1858           0 :         keySetMeta(warningKey, buffer, r);
    1859           0 :         elektraFree(r);
    1860           0 :         va_end(arg);
    1861             : }
    1862             : 
    1863           0 : static inline void elektraAddWarningC03200(Key *warningKey, const char *reason,
    1864             :         const char *file, const char *line, const char *module)
    1865             : {
    1866           0 :         if (!warningKey) return;
    1867             : 
    1868           0 :         char buffer[25] = "warnings/#00";buffer[12] = '\0';
    1869           0 :         const Key *meta = keyGetMeta(warningKey, "warnings");
    1870           0 :         if (meta)
    1871             :         {
    1872           0 :                 buffer[10] = keyString(meta)[0];
    1873           0 :                 buffer[11] = keyString(meta)[1];
    1874           0 :                 buffer[11]++;
    1875           0 :                 if (buffer[11] > '9')
    1876             :                 {
    1877           0 :                         buffer[11] = '0';
    1878           0 :                         buffer[10]++;
    1879           0 :                         if (buffer[10] > '9') buffer[10] = '0';
    1880             :                 }
    1881           0 :                 keySetMeta(warningKey, "warnings", &buffer[10]);
    1882           0 :         } else  keySetMeta(warningKey, "warnings", "00");
    1883             : 
    1884           0 :         keySetMeta(warningKey, buffer, "number description  module file line function reason");
    1885           0 :         strcat(buffer, "/number" );
    1886           0 :         keySetMeta(warningKey, buffer, "C03200");
    1887           0 :         buffer[12] = '\0'; strcat(buffer, "/description");
    1888           0 :         keySetMeta(warningKey, buffer, "Validation Semantic");
    1889           0 :         buffer[12] = '\0'; strcat(buffer, "/module");
    1890           0 :         if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1891           0 :         keySetMeta(warningKey, buffer, module);
    1892           0 :         buffer[12] = '\0'; strcat(buffer, "/file");
    1893           0 :         keySetMeta(warningKey, buffer, file);
    1894           0 :         buffer[12] = '\0'; strcat(buffer, "/line");
    1895           0 :         keySetMeta(warningKey, buffer, line);
    1896           0 :         buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1897           0 :         keySetMeta(warningKey, buffer, keyName(warningKey));
    1898           0 :         buffer[12] = '\0'; strcat(buffer, "/configfile");
    1899           0 :         keySetMeta(warningKey, buffer, keyString(warningKey));
    1900           0 :         buffer[12] = '\0'; strcat(buffer, "/reason");
    1901           0 :         keySetMeta(warningKey, buffer, reason);
    1902             : }
    1903             : 
    1904             : static inline void elektraSetErrorfC03200(Key *errorKey, const char *reason,
    1905             :         const char *file, const char *line, const char *module, ...)  __attribute__ ((format (printf, 2, 6)));
    1906         347 : static inline void elektraSetErrorfC03200(Key *errorKey, const char *reason,
    1907             :         const char *file, const char *line, const char *module, ...)
    1908             : {
    1909         347 :         if (!errorKey) return;
    1910         347 :         char buffer[25] = "warnings/#00";
    1911         347 :         const Key *meta = keyGetMeta(errorKey, "error");
    1912         347 :         if (meta)
    1913             :         {
    1914         160 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1915         160 :                 if (warningMeta)
    1916             :                 {
    1917         146 :                         buffer[10] = keyString(warningMeta)[0];
    1918         146 :                         buffer[11] = keyString(warningMeta)[1];
    1919         146 :                         buffer[11]++;
    1920         146 :                         if (buffer[11] > '9')
    1921             :                         {
    1922          12 :                                 buffer[11] = '0';
    1923          12 :                                 buffer[10]++;
    1924          12 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1925             :                         }
    1926         146 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1927          14 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1928         160 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1929         160 :                 strcat(buffer, "/number" );
    1930         160 :                 keySetMeta(errorKey, buffer, "C03200");
    1931         160 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1932         160 :                 keySetMeta(errorKey, buffer, "Validation Semantic");
    1933         160 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1934         160 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1935         160 :                 keySetMeta(errorKey, buffer, module);
    1936         160 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    1937         160 :                 keySetMeta(errorKey, buffer, file);
    1938         160 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    1939         160 :                 keySetMeta(errorKey, buffer, line);
    1940         160 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    1941         160 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    1942         160 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    1943         160 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    1944         160 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    1945             :         }
    1946             :         else
    1947             :         {
    1948         187 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    1949         187 :                 keySetMeta(errorKey, "error/number", "C03200");
    1950         187 :                 keySetMeta(errorKey, "error/description", "Validation Semantic");
    1951         187 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1952         187 :                 keySetMeta(errorKey, "error/module", module);
    1953         187 :                 keySetMeta(errorKey, "error/file", file);
    1954         187 :                 keySetMeta(errorKey, "error/line", line);
    1955         187 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    1956         187 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    1957             :         }
    1958             :         va_list arg;
    1959         347 :         va_start(arg, module);
    1960         347 :         char * r = elektraVFormat(reason, arg);
    1961         347 :         if (meta)
    1962         160 :                         keySetMeta(errorKey, buffer, r);
    1963             :         else
    1964         187 :                         keySetMeta(errorKey, "error/reason", r);
    1965         347 :         elektraFree(r);
    1966         347 :         va_end(arg);
    1967             : }
    1968             : 
    1969         669 : static inline void elektraSetErrorC03200(Key *errorKey, const char *reason,
    1970             :         const char *file, const char *line, const char *module)
    1971             : {
    1972         669 :         if (!errorKey) return;
    1973         669 :         char buffer[25] = "warnings/#00";
    1974         669 :         const Key *meta = keyGetMeta(errorKey, "error");
    1975         669 :         if (meta)
    1976             :         {
    1977           6 :                 const Key *warningMeta = keyGetMeta(errorKey, "warnings");
    1978           6 :                 if (warningMeta)
    1979             :                 {
    1980           4 :                         buffer[10] = keyString(warningMeta)[0];
    1981           4 :                         buffer[11] = keyString(warningMeta)[1];
    1982           4 :                         buffer[11]++;
    1983           4 :                         if (buffer[11] > '9')
    1984             :                         {
    1985           0 :                                 buffer[11] = '0';
    1986           0 :                                 buffer[10]++;
    1987           0 :                                 if (buffer[10] > '9') buffer[10] = '0';
    1988             :                         }
    1989           4 :                         keySetMeta(errorKey, "warnings", &buffer[10]);
    1990           2 :                 } else  keySetMeta(errorKey, "warnings", "00");
    1991           6 :                 keySetMeta(errorKey, buffer, "number description  module file line function reason");
    1992           6 :                 strcat(buffer, "/number" );
    1993           6 :                 keySetMeta(errorKey, buffer, "C03200");
    1994           6 :                 buffer[12] = '\0'; strcat(buffer, "/description");
    1995           6 :                 keySetMeta(errorKey, buffer, "Validation Semantic");
    1996           6 :                 buffer[12] = '\0'; strcat(buffer, "/module");
    1997           6 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    1998           6 :                 keySetMeta(errorKey, buffer, module);
    1999           6 :                 buffer[12] = '\0'; strcat(buffer, "/file");
    2000           6 :                 keySetMeta(errorKey, buffer, file);
    2001           6 :                 buffer[12] = '\0'; strcat(buffer, "/line");
    2002           6 :                 keySetMeta(errorKey, buffer, line);
    2003           6 :                 buffer[12] = '\0'; strcat(buffer, "/mountpoint");
    2004           6 :                 keySetMeta(errorKey, buffer, keyName(errorKey));
    2005           6 :                 buffer[12] = '\0'; strcat(buffer, "/configfile");
    2006           6 :                 keySetMeta(errorKey, buffer, keyString(errorKey));
    2007           6 :                 buffer[12] = '\0'; strcat(buffer, "/reason");
    2008             :         }
    2009             :         else
    2010             :         {
    2011         663 :                 keySetMeta(errorKey, "error", "number description  module file line function reason");
    2012         663 :                 keySetMeta(errorKey, "error/number", "C03200");
    2013         663 :                 keySetMeta(errorKey, "error/description", "Validation Semantic");
    2014         663 :                 if (strcmp(module, "ELEKTRA_MODULE_NAME") == 0) module = "kdb";
    2015         663 :                 keySetMeta(errorKey, "error/module", module);
    2016         663 :                 keySetMeta(errorKey, "error/file", file);
    2017         663 :                 keySetMeta(errorKey, "error/line", line);
    2018         663 :                 keySetMeta(errorKey, "error/mountpoint", keyName(errorKey));
    2019         663 :                 keySetMeta(errorKey, "error/configfile", keyString(errorKey));
    2020             :         }
    2021         669 :         if (meta)
    2022           6 :                         keySetMeta(errorKey, buffer, reason);
    2023             :         else
    2024         663 :                         keySetMeta(errorKey, "error/reason", reason);
    2025             : }
    2026             : 
    2027         308 : static inline KeySet *elektraErrorSpecification (void)
    2028             : {
    2029         308 :         return ksNew (30,
    2030             :                 keyNew ("system/elektra/modules/error/specification",
    2031             :                         KEY_VALUE, "the specification of all error codes", KEY_END),
    2032             :                 keyNew ("system/elektra/modules/error/specification/C01100",
    2033             :                         KEY_END),
    2034             :                 keyNew ("system/elektra/modules/error/specification/C01100/description",
    2035             :                         KEY_VALUE, "Resource", KEY_END),
    2036             :                 keyNew ("system/elektra/modules/error/specification/C01110",
    2037             :                         KEY_END),
    2038             :                 keyNew ("system/elektra/modules/error/specification/C01110/description",
    2039             :                         KEY_VALUE, "Out of Memory", KEY_END),
    2040             :                 keyNew ("system/elektra/modules/error/specification/C01200",
    2041             :                         KEY_END),
    2042             :                 keyNew ("system/elektra/modules/error/specification/C01200/description",
    2043             :                         KEY_VALUE, "Installation", KEY_END),
    2044             :                 keyNew ("system/elektra/modules/error/specification/C01310",
    2045             :                         KEY_END),
    2046             :                 keyNew ("system/elektra/modules/error/specification/C01310/description",
    2047             :                         KEY_VALUE, "Internal", KEY_END),
    2048             :                 keyNew ("system/elektra/modules/error/specification/C01320",
    2049             :                         KEY_END),
    2050             :                 keyNew ("system/elektra/modules/error/specification/C01320/description",
    2051             :                         KEY_VALUE, "Interface", KEY_END),
    2052             :                 keyNew ("system/elektra/modules/error/specification/C01330",
    2053             :                         KEY_END),
    2054             :                 keyNew ("system/elektra/modules/error/specification/C01330/description",
    2055             :                         KEY_VALUE, "Plugin Misbehavior", KEY_END),
    2056             :                 keyNew ("system/elektra/modules/error/specification/C02000",
    2057             :                         KEY_END),
    2058             :                 keyNew ("system/elektra/modules/error/specification/C02000/description",
    2059             :                         KEY_VALUE, "Conflict", KEY_END),
    2060             :                 keyNew ("system/elektra/modules/error/specification/C03100",
    2061             :                         KEY_END),
    2062             :                 keyNew ("system/elektra/modules/error/specification/C03100/description",
    2063             :                         KEY_VALUE, "Validation Syntactic", KEY_END),
    2064             :                 keyNew ("system/elektra/modules/error/specification/C03200",
    2065             :                         KEY_END),
    2066             :                 keyNew ("system/elektra/modules/error/specification/C03200/description",
    2067             :                         KEY_VALUE, "Validation Semantic", KEY_END),
    2068             :                 KS_END);
    2069             : }
    2070          12 : static inline void elektraTriggerWarnings (const char *nr, Key *parentKey, const char *message)
    2071             : {
    2072          12 :         if (strcmp(nr, "C01100") == 0)
    2073             :         {
    2074           0 :                 ELEKTRA_ADD_RESOURCE_WARNING (parentKey, message);
    2075           0 :                 return;
    2076             :         }
    2077          12 :         if (strcmp(nr, "C01110") == 0)
    2078             :         {
    2079           0 :                 ELEKTRA_ADD_OUT_OF_MEMORY_WARNING (parentKey, message);
    2080           0 :                 return;
    2081             :         }
    2082          12 :         if (strcmp(nr, "C01200") == 0)
    2083             :         {
    2084           0 :                 ELEKTRA_ADD_INSTALLATION_WARNING (parentKey, message);
    2085           0 :                 return;
    2086             :         }
    2087          12 :         if (strcmp(nr, "C01310") == 0)
    2088             :         {
    2089           0 :                 ELEKTRA_ADD_INTERNAL_WARNING (parentKey, message);
    2090           0 :                 return;
    2091             :         }
    2092          12 :         if (strcmp(nr, "C01320") == 0)
    2093             :         {
    2094           0 :                 ELEKTRA_ADD_INTERFACE_WARNING (parentKey, message);
    2095           0 :                 return;
    2096             :         }
    2097          12 :         if (strcmp(nr, "C01330") == 0)
    2098             :         {
    2099           0 :                 ELEKTRA_ADD_PLUGIN_MISBEHAVIOR_WARNING (parentKey, message);
    2100           0 :                 return;
    2101             :         }
    2102          12 :         if (strcmp(nr, "C02000") == 0)
    2103             :         {
    2104           0 :                 ELEKTRA_ADD_CONFLICTING_STATE_WARNING (parentKey, message);
    2105           0 :                 return;
    2106             :         }
    2107          12 :         if (strcmp(nr, "C03100") == 0)
    2108             :         {
    2109           0 :                 ELEKTRA_ADD_VALIDATION_SYNTACTIC_WARNING (parentKey, message);
    2110           0 :                 return;
    2111             :         }
    2112          12 :         if (strcmp(nr, "C03200") == 0)
    2113             :         {
    2114           0 :                 ELEKTRA_ADD_VALIDATION_SEMANTIC_WARNING (parentKey, message);
    2115           0 :                 return;
    2116             :         }
    2117          12 :         ELEKTRA_ADD_INTERNAL_WARNINGF (parentKey, "Unkown warning code %s", nr);
    2118             : }
    2119             : 
    2120          41 : static inline void elektraTriggerError (const char *nr, Key *parentKey, const char *message)
    2121             : {
    2122          41 :         if (strcmp(nr, "C01100") == 0)
    2123             :         {
    2124           2 :                 ELEKTRA_SET_RESOURCE_ERROR (parentKey, message);
    2125           2 :                 return;
    2126             :         }
    2127          39 :         if (strcmp(nr, "C01110") == 0)
    2128             :         {
    2129           6 :                 ELEKTRA_SET_OUT_OF_MEMORY_ERROR (parentKey, message);
    2130           6 :                 return;
    2131             :         }
    2132          33 :         if (strcmp(nr, "C01200") == 0)
    2133             :         {
    2134           2 :                 ELEKTRA_SET_INSTALLATION_ERROR (parentKey, message);
    2135           2 :                 return;
    2136             :         }
    2137          31 :         if (strcmp(nr, "C01310") == 0)
    2138             :         {
    2139          14 :                 ELEKTRA_SET_INTERNAL_ERROR (parentKey, message);
    2140          14 :                 return;
    2141             :         }
    2142          17 :         if (strcmp(nr, "C01320") == 0)
    2143             :         {
    2144           2 :                 ELEKTRA_SET_INTERFACE_ERROR (parentKey, message);
    2145           2 :                 return;
    2146             :         }
    2147          15 :         if (strcmp(nr, "C01330") == 0)
    2148             :         {
    2149           2 :                 ELEKTRA_SET_PLUGIN_MISBEHAVIOR_ERROR (parentKey, message);
    2150           2 :                 return;
    2151             :         }
    2152          13 :         if (strcmp(nr, "C02000") == 0)
    2153             :         {
    2154           2 :                 ELEKTRA_SET_CONFLICTING_STATE_ERROR (parentKey, message);
    2155           2 :                 return;
    2156             :         }
    2157          11 :         if (strcmp(nr, "C03100") == 0)
    2158             :         {
    2159           4 :                 ELEKTRA_SET_VALIDATION_SYNTACTIC_ERROR (parentKey, message);
    2160           4 :                 return;
    2161             :         }
    2162           7 :         if (strcmp(nr, "C03200") == 0)
    2163             :         {
    2164           3 :                 ELEKTRA_SET_VALIDATION_SEMANTIC_ERROR (parentKey, message);
    2165           3 :                 return;
    2166             :         }
    2167           4 :         ELEKTRA_SET_INTERNAL_ERRORF (parentKey, "Unkown error code %s", nr);
    2168             : }
    2169             : #endif

Generated by: LCOV version 1.13