mandoc/chars.c - diff

Return to chars.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/chars.c between version 1.30 and 1.46

version 1.30, 2010/09/15 13:10:30

version 1.46, 2011/05/24 21:31:23

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 19

Line 20

#endif

#include <assert.h>

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "mandoc.h"

#include "chars.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 351

#define LINES_MAX 325

#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 inline int match(const struct ln *, const char *, size_t);

const char *, size_t, int);

static const struct ln *find(struct mchars *, 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 91 chars_init(enum chars type)

Line 78 chars_init(enum chars type)

* (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);

}

Line 126 chars_init(enum chars type)

Line 103 chars_init(enum chars type)

* Special character to Unicode codepoint.

int

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

mchars_spec2cp(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(-1);

return(ln->unicode);

}

* Numbered character string to ASCII codepoint.

* Reserved word to Unicode codepoint.

* This can only be a printable character (i.e., alnum, punct, space) so

* prevent the character from ruining our state (backspace, newline, and

* so on).

* If the character is illegal, returns '\0'.

int

char

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

mchars_num2char(const char *p, size_t sz)

{

const struct ln *ln;

int i;

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

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

if (NULL == ln)

return('\0');

return(-1);

return(isprint(i) ? i : '\0');

return(ln->unicode);

}

* Hex character string to Unicode codepoint.

* Special character to string array.

* If the character is illegal, returns '\0'.

const char *

int

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

mchars_num2uc(const char *p, size_t sz)

{

const struct ln *ln;

int i;

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

if ((i = mandoc_strntou(p, sz, 16)) < 0)

if (NULL == ln)

return('\0');

return(NULL);

/* FIXME: make sure we're not in a bogus range. */

return(i > 0x80 && i <= 0x10FFFF ? i : '\0');

*rsz = strlen(ln->ascii);

return(ln->ascii);

}

* Reserved word to string array.

* Special character to string array.

const char *

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

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

{

const struct ln *ln;

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

ln = find(arg, p, sz);

if (NULL == ln)

return(NULL);

Line 185 chars_res2str(void *arg, const char *p, size_t sz, siz

Line 161 chars_res2str(void *arg, const char *p, size_t sz, siz

return(ln->ascii);

}

static const struct ln *

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

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

{

struct ln *pp, *prev;

struct ln **htab;

Line 213 find(struct tbl *tab, const char *p, size_t sz, int ty

Line 188 find(struct tbl *tab, const char *p, size_t sz, int ty

return(NULL);

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

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

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

prev = pp;

continue;

}

Line 230 find(struct tbl *tab, const char *p, size_t sz, int ty

Line 205 find(struct tbl *tab, const char *p, size_t sz, int ty

return(NULL);

}

static inline int

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

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

{

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

return(0);

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

return(0);

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

CVSweb