/src/open5gs/lib/app/ogs-yaml.c

Source (jump to first uncovered line)
/*
 * Copyright (C) 2019-2023 by Sukchan Lee <acetcom@gmail.com>
 *
 * This file is part of Open5GS.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "ogs-app.h"

void ogs_yaml_iter_init(ogs_yaml_iter_t *iter, yaml_document_t *document)
{
    ogs_assert(iter);
    ogs_assert(document);

    memset(iter, 0, sizeof(ogs_yaml_iter_t));

    iter->document = document;
    iter->node = yaml_document_get_root_node(document);

    ogs_assert(iter->node);
    if (iter->node->type == YAML_MAPPING_NODE)
        iter->pair = iter->node->data.mapping.pairs.start - 1;
    else if (iter->node->type == YAML_SEQUENCE_NODE)
        iter->item = iter->node->data.sequence.items.start - 1;
}

int ogs_yaml_iter_next(ogs_yaml_iter_t *iter)
{
    ogs_assert(iter);
    ogs_assert(iter->document);
    ogs_assert(iter->node);

    if (iter->node->type == YAML_MAPPING_NODE)
    {
        if (iter->pair)
        {
            iter->pair++;
            if (iter->pair < iter->node->data.mapping.pairs.top)
                return 1;
        }

    }
    else if (iter->node->type == YAML_SEQUENCE_NODE)
    {
        if (iter->item)
        {
            iter->item++;
            if (iter->item < iter->node->data.sequence.items.top)
                return 1;
        }
    }

    return 0;
}

void ogs_yaml_iter_recurse(ogs_yaml_iter_t *parent, ogs_yaml_iter_t *iter)
{
    ogs_assert(parent);
    ogs_assert(parent->document);
    ogs_assert(parent->node);
    ogs_assert(iter);

    memset(iter, 0, sizeof(ogs_yaml_iter_t));

    iter->document = parent->document;

    if (parent->node->type == YAML_MAPPING_NODE)
    {
        ogs_assert(parent->pair);
        iter->node = yaml_document_get_node(
                parent->document, parent->pair->value);
        ogs_assert(iter->node);
        if (iter->node->type == YAML_MAPPING_NODE)
            iter->pair = iter->node->data.mapping.pairs.start - 1;
        else if (iter->node->type == YAML_SEQUENCE_NODE)
            iter->item = iter->node->data.sequence.items.start - 1;
    }
    else if (parent->node->type == YAML_SEQUENCE_NODE)
    {
        ogs_assert(parent->item);
        iter->node = yaml_document_get_node(parent->document, *parent->item);
        ogs_assert(iter->node);
        if (iter->node->type == YAML_MAPPING_NODE)
            iter->pair = iter->node->data.mapping.pairs.start - 1;
        else if (iter->node->type == YAML_SEQUENCE_NODE)
            iter->item = iter->node->data.sequence.items.start - 1;
    }
    else
        ogs_assert_if_reached();
}

int ogs_yaml_iter_type(ogs_yaml_iter_t *iter)
{
    ogs_assert(iter);
    ogs_assert(iter->node);

    return iter->node->type;
}


const char *ogs_yaml_iter_key(ogs_yaml_iter_t *iter)
{
    yaml_node_t *node = NULL;

    ogs_assert(iter);
    ogs_assert(iter->document);
    ogs_assert(iter->node);

    if (iter->node->type == YAML_MAPPING_NODE)
    {
        ogs_assert(iter->pair);
        node = yaml_document_get_node(iter->document, iter->pair->key);
        ogs_assert(node);
        ogs_assert(node->type == YAML_SCALAR_NODE);

        return (const char *)node->data.scalar.value;
    }
    else if (iter->node->type == YAML_SEQUENCE_NODE)
    {
        ogs_assert(iter->item);
        node = yaml_document_get_node(iter->document, *iter->item);
        ogs_assert(node);
        ogs_assert(node->type == YAML_SCALAR_NODE);

        return (const char *)node->data.scalar.value;
    }

    ogs_assert_if_reached();
    return NULL;
}

const char *ogs_yaml_iter_value(ogs_yaml_iter_t *iter)
{
    ogs_assert(iter);
    ogs_assert(iter->document);
    ogs_assert(iter->node);

    if (iter->node->type == YAML_SCALAR_NODE)
    {
        return (const char *)iter->node->data.scalar.value;
    }
    else if (iter->node->type == YAML_MAPPING_NODE)
    {
        yaml_node_t *node = NULL;

        ogs_assert(iter->pair);
        node = yaml_document_get_node(iter->document, iter->pair->value);
        ogs_assert(node);
        ogs_assert(node->type == YAML_SCALAR_NODE);

        return (const char *)node->data.scalar.value;
    }
    else if (iter->node->type == YAML_SEQUENCE_NODE)
    {
        yaml_node_t *node = NULL;

        ogs_assert(iter->item);
        node = yaml_document_get_node(iter->document, *iter->item);
        ogs_assert(node);
        ogs_assert(node->type == YAML_SCALAR_NODE);

        return (const char *)node->data.scalar.value;
    }

    ogs_assert_if_reached();
    return NULL;
}

int ogs_yaml_iter_has_value(ogs_yaml_iter_t *iter)
{
    ogs_assert(iter);
    ogs_assert(iter->document);
    ogs_assert(iter->node);

    if (iter->node->type == YAML_SCALAR_NODE) {
        return 1;
    } else if (iter->node->type == YAML_MAPPING_NODE) {
        yaml_node_t *node = NULL;

        ogs_assert(iter->pair);
        node = yaml_document_get_node(iter->document, iter->pair->value);
        ogs_assert(node);
        return node->type == YAML_SCALAR_NODE;
    } else if (iter->node->type == YAML_SEQUENCE_NODE) {
        yaml_node_t *node = NULL;

        ogs_assert(iter->item);
        node = yaml_document_get_node(iter->document, *iter->item);
        ogs_assert(node);
        return node->type == YAML_SCALAR_NODE;
    }

    ogs_assert_if_reached();
    return 0;
}

int ogs_yaml_iter_bool(ogs_yaml_iter_t *iter)
{
    const char *v = ogs_yaml_iter_value(iter);
    if (v)
    {
        if (!strcasecmp(v, "true") || !strcasecmp(v, "yes")) return 1;
        if (atoi(v)) return 1;
    }

    return 0;
}

Coverage Report

Created: 2025-07-11 06:44

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright (C) 2019-2023 by Sukchan Lee <acetcom@gmail.com>
3		*
4		* This file is part of Open5GS.
5		*
6		* This program is free software: you can redistribute it and/or modify
7		* it under the terms of the GNU Affero General Public License as published by
8		* the Free Software Foundation, either version 3 of the License, or
9		* (at your option) any later version.
10		*
11		* This program is distributed in the hope that it will be useful,
12		* but WITHOUT ANY WARRANTY; without even the implied warranty of
13		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14		* GNU General Public License for more details.
15		*
16		* You should have received a copy of the GNU General Public License
17		* along with this program. If not, see <https://www.gnu.org/licenses/>.
18		*/
19
20		#include "ogs-app.h"
21
22		void ogs_yaml_iter_init(ogs_yaml_iter_t iter, yaml_document_t document)
23	0	{
24	0	ogs_assert(iter);
25	0	ogs_assert(document);
26
27	0	memset(iter, 0, sizeof(ogs_yaml_iter_t));
28
29	0	iter->document = document;
30	0	iter->node = yaml_document_get_root_node(document);
31
32	0	ogs_assert(iter->node);
33	0	if (iter->node->type == YAML_MAPPING_NODE)
34	0	iter->pair = iter->node->data.mapping.pairs.start - 1;
35	0	else if (iter->node->type == YAML_SEQUENCE_NODE)
36	0	iter->item = iter->node->data.sequence.items.start - 1;
37	0	}
38
39		int ogs_yaml_iter_next(ogs_yaml_iter_t *iter)
40	0	{
41	0	ogs_assert(iter);
42	0	ogs_assert(iter->document);
43	0	ogs_assert(iter->node);
44
45	0	if (iter->node->type == YAML_MAPPING_NODE)
46	0	{
47	0	if (iter->pair)
48	0	{
49	0	iter->pair++;
50	0	if (iter->pair < iter->node->data.mapping.pairs.top)
51	0	return 1;
52	0	}
53
54	0	}
55	0	else if (iter->node->type == YAML_SEQUENCE_NODE)
56	0	{
57	0	if (iter->item)
58	0	{
59	0	iter->item++;
60	0	if (iter->item < iter->node->data.sequence.items.top)
61	0	return 1;
62	0	}
63	0	}
64
65	0	return 0;
66	0	}
67
68		void ogs_yaml_iter_recurse(ogs_yaml_iter_t parent, ogs_yaml_iter_t iter)
69	0	{
70	0	ogs_assert(parent);
71	0	ogs_assert(parent->document);
72	0	ogs_assert(parent->node);
73	0	ogs_assert(iter);
74
75	0	memset(iter, 0, sizeof(ogs_yaml_iter_t));
76
77	0	iter->document = parent->document;
78
79	0	if (parent->node->type == YAML_MAPPING_NODE)
80	0	{
81	0	ogs_assert(parent->pair);
82	0	iter->node = yaml_document_get_node(
83	0	parent->document, parent->pair->value);
84	0	ogs_assert(iter->node);
85	0	if (iter->node->type == YAML_MAPPING_NODE)
86	0	iter->pair = iter->node->data.mapping.pairs.start - 1;
87	0	else if (iter->node->type == YAML_SEQUENCE_NODE)
88	0	iter->item = iter->node->data.sequence.items.start - 1;
89	0	}
90	0	else if (parent->node->type == YAML_SEQUENCE_NODE)
91	0	{
92	0	ogs_assert(parent->item);
93	0	iter->node = yaml_document_get_node(parent->document, *parent->item);
94	0	ogs_assert(iter->node);
95	0	if (iter->node->type == YAML_MAPPING_NODE)
96	0	iter->pair = iter->node->data.mapping.pairs.start - 1;
97	0	else if (iter->node->type == YAML_SEQUENCE_NODE)
98	0	iter->item = iter->node->data.sequence.items.start - 1;
99	0	}
100	0	else
101	0	ogs_assert_if_reached();
102	0	}
103
104		int ogs_yaml_iter_type(ogs_yaml_iter_t *iter)
105	0	{
106	0	ogs_assert(iter);
107	0	ogs_assert(iter->node);
108
109	0	return iter->node->type;
110	0	}
111
112
113		const char ogs_yaml_iter_key(ogs_yaml_iter_t iter)
114	0	{
115	0	yaml_node_t *node = NULL;
116
117	0	ogs_assert(iter);
118	0	ogs_assert(iter->document);
119	0	ogs_assert(iter->node);
120
121	0	if (iter->node->type == YAML_MAPPING_NODE)
122	0	{
123	0	ogs_assert(iter->pair);
124	0	node = yaml_document_get_node(iter->document, iter->pair->key);
125	0	ogs_assert(node);
126	0	ogs_assert(node->type == YAML_SCALAR_NODE);
127
128	0	return (const char *)node->data.scalar.value;
129	0	}
130	0	else if (iter->node->type == YAML_SEQUENCE_NODE)
131	0	{
132	0	ogs_assert(iter->item);
133	0	node = yaml_document_get_node(iter->document, *iter->item);
134	0	ogs_assert(node);
135	0	ogs_assert(node->type == YAML_SCALAR_NODE);
136
137	0	return (const char *)node->data.scalar.value;
138	0	}
139
140	0	ogs_assert_if_reached();
141	0	return NULL;
142	0	}
143
144		const char ogs_yaml_iter_value(ogs_yaml_iter_t iter)
145	0	{
146	0	ogs_assert(iter);
147	0	ogs_assert(iter->document);
148	0	ogs_assert(iter->node);
149
150	0	if (iter->node->type == YAML_SCALAR_NODE)
151	0	{
152	0	return (const char *)iter->node->data.scalar.value;
153	0	}
154	0	else if (iter->node->type == YAML_MAPPING_NODE)
155	0	{
156	0	yaml_node_t *node = NULL;
157
158	0	ogs_assert(iter->pair);
159	0	node = yaml_document_get_node(iter->document, iter->pair->value);
160	0	ogs_assert(node);
161	0	ogs_assert(node->type == YAML_SCALAR_NODE);
162
163	0	return (const char *)node->data.scalar.value;
164	0	}
165	0	else if (iter->node->type == YAML_SEQUENCE_NODE)
166	0	{
167	0	yaml_node_t *node = NULL;
168
169	0	ogs_assert(iter->item);
170	0	node = yaml_document_get_node(iter->document, *iter->item);
171	0	ogs_assert(node);
172	0	ogs_assert(node->type == YAML_SCALAR_NODE);
173
174	0	return (const char *)node->data.scalar.value;
175	0	}
176
177	0	ogs_assert_if_reached();
178	0	return NULL;
179	0	}
180
181		int ogs_yaml_iter_has_value(ogs_yaml_iter_t *iter)
182	0	{
183	0	ogs_assert(iter);
184	0	ogs_assert(iter->document);
185	0	ogs_assert(iter->node);
186
187	0	if (iter->node->type == YAML_SCALAR_NODE) {
188	0	return 1;
189	0	} else if (iter->node->type == YAML_MAPPING_NODE) {
190	0	yaml_node_t *node = NULL;
191
192	0	ogs_assert(iter->pair);
193	0	node = yaml_document_get_node(iter->document, iter->pair->value);
194	0	ogs_assert(node);
195	0	return node->type == YAML_SCALAR_NODE;
196	0	} else if (iter->node->type == YAML_SEQUENCE_NODE) {
197	0	yaml_node_t *node = NULL;
198
199	0	ogs_assert(iter->item);
200	0	node = yaml_document_get_node(iter->document, *iter->item);
201	0	ogs_assert(node);
202	0	return node->type == YAML_SCALAR_NODE;
203	0	}
204
205	0	ogs_assert_if_reached();
206	0	return 0;
207	0	}
208
209		int ogs_yaml_iter_bool(ogs_yaml_iter_t *iter)
210	0	{
211	0	const char *v = ogs_yaml_iter_value(iter);
212	0	if (v)
213	0	{
214	0	if (!strcasecmp(v, "true") \|\| !strcasecmp(v, "yes")) return 1;
215	0	if (atoi(v)) return 1;
216	0	}
217
218	0	return 0;
219	0	}