Debian Codegraph @

src/syntax.c

raw
1 // Copyright 2011-2015 David Robillard <[email protected]>
2 // SPDX-License-Identifier: ISC
3
4 #include <serd/serd.h>
5 #include <sord/sord.h>
6
7 #include <stdbool.h>
8 #include <stdint.h>
9 #include <stdlib.h>
10 #include <string.h>
11
12 struct SordInserterImpl {
13 SordModel* model;
14 SerdEnv* env;
15 };
16
17 SordInserter*
18 sord_inserter_new(SordModel* model, SerdEnv* env)
19 {
20 SordInserter* inserter = (SordInserter*)malloc(sizeof(SordInserter));
21 inserter->model = model;
22 inserter->env = env;
23 return inserter;
24 }
25
26 void
27 sord_inserter_free(SordInserter* inserter)
28 {
29 free(inserter);
30 }
31
32 SerdStatus
33 sord_inserter_set_base_uri(SordInserter* inserter, const SerdNode* uri)
34 {
35 return serd_env_set_base_uri(inserter->env, uri);
36 }
37
38 SerdStatus
39 sord_inserter_set_prefix(SordInserter* inserter,
40 const SerdNode* name,
41 const SerdNode* uri)
42 {
43 return serd_env_set_prefix(inserter->env, name, uri);
44 }
45
46 SerdStatus
47 sord_inserter_write_statement(SordInserter* inserter,
48 SerdStatementFlags flags,
49 const SerdNode* graph,
50 const SerdNode* subject,
51 const SerdNode* predicate,
52 const SerdNode* object,
53 const SerdNode* object_datatype,
54 const SerdNode* object_lang)
55 {
56 (void)flags;
57
58 SordWorld* world = sord_get_world(inserter->model);
59 SerdEnv* env = inserter->env;
60
61 SordNode* g = sord_node_from_serd_node(world, env, graph, NULL, NULL);
62 SordNode* s = sord_node_from_serd_node(world, env, subject, NULL, NULL);
63 SordNode* p = sord_node_from_serd_node(world, env, predicate, NULL, NULL);
64 SordNode* o =
65 sord_node_from_serd_node(world, env, object, object_datatype, object_lang);
66
67 if (!s || !p || !o) {
68 return SERD_ERR_BAD_ARG;
69 }
70
71 const SordQuad tup = {s, p, o, g};
72 sord_add(inserter->model, tup);
73
74 sord_node_free(world, o);
75 sord_node_free(world, p);
76 sord_node_free(world, s);
77 sord_node_free(world, g);
78
79 return SERD_SUCCESS;
80 }
81
82 SORD_API SerdReader*
83 sord_new_reader(SordModel* model,
84 SerdEnv* env,
85 SerdSyntax syntax,
86 const SordNode* graph)
87 {
88 SordInserter* inserter = sord_inserter_new(model, env);
89
90 SerdReader* reader =
91 serd_reader_new(syntax,
92 inserter,
93 (void (*)(void* ptr))sord_inserter_free,
94 (SerdBaseSink)sord_inserter_set_base_uri,
95 (SerdPrefixSink)sord_inserter_set_prefix,
96 (SerdStatementSink)sord_inserter_write_statement,
97 NULL);
98
99 if (graph) {
100 serd_reader_set_default_graph(reader, sord_node_to_serd_node(graph));
101 }
102
103 return reader;
104 }
105
106 static SerdStatus
107 write_statement(SordModel* sord,
108 SerdWriter* writer,
109 SordQuad tup,
110 SerdStatementFlags flags)
111 {
112 const SordNode* s = tup[SORD_SUBJECT];
113 const SordNode* p = tup[SORD_PREDICATE];
114 const SordNode* o = tup[SORD_OBJECT];
115 const SordNode* d = sord_node_get_datatype(o);
116 const SerdNode* ss = sord_node_to_serd_node(s);
117 const SerdNode* sp = sord_node_to_serd_node(p);
118 const SerdNode* so = sord_node_to_serd_node(o);
119 const SerdNode* sd = sord_node_to_serd_node(d);
120
121 const char* lang_str = sord_node_get_language(o);
122 size_t lang_len = lang_str ? strlen(lang_str) : 0;
123 SerdNode language = SERD_NODE_NULL;
124 if (lang_str) {
125 language.type = SERD_LITERAL;
126 language.n_bytes = lang_len;
127 language.n_chars = lang_len;
128 language.buf = (const uint8_t*)lang_str;
129 }
130
131 // TODO: Subject abbreviation
132
133 if (sord_node_is_inline_object(s) && !(flags & SERD_ANON_CONT)) {
134 return SERD_SUCCESS;
135 }
136
137 SerdStatus st = SERD_SUCCESS;
138 if (sord_node_is_inline_object(o)) {
139 SordQuad sub_pat = {o, 0, 0, 0};
140 SordIter* sub_iter = sord_find(sord, sub_pat);
141
142 SerdStatementFlags start_flags =
143 flags | ((sub_iter) ? SERD_ANON_O_BEGIN : SERD_EMPTY_O);
144
145 st = serd_writer_write_statement(
146 writer, start_flags, NULL, ss, sp, so, sd, &language);
147
148 if (!st && sub_iter) {
149 flags |= SERD_ANON_CONT;
150 for (; !st && !sord_iter_end(sub_iter); sord_iter_next(sub_iter)) {
151 SordQuad sub_tup;
152 sord_iter_get(sub_iter, sub_tup);
153 st = write_statement(sord, writer, sub_tup, flags);
154 }
155 serd_writer_end_anon(writer, so);
156 }
157 sord_iter_free(sub_iter);
158 } else {
159 st = serd_writer_write_statement(
160 writer, flags, NULL, ss, sp, so, sd, &language);
161 }
162
163 return st;
164 }
165
166 bool
167 sord_write(SordModel* model, SerdWriter* writer, const SordNode* graph)
168 {
169 SordQuad pat = {0, 0, 0, graph};
170 SordIter* iter = sord_find(model, pat);
171 return sord_write_iter(iter, writer);
172 }
173
174 static bool
175 sord_write_iter_internal(SordIter* iter, SerdWriter* writer)
176 {
177 SordModel* model = (SordModel*)sord_iter_get_model(iter);
178 SerdStatus st = SERD_SUCCESS;
179 for (; !st && !sord_iter_end(iter); sord_iter_next(iter)) {
180 SordQuad tup;
181 sord_iter_get(iter, tup);
182 st = write_statement(model, writer, tup, 0);
183 }
184 sord_iter_free(iter);
185
186 return !st;
187 }
188
189 bool
190 sord_write_iter(SordIter* iter, SerdWriter* writer)
191 {
192 return iter ? sord_write_iter_internal(iter, writer) : false;
193 }