Annotation of docbook2mdoc/node.c, Revision 1.22
1.22 ! schwarze 1: /* $Id: node.c,v 1.21 2019/04/16 14:58:19 schwarze Exp $ */
1.1 schwarze 2: /*
3: * Copyright (c) 2014 Kristaps Dzonsons <kristaps@bsd.lv>
4: * Copyright (c) 2019 Ingo Schwarze <schwarze@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
1.10 schwarze 18: #include <assert.h>
1.1 schwarze 19: #include <stdlib.h>
20: #include <string.h>
21:
22: #include "node.h"
23:
24: /*
25: * The implementation of the DocBook syntax tree.
26: */
27:
1.10 schwarze 28: struct nodeprop {
29: const char *name;
30: enum nodeclass class;
31: };
32:
33: static const struct nodeprop properties[] = {
34: { "appendix", CLASS_BLOCK },
35: { "arg", CLASS_ENCL },
36: { "author", CLASS_LINE },
37: { "authorgroup", CLASS_BLOCK },
38: { "blockquote", CLASS_BLOCK },
39: { "bookinfo", CLASS_BLOCK },
40: { "caution", CLASS_BLOCK },
41: { "citerefentry", CLASS_LINE },
42: { "citetitle", CLASS_LINE },
43: { "cmdsynopsis", CLASS_TRANS },
44: { "colspec", CLASS_VOID },
45: { "command", CLASS_LINE },
46: { "constant", CLASS_LINE },
47: { "contrib", CLASS_TRANS },
1.15 schwarze 48: { "copyright", CLASS_LINE },
1.10 schwarze 49: { "date", CLASS_TRANS },
50: { "!DOCTYPE", CLASS_VOID },
51: { "editor", CLASS_LINE },
52: { "email", CLASS_ENCL },
53: { "emphasis", CLASS_LINE },
54: { "!ENTITY", CLASS_VOID },
55: { "entry", CLASS_ENCL },
56: { "envar", CLASS_LINE },
57: { "errorname", CLASS_LINE },
58: { "fieldsynopsis", CLASS_TRANS },
59: { "filename", CLASS_LINE },
60: { "firstterm", CLASS_LINE },
1.17 schwarze 61: { "footnote", CLASS_BLOCK },
1.10 schwarze 62: { "funcdef", CLASS_BLOCK },
63: { "funcprototype", CLASS_BLOCK },
64: { "funcsynopsis", CLASS_TRANS },
65: { "funcsynopsisinfo", CLASS_LINE },
66: { "function", CLASS_LINE },
67: { "glossterm", CLASS_LINE },
68: { "group", CLASS_ENCL },
1.18 schwarze 69: { "imagedata", CLASS_TEXT },
1.10 schwarze 70: { "xi:include", CLASS_VOID },
71: { "index", CLASS_TRANS },
72: { "info", CLASS_TRANS },
73: { "informalequation", CLASS_BLOCK },
74: { "inlineequation", CLASS_BLOCK },
75: { "itemizedlist", CLASS_BLOCK },
76: { "keysym", CLASS_LINE },
77: { "legalnotice", CLASS_BLOCK },
78: { "link", CLASS_ENCL },
79: { "listitem", CLASS_TRANS },
80: { "literal", CLASS_ENCL },
1.21 schwarze 81: { "literallayout", CLASS_NOFILL },
1.10 schwarze 82: { "manvolnum", CLASS_TRANS },
83: { "markup", CLASS_LINE },
84: { "member", CLASS_LINE },
85: { "mml:math", CLASS_LINE },
86: { "mml:mfenced", CLASS_LINE },
87: { "mml:mfrac", CLASS_LINE },
88: { "mml:mi", CLASS_LINE },
89: { "mml:mn", CLASS_LINE },
90: { "mml:mo", CLASS_LINE },
91: { "mml:mrow", CLASS_LINE },
92: { "mml:msub", CLASS_LINE },
93: { "mml:msup", CLASS_LINE },
94: { "modifier", CLASS_LINE },
95: { "note", CLASS_BLOCK },
1.19 schwarze 96: { "olink", CLASS_ENCL },
1.10 schwarze 97: { "option", CLASS_LINE },
98: { "orderedlist", CLASS_BLOCK },
99: { "para", CLASS_BLOCK },
100: { "paramdef", CLASS_LINE },
101: { "parameter", CLASS_LINE },
102: { "personname", CLASS_TRANS },
103: { "preface", CLASS_BLOCK },
1.22 ! schwarze 104: { "productname", CLASS_LINE },
1.21 schwarze 105: { "programlisting", CLASS_NOFILL },
1.10 schwarze 106: { "prompt", CLASS_TRANS },
1.12 schwarze 107: { "pubdate", CLASS_TRANS },
1.10 schwarze 108: { "quote", CLASS_ENCL },
109: { "refclass", CLASS_TRANS },
110: { "refdescriptor", CLASS_TRANS },
111: { "refentry", CLASS_TRANS },
112: { "refentryinfo", CLASS_VOID },
113: { "refentrytitle", CLASS_TRANS },
114: { "refmeta", CLASS_TRANS },
115: { "refmetainfo", CLASS_TRANS },
116: { "refmiscinfo", CLASS_TRANS },
117: { "refname", CLASS_LINE },
118: { "refnamediv", CLASS_BLOCK },
119: { "refpurpose", CLASS_LINE },
120: { "refsynopsisdiv", CLASS_BLOCK },
121: { "replaceable", CLASS_LINE },
122: { "row", CLASS_BLOCK },
123: { "sbr", CLASS_BLOCK },
1.21 schwarze 124: { "screen", CLASS_NOFILL },
1.10 schwarze 125: { "section", CLASS_BLOCK },
126: { "simplelist", CLASS_TRANS },
1.15 schwarze 127: { "simplesect", CLASS_BLOCK },
1.10 schwarze 128: { "spanspec", CLASS_TRANS },
1.16 schwarze 129: { "subscript", CLASS_TEXT },
1.15 schwarze 130: { "subtitle", CLASS_BLOCK },
1.16 schwarze 131: { "superscript", CLASS_TEXT },
1.21 schwarze 132: { "synopsis", CLASS_NOFILL },
1.13 schwarze 133: { "systemitem", CLASS_LINE },
1.10 schwarze 134: { "table", CLASS_TRANS },
135: { "tbody", CLASS_TRANS },
136: { "term", CLASS_LINE },
137: { "tfoot", CLASS_TRANS },
138: { "tgroup", CLASS_BLOCK },
139: { "thead", CLASS_TRANS },
140: { "tip", CLASS_BLOCK },
141: { "title", CLASS_BLOCK },
142: { "type", CLASS_LINE },
143: { "variablelist", CLASS_BLOCK },
144: { "varlistentry", CLASS_BLOCK },
145: { "varname", CLASS_LINE },
146: { "warning", CLASS_BLOCK },
147: { "wordasword", CLASS_TRANS },
1.20 schwarze 148: { "xref", CLASS_LINE },
1.10 schwarze 149: { "[UNKNOWN]", CLASS_VOID },
1.11 schwarze 150: { "(t)", CLASS_TEXT },
151: { "(e)", CLASS_TEXT }
1.10 schwarze 152: };
153:
1.1 schwarze 154: static const char *const attrkeys[ATTRKEY__MAX] = {
155: "choice",
156: "class",
157: "close",
1.3 schwarze 158: "cols",
1.5 schwarze 159: "DEFINITION",
1.4 schwarze 160: "endterm",
1.18 schwarze 161: "entityref",
162: "fileref",
1.6 schwarze 163: "href",
1.1 schwarze 164: "id",
165: "linkend",
1.19 schwarze 166: "localinfo",
1.5 schwarze 167: "NAME",
1.1 schwarze 168: "open",
1.5 schwarze 169: "PUBLIC",
1.4 schwarze 170: "rep",
1.5 schwarze 171: "SYSTEM",
1.19 schwarze 172: "targetdoc",
173: "targetptr",
1.4 schwarze 174: "url",
175: "xlink:href"
1.1 schwarze 176: };
177:
178: static const char *const attrvals[ATTRVAL__MAX] = {
1.13 schwarze 179: "event",
180: "ipaddress",
1.1 schwarze 181: "monospaced",
182: "norepeat",
183: "opt",
184: "plain",
185: "repeat",
1.13 schwarze 186: "req",
187: "systemname"
1.1 schwarze 188: };
189:
190: enum attrkey
191: attrkey_parse(const char *name)
192: {
193: enum attrkey key;
194:
195: for (key = 0; key < ATTRKEY__MAX; key++)
196: if (strcmp(name, attrkeys[key]) == 0)
197: break;
198: return key;
199: }
200:
1.11 schwarze 201: const char *
202: attrkey_name(enum attrkey key)
203: {
204: return attrkeys[key];
205: }
206:
1.1 schwarze 207: enum attrval
208: attrval_parse(const char *name)
209: {
210: enum attrval val;
211:
212: for (val = 0; val < ATTRVAL__MAX; val++)
213: if (strcmp(name, attrvals[val]) == 0)
214: break;
215: return val;
1.11 schwarze 216: }
217:
218: const char *
219: attr_getval(const struct pattr *a)
220: {
221: return a->val == ATTRVAL__MAX ? a->rawval : attrvals[a->val];
1.10 schwarze 222: }
223:
224: enum nodeid
225: pnode_parse(const char *name)
226: {
227: enum nodeid node;
228:
229: for (node = 0; node < NODE_UNKNOWN; node++)
230: if (strcmp(name, properties[node].name) == 0)
231: break;
232: return node;
233: }
234:
235: const char *
236: pnode_name(enum nodeid node)
237: {
238: assert(node < NODE_IGNORE);
239: return properties[node].name;
240: }
241:
242: enum nodeclass
243: pnode_class(enum nodeid node)
244: {
245: assert(node < NODE_IGNORE);
246: return properties[node].class;
1.9 schwarze 247: }
248:
249: struct pnode *
250: pnode_alloc(struct pnode *np)
251: {
252: struct pnode *n;
253:
254: if ((n = calloc(1, sizeof(*n))) != NULL) {
255: TAILQ_INIT(&n->childq);
256: TAILQ_INIT(&n->attrq);
257: if ((n->parent = np) != NULL)
258: TAILQ_INSERT_TAIL(&np->childq, n, child);
259: }
260: return n;
1.1 schwarze 261: }
262:
263: /*
264: * Recursively free a node (NULL is ok).
265: */
266: static void
1.7 schwarze 267: pnode_free(struct pnode *n)
1.1 schwarze 268: {
1.7 schwarze 269: struct pnode *nc;
270: struct pattr *a;
1.1 schwarze 271:
1.7 schwarze 272: if (n == NULL)
1.1 schwarze 273: return;
274:
1.7 schwarze 275: while ((nc = TAILQ_FIRST(&n->childq)) != NULL) {
276: TAILQ_REMOVE(&n->childq, nc, child);
277: pnode_free(nc);
1.1 schwarze 278: }
1.7 schwarze 279: while ((a = TAILQ_FIRST(&n->attrq)) != NULL) {
280: TAILQ_REMOVE(&n->attrq, a, child);
281: free(a->rawval);
282: free(a);
1.1 schwarze 283: }
1.8 schwarze 284: free(n->b);
1.7 schwarze 285: free(n);
1.1 schwarze 286: }
287:
288: /*
289: * Unlink a node from its parent and pnode_free() it.
290: */
291: void
1.7 schwarze 292: pnode_unlink(struct pnode *n)
1.1 schwarze 293: {
1.7 schwarze 294: if (n == NULL)
1.1 schwarze 295: return;
1.7 schwarze 296: if (n->parent != NULL)
297: TAILQ_REMOVE(&n->parent->childq, n, child);
298: pnode_free(n);
1.1 schwarze 299: }
300:
301: /*
302: * Unlink all children of a node and pnode_free() them.
303: */
304: void
1.7 schwarze 305: pnode_unlinksub(struct pnode *n)
1.1 schwarze 306: {
1.7 schwarze 307: while (TAILQ_EMPTY(&n->childq) == 0)
308: pnode_unlink(TAILQ_FIRST(&n->childq));
1.1 schwarze 309: }
310:
311: /*
312: * Retrieve an enumeration attribute from a node.
313: * Return ATTRVAL__MAX if the node has no such attribute.
314: */
315: enum attrval
1.7 schwarze 316: pnode_getattr(struct pnode *n, enum attrkey key)
1.1 schwarze 317: {
1.7 schwarze 318: struct pattr *a;
1.1 schwarze 319:
1.7 schwarze 320: if (n == NULL)
1.1 schwarze 321: return ATTRVAL__MAX;
1.7 schwarze 322: TAILQ_FOREACH(a, &n->attrq, child)
323: if (a->key == key)
324: return a->val;
1.1 schwarze 325: return ATTRVAL__MAX;
326: }
327:
328: /*
329: * Retrieve an attribute string from a node.
330: * Return defval if the node has no such attribute.
331: */
332: const char *
1.7 schwarze 333: pnode_getattr_raw(struct pnode *n, enum attrkey key, const char *defval)
1.1 schwarze 334: {
1.7 schwarze 335: struct pattr *a;
1.1 schwarze 336:
1.7 schwarze 337: if (n == NULL)
1.1 schwarze 338: return defval;
1.7 schwarze 339: TAILQ_FOREACH(a, &n->attrq, child)
340: if (a->key == key)
341: return a->val != ATTRVAL__MAX ? attrvals[a->val] :
342: a->rawval != NULL ? a->rawval : defval;
1.1 schwarze 343: return defval;
344: }
345:
346: /*
347: * Recursively search and return the first instance of "node".
348: */
349: struct pnode *
1.7 schwarze 350: pnode_findfirst(struct pnode *n, enum nodeid node)
1.1 schwarze 351: {
1.7 schwarze 352: struct pnode *nc, *res;
1.1 schwarze 353:
1.12 schwarze 354: if (n == NULL)
355: return NULL;
1.7 schwarze 356: if (n->node == node)
357: return n;
358: TAILQ_FOREACH(nc, &n->childq, child)
359: if ((res = pnode_findfirst(nc, node)) != NULL)
1.1 schwarze 360: return res;
361: return NULL;
1.12 schwarze 362: }
363:
364: /*
365: * Like pnode_findfirst(), but also take the node out of the tree.
366: */
367: struct pnode *
368: pnode_takefirst(struct pnode *n, enum nodeid node)
369: {
370: struct pnode *nc;
371:
372: if ((nc = pnode_findfirst(n, node)) != NULL && nc->parent != NULL)
373: TAILQ_REMOVE(&nc->parent->childq, nc, child);
374: return nc;
1.1 schwarze 375: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to node.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / docbook2mdoc