mandoc/mandocdb.c - diff

Return to mandocdb.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandocdb.c between version 1.197 and 1.203

version 1.197, 2015/10/06 18:32:19

version 1.203, 2015/10/13 22:59:54

Line 23

#include <assert.h>

#include <ctype.h>

#include <err.h>

#include <errno.h>

#include <fcntl.h>

#if HAVE_FTS

Line 39

Line 40

#include <string.h>

#include <unistd.h>

#if HAVE_OHASH

#include <ohash.h>

#else

#include "compat_ohash.h"

#endif

#include <sqlite3.h>

#include "mandoc_aux.h"

#include "mandoc_ohash.h"

#include "mandoc.h"

#include "roff.h"

#include "mdoc.h"

Line 145 static void dbadd_mlink_name(const struct mlink *mlin

Line 142 static void dbadd_mlink_name(const struct mlink *mlin

static int dbopen(int);

static void dbprune(void);

static void filescan(const char *);

static void *hash_alloc(size_t, void *);

static void hash_free(void *, void *);

static void *hash_calloc(size_t, size_t, void *);

static void mlink_add(struct mlink *, const struct stat *);

static void mlink_check(struct mpage *, struct mlink *);

static void mlink_free(struct mlink *);

Line 189 static int set_basedir(const char *, int);

Line 183 static int set_basedir(const char *, int);

static int treescan(void);

static size_t utf8(unsigned int, char [7]);

extern char *__progname;

static char tempfilename[32];

static char *progname;

static int nodb; /* no database changes */

static int mparse_options; /* abort the parse early */

static int use_all; /* use all found files */

Line 200 static int write_utf8; /* write UTF-8 output; else A

Line 195 static int write_utf8; /* write UTF-8 output; else A

static int exitcode; /* to be returned by main */

static enum op op; /* operational mode */

static char basedir[PATH_MAX]; /* current base directory */

static struct mchars *mchars; /* table of named characters */

static struct ohash mpages; /* table of distinct manual pages */

static struct ohash mlinks; /* table of directory entries */

static struct ohash names; /* table of all names */

Line 340 int

Line 334 int

mandocdb(int argc, char *argv[])

{

struct manconf conf;

struct ohash_info mpages_info, mlinks_info;

struct mparse *mp;

const char *path_arg;

size_t j, sz;

Line 349 mandocdb(int argc, char *argv[])

Line 342 mandocdb(int argc, char *argv[])

memset(&conf, 0, sizeof(conf));

memset(stmts, 0, STMT__MAX * sizeof(sqlite3_stmt *));

mpages_info.alloc = mlinks_info.alloc = hash_alloc;

mpages_info.calloc = mlinks_info.calloc = hash_calloc;

mpages_info.free = mlinks_info.free = hash_free;

mpages_info.data = mlinks_info.data = NULL;

mpages_info.key_offset = offsetof(struct mpage, inodev);

mlinks_info.key_offset = offsetof(struct mlink, file);

progname = strrchr(argv[0], '/');

if (progname == NULL)

progname = argv[0];

else

++progname;

* We accept a few different invocations.

* The CHECKOP macro makes sure that invocation styles don't

Line 370 mandocdb(int argc, char *argv[])

Line 349 mandocdb(int argc, char *argv[])

#define CHECKOP(_op, _ch) do \

if (OP_DEFAULT != (_op)) { \

fprintf(stderr, "%s: -%c: Conflicting option\n", \

warnx("-%c: Conflicting option", (_ch)); \

progname, (_ch)); \

goto usage; \

} while (/*CONSTCOND*/0)

Line 407 mandocdb(int argc, char *argv[])

Line 385 mandocdb(int argc, char *argv[])

break;

case 'T':

if (strcmp(optarg, "utf8")) {

fprintf(stderr, "%s: -T%s: "

warnx("-T%s: Unsupported output format",

"Unsupported output format\n",

optarg);

progname, optarg);

goto usage;

}

write_utf8 = 1;

Line 436 mandocdb(int argc, char *argv[])

Line 413 mandocdb(int argc, char *argv[])

argv += optind;

if (OP_CONFFILE == op && argc > 0) {

fprintf(stderr, "%s: -C: Too many arguments\n",

warnx("-C: Too many arguments");

progname);

goto usage;

}

exitcode = (int)MANDOCLEVEL_OK;

mchars = mchars_alloc();

mchars_alloc();

mp = mparse_alloc(mparse_options, MANDOCLEVEL_BADARG, NULL,

mp = mparse_alloc(mparse_options, MANDOCLEVEL_BADARG, NULL, NULL);

mchars, NULL);

mandoc_ohash_init(&mpages, 6, offsetof(struct mpage, inodev));

ohash_init(&mpages, 6, &mpages_info);

mandoc_ohash_init(&mlinks, 6, offsetof(struct mlink, file));

ohash_init(&mlinks, 6, &mlinks_info);

if (OP_UPDATE == op || OP_DELETE == op || OP_TEST == op) {

Line 516 mandocdb(int argc, char *argv[])

Line 491 mandocdb(int argc, char *argv[])

continue;

if (j) {

ohash_init(&mpages, 6, &mpages_info);

mandoc_ohash_init(&mpages, 6,

ohash_init(&mlinks, 6, &mlinks_info);

offsetof(struct mpage, inodev));

mandoc_ohash_init(&mlinks, 6,

offsetof(struct mlink, file));

}

if ( ! set_basedir(conf.manpath.paths[j], argc > 0))

Line 543 mandocdb(int argc, char *argv[])

Line 520 mandocdb(int argc, char *argv[])

out:

manconf_free(&conf);

mparse_free(mp);

mchars_free(mchars);

mchars_free();

mpages_free();

ohash_delete(&mpages);

ohash_delete(&mlinks);

Line 554 usage:

Line 531 usage:

" %s [-DnpQ] [-Tutf8] -d dir [file ...]\n"

" %s [-Dnp] -u dir [file ...]\n"

" %s [-Q] -t file ...\n",

progname, progname, progname,

__progname, __progname, __progname,

progname, progname);

__progname, __progname);

return (int)MANDOCLEVEL_BADARG;

}

Line 591 treescan(void)

Line 568 treescan(void)

f = fts_open((char * const *)argv,

FTS_PHYSICAL | FTS_NOCHDIR, NULL);

if (NULL == f) {

if (f == NULL) {

exitcode = (int)MANDOCLEVEL_SYSERR;

say("", "&fts_open");

return 0;

Line 600 treescan(void)

Line 577 treescan(void)

dsec = arch = NULL;

dform = FORM_NONE;

while (NULL != (ff = fts_read(f))) {

while ((ff = fts_read(f)) != NULL) {

path = ff->fts_path + 2;

switch (ff->fts_info) {

Line 609 treescan(void)

Line 586 treescan(void)

* then get handled just like regular files.

case FTS_SL:

if (NULL == realpath(path, buf)) {

if (realpath(path, buf) == NULL) {

if (warnings)

say(path, "&realpath");

continue;

Line 624 treescan(void)

Line 601 treescan(void)

continue;

}

/* Use logical inode to avoid mpages dupe. */

if (-1 == stat(path, ff->fts_statp)) {

if (stat(path, ff->fts_statp) == -1) {

if (warnings)

say(path, "&stat");

continue;

Line 636 treescan(void)

Line 613 treescan(void)

* stored directory data and handling the filename.

case FTS_F:

if (0 == strcmp(path, MANDOC_DB))

if ( ! strcmp(path, MANDOC_DB))

continue;

if ( ! use_all && ff->fts_level < 2) {

if (warnings)

Line 645 treescan(void)

Line 622 treescan(void)

}

gzip = 0;

fsec = NULL;

while (NULL == fsec) {

while (fsec == NULL) {

fsec = strrchr(ff->fts_name, '.');

if (NULL == fsec || strcmp(fsec+1, "gz"))

if (fsec == NULL || strcmp(fsec+1, "gz"))

break;

gzip = 1;

*fsec = '\0';

fsec = NULL;

}

if (NULL == fsec) {

if (fsec == NULL) {

if ( ! use_all) {

if (warnings)

say(path,

"No filename suffix");

continue;

}

} else if (0 == strcmp(++fsec, "html")) {

} else if ( ! strcmp(++fsec, "html")) {

if (warnings)

say(path, "Skip html");

continue;

} else if (0 == strcmp(fsec, "ps")) {

} else if ( ! strcmp(fsec, "ps")) {

if (warnings)

say(path, "Skip ps");

continue;

} else if (0 == strcmp(fsec, "pdf")) {

} else if ( ! strcmp(fsec, "pdf")) {

if (warnings)

say(path, "Skip pdf");

continue;

} else if ( ! use_all &&

((FORM_SRC == dform &&

((dform == FORM_SRC &&

strncmp(fsec, dsec, strlen(dsec))) ||

(FORM_CAT == dform && strcmp(fsec, "0")))) {

(dform == FORM_CAT && strcmp(fsec, "0")))) {

if (warnings)

say(path, "Wrong filename suffix");

continue;

Line 700 treescan(void)

Line 677 treescan(void)

continue;

case FTS_D:

/* FALLTHROUGH */

case FTS_DP:

break;

Line 721 treescan(void)

Line 697 treescan(void)

* If we're not in use_all, enforce it.

cp = ff->fts_name;

if (FTS_DP == ff->fts_info)

if (ff->fts_info == FTS_DP) {

dform = FORM_NONE;

dsec = NULL;

break;

}

if (0 == strncmp(cp, "man", 3)) {

if ( ! strncmp(cp, "man", 3)) {

dform = FORM_SRC;

dsec = cp + 3;

} else if (0 == strncmp(cp, "cat", 3)) {

} else if ( ! strncmp(cp, "cat", 3)) {

dform = FORM_CAT;

dsec = cp + 3;

} else {

Line 735 treescan(void)

Line 714 treescan(void)

dsec = NULL;

}

if (NULL != dsec || use_all)

if (dsec != NULL || use_all)

break;

if (warnings)

Line 747 treescan(void)

Line 726 treescan(void)

* Possibly our architecture.

* If we're descending, keep tabs on it.

if (FTS_DP != ff->fts_info && NULL != dsec)

if (ff->fts_info != FTS_DP && dsec != NULL)

arch = ff->fts_name;

else

arch = NULL;

break;

default:

if (FTS_DP == ff->fts_info || use_all)

if (ff->fts_info == FTS_DP || use_all)

break;

if (warnings)

say(path, "Extraneous directory part");

Line 1104 static void

Line 1083 static void

mpages_merge(struct mparse *mp)

{

char any[] = "any";

struct ohash_info str_info;

struct mpage *mpage, *mpage_dest;

struct mlink *mlink, *mlink_dest;

struct roff_man *man;

Line 1113 mpages_merge(struct mparse *mp)

Line 1091 mpages_merge(struct mparse *mp)

int fd;

unsigned int pslot;

str_info.alloc = hash_alloc;

str_info.calloc = hash_calloc;

str_info.free = hash_free;

str_info.data = NULL;

str_info.key_offset = offsetof(struct str, key);

if ( ! nodb)

SQL_EXEC("BEGIN TRANSACTION");

Line 1131 mpages_merge(struct mparse *mp)

Line 1103 mpages_merge(struct mparse *mp)

}

name_mask = NAME_MASK;

ohash_init(&names, 4, &str_info);

mandoc_ohash_init(&names, 4, offsetof(struct str, key));

ohash_init(&strings, 6, &str_info);

mandoc_ohash_init(&strings, 6, offsetof(struct str, key));

mparse_reset(mp);

man = NULL;

sodest = NULL;

Line 1260 names_check(void)

Line 1232 names_check(void)

{

sqlite3_stmt *stmt;

const char *name, *sec, *arch, *key;

int irc;

sqlite3_prepare_v2(db,

"SELECT name, sec, arch, key FROM ("

Line 1276 names_check(void)

Line 1247 names_check(void)

") USING (pageid);",

-1, &stmt, NULL);

if (SQLITE_OK != sqlite3_bind_int64(stmt, 1, NAME_TITLE))

if (sqlite3_bind_int64(stmt, 1, NAME_TITLE) != SQLITE_OK)

say("", "%s", sqlite3_errmsg(db));

while (SQLITE_ROW == (irc = sqlite3_step(stmt))) {

while (sqlite3_step(stmt) == SQLITE_ROW) {

name = (const char *)sqlite3_column_text(stmt, 0);

sec = (const char *)sqlite3_column_text(stmt, 1);

arch = (const char *)sqlite3_column_text(stmt, 2);

Line 1570 parse_mdoc(struct mpage *mpage, const struct roff_meta

Line 1541 parse_mdoc(struct mpage *mpage, const struct roff_meta

for (n = n->child; NULL != n; n = n->next) {

switch (n->type) {

case ROFFT_ELEM:

/* FALLTHROUGH */

case ROFFT_BLOCK:

/* FALLTHROUGH */

case ROFFT_HEAD:

/* FALLTHROUGH */

case ROFFT_BODY:

/* FALLTHROUGH */

case ROFFT_TAIL:

if (NULL != mdocs[n->tok].fp)

if (0 == (*mdocs[n->tok].fp)(mpage, meta, n))

Line 1929 render_string(char **public, size_t *psz)

Line 1896 render_string(char **public, size_t *psz)

case '\\':

break;

case '\t':

/* FALLTHROUGH */

case ASCII_NBRSP:

dst[dsz++] = ' ';

scp++;

Line 1960 render_string(char **public, size_t *psz)

Line 1926 render_string(char **public, size_t *psz)

if (write_utf8) {

unicode = mchars_spec2cp(mchars, seq, seqlen);

unicode = mchars_spec2cp(seq, seqlen);

if (unicode <= 0)

continue;

addsz = utf8(unicode, utfbuf);

Line 1968 render_string(char **public, size_t *psz)

Line 1934 render_string(char **public, size_t *psz)

continue;

addcp = utfbuf;

} else {

addcp = mchars_spec2str(mchars, seq, seqlen, &addsz);

addcp = mchars_spec2str(seq, seqlen, &addsz);

if (addcp == NULL)

continue;

if (*addcp == ASCII_NBRSP) {

Line 2393 prepare_statements:

Line 2359 prepare_statements:

#endif

return 1;

}

static void *

hash_calloc(size_t n, size_t sz, void *arg)

{

return mandoc_calloc(n, sz);

}

static void *

hash_alloc(size_t sz, void *arg)

{

return mandoc_malloc(sz);

}

static void

hash_free(void *p, void *arg)

{

free(p);

}

static int

CVSweb