Annotation of src/usr.bin/mandoc/dba.c, Revision 1.5
1.5 ! schwarze 1: /* $OpenBSD: dba.c,v 1.4 2016/08/17 18:58:31 schwarze Exp $ */
1.1 schwarze 2: /*
3: * Copyright (c) 2016 Ingo Schwarze <schwarze@openbsd.org>
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: *
17: * Allocation-based version of the mandoc database, for read-write access.
18: * The interface is defined in "dba.h".
19: */
20: #include <sys/types.h>
1.2 schwarze 21: #include <endian.h>
1.1 schwarze 22: #include <errno.h>
23: #include <stdint.h>
24: #include <stdlib.h>
25: #include <string.h>
26: #include <unistd.h>
27:
28: #include "mandoc_aux.h"
29: #include "mansearch.h"
30: #include "dba_write.h"
31: #include "dba_array.h"
32: #include "dba.h"
33:
34: static void *prepend(const char *, char);
35: static void dba_pages_write(struct dba_array *);
36: static int compare_names(const void *, const void *);
37: static int compare_strings(const void *, const void *);
38: static void dba_macros_write(struct dba_array *);
39: static void dba_macro_write(struct dba_array *);
40:
41:
42: /*** top-level functions **********************************************/
43:
44: struct dba *
45: dba_new(int32_t npages)
46: {
47: struct dba *dba;
48: int32_t im;
49:
50: dba = mandoc_malloc(sizeof(*dba));
51: dba->pages = dba_array_new(npages, DBA_GROW);
52: dba->macros = dba_array_new(MACRO_MAX, 0);
53: for (im = 0; im < MACRO_MAX; im++)
54: dba_array_set(dba->macros, im, dba_array_new(128, DBA_GROW));
55: return dba;
56: }
57:
58: void
59: dba_free(struct dba *dba)
60: {
61: struct dba_array *page, *macro, *entry;
62:
63: dba_array_FOREACH(dba->macros, macro) {
64: dba_array_undel(macro);
65: dba_array_FOREACH(macro, entry) {
66: free(dba_array_get(entry, 0));
67: dba_array_free(dba_array_get(entry, 1));
68: dba_array_free(entry);
69: }
70: dba_array_free(macro);
71: }
72: dba_array_free(dba->macros);
73:
74: dba_array_undel(dba->pages);
75: dba_array_FOREACH(dba->pages, page) {
76: dba_array_free(dba_array_get(page, DBP_NAME));
77: dba_array_free(dba_array_get(page, DBP_SECT));
78: dba_array_free(dba_array_get(page, DBP_ARCH));
79: free(dba_array_get(page, DBP_DESC));
80: dba_array_free(dba_array_get(page, DBP_FILE));
81: dba_array_free(page);
82: }
83: dba_array_free(dba->pages);
84:
85: free(dba);
86: }
87:
88: /*
89: * Write the complete mandoc database to disk; the format is:
90: * - One integer each for magic and version.
91: * - One pointer each to the macros table and to the final magic.
92: * - The pages table.
93: * - The macros table.
94: * - And at the very end, the magic integer again.
95: */
96: int
97: dba_write(const char *fname, struct dba *dba)
98: {
99: int save_errno;
100: int32_t pos_end, pos_macros, pos_macros_ptr;
101:
102: if (dba_open(fname) == -1)
103: return -1;
104: dba_int_write(MANDOCDB_MAGIC);
105: dba_int_write(MANDOCDB_VERSION);
106: pos_macros_ptr = dba_skip(1, 2);
107: dba_pages_write(dba->pages);
108: pos_macros = dba_tell();
109: dba_macros_write(dba->macros);
110: pos_end = dba_tell();
111: dba_int_write(MANDOCDB_MAGIC);
112: dba_seek(pos_macros_ptr);
113: dba_int_write(pos_macros);
114: dba_int_write(pos_end);
115: if (dba_close() == -1) {
116: save_errno = errno;
117: unlink(fname);
118: errno = save_errno;
119: return -1;
120: }
121: return 0;
122: }
123:
124:
125: /*** functions for handling pages *************************************/
126:
127: /*
128: * Create a new page and append it to the pages table.
129: */
130: struct dba_array *
1.5 ! schwarze 131: dba_page_new(struct dba_array *pages, const char *arch,
! 132: const char *desc, const char *file, enum form form)
1.1 schwarze 133: {
134: struct dba_array *page, *entry;
135:
136: page = dba_array_new(DBP_MAX, 0);
137: entry = dba_array_new(1, DBA_STR | DBA_GROW);
138: dba_array_add(page, entry);
139: entry = dba_array_new(1, DBA_STR | DBA_GROW);
140: dba_array_add(page, entry);
141: if (arch != NULL && *arch != '\0') {
142: entry = dba_array_new(1, DBA_STR | DBA_GROW);
143: dba_array_add(entry, (void *)arch);
144: } else
145: entry = NULL;
146: dba_array_add(page, entry);
147: dba_array_add(page, mandoc_strdup(desc));
148: entry = dba_array_new(1, DBA_STR | DBA_GROW);
149: dba_array_add(entry, prepend(file, form));
150: dba_array_add(page, entry);
151: dba_array_add(pages, page);
152: return page;
153: }
154:
155: /*
156: * Add a section, architecture, or file name to an existing page.
157: * Passing the NULL pointer for the architecture makes the page MI.
158: * In that case, any earlier or later architectures are ignored.
159: */
160: void
161: dba_page_add(struct dba_array *page, int32_t ie, const char *str)
162: {
163: struct dba_array *entries;
164: char *entry;
165:
166: entries = dba_array_get(page, ie);
167: if (ie == DBP_ARCH) {
168: if (entries == NULL)
169: return;
1.3 schwarze 170: if (str == NULL || *str == '\0') {
1.1 schwarze 171: dba_array_free(entries);
172: dba_array_set(page, DBP_ARCH, NULL);
173: return;
174: }
175: }
176: if (*str == '\0')
177: return;
178: dba_array_FOREACH(entries, entry) {
179: if (ie == DBP_FILE && *entry < ' ')
180: entry++;
181: if (strcmp(entry, str) == 0)
182: return;
183: }
184: dba_array_add(entries, (void *)str);
185: }
186:
187: /*
188: * Add an additional name to an existing page.
189: */
190: void
191: dba_page_alias(struct dba_array *page, const char *name, uint64_t mask)
192: {
193: struct dba_array *entries;
194: char *entry;
195: char maskbyte;
196:
197: if (*name == '\0')
198: return;
199: maskbyte = mask & NAME_MASK;
200: entries = dba_array_get(page, DBP_NAME);
201: dba_array_FOREACH(entries, entry) {
202: if (strcmp(entry + 1, name) == 0) {
203: *entry |= maskbyte;
204: return;
205: }
206: }
207: dba_array_add(entries, prepend(name, maskbyte));
208: }
209:
210: /*
211: * Return a pointer to a temporary copy of instr with inbyte prepended.
212: */
213: static void *
214: prepend(const char *instr, char inbyte)
215: {
216: static char *outstr = NULL;
217: static size_t outlen = 0;
218: size_t newlen;
219:
220: newlen = strlen(instr) + 1;
221: if (newlen > outlen) {
222: outstr = mandoc_realloc(outstr, newlen + 1);
223: outlen = newlen;
224: }
225: *outstr = inbyte;
226: memcpy(outstr + 1, instr, newlen);
227: return outstr;
228: }
229:
230: /*
231: * Write the pages table to disk; the format is:
232: * - One integer containing the number of pages.
233: * - For each page, five pointers to the names, sections,
234: * architectures, description, and file names of the page.
235: * MI pages write 0 instead of the architecture pointer.
236: * - One list each for names, sections, architectures, descriptions and
237: * file names. The description for each page ends with a NUL byte.
238: * For all the other lists, each string ends with a NUL byte,
239: * and the last string for a page ends with two NUL bytes.
240: * - To assure alignment of following integers,
241: * the end is padded with NUL bytes up to a multiple of four bytes.
242: */
243: static void
244: dba_pages_write(struct dba_array *pages)
245: {
246: struct dba_array *page, *entry;
247: int32_t pos_pages, pos_end;
248:
249: pos_pages = dba_array_writelen(pages, 5);
250: dba_array_FOREACH(pages, page) {
251: dba_array_setpos(page, DBP_NAME, dba_tell());
252: entry = dba_array_get(page, DBP_NAME);
253: dba_array_sort(entry, compare_names);
254: dba_array_writelst(entry);
255: }
256: dba_array_FOREACH(pages, page) {
257: dba_array_setpos(page, DBP_SECT, dba_tell());
258: entry = dba_array_get(page, DBP_SECT);
259: dba_array_sort(entry, compare_strings);
260: dba_array_writelst(entry);
261: }
262: dba_array_FOREACH(pages, page) {
263: if ((entry = dba_array_get(page, DBP_ARCH)) != NULL) {
264: dba_array_setpos(page, DBP_ARCH, dba_tell());
265: dba_array_sort(entry, compare_strings);
266: dba_array_writelst(entry);
267: } else
268: dba_array_setpos(page, DBP_ARCH, 0);
269: }
270: dba_array_FOREACH(pages, page) {
271: dba_array_setpos(page, DBP_DESC, dba_tell());
272: dba_str_write(dba_array_get(page, DBP_DESC));
273: }
274: dba_array_FOREACH(pages, page) {
275: dba_array_setpos(page, DBP_FILE, dba_tell());
276: dba_array_writelst(dba_array_get(page, DBP_FILE));
277: }
278: pos_end = dba_align();
279: dba_seek(pos_pages);
280: dba_array_FOREACH(pages, page)
281: dba_array_writepos(page);
282: dba_seek(pos_end);
283: }
284:
285: static int
286: compare_names(const void *vp1, const void *vp2)
287: {
288: const char *cp1, *cp2;
289: int diff;
290:
291: cp1 = *(char **)vp1;
292: cp2 = *(char **)vp2;
293: return (diff = *cp2 - *cp1) ? diff :
294: strcasecmp(cp1 + 1, cp2 + 1);
295: }
296:
297: static int
298: compare_strings(const void *vp1, const void *vp2)
299: {
300: const char *cp1, *cp2;
301:
302: cp1 = *(char **)vp1;
303: cp2 = *(char **)vp2;
304: return strcmp(cp1, cp2);
305: }
306:
307: /*** functions for handling macros ************************************/
308:
309: /*
310: * Create a new macro entry and append it to one of the macro tables.
311: */
312: void
313: dba_macro_new(struct dba *dba, int32_t im, const char *value,
314: const int32_t *pp)
315: {
316: struct dba_array *entry, *pages;
317: const int32_t *ip;
318: int32_t np;
319:
320: np = 0;
321: for (ip = pp; *ip; ip++)
322: np++;
323: pages = dba_array_new(np, DBA_GROW);
324: for (ip = pp; *ip; ip++)
325: dba_array_add(pages, dba_array_get(dba->pages,
326: be32toh(*ip) / 5 / sizeof(*ip) - 1));
327:
328: entry = dba_array_new(2, 0);
329: dba_array_add(entry, mandoc_strdup(value));
330: dba_array_add(entry, pages);
331:
332: dba_array_add(dba_array_get(dba->macros, im), entry);
333: }
334:
335: /*
336: * Look up a macro entry by value and add a reference to a new page to it.
337: * If the value does not yet exist, create a new macro entry
338: * and add it to the macro table in question.
339: */
340: void
341: dba_macro_add(struct dba_array *macros, int32_t im, const char *value,
342: struct dba_array *page)
343: {
344: struct dba_array *macro, *entry, *pages;
345:
346: if (*value == '\0')
347: return;
348: macro = dba_array_get(macros, im);
349: dba_array_FOREACH(macro, entry)
350: if (strcmp(value, dba_array_get(entry, 0)) == 0)
351: break;
352: if (entry == NULL) {
353: entry = dba_array_new(2, 0);
354: dba_array_add(entry, mandoc_strdup(value));
355: pages = dba_array_new(1, DBA_GROW);
356: dba_array_add(entry, pages);
357: dba_array_add(macro, entry);
358: } else
359: pages = dba_array_get(entry, 1);
360: dba_array_add(pages, page);
361: }
362:
363: /*
364: * Write the macros table to disk; the format is:
365: * - The number of macro tables (actually, MACRO_MAX).
366: * - That number of pointers to the individual macro tables.
367: * - The individual macro tables.
368: */
369: static void
370: dba_macros_write(struct dba_array *macros)
371: {
372: struct dba_array *macro;
373: int32_t im, pos_macros, pos_end;
374:
375: pos_macros = dba_array_writelen(macros, 1);
376: im = 0;
377: dba_array_FOREACH(macros, macro) {
378: dba_array_setpos(macros, im++, dba_tell());
379: dba_macro_write(macro);
380: }
381: pos_end = dba_tell();
382: dba_seek(pos_macros);
383: dba_array_writepos(macros);
384: dba_seek(pos_end);
385: }
386:
387: /*
388: * Write one individual macro table to disk; the format is:
389: * - The number of entries in the table.
390: * - For each entry, two pointers, the first one to the value
391: * and the second one to the list of pages.
392: * - A list of values, each ending in a NUL byte.
393: * - To assure alignment of following integers,
394: * padding with NUL bytes up to a multiple of four bytes.
395: * - A list of pointers to pages, each list ending in a 0 integer.
396: */
397: static void
398: dba_macro_write(struct dba_array *macro)
399: {
400: struct dba_array *entry, *pages, *page;
401: int empty;
402: int32_t addr, pos_macro, pos_end;
403:
404: dba_array_FOREACH(macro, entry) {
405: pages = dba_array_get(entry, 1);
406: empty = 1;
407: dba_array_FOREACH(pages, page)
408: if (dba_array_getpos(page))
409: empty = 0;
410: if (empty)
411: dba_array_del(macro);
412: }
413: pos_macro = dba_array_writelen(macro, 2);
414: dba_array_FOREACH(macro, entry) {
415: dba_array_setpos(entry, 0, dba_tell());
416: dba_str_write(dba_array_get(entry, 0));
417: }
418: dba_align();
419: dba_array_FOREACH(macro, entry) {
420: dba_array_setpos(entry, 1, dba_tell());
421: pages = dba_array_get(entry, 1);
422: dba_array_FOREACH(pages, page)
423: if ((addr = dba_array_getpos(page)))
424: dba_int_write(addr);
425: dba_int_write(0);
426: }
427: pos_end = dba_tell();
428: dba_seek(pos_macro);
429: dba_array_FOREACH(macro, entry)
430: dba_array_writepos(entry);
431: dba_seek(pos_end);
432: }
![[BACK]](/icons/back.gif){kind=icon}
Return to dba.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / mandoc