mandoc/chars.c - diff

Return to chars.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/chars.c between version 1.29 and 1.64

version 1.29, 2010/09/04 20:18:53

version 1.64, 2014/10/28 17:36:19

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 14

Line 15

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <sys/types.h>

#include <assert.h>

#include <stdio.h>

#include <ctype.h>

#include <stdlib.h>

#include <string.h>

#include "mandoc.h"

#include "chars.h"

#include "mandoc_aux.h"

#include "libmandoc.h"

#define PRINT_HI 126

#define PRINT_LO 32

Line 34 struct ln {

Line 36 struct ln {

const char *code;

const char *ascii;

int unicode;

int type;

#define CHARS_CHAR (1 << 0)

#define CHARS_STRING (1 << 1)

#define CHARS_BOTH (CHARS_CHAR | CHARS_STRING)

};

#define LINES_MAX 362

#define LINES_MAX 330

#define CHAR(in, ch, code) \

{ NULL, (in), (ch), (code), CHARS_CHAR },

{ NULL, (in), (ch), (code) },

#define STRING(in, ch, code) \

{ NULL, (in), (ch), (code), CHARS_STRING },

#define BOTH(in, ch, code) \

{ NULL, (in), (ch), (code), CHARS_BOTH },

#define CHAR_TBL_START static struct ln lines[LINES_MAX] = {

#define CHAR_TBL_END };

#include "chars.in"

struct tbl {

struct mchars {

enum chars type;

struct ln **htab;

};

static inline int match(const struct ln *,

static const struct ln *find(const struct mchars *,

const char *, size_t, int);

const char *, size_t);

static const struct ln *find(struct tbl *, const char *, size_t, int);

void

chars_free(void *arg)

mchars_free(struct mchars *arg)

{

struct tbl *tab;

tab = (struct tbl *)arg;

free(arg->htab);

free(arg);

free(tab->htab);

free(tab);

}

struct mchars *

void *

mchars_alloc(void)

chars_init(enum chars type)

{

struct tbl *tab;

struct mchars *tab;

struct ln **htab;

struct ln *pp;

int i, hash;

Line 87 chars_init(enum chars type)

Line 75 chars_init(enum chars type)

* Constructs a very basic chaining hashtable. The hash routine

* is simply the integral value of the first character.

* Subsequent entries are chained in the order they're processed

* Subsequent entries are chained in the order they're processed.

* (they're in-line re-ordered during lookup).

tab = malloc(sizeof(struct tbl));

tab = mandoc_malloc(sizeof(struct mchars));

if (NULL == tab) {

htab = mandoc_calloc(PRINT_HI - PRINT_LO + 1, sizeof(struct ln *));

perror(NULL);

exit((int)MANDOCLEVEL_SYSERR);

}

htab = calloc(PRINT_HI - PRINT_LO + 1, sizeof(struct ln **));

if (NULL == htab) {

perror(NULL);

exit((int)MANDOCLEVEL_SYSERR);

}

for (i = 0; i < LINES_MAX; i++) {

hash = (int)lines[i].code[0] - PRINT_LO;

Line 117 chars_init(enum chars type)

Line 95 chars_init(enum chars type)

}

tab->htab = htab;

tab->type = type;

return(tab);

}

* Special character to Unicode codepoint.

int

chars_spec2cp(void *arg, const char *p, size_t sz)

mchars_spec2cp(const struct mchars *arg, const char *p, size_t sz)

{

const struct ln *ln;

ln = find((struct tbl *)arg, p, sz, CHARS_CHAR);

ln = find(arg, p, sz);

if (NULL == ln)

return(ln != NULL ? ln->unicode : sz == 1 ? (unsigned char)*p : -1);

return(-1);

return(ln->unicode);

}

char

mchars_num2char(const char *p, size_t sz)

{

int i;

if ((i = mandoc_strntoi(p, sz, 10)) < 0)

* Reserved word to Unicode codepoint.

return('\0');

return(i > 0 && i < 256 && isprint(i) ? i : '\0');

}

int

chars_res2cp(void *arg, const char *p, size_t sz)

mchars_num2uc(const char *p, size_t sz)

{

const struct ln *ln;

int i;

ln = find((struct tbl *)arg, p, sz, CHARS_STRING);

i = mandoc_strntoi(p, sz, 16);

if (NULL == ln)

assert(i >= 0 && i <= 0x10FFFF);

return(-1);

return(i);

return(ln->unicode);

}

* Special character to string array.

const char *

chars_spec2str(void *arg, const char *p, size_t sz, size_t *rsz)

mchars_spec2str(const struct mchars *arg,

const char *p, size_t sz, size_t *rsz)

{

const struct ln *ln;

ln = find((struct tbl *)arg, p, sz, CHARS_CHAR);

ln = find(arg, p, sz);

if (NULL == ln)

if (ln == NULL) {

return(NULL);

*rsz = 1;

return(sz == 1 ? p : NULL);

}

*rsz = strlen(ln->ascii);

return(ln->ascii);

}

* Reserved word to string array.

const char *

chars_res2str(void *arg, const char *p, size_t sz, size_t *rsz)

mchars_uc2str(int uc)

{

const struct ln *ln;

int i;

ln = find((struct tbl *)arg, p, sz, CHARS_STRING);

for (i = 0; i < LINES_MAX; i++)

if (NULL == ln)

if (uc == lines[i].unicode)

return(NULL);

return(lines[i].ascii);

return("<?>");

*rsz = strlen(ln->ascii);

return(ln->ascii);

}

static const struct ln *

find(struct tbl *tab, const char *p, size_t sz, int type)

find(const struct mchars *tab, const char *p, size_t sz)

{

struct ln *pp, *prev;

const struct ln *pp;

struct ln **htab;

int hash;

assert(p);

if (0 == sz)

return(NULL);

if (p[0] < PRINT_LO || p[0] > PRINT_HI)

if (0 == sz || p[0] < PRINT_LO || p[0] > PRINT_HI)

return(NULL);

* Lookup the symbol in the symbol hash. See ascii2htab for the

* hashtable specs. This dynamically re-orders the hash chain

* to optimise for repeat hits.

hash = (int)p[0] - PRINT_LO;

htab = tab->htab;

if (NULL == (pp = htab[hash]))

for (pp = tab->htab[hash]; pp; pp = pp->next)

return(NULL);

if (0 == strncmp(pp->code, p, sz) &&

'\0' == pp->code[(int)sz])

return(pp);

for (prev = NULL; pp; pp = pp->next) {

if ( ! match(pp, p, sz, type)) {

prev = pp;

continue;

}

if (prev) {

prev->next = pp->next;

pp->next = htab[hash];

htab[hash] = pp;

}

return(pp);

}

return(NULL);

}

static inline int

match(const struct ln *ln, const char *p, size_t sz, int type)

{

if ( ! (ln->type & type))

return(0);

if (strncmp(ln->code, p, sz))

return(0);

return('\0' == ln->code[(int)sz]);

}

CVSweb