blob: d5209c5730484ba50ae61d54fe63d95e4e09feca [file] [log] [blame]
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001/**
2 * @file common.h
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief common internal definitions for libyang
5 *
6 * Copyright (c) 2015 - 2018 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
15#ifndef LY_COMMON_H_
16#define LY_COMMON_H_
17
Radek Krejci6caa6ab2018-10-24 10:04:48 +020018#include <pthread.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020019#include <stddef.h>
Radek Krejci5aeea3a2018-09-05 13:29:36 +020020#include <stdint.h>
Radek Krejci5aeea3a2018-09-05 13:29:36 +020021
Radek Krejcid33273d2018-10-25 14:55:52 +020022#include "context.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020023#include "dict.h"
Radek Krejci6caa6ab2018-10-24 10:04:48 +020024#include "hash_table.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020025#include "log.h"
26#include "set.h"
Radek Krejcic4fa0292020-05-14 10:54:49 +020027#include "tree.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020028#include "tree_data.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020029
30struct ly_ctx;
Radek Krejci535ea9f2020-05-29 16:01:05 +020031struct lys_module;
Radek Krejci5aeea3a2018-09-05 13:29:36 +020032
33#if __STDC_VERSION__ >= 201112 && !defined __STDC_NO_THREADS__
34# define THREAD_LOCAL _Thread_local
35#elif defined __GNUC__ || \
Radek Krejci0f969882020-08-21 16:56:47 +020036 defined __SUNPRO_C || \
37 defined __xlC__
Radek Krejci5aeea3a2018-09-05 13:29:36 +020038# define THREAD_LOCAL __thread
39#else
40# error "Cannot define THREAD_LOCAL"
41#endif
42
Radek Krejcic59bc972018-09-17 16:13:06 +020043#define GETMACRO1(_1, NAME, ...) NAME
Radek Krejci5aeea3a2018-09-05 13:29:36 +020044#define GETMACRO2(_1, _2, NAME, ...) NAME
45#define GETMACRO3(_1, _2, _3, NAME, ...) NAME
46#define GETMACRO4(_1, _2, _3, _4, NAME, ...) NAME
Michal Vaskodc779a82019-11-06 15:44:06 +010047#define GETMACRO5(_1, _2, _3, _4, _5, NAME, ...) NAME
Radek Krejci5aeea3a2018-09-05 13:29:36 +020048
49/*
Radek Krejcic59bc972018-09-17 16:13:06 +020050 * If the compiler supports attribute to mark objects as hidden, mark all
51 * objects as hidden and export only objects explicitly marked to be part of
52 * the public API.
Radek Krejci5aeea3a2018-09-05 13:29:36 +020053 */
Radek Krejcic59bc972018-09-17 16:13:06 +020054#define API __attribute__((visibility("default")))
55
56/******************************************************************************
57 * Logger
58 *****************************************************************************/
Radek Krejci5aeea3a2018-09-05 13:29:36 +020059
Radek Krejci94aa9942018-09-07 17:12:17 +020060enum LY_VLOG_ELEM {
61 LY_VLOG_NONE = 0,
Michal Vaskof6e51882019-12-16 09:59:45 +010062 LY_VLOG_LINE, /* line number (uint64_t*) */
63 LY_VLOG_LYSC, /* struct lysc_node* */
64 LY_VLOG_LYD, /* struct lyd_node* */
65 LY_VLOG_STR, /* const char* */
66 LY_VLOG_PREV /* use exact same previous path */
Radek Krejci94aa9942018-09-07 17:12:17 +020067};
68
Radek Krejci5aeea3a2018-09-05 13:29:36 +020069extern THREAD_LOCAL enum int_log_opts log_opt;
Radek Krejci52b6d512020-10-12 12:33:17 +020070extern volatile LY_LOG_LEVEL ly_ll;
Radek Krejci1deb5be2020-08-26 16:43:36 +020071extern volatile uint32_t ly_log_opts;
Radek Krejci5aeea3a2018-09-05 13:29:36 +020072
Radek Krejcie7b95092019-05-15 11:03:07 +020073/**
Radek Krejcie7b95092019-05-15 11:03:07 +020074 * @brief Print a log message and store it into the context (if provided).
75 *
76 * @param[in] ctx libyang context to store the error record. If not provided, the error is just printed.
77 * @param[in] level Log message level (error, warning, etc.)
78 * @param[in] no Error type code.
79 * @param[in] format Format string to print.
80 */
Radek Krejci5aeea3a2018-09-05 13:29:36 +020081void ly_log(const struct ly_ctx *ctx, LY_LOG_LEVEL level, LY_ERR no, const char *format, ...);
Radek Krejcie7b95092019-05-15 11:03:07 +020082
83/**
84 * @brief Print Validation error and store it into the context (if provided).
85 *
86 * @param[in] ctx libyang context to store the error record. If not provided, the error is just printed.
87 * @param[in] elem_type Type of the data in @p elem variable.
88 * @param[in] elem Object to provide more information about the place where the error appeared.
89 * @param[in] code Validation error code.
90 * @param[in] format Format string to print.
91 */
Radek Krejci94aa9942018-09-07 17:12:17 +020092void ly_vlog(const struct ly_ctx *ctx, enum LY_VLOG_ELEM elem_type, const void *elem, LY_VECODE code, const char *format, ...);
Radek Krejci5aeea3a2018-09-05 13:29:36 +020093
Radek Krejcic0c66412020-08-21 13:53:50 +020094#define LOGERR(ctx, errno, str, ...) ly_log(ctx, LY_LLERR, errno, str, ##__VA_ARGS__)
Radek Krejcif3f47842018-11-15 11:22:15 +010095#define LOGWRN(ctx, str, ...) ly_log(ctx, LY_LLWRN, 0, str, ##__VA_ARGS__)
Radek Krejcic0c66412020-08-21 13:53:50 +020096#define LOGVRB(str, ...) ly_log(NULL, LY_LLVRB, 0, str, ##__VA_ARGS__)
Radek Krejci5aeea3a2018-09-05 13:29:36 +020097
Radek Krejci4ab61562018-09-05 15:00:37 +020098#ifdef NDEBUG
Radek Krejcic0c66412020-08-21 13:53:50 +020099# define LOGDBG(dbg_group, str, ...)
Radek Krejci4ab61562018-09-05 15:00:37 +0200100#else
Radek Krejci1deb5be2020-08-26 16:43:36 +0200101void ly_log_dbg(uint32_t group, const char *format, ...);
Radek Krejcic0c66412020-08-21 13:53:50 +0200102# define LOGDBG(dbg_group, str, ...) ly_log_dbg(dbg_group, str, ##__VA_ARGS__);
Radek Krejci4ab61562018-09-05 15:00:37 +0200103#endif
104
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200105#define LOGMEM(CTX) LOGERR(CTX, LY_EMEM, "Memory allocation failed (%s()).", __func__)
106#define LOGINT(CTX) LOGERR(CTX, LY_EINT, "Internal error (%s:%d).", __FILE__, __LINE__)
107#define LOGARG(CTX, ARG) LOGERR(CTX, LY_EINVAL, "Invalid argument %s (%s()).", #ARG, __func__)
Radek Krejcic0c66412020-08-21 13:53:50 +0200108#define LOGVAL(CTX, ELEM_TYPE, ELEM, CODE, ...) ly_vlog(CTX, ELEM_TYPE, ELEM, CODE, ##__VA_ARGS__)
Radek Krejci94aa9942018-09-07 17:12:17 +0200109
110#define LOGMEM_RET(CTX) LOGMEM(CTX); return LY_EMEM
111#define LOGINT_RET(CTX) LOGINT(CTX); return LY_EINT
112#define LOGARG_RET(CTX) LOGARG(CTX); return LY_EINVAL
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200113
114/*
115 * Common code to check return value and perform appropriate action.
116 */
Radek Krejcie88beef2019-05-30 15:47:19 +0200117#define LY_CHECK_GOTO(COND, GOTO) if ((COND)) {goto GOTO;}
118#define LY_CHECK_ERR_GOTO(COND, ERR, GOTO) if ((COND)) {ERR; goto GOTO;}
Radek Krejci6d9b9b52018-11-02 12:43:39 +0100119#define LY_CHECK_RET1(RETVAL) {LY_ERR ret__ = RETVAL;if (ret__ != LY_SUCCESS) {return ret__;}}
Radek Krejcie88beef2019-05-30 15:47:19 +0200120#define LY_CHECK_RET2(COND, RETVAL) if ((COND)) {return RETVAL;}
Radek Krejcic59bc972018-09-17 16:13:06 +0200121#define LY_CHECK_RET(...) GETMACRO2(__VA_ARGS__, LY_CHECK_RET2, LY_CHECK_RET1)(__VA_ARGS__)
Radek Krejcie88beef2019-05-30 15:47:19 +0200122#define LY_CHECK_ERR_RET(COND, ERR, RETVAL) if ((COND)) {ERR; return RETVAL;}
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200123
Radek Krejcia3045382018-11-22 14:30:31 +0100124#define LY_CHECK_ARG_GOTO1(CTX, ARG, GOTO) if (!(ARG)) {LOGARG(CTX, ARG);goto GOTO;}
Michal Vaskob3d0d6b2018-09-07 10:17:33 +0200125#define LY_CHECK_ARG_GOTO2(CTX, ARG1, ARG2, GOTO) LY_CHECK_ARG_GOTO1(CTX, ARG1, GOTO);LY_CHECK_ARG_GOTO1(CTX, ARG2, GOTO)
126#define LY_CHECK_ARG_GOTO3(CTX, ARG1, ARG2, ARG3, GOTO) LY_CHECK_ARG_GOTO2(CTX, ARG1, ARG2, GOTO);LY_CHECK_ARG_GOTO1(CTX, ARG3, GOTO)
Michal Vaskodc779a82019-11-06 15:44:06 +0100127#define LY_CHECK_ARG_GOTO4(CTX, ARG1, ARG2, ARG3, ARG4, GOTO) LY_CHECK_ARG_GOTO3(CTX, ARG1, ARG2, ARG3, GOTO);\
128 LY_CHECK_ARG_GOTO1(CTX, ARG4, GOTO)
129#define LY_CHECK_ARG_GOTO(CTX, ...) GETMACRO5(__VA_ARGS__, LY_CHECK_ARG_GOTO4, LY_CHECK_ARG_GOTO3, LY_CHECK_ARG_GOTO2, \
130 LY_CHECK_ARG_GOTO1)(CTX, __VA_ARGS__)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200131
Radek Krejcia3045382018-11-22 14:30:31 +0100132#define LY_CHECK_ARG_RET1(CTX, ARG, RETVAL) if (!(ARG)) {LOGARG(CTX, ARG);return RETVAL;}
Michal Vaskob3d0d6b2018-09-07 10:17:33 +0200133#define LY_CHECK_ARG_RET2(CTX, ARG1, ARG2, RETVAL) LY_CHECK_ARG_RET1(CTX, ARG1, RETVAL);LY_CHECK_ARG_RET1(CTX, ARG2, RETVAL)
134#define LY_CHECK_ARG_RET3(CTX, ARG1, ARG2, ARG3, RETVAL) LY_CHECK_ARG_RET2(CTX, ARG1, ARG2, RETVAL);LY_CHECK_ARG_RET1(CTX, ARG3, RETVAL)
Michal Vaskodc779a82019-11-06 15:44:06 +0100135#define LY_CHECK_ARG_RET4(CTX, ARG1, ARG2, ARG3, ARG4, RETVAL) LY_CHECK_ARG_RET3(CTX, ARG1, ARG2, ARG3, RETVAL);\
136 LY_CHECK_ARG_RET1(CTX, ARG4, RETVAL)
137#define LY_CHECK_ARG_RET(CTX, ...) GETMACRO5(__VA_ARGS__, LY_CHECK_ARG_RET4, LY_CHECK_ARG_RET3, LY_CHECK_ARG_RET2, LY_CHECK_ARG_RET1)\
138 (CTX, __VA_ARGS__)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200139
Radek Krejcid972c252018-09-25 13:23:39 +0200140/* count sequence size for LY_VCODE_INCHILDSTMT validation error code */
141size_t LY_VCODE_INSTREXP_len(const char *str);
142/* default maximum characters to print in LY_VCODE_INCHILDSTMT */
143#define LY_VCODE_INSTREXP_MAXLEN 20
144
Michal Vaskoecd62de2019-11-13 12:35:11 +0100145#define LY_VCODE_INCHAR LYVE_SYNTAX, "Invalid character 0x%x."
146#define LY_VCODE_INSTREXP LYVE_SYNTAX, "Invalid character sequence \"%.*s\", expected %s."
147#define LY_VCODE_EOF LYVE_SYNTAX, "Unexpected end-of-input."
148#define LY_VCODE_NTERM LYVE_SYNTAX, "%s not terminated."
149#define LY_VCODE_NSUPP LYVE_SYNTAX, "%s not supported."
150#define LY_VCODE_MOD_SUBOMD LYVE_SYNTAX, "Invalid keyword \"%s\", expected \"module\" or \"submodule\"."
151#define LY_VCODE_TRAILING_MOD LYVE_SYNTAX, "Trailing garbage \"%.*s%s\" after module, expected end-of-input."
David Sedlák1538a842019-08-08 15:38:51 +0200152#define LY_VCODE_TRAILING_SUBMOD LYVE_SYNTAX, "Trailing garbage \"%.*s%s\" after submodule, expected end-of-input."
153
Michal Vaskoecd62de2019-11-13 12:35:11 +0100154#define LY_VCODE_INVAL_MINMAX LYVE_SEMANTICS, "Invalid combination of min-elements and max-elements: min value %u is bigger than the max value %u."
155#define LY_VCODE_CIRC_WHEN LYVE_SEMANTICS, "When condition of \"%s\" includes a self-reference (referenced by when of \"%s\")."
Michal Vasko5c4e5892019-11-14 12:31:38 +0100156#define LY_VCODE_DUMMY_WHEN LYVE_SEMANTICS, "When condition of \"%s\" is accessing its own conditional node."
David Sedlák0c2bab92019-07-22 15:33:19 +0200157
Michal Vaskoecd62de2019-11-13 12:35:11 +0100158#define LY_VCODE_INSTMT LYVE_SYNTAX_YANG, "Invalid keyword \"%s\"."
159#define LY_VCODE_INCHILDSTMT LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s\"."
160#define LY_VCODE_INCHILDSTMT2 LYVE_SYNTAX_YANG, "Invalid keyword \"%s\" as a child of \"%s\" - the statement is allowed only in YANG 1.1 modules."
Radek Krejcia9026eb2018-12-12 16:04:47 +0100161#define LY_VCODE_INCHILDSTMSCOMB LYVE_SYNTAX_YANG, "Invalid combination of keywords \"%s\" and \"%s\" as substatements of \"%s\"."
Michal Vaskoecd62de2019-11-13 12:35:11 +0100162#define LY_VCODE_DUPSTMT LYVE_SYNTAX_YANG, "Duplicate keyword \"%s\"."
163#define LY_VCODE_DUPIDENT LYVE_SYNTAX_YANG, "Duplicate identifier \"%s\" of %s statement."
164#define LY_VCODE_INVAL LYVE_SYNTAX_YANG, "Invalid value \"%.*s\" of \"%s\"."
165#define LY_VCODE_MISSTMT LYVE_SYNTAX_YANG, "Missing mandatory keyword \"%s\" as a child of \"%s\"."
166#define LY_VCODE_MISSCHILDSTMT LYVE_SYNTAX_YANG, "Missing %s substatement for %s%s."
167#define LY_VCODE_INORD LYVE_SYNTAX_YANG, "Invalid keyword \"%s\", it cannot appear after \"%s\"."
168#define LY_VCODE_OOB LYVE_SYNTAX_YANG, "Value \"%.*s\" is out of \"%s\" bounds."
169#define LY_VCODE_INDEV LYVE_SYNTAX_YANG, "Deviate \"%s\" does not support keyword \"%s\"."
170#define LY_VCODE_INREGEXP LYVE_SYNTAX_YANG, "Regular expression \"%s\" is not valid (\"%s\": %s)."
David Sedlák0c2bab92019-07-22 15:33:19 +0200171
Michal Vaskoecd62de2019-11-13 12:35:11 +0100172#define LY_VCODE_INSUBELEM2 LYVE_SYNTAX_YIN, "Invalid sub-elemnt \"%s\" of \"%s\" element - this sub-element is allowed only in modules with version 1.1 or newer."
173#define LY_VCODE_INVAL_YIN LYVE_SYNTAX_YIN, "Invalid value \"%s\" of \"%s\" attribute in \"%s\" element."
174#define LY_VCODE_UNEXP_SUBELEM LYVE_SYNTAX_YIN, "Unexpected sub-element \"%.*s\" of \"%s\" element."
175#define LY_VCODE_INDEV_YIN LYVE_SYNTAX_YIN, "Deviate of this type doesn't allow \"%s\" as it's sub-element."
176#define LY_VCODE_INORDER_YIN LYVE_SYNTAX_YIN, "Invalid order of %s\'s sub-elements \"%s\" can't appear after \"%s\"."
177#define LY_VCODE_OOB_YIN LYVE_SYNTAX_YIN, "Value \"%s\" of \"%s\" attribute in \"%s\" element is out of bounds."
David Sedlák1538a842019-08-08 15:38:51 +0200178#define LY_VCODE_INCHILDSTMSCOMB_YIN LYVE_SYNTAX_YIN, "Invalid combination of sub-elemnts \"%s\" and \"%s\" in \"%s\" element."
Michal Vaskoecd62de2019-11-13 12:35:11 +0100179#define LY_VCODE_DUP_ATTR LYVE_SYNTAX_YIN, "Duplicit definition of \"%s\" attribute in \"%s\" element."
180#define LY_VCODE_UNEXP_ATTR LYVE_SYNTAX_YIN, "Unexpected attribute \"%.*s\" of \"%s\" element."
181#define LY_VCODE_MAND_SUBELEM LYVE_SYNTAX_YIN, "Missing mandatory sub-element \"%s\" of \"%s\" element."
182#define LY_VCODE_FIRT_SUBELEM LYVE_SYNTAX_YIN, "Sub-element \"%s\" of \"%s\" element must be defined as it's first sub-element."
183#define LY_VCODE_NAME_COL LYVE_SYNTAX_YIN, "Name collision between module and submodule of name \"%s\"."
184#define LY_VCODE_SUBELEM_REDEF LYVE_SYNTAX_YIN, "Redefinition of \"%s\" sub-element in \"%s\" element."
David Sedlák0c2bab92019-07-22 15:33:19 +0200185
Michal Vaskoecd62de2019-11-13 12:35:11 +0100186#define LY_VCODE_XP_EOE LYVE_XPATH, "Unterminated string delimited with %c (%.15s)."
187#define LY_VCODE_XP_INEXPR LYVE_XPATH, "Invalid character number %u of expression \'%s\'."
188#define LY_VCODE_XP_EOF LYVE_XPATH, "Unexpected XPath expression end."
Michal Vasko0b468e62020-10-19 09:33:04 +0200189#define LY_VCODE_XP_INTOK LYVE_XPATH, "Unexpected XPath token \"%s\" (\"%.15s\")."
190#define LY_VCODE_XP_INTOK2 LYVE_XPATH, "Unexpected XPath token \"%s\" (\"%.15s\"), expected \"%s\"."
Michal Vaskoecd62de2019-11-13 12:35:11 +0100191#define LY_VCODE_XP_INFUNC LYVE_XPATH, "Unknown XPath function \"%.*s\"."
192#define LY_VCODE_XP_INARGCOUNT LYVE_XPATH, "Invalid number of arguments (%d) for the XPath function %.*s."
193#define LY_VCODE_XP_INARGTYPE LYVE_XPATH, "Wrong type of argument #%d (%s) for the XPath function %s."
194#define LY_VCODE_XP_INCTX LYVE_XPATH, "Invalid context type %s in %s."
Michal Vaskoecd62de2019-11-13 12:35:11 +0100195#define LY_VCODE_XP_INOP_1 LYVE_XPATH, "Cannot apply XPath operation %s on %s."
196#define LY_VCODE_XP_INOP_2 LYVE_XPATH, "Cannot apply XPath operation %s on %s and %s."
Michal Vasko004d3152020-06-11 19:59:22 +0200197#define LY_VCODE_XP_INMOD LYVE_XPATH, "Unknown/non-implemented module \"%.*s\"."
David Sedlák0c2bab92019-07-22 15:33:19 +0200198
Radek Krejci327de162019-06-14 12:52:07 +0200199#define LY_VCODE_DEV_NOT_PRESENT LYVE_REFERENCE, "Invalid deviation %s \"%s\" property \"%s\" which is not present."
Radek Krejci94aa9942018-09-07 17:12:17 +0200200
Michal Vaskoecd62de2019-11-13 12:35:11 +0100201#define LY_VCODE_NOWHEN LYVE_DATA, "When condition \"%s\" not satisfied."
Michal Vaskocc048b22020-03-27 15:52:38 +0100202#define LY_VCODE_NOMUST LYVE_DATA, "Must condition \"%s\" not satisfied."
Michal Vaskoa3881362020-01-21 15:57:35 +0100203#define LY_VCODE_NOMAND LYVE_DATA, "Mandatory node \"%s\" instance does not exist."
Michal Vaskoacd83e72020-02-04 14:12:01 +0100204#define LY_VCODE_NOMIN LYVE_DATA, "Too few \"%s\" instances."
205#define LY_VCODE_NOMAX LYVE_DATA, "Too many \"%s\" instances."
Michal Vasko14654712020-02-06 08:35:21 +0100206#define LY_VCODE_NOUNIQ LYVE_DATA, "Unique data leaf(s) \"%s\" not satisfied in \"%s\" and \"%s\"."
Michal Vaskof03ed032020-03-04 13:31:44 +0100207#define LY_VCODE_DUP LYVE_DATA, "Duplicate instance of \"%s\"."
208#define LY_VCODE_DUPCASE LYVE_DATA, "Data for both cases \"%s\" and \"%s\" exist."
Michal Vaskocb7526d2020-03-30 15:08:26 +0200209#define LY_VCODE_INNODE LYVE_DATA, "Invalid %s data node \"%s\" found."
Michal Vasko9f96a052020-03-10 09:41:45 +0100210#define LY_VCODE_NOKEY LYVE_DATA, "List instance is missing its key \"%s\"."
Michal Vaskoecd62de2019-11-13 12:35:11 +0100211
Radek Krejcic59bc972018-09-17 16:13:06 +0200212/******************************************************************************
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200213 * Context
214 *****************************************************************************/
215
216/**
217 * @brief Context of the YANG schemas
218 */
219struct ly_ctx {
220 struct dict_table dict; /**< dictionary to effectively store strings used in the context related structures */
221 struct ly_set search_paths; /**< set of directories where to search for schema's imports/includes */
Michal Vasko89b5c072020-10-06 13:52:44 +0200222 struct ly_set list; /**< set of loaded YANG schemas */
223 struct ly_set implementing; /**< set of YANG schemas being atomically implemented (compiled); the first added
224 module is always the explcitly implemented module, the other ones are dependencies */
Radek Krejcid33273d2018-10-25 14:55:52 +0200225 ly_module_imp_clb imp_clb; /**< Optional callback for retrieving missing included or imported models in a custom way. */
Radek Krejci8678fa42020-08-18 16:07:28 +0200226 void *imp_clb_data; /**< Optional private data for ::ly_ctx.imp_clb */
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200227 uint16_t module_set_id; /**< ID of the current set of schemas */
228 uint16_t flags; /**< context settings, see @ref contextoptions. */
229 pthread_key_t errlist_key; /**< key for the thread-specific list of errors related to the context */
230};
231
Radek Krejcid33273d2018-10-25 14:55:52 +0200232/**
233 * @brief Try to find submodule in the context. Submodules are present only in the parsed (lysp_) schema trees, if only
234 * the compiled versions of the schemas are present, the submodule cannot be returned even if it was used to compile
235 * some of the currently present schemas.
236 *
Michal Vaskoc3781c32020-10-06 14:04:08 +0200237 * @param[in] ctx Context where to search in case @p module is NULL.
238 * @param[in] module Submodule parent (belongs-to) module in case @p ctx is NULL.
Radek Krejcid33273d2018-10-25 14:55:52 +0200239 * @param[in] submodule Name of the submodule to find.
240 * @param[in] revision Optional revision of the submodule to find. If not specified, the latest revision is returned.
241 * @return Pointer to the specified submodule if it is present in the context.
242 */
Michal Vaskoc3781c32020-10-06 14:04:08 +0200243struct lysp_submodule *ly_ctx_get_submodule(const struct ly_ctx *ctx, const struct lys_module *module,
244 const char *submodule, const char *revision);
Radek Krejcid33273d2018-10-25 14:55:52 +0200245
Radek Krejci0ad51f12020-07-16 12:08:12 +0200246/**
247 * @brief Get the (only) implemented YANG module specified by its name.
248 *
249 * @param[in] ctx Context where to search.
250 * @param[in] name Name of the YANG module to get.
251 * @param[in] name_len Optional length of the @p name. If zero, NULL-terminated name is expected.
252 * @return The only implemented YANG module revision of the given name in the given context. NULL if there is no
253 * implemented module of the given name.
254 */
255struct lys_module *ly_ctx_get_module_implemented2(const struct ly_ctx *ctx, const char *name, size_t name_len);
256
Radek Krejci6caa6ab2018-10-24 10:04:48 +0200257/******************************************************************************
Radek Krejcic59bc972018-09-17 16:13:06 +0200258 * Parsers
259 *****************************************************************************/
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200260
Radek Krejcic59bc972018-09-17 16:13:06 +0200261/* list of the YANG statements strings */
Michal Vasko22df3f02020-08-24 13:29:22 +0200262extern const char * const ly_stmt_list[];
Radek Krejcic59bc972018-09-17 16:13:06 +0200263#define ly_stmt2str(STMT) ly_stmt_list[STMT]
264
265/* list of the extensions' substatements strings */
Michal Vasko22df3f02020-08-24 13:29:22 +0200266extern const char * const lyext_substmt_list[];
Radek Krejcic59bc972018-09-17 16:13:06 +0200267#define lyext_substmt2str(STMT) lyext_substmt_list[STMT]
268
269/* list of the deviate modifications strings */
Michal Vasko22df3f02020-08-24 13:29:22 +0200270extern const char * const ly_devmod_list[];
Radek Krejcic59bc972018-09-17 16:13:06 +0200271#define ly_devmod2str(TYPE) ly_devmod_list[TYPE]
272
273/******************************************************************************
Michal Vasko1324b6c2018-09-07 11:16:23 +0200274 * Generic useful functions.
Radek Krejcic59bc972018-09-17 16:13:06 +0200275 *****************************************************************************/
Michal Vasko1324b6c2018-09-07 11:16:23 +0200276
Michal Vaskob36053d2020-03-26 15:49:30 +0100277/**
278 * @brief Insert string into dictionary.
279 *
280 * @param[in] CTX libyang context.
281 * @param[in] STRING string to store.
282 * @param[in] LEN length of the string in WORD to store.
283 * @param[in,out] DYNAMIC Set to 1 if STR is dynamically allocated, 0 otherwise. If set to 1, zerocopy version of lydict_insert is used.
284 */
Radek Krejci011e4aa2020-09-04 15:22:31 +0200285#define INSERT_STRING_RET(CTX, STRING, LEN, DYNAMIC, TARGET) \
286 if (DYNAMIC) { \
287 LY_CHECK_RET(lydict_insert_zc(CTX, (char *)(STRING), &(TARGET))); \
288 } else { \
289 LY_CHECK_RET(lydict_insert(CTX, LEN ? (STRING) : "", LEN, &(TARGET))); \
290 } \
291 DYNAMIC = 0
Michal Vaskob36053d2020-03-26 15:49:30 +0100292
Radek Krejci76b3e962018-12-14 17:01:25 +0100293#define FREE_STRING(CTX, STRING) if (STRING) {lydict_remove(CTX, STRING);}
294
Michal Vasko1324b6c2018-09-07 11:16:23 +0200295/**
296 * @brief Wrapper for realloc() call. The only difference is that if it fails to
297 * allocate the requested memory, the original memory is freed as well.
298 *
299 * @param[in] ptr Memory to reallocate.
300 * @param[in] size New size of the memory block.
301 *
302 * @return Pointer to the new memory, NULL on error.
303 */
304void *ly_realloc(void *ptr, size_t size);
305
Radek Krejcif345c012018-09-19 11:12:59 +0200306/**
Michal Vasko03ff5a72019-09-11 13:49:33 +0200307 * @brief Just like strchr() function except limit the number of examined characters.
308 *
309 * @param[in] s String to search in.
310 * @param[in] c Character to search for.
311 * @param[in] len Limit the search to this number of characters in @p s.
312 * @return Pointer to first @p c occurence in @p s, NULL if not found in first @p len characters.
313 */
Radek Krejci1deb5be2020-08-26 16:43:36 +0200314char *ly_strnchr(const char *s, int c, size_t len);
Michal Vasko03ff5a72019-09-11 13:49:33 +0200315
316/**
Radek Krejci7f9b6512019-09-18 13:11:09 +0200317 * @brief Compare NULL-terminated @p refstr with @str_len bytes from @p str.
318 *
319 * @param[in] refstr NULL-terminated string which must match @str_len bytes from @str followed by NULL-byte.
320 * @param[in] str String to compare
321 * @param[in] str_len Number of bytes to take into comparison from @p str.
322 * @return An integer less than, equal to, or greater than zero if @p refstr matches,
323 * respectively, to be less than, to match, or be greater than @p str.
324 */
325int ly_strncmp(const char *refstr, const char *str, size_t str_len);
326
327/**
Radek Krejci1798aae2020-07-14 13:26:06 +0200328 * @brief Wrapper around strlen() to handle NULL strings.
329 */
330#define ly_strlen(STR) (STR ? strlen(STR) : 0)
331
332/**
Radek Krejcib416be62018-10-01 14:51:45 +0200333 * @brief Get UTF8 code point of the next character in the input string.
334 *
335 * @param[in,out] input Input string to process, updated according to the processed/read data.
336 * @param[out] utf8_char UTF8 code point of the next character.
337 * @param[out] bytes_read Number of bytes used to encode the read utf8_char.
338 * @return LY_ERR value
339 */
Michal Vaskob36053d2020-03-26 15:49:30 +0100340LY_ERR ly_getutf8(const char **input, uint32_t *utf8_char, size_t *bytes_read);
Radek Krejcib416be62018-10-01 14:51:45 +0200341
342/**
Radek Krejci50f0c6b2020-06-18 16:31:48 +0200343 * Store UTF-8 character specified as 4byte integer into the dst buffer.
344 *
345 * UTF-8 mapping:
346 * 00000000 -- 0000007F: 0xxxxxxx
347 * 00000080 -- 000007FF: 110xxxxx 10xxxxxx
348 * 00000800 -- 0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
349 * 00010000 -- 001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
350 *
351 * Includes checking for valid characters (following RFC 7950, sec 9.4)
352 *
353 * @param[in, out] dst Destination buffer to store the UTF-8 character, must provide enough space (up to 4 bytes) for storing the UTF-8 character.
354 * @param[in] value 32b value of the UTF-8 character to store.
355 * @param[out] bytes_written Number of bytes written into @p dst (size of the written UTF-8 character).
356 * @return LY_SUCCESS on success
357 * @return LY_EINVAL in case of invalid UTF-8 @p value to store.
358 */
359LY_ERR ly_pututf8(char *dst, uint32_t value, size_t *bytes_written);
360
361/**
Radek Krejci76c98012019-08-14 11:23:24 +0200362 * @brief Get number of characters in the @p str, taking multibyte characters into account.
363 * @param[in] str String to examine.
364 * @param[in] bytes Number of valid bytes that are supposed to be taken into account in @p str.
365 * This parameter is useful mainly for non NULL-terminated strings. In case of NULL-terminated
366 * string, strlen() can be used.
367 * @return Number of characters in (possibly) multibyte characters string.
368 */
369size_t ly_utf8len(const char *str, size_t bytes);
370
371/**
Radek Krejci4f28eda2018-11-12 11:46:16 +0100372 * @brief Parse signed integer with possible limitation.
373 * @param[in] val_str String value containing signed integer, note that
374 * nothing else than whitespaces are expected after the value itself.
Radek Krejci249973a2019-06-10 10:50:54 +0200375 * @param[in] val_len Length of the @p val_str string.
Radek Krejci4f28eda2018-11-12 11:46:16 +0100376 * @param[in] min Limitation for the value which must not be lower than min.
377 * @param[in] max Limitation for the value which must not be higher than max.
378 * @param[in] base Numeric base for parsing:
379 * 0 - to accept decimal, octal, hexadecimal (e.g. in default value)
380 * 10 - to accept only decimal (e.g. data instance value)
381 * @param[out] ret Resulting value.
382 * @return LY_ERR value:
383 * LY_EDENIED - the value breaks the limits,
384 * LY_EVALID - string contains invalid value,
385 * LY_SUCCESS - successful parsing.
386 */
Radek Krejci249973a2019-06-10 10:50:54 +0200387LY_ERR ly_parse_int(const char *val_str, size_t val_len, int64_t min, int64_t max, int base, int64_t *ret);
Radek Krejci4f28eda2018-11-12 11:46:16 +0100388
389/**
390 * @brief Parse unsigned integer with possible limitation.
391 * @param[in] val_str String value containing unsigned integer, note that
392 * nothing else than whitespaces are expected after the value itself.
Radek Krejci249973a2019-06-10 10:50:54 +0200393 * @param[in] val_len Length of the @p val_str string.
Radek Krejci4f28eda2018-11-12 11:46:16 +0100394 * @param[in] max Limitation for the value which must not be higher than max.
395 * @param[in] base Numeric base for parsing:
396 * 0 - to accept decimal, octal, hexadecimal (e.g. in default value)
397 * 10 - to accept only decimal (e.g. data instance value)
398 * @param[out] ret Resulting value.
399 * @return LY_ERR value:
400 * LY_EDENIED - the value breaks the limits,
401 * LY_EVALID - string contains invalid value,
402 * LY_SUCCESS - successful parsing.
403 */
Radek Krejci249973a2019-06-10 10:50:54 +0200404LY_ERR ly_parse_uint(const char *val_str, size_t val_len, uint64_t max, int base, uint64_t *ret);
Radek Krejci4f28eda2018-11-12 11:46:16 +0100405
406/**
Radek Krejcib4a4a272019-06-10 12:44:52 +0200407 * @brief Parse a node-identifier.
408 *
409 * node-identifier = [prefix ":"] identifier
410 *
411 * @param[in, out] id Identifier to parse. When returned, it points to the first character which is not part of the identifier.
412 * @param[out] prefix Node's prefix, NULL if there is not any.
413 * @param[out] prefix_len Length of the node's prefix, 0 if there is not any.
414 * @param[out] name Node's name.
415 * @param[out] nam_len Length of the node's name.
416 * @return LY_ERR value: LY_SUCCESS or LY_EINVAL in case of invalid character in the id.
417 */
418LY_ERR ly_parse_nodeid(const char **id, const char **prefix, size_t *prefix_len, const char **name, size_t *name_len);
419
420/**
421 * @brief parse instance-identifier's predicate, supports key-predicate, leaf-list-predicate and pos rules from YANG ABNF Grammar.
422 *
423 * @param[in, out] pred Predicate string (including the leading '[') to parse. The string is updated according to what was parsed
424 * (even for error case, so it can be used to determine which substring caused failure).
425 * @param[in] limit Limiting length of the @p pred. Function expects NULL terminated string which is not overread.
426 * The limit value is not checked with each character, so it can be overread and the failure is detected later.
Radek Krejci084289f2019-07-09 17:35:30 +0200427 * @param[in] format Input format of the data containing the @p pred.
Radek Krejcib4a4a272019-06-10 12:44:52 +0200428 * @param[out] prefix Start of the node-identifier's prefix if any, NULL in case of pos or leaf-list-predicate rules.
429 * @param[out] prefix_len Length of the parsed @p prefix.
430 * @param[out] id Start of the node-identifier's identifier string, NULL in case of pos rule, "." in case of leaf-list-predicate rule.
431 * @param[out] id_len Length of the parsed @p id.
Radek Krejci084289f2019-07-09 17:35:30 +0200432 * @param[out] value Start of the quoted-string (without quotation marks), not NULL in case of success.
Radek Krejcib4a4a272019-06-10 12:44:52 +0200433 * @param[out] value_len Length of the parsed @p value.
434 * @param[out] errmsg Error message string in case of error.
435 * @return LY_SUCCESS in case a complete predicate was parsed.
436 * @return LY_EVALID in case of invalid predicate form.
437 * @return LY_EINVAL in case of reaching @p limit when parsing @p pred.
438 */
Radek Krejci084289f2019-07-09 17:35:30 +0200439LY_ERR ly_parse_instance_predicate(const char **pred, size_t limit, LYD_FORMAT format,
Radek Krejci0f969882020-08-21 16:56:47 +0200440 const char **prefix, size_t *prefix_len, const char **id, size_t *id_len,
441 const char **value, size_t *value_len, const char **errmsg);
Michal Vasko1324b6c2018-09-07 11:16:23 +0200442
Radek Krejcif345c012018-09-19 11:12:59 +0200443/**
Radek Krejci86d106e2018-10-18 09:53:19 +0200444 * @brief mmap(2) wrapper to map input files into memory to unify parsing.
Radek Krejcif345c012018-09-19 11:12:59 +0200445 *
Radek Krejci86d106e2018-10-18 09:53:19 +0200446 * The address space is allocate only for reading.
447 *
448 * @param[in] ctx libyang context for logging
449 * @param[in] fd Open file descriptor of a file to map.
450 * @param[out] length Allocated size.
451 * @param[out] addr Address where the file is mapped.
Radek Krejcif345c012018-09-19 11:12:59 +0200452 * @return LY_ERR value.
453 */
Radek Krejci86d106e2018-10-18 09:53:19 +0200454LY_ERR ly_mmap(struct ly_ctx *ctx, int fd, size_t *length, void **addr);
Michal Vasko841d1a92018-09-07 15:40:31 +0200455
Radek Krejci86d106e2018-10-18 09:53:19 +0200456/**
Radek Krejci8678fa42020-08-18 16:07:28 +0200457 * @brief munmap(2) wrapper to free the memory mapped by ::ly_mmap()
Michal Vasko1324b6c2018-09-07 11:16:23 +0200458 *
Radek Krejci86d106e2018-10-18 09:53:19 +0200459 * @param[in] addr Address where the input file is mapped.
460 * @param[in] length Allocated size of the address space.
461 * @return LY_ERR value.
462 */
463LY_ERR ly_munmap(void *addr, size_t length);
464
465/**
Radek Krejci4546aa62019-07-15 16:53:32 +0200466 * @brief Concatenate formating string to the @p dest.
467 *
468 * @param[in, out] dest String to be concatenated by @p format.
469 * Note that the input string can be reallocated during concatenation.
470 * @param[in] format Formating string (as for printf) which is supposed to be added after @p dest.
471 * @return LY_SUCCESS or LY_EMEM.
472 */
473LY_ERR ly_strcat(char **dest, const char *format, ...);
474
475/**
Radek Krejci86d106e2018-10-18 09:53:19 +0200476 * @brief (Re-)Allocation of a ([sized array](@ref sizedarrays)).
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200477 *
Radek Krejci2c4e7172018-10-19 15:56:26 +0200478 * Increases the size information.
479 *
Radek Krejci86d106e2018-10-18 09:53:19 +0200480 * @param[in] CTX libyang context for logging.
Radek Krejci2c4e7172018-10-19 15:56:26 +0200481 * @param[in,out] ARRAY Pointer to the array to allocate/resize. The size of the allocated
482 * space is counted from the type of the ARRAY, so do not provide placeholder void pointers.
Radek Krejci86d106e2018-10-18 09:53:19 +0200483 * @param[out] NEW_ITEM Returning pointer to the newly allocated record in the ARRAY.
484 * @param[in] RETVAL Return value for the case of error (memory allocation failure).
Michal Vasko1324b6c2018-09-07 11:16:23 +0200485 */
Radek Krejci2c4e7172018-10-19 15:56:26 +0200486#define LY_ARRAY_NEW_RET(CTX, ARRAY, NEW_ITEM, RETVAL) \
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200487 if (!(ARRAY)) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200488 ARRAY = malloc(sizeof(LY_ARRAY_COUNT_TYPE) + sizeof *(ARRAY)); \
489 *((LY_ARRAY_COUNT_TYPE*)(ARRAY)) = 1; \
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200490 } else { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200491 ++(*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1)); \
492 ARRAY = ly_realloc(((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1), sizeof(LY_ARRAY_COUNT_TYPE) + (*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1) * sizeof *(ARRAY))); \
Radek Krejcie53a8dc2018-10-17 12:52:40 +0200493 LY_CHECK_ERR_RET(!(ARRAY), LOGMEM(CTX), RETVAL); \
494 } \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200495 ARRAY = (void*)((LY_ARRAY_COUNT_TYPE*)(ARRAY) + 1); \
496 (NEW_ITEM) = &(ARRAY)[*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1) - 1]; \
Radek Krejci2c4e7172018-10-19 15:56:26 +0200497 memset(NEW_ITEM, 0, sizeof *(NEW_ITEM))
Michal Vasko1324b6c2018-09-07 11:16:23 +0200498
Radek Krejci2c4e7172018-10-19 15:56:26 +0200499/**
Radek Krejci4f28eda2018-11-12 11:46:16 +0100500 * @brief (Re-)Allocation of a ([sized array](@ref sizedarrays)).
501 *
502 * Increases the size information.
503 *
504 * @param[in] CTX libyang context for logging.
505 * @param[in,out] ARRAY Pointer to the array to allocate/resize. The size of the allocated
506 * space is counted from the type of the ARRAY, so do not provide placeholder void pointers.
507 * @param[out] NEW_ITEM Returning pointer to the newly allocated record in the ARRAY.
508 * @param[out] RET Variable to store error code.
509 * @param[in] GOTO Label to go in case of error (memory allocation failure).
510 */
511#define LY_ARRAY_NEW_GOTO(CTX, ARRAY, NEW_ITEM, RET, GOTO) \
512 if (!(ARRAY)) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200513 ARRAY = malloc(sizeof(LY_ARRAY_COUNT_TYPE) + sizeof *(ARRAY)); \
514 *((LY_ARRAY_COUNT_TYPE*)(ARRAY)) = 1; \
Radek Krejci4f28eda2018-11-12 11:46:16 +0100515 } else { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200516 ++(*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1)); \
517 ARRAY = ly_realloc(((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1), sizeof(LY_ARRAY_COUNT_TYPE) + (*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1) * sizeof *(ARRAY))); \
Radek Krejci4f28eda2018-11-12 11:46:16 +0100518 LY_CHECK_ERR_GOTO(!(ARRAY), LOGMEM(CTX); RET = LY_EMEM, GOTO); \
519 } \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200520 ARRAY = (void*)((LY_ARRAY_COUNT_TYPE*)(ARRAY) + 1); \
521 (NEW_ITEM) = &(ARRAY)[*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1) - 1]; \
Radek Krejci4f28eda2018-11-12 11:46:16 +0100522 memset(NEW_ITEM, 0, sizeof *(NEW_ITEM))
523
524/**
Radek Krejci2c4e7172018-10-19 15:56:26 +0200525 * @brief Allocate a ([sized array](@ref sizedarrays)) for the specified number of items.
Radek Krejcic4fa0292020-05-14 10:54:49 +0200526 * If the ARRAY already exists, it is resized (space for SIZE items is added and zeroed).
Radek Krejci2c4e7172018-10-19 15:56:26 +0200527 *
528 * Does not set the size information, it is supposed to be incremented via ::LY_ARRAY_INCREMENT
529 * when the items are filled.
530 *
531 * @param[in] CTX libyang context for logging.
532 * @param[in,out] ARRAY Pointer to the array to create.
533 * @param[in] SIZE Number of items the array is supposed to hold. The size of the allocated
534 * space is then counted from the type of the ARRAY, so do not provide placeholder void pointers.
535 * @param[in] RETVAL Return value for the case of error (memory allocation failure).
536 */
537#define LY_ARRAY_CREATE_RET(CTX, ARRAY, SIZE, RETVAL) \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100538 if (ARRAY) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200539 ARRAY = ly_realloc(((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1), sizeof(LY_ARRAY_COUNT_TYPE) + ((*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1) + SIZE) * sizeof *(ARRAY))); \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100540 LY_CHECK_ERR_RET(!(ARRAY), LOGMEM(CTX), RETVAL); \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200541 ARRAY = (void*)((LY_ARRAY_COUNT_TYPE*)(ARRAY) + 1); \
542 memset(&(ARRAY)[*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1)], 0, SIZE * sizeof *(ARRAY)); \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100543 } else { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200544 ARRAY = calloc(1, sizeof(LY_ARRAY_COUNT_TYPE) + SIZE * sizeof *(ARRAY)); \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100545 LY_CHECK_ERR_RET(!(ARRAY), LOGMEM(CTX), RETVAL); \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200546 ARRAY = (void*)((LY_ARRAY_COUNT_TYPE*)(ARRAY) + 1); \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100547 }
Radek Krejci2c4e7172018-10-19 15:56:26 +0200548
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100549/**
550 * @brief Allocate a ([sized array](@ref sizedarrays)) for the specified number of items.
Radek Krejcid05cbd92018-12-05 14:26:40 +0100551 * If the ARRAY already exists, it is resized (space for SIZE items is added).
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100552 *
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200553 * Does not set the count information, it is supposed to be incremented via ::LY_ARRAY_INCREMENT
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100554 * when the items are filled.
555 *
556 * @param[in] CTX libyang context for logging.
557 * @param[in,out] ARRAY Pointer to the array to create.
Radek Krejci00b874b2019-02-12 10:54:50 +0100558 * @param[in] SIZE Number of the new items the array is supposed to hold. The size of the allocated
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100559 * space is then counted from the type of the ARRAY, so do not provide placeholder void pointers.
560 * @param[out] RET Variable to store error code.
561 * @param[in] GOTO Label to go in case of error (memory allocation failure).
562 */
563#define LY_ARRAY_CREATE_GOTO(CTX, ARRAY, SIZE, RET, GOTO) \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100564 if (ARRAY) { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200565 ARRAY = ly_realloc(((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1), sizeof(LY_ARRAY_COUNT_TYPE) + ((*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1) + (SIZE)) * sizeof *(ARRAY))); \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100566 LY_CHECK_ERR_GOTO(!(ARRAY), LOGMEM(CTX); RET = LY_EMEM, GOTO); \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200567 ARRAY = (void*)((LY_ARRAY_COUNT_TYPE*)(ARRAY) + 1); \
568 memset(&(ARRAY)[*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1)], 0, (SIZE) * sizeof *(ARRAY)); \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100569 } else { \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200570 ARRAY = calloc(1, sizeof(LY_ARRAY_COUNT_TYPE) + (SIZE) * sizeof *(ARRAY)); \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100571 LY_CHECK_ERR_GOTO(!(ARRAY), LOGMEM(CTX); RET = LY_EMEM, GOTO); \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200572 ARRAY = (void*)((LY_ARRAY_COUNT_TYPE*)(ARRAY) + 1); \
Radek Krejcid05cbd92018-12-05 14:26:40 +0100573 }
Radek Krejci6d6e4e42018-10-29 13:28:19 +0100574
Radek Krejcic4fa0292020-05-14 10:54:49 +0200575/**
576 * @brief Resize a ([sized array](@ref sizedarrays)) to the the specified number of items.
577 *
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200578 * Does not change the count information, it is supposed to be incremented via ::LY_ARRAY_INCREMENT
Radek Krejcic4fa0292020-05-14 10:54:49 +0200579 * when the items are filled.
580 *
581 * @param[in] CTX libyang context for logging.
582 * @param[in,out] ARRAY Pointer to the array to create.
583 * @param[in] SIZE Number of items the array is supposed to hold. The size of the allocated
584 * space is then counted from the type of the ARRAY, so do not provide placeholder void pointers.
585 * @param[in] ERR Additional action(s) in case of error (passed to LY_CHECK_ERR_RET).
586 * @param[in] RETVAL Return value for the case of error (memory allocation failure).
587 */
588#define LY_ARRAY_RESIZE_ERR_RET(CTX, ARRAY, SIZE, ERR, RETVAL) \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200589 ARRAY = ly_realloc(((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1), sizeof(LY_ARRAY_COUNT_TYPE) + ((SIZE) * sizeof *(ARRAY))); \
Radek Krejcic4fa0292020-05-14 10:54:49 +0200590 LY_CHECK_ERR_RET(!(ARRAY), LOGMEM(CTX); ERR, RETVAL); \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200591 ARRAY = (void*)((LY_ARRAY_COUNT_TYPE*)(ARRAY) + 1);
Radek Krejciccd20f12019-02-15 14:12:27 +0100592
Radek Krejcic4fa0292020-05-14 10:54:49 +0200593/**
594 * @brief Increment the items counter in a ([sized array](@ref sizedarrays)).
595 *
596 * Does not change the allocated memory used by the ARRAY. To do so, use LY_ARRAY_CREATE_RET,
597 * LY_ARRAY_CREATE_GOTO or LY_ARRAY_RESIZE_ERR_RET.
598 *
599 * @param[in] ARRAY Pointer to the array to affect.
600 */
601#define LY_ARRAY_INCREMENT(ARRAY) \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200602 ++(*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1))
Radek Krejcic4fa0292020-05-14 10:54:49 +0200603
604/**
605 * @brief Decrement the items counter in a ([sized array](@ref sizedarrays)).
606 *
607 * Does not change the allocated memory used by the ARRAY. To do so, use LY_ARRAY_CREATE_RET,
608 * LY_ARRAY_CREATE_GOTO or LY_ARRAY_RESIZE_ERR_RET.
609 *
610 * @param[in] ARRAY Pointer to the array to affect.
611 */
Radek Krejciccd20f12019-02-15 14:12:27 +0100612#define LY_ARRAY_DECREMENT(ARRAY) \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200613 --(*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1))
Radek Krejciccd20f12019-02-15 14:12:27 +0100614
Radek Krejci2c4e7172018-10-19 15:56:26 +0200615/**
Michal Vasko7b1ad1a2020-11-02 15:41:27 +0100616 * @brief Decrement the items counter in a ([sized array](@ref sizedarrays)) and free the whole array
617 * in case it was decremented to 0.
618 *
619 * @param[in] ARRAY Pointer to the array to affect.
620 */
621#define LY_ARRAY_DECREMENT_FREE(ARRAY) \
622 --(*((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1)); \
623 if (!LY_ARRAY_COUNT(ARRAY)) { \
624 LY_ARRAY_FREE(ARRAY); \
625 (ARRAY) = NULL; \
626 }
627
628/**
Radek Krejci2c4e7172018-10-19 15:56:26 +0200629 * @brief Free the space allocated for the ([sized array](@ref sizedarrays)).
630 *
631 * The items inside the array are not freed.
632 *
633 * @param[in] ARRAY A ([sized array](@ref sizedarrays)) to be freed.
634 */
635#define LY_ARRAY_FREE(ARRAY) \
Michal Vaskofd69e1d2020-07-03 11:57:17 +0200636 if (ARRAY){free((LY_ARRAY_COUNT_TYPE*)(ARRAY) - 1);}
David Sedlák8d552d62019-08-06 15:29:05 +0200637
David Sedlák26ea1432019-08-14 13:42:23 +0200638/**
David Sedlákaa98bba2019-09-12 11:52:14 +0200639 * @brief Insert item into linked list.
David Sedlák26ea1432019-08-14 13:42:23 +0200640 *
641 * @param[in,out] LIST Linked list to add to.
642 * @param[in] NEW_ITEM New item, that will be appended to the list, must be already allocated.
643 * @param[in] LINKER name of structuin member that is used to connect items together.
644 */
David Sedlák8d552d62019-08-06 15:29:05 +0200645#define LY_LIST_INSERT(LIST, NEW_ITEM, LINKER)\
646 if (!(*LIST)) { \
647 *LIST = (__typeof__(*(LIST)))NEW_ITEM; \
648 } else { \
649 do { \
650 __typeof__(*(LIST)) iterator; \
Radek Krejci1e008d22020-08-17 11:37:37 +0200651 for (iterator = *(LIST); iterator->LINKER; iterator = iterator->LINKER) {} \
David Sedlák8d552d62019-08-06 15:29:05 +0200652 iterator->LINKER = (__typeof__(*(LIST)))NEW_ITEM; \
653 } while (0); \
654 }
655
David Sedlák26ea1432019-08-14 13:42:23 +0200656/**
David Sedlákaa98bba2019-09-12 11:52:14 +0200657 * @brief Allocate and insert new item into linked list, return in case of error.
David Sedlák26ea1432019-08-14 13:42:23 +0200658 *
David Sedláke6284fc2019-09-10 11:57:02 +0200659 * @param[in] CTX used for logging.
660 * @param[in,out] LIST Linked list to add to.
661 * @param[out] NEW_ITEM New item that is appended to the list.
662 * @param[in] LINKER name of structure member that is used to connect items together.
David Sedlákfbe240f2019-09-13 11:18:53 +0200663 * @param[in] RETVAL Return value for the case of error (memory allocation failure).
David Sedlák26ea1432019-08-14 13:42:23 +0200664 */
David Sedlákb9eeb9c2019-09-13 11:17:19 +0200665#define LY_LIST_NEW_RET(CTX, LIST, NEW_ITEM, LINKER, RETVAL) \
David Sedlák8d552d62019-08-06 15:29:05 +0200666 NEW_ITEM = calloc(1, sizeof *NEW_ITEM); \
David Sedlákb9eeb9c2019-09-13 11:17:19 +0200667 LY_CHECK_ERR_RET(!(NEW_ITEM), LOGMEM(CTX), RETVAL); \
David Sedlák8d552d62019-08-06 15:29:05 +0200668 LY_LIST_INSERT(LIST, NEW_ITEM, LINKER)
669
David Sedláke6284fc2019-09-10 11:57:02 +0200670/**
David Sedlákaa98bba2019-09-12 11:52:14 +0200671 * @brief Allocate and insert new item into linked list, goto specified label in case of error.
David Sedláke6284fc2019-09-10 11:57:02 +0200672 *
673 * @param[in] CTX used for logging.
674 * @param[in,out] LIST Linked list to add to.
675 * @param[out] NEW_ITEM New item that is appended to the list.
676 * @param[in] LINKER name of structure member that is used to connect items together.
677 * @param[in] RET variable to store returned error type.
678 * @param[in] LABEL label to goto in case of error.
679 */
680#define LY_LIST_NEW_GOTO(CTX, LIST, NEW_ITEM, LINKER, RET, LABEL) \
681 NEW_ITEM = calloc(1, sizeof *NEW_ITEM); \
682 LY_CHECK_ERR_GOTO(!(NEW_ITEM), RET = LY_EMEM; LOGMEM(CTX), LABEL); \
683 LY_LIST_INSERT(LIST, NEW_ITEM, LINKER)
684
David Sedláke6cd89e2019-08-07 12:46:02 +0200685#endif /* LY_COMMON_H_ */