version 1.146, 2010/12/22 22:05:38 |
version 1.154, 2011/01/25 15:46:05 |
|
|
/* $Id$ */ |
/* $Id$ */ |
/* |
/* |
* Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv> |
* Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv> |
|
* Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org> |
* |
* |
* Permission to use, copy, modify, and distribute this software for any |
* Permission to use, copy, modify, and distribute this software for any |
* purpose with or without fee is hereby granted, provided that the above |
* purpose with or without fee is hereby granted, provided that the above |
|
|
#define PRE_ARGS struct mdoc *mdoc, struct mdoc_node *n |
#define PRE_ARGS struct mdoc *mdoc, struct mdoc_node *n |
#define POST_ARGS struct mdoc *mdoc |
#define POST_ARGS struct mdoc *mdoc |
|
|
#define NORM_BUMP(dst, src) do { \ |
|
(dst)->norm = (src)->norm; \ |
|
((dst)->norm->refcnt)++; \ |
|
} while (/* CONSTCOND */ 0) |
|
#define NORM_ALLOC(dst) do { \ |
|
(dst)->norm = \ |
|
mandoc_calloc(1, sizeof(struct mdoc_norm)); \ |
|
(dst)->norm->refcnt = 1; \ |
|
} while (/* CONSTCOND */ 0) |
|
|
|
#define NUMSIZ 32 |
#define NUMSIZ 32 |
#define DATESIZE 32 |
#define DATESIZE 32 |
|
|
Line 63 enum check_ineq { |
|
Line 54 enum check_ineq { |
|
enum check_lvl { |
enum check_lvl { |
CHECK_WARN, |
CHECK_WARN, |
CHECK_ERROR, |
CHECK_ERROR, |
CHECK_FATAL |
|
}; |
}; |
|
|
typedef int (*v_pre)(PRE_ARGS); |
typedef int (*v_pre)(PRE_ARGS); |
Line 88 static int concat(struct mdoc *, char *, |
|
Line 78 static int concat(struct mdoc *, char *, |
|
static int ebool(POST_ARGS); |
static int ebool(POST_ARGS); |
static int berr_ge1(POST_ARGS); |
static int berr_ge1(POST_ARGS); |
static int bwarn_ge1(POST_ARGS); |
static int bwarn_ge1(POST_ARGS); |
static int eerr_eq0(POST_ARGS); |
|
static int eerr_eq1(POST_ARGS); |
|
static int eerr_ge1(POST_ARGS); |
|
static int eerr_le1(POST_ARGS); |
|
static int ewarn_eq0(POST_ARGS); |
static int ewarn_eq0(POST_ARGS); |
|
static int ewarn_eq1(POST_ARGS); |
static int ewarn_ge1(POST_ARGS); |
static int ewarn_ge1(POST_ARGS); |
static int herr_eq0(POST_ARGS); |
static int ewarn_le1(POST_ARGS); |
static int herr_ge1(POST_ARGS); |
|
static int hwarn_eq0(POST_ARGS); |
static int hwarn_eq0(POST_ARGS); |
static int hwarn_eq1(POST_ARGS); |
static int hwarn_eq1(POST_ARGS); |
|
static int hwarn_ge1(POST_ARGS); |
static int hwarn_le1(POST_ARGS); |
static int hwarn_le1(POST_ARGS); |
|
|
static int post_an(POST_ARGS); |
static int post_an(POST_ARGS); |
Line 108 static int post_bl_block(POST_ARGS); |
|
Line 95 static int post_bl_block(POST_ARGS); |
|
static int post_bl_block_width(POST_ARGS); |
static int post_bl_block_width(POST_ARGS); |
static int post_bl_block_tag(POST_ARGS); |
static int post_bl_block_tag(POST_ARGS); |
static int post_bl_head(POST_ARGS); |
static int post_bl_head(POST_ARGS); |
|
static int post_bx(POST_ARGS); |
static int post_dd(POST_ARGS); |
static int post_dd(POST_ARGS); |
static int post_dt(POST_ARGS); |
static int post_dt(POST_ARGS); |
static int post_defaults(POST_ARGS); |
static int post_defaults(POST_ARGS); |
Line 147 static v_post posts_bd[] = { post_literal, hwarn_eq0, |
|
Line 135 static v_post posts_bd[] = { post_literal, hwarn_eq0, |
|
static v_post posts_bf[] = { hwarn_le1, post_bf, NULL }; |
static v_post posts_bf[] = { hwarn_le1, post_bf, NULL }; |
static v_post posts_bk[] = { hwarn_eq0, bwarn_ge1, NULL }; |
static v_post posts_bk[] = { hwarn_eq0, bwarn_ge1, NULL }; |
static v_post posts_bl[] = { bwarn_ge1, post_bl, NULL }; |
static v_post posts_bl[] = { bwarn_ge1, post_bl, NULL }; |
static v_post posts_bool[] = { eerr_eq1, ebool, NULL }; |
static v_post posts_bx[] = { post_bx, NULL }; |
|
static v_post posts_bool[] = { ebool, NULL }; |
static v_post posts_eoln[] = { post_eoln, NULL }; |
static v_post posts_eoln[] = { post_eoln, NULL }; |
static v_post posts_defaults[] = { post_defaults, NULL }; |
static v_post posts_defaults[] = { post_defaults, NULL }; |
static v_post posts_dd[] = { ewarn_ge1, post_dd, post_prol, NULL }; |
static v_post posts_dd[] = { ewarn_ge1, post_dd, post_prol, NULL }; |
static v_post posts_dl[] = { post_literal, bwarn_ge1, herr_eq0, NULL }; |
static v_post posts_dl[] = { post_literal, bwarn_ge1, NULL }; |
static v_post posts_dt[] = { post_dt, post_prol, NULL }; |
static v_post posts_dt[] = { post_dt, post_prol, NULL }; |
static v_post posts_fo[] = { hwarn_eq1, bwarn_ge1, NULL }; |
static v_post posts_fo[] = { hwarn_eq1, bwarn_ge1, NULL }; |
static v_post posts_it[] = { post_it, NULL }; |
static v_post posts_it[] = { post_it, NULL }; |
static v_post posts_lb[] = { eerr_eq1, post_lb, NULL }; |
static v_post posts_lb[] = { post_lb, NULL }; |
static v_post posts_nd[] = { berr_ge1, NULL }; |
static v_post posts_nd[] = { berr_ge1, NULL }; |
static v_post posts_nm[] = { post_nm, NULL }; |
static v_post posts_nm[] = { post_nm, NULL }; |
static v_post posts_notext[] = { ewarn_eq0, NULL }; |
static v_post posts_notext[] = { ewarn_eq0, NULL }; |
static v_post posts_os[] = { post_os, post_prol, NULL }; |
static v_post posts_os[] = { post_os, post_prol, NULL }; |
static v_post posts_rs[] = { berr_ge1, herr_eq0, post_rs, NULL }; |
static v_post posts_rs[] = { post_rs, NULL }; |
static v_post posts_sh[] = { post_ignpar, herr_ge1, bwarn_ge1, post_sh, NULL }; |
static v_post posts_sh[] = { post_ignpar, hwarn_ge1, bwarn_ge1, post_sh, NULL }; |
static v_post posts_sp[] = { eerr_le1, NULL }; |
static v_post posts_sp[] = { ewarn_le1, NULL }; |
static v_post posts_ss[] = { post_ignpar, herr_ge1, bwarn_ge1, NULL }; |
static v_post posts_ss[] = { post_ignpar, hwarn_ge1, bwarn_ge1, NULL }; |
static v_post posts_st[] = { eerr_eq1, post_st, NULL }; |
static v_post posts_st[] = { post_st, NULL }; |
static v_post posts_std[] = { post_std, NULL }; |
static v_post posts_std[] = { post_std, NULL }; |
static v_post posts_text[] = { eerr_ge1, NULL }; |
static v_post posts_text[] = { ewarn_ge1, NULL }; |
static v_post posts_text1[] = { eerr_eq1, NULL }; |
static v_post posts_text1[] = { ewarn_eq1, NULL }; |
static v_post posts_vt[] = { post_vt, NULL }; |
static v_post posts_vt[] = { post_vt, NULL }; |
static v_post posts_wline[] = { bwarn_ge1, herr_eq0, NULL }; |
static v_post posts_wline[] = { bwarn_ge1, NULL }; |
static v_post posts_wtext[] = { ewarn_ge1, NULL }; |
|
static v_pre pres_an[] = { pre_an, NULL }; |
static v_pre pres_an[] = { pre_an, NULL }; |
static v_pre pres_bd[] = { pre_display, pre_bd, pre_literal, pre_par, NULL }; |
static v_pre pres_bd[] = { pre_display, pre_bd, pre_literal, pre_par, NULL }; |
static v_pre pres_bl[] = { pre_bl, pre_par, NULL }; |
static v_pre pres_bl[] = { pre_bl, pre_par, NULL }; |
Line 202 const struct valids mdoc_valids[MDOC_MAX] = { |
|
Line 190 const struct valids mdoc_valids[MDOC_MAX] = { |
|
{ pres_bl, posts_bl }, /* Bl */ |
{ pres_bl, posts_bl }, /* Bl */ |
{ NULL, NULL }, /* El */ |
{ NULL, NULL }, /* El */ |
{ pres_it, posts_it }, /* It */ |
{ pres_it, posts_it }, /* It */ |
{ NULL, posts_text }, /* Ad */ |
{ NULL, NULL }, /* Ad */ |
{ pres_an, posts_an }, /* An */ |
{ pres_an, posts_an }, /* An */ |
{ NULL, posts_defaults }, /* Ar */ |
{ NULL, posts_defaults }, /* Ar */ |
{ NULL, posts_text }, /* Cd */ |
{ NULL, NULL }, /* Cd */ |
{ NULL, NULL }, /* Cm */ |
{ NULL, NULL }, /* Cm */ |
{ NULL, NULL }, /* Dv */ |
{ NULL, NULL }, /* Dv */ |
{ pres_er, posts_text }, /* Er */ |
{ pres_er, NULL }, /* Er */ |
{ NULL, NULL }, /* Ev */ |
{ NULL, NULL }, /* Ev */ |
{ pres_std, posts_std }, /* Ex */ |
{ pres_std, posts_std }, /* Ex */ |
{ NULL, NULL }, /* Fa */ |
{ NULL, NULL }, /* Fa */ |
{ pres_fd, posts_wtext }, /* Fd */ |
{ pres_fd, posts_text }, /* Fd */ |
{ NULL, NULL }, /* Fl */ |
{ NULL, NULL }, /* Fl */ |
{ NULL, posts_text }, /* Fn */ |
{ NULL, NULL }, /* Fn */ |
{ NULL, posts_wtext }, /* Ft */ |
{ NULL, NULL }, /* Ft */ |
{ NULL, posts_text }, /* Ic */ |
{ NULL, NULL }, /* Ic */ |
{ NULL, posts_text1 }, /* In */ |
{ NULL, posts_text1 }, /* In */ |
{ NULL, posts_defaults }, /* Li */ |
{ NULL, posts_defaults }, /* Li */ |
{ NULL, posts_nd }, /* Nd */ |
{ NULL, posts_nd }, /* Nd */ |
Line 228 const struct valids mdoc_valids[MDOC_MAX] = { |
|
Line 216 const struct valids mdoc_valids[MDOC_MAX] = { |
|
{ NULL, posts_st }, /* St */ |
{ NULL, posts_st }, /* St */ |
{ NULL, NULL }, /* Va */ |
{ NULL, NULL }, /* Va */ |
{ NULL, posts_vt }, /* Vt */ |
{ NULL, posts_vt }, /* Vt */ |
{ NULL, posts_wtext }, /* Xr */ |
{ NULL, posts_text }, /* Xr */ |
{ NULL, posts_text }, /* %A */ |
{ NULL, posts_text }, /* %A */ |
{ NULL, posts_text }, /* %B */ /* FIXME: can be used outside Rs/Re. */ |
{ NULL, posts_text }, /* %B */ /* FIXME: can be used outside Rs/Re. */ |
{ NULL, posts_text }, /* %D */ /* FIXME: check date with mandoc_a2time(). */ |
{ NULL, posts_text }, /* %D */ /* FIXME: check date with mandoc_a2time(). */ |
Line 249 const struct valids mdoc_valids[MDOC_MAX] = { |
|
Line 237 const struct valids mdoc_valids[MDOC_MAX] = { |
|
{ NULL, NULL }, /* Bo */ |
{ NULL, NULL }, /* Bo */ |
{ NULL, NULL }, /* Bq */ |
{ NULL, NULL }, /* Bq */ |
{ NULL, NULL }, /* Bsx */ |
{ NULL, NULL }, /* Bsx */ |
{ NULL, NULL }, /* Bx */ |
{ NULL, posts_bx }, /* Bx */ |
{ NULL, posts_bool }, /* Db */ |
{ NULL, posts_bool }, /* Db */ |
{ NULL, NULL }, /* Dc */ |
{ NULL, NULL }, /* Dc */ |
{ NULL, NULL }, /* Do */ |
{ NULL, NULL }, /* Do */ |
Line 259 const struct valids mdoc_valids[MDOC_MAX] = { |
|
Line 247 const struct valids mdoc_valids[MDOC_MAX] = { |
|
{ NULL, NULL }, /* Em */ |
{ NULL, NULL }, /* Em */ |
{ NULL, NULL }, /* Eo */ |
{ NULL, NULL }, /* Eo */ |
{ NULL, NULL }, /* Fx */ |
{ NULL, NULL }, /* Fx */ |
{ NULL, posts_text }, /* Ms */ |
{ NULL, NULL }, /* Ms */ |
{ NULL, posts_notext }, /* No */ |
{ NULL, posts_notext }, /* No */ |
{ NULL, posts_notext }, /* Ns */ |
{ NULL, posts_notext }, /* Ns */ |
{ NULL, NULL }, /* Nx */ |
{ NULL, NULL }, /* Nx */ |
Line 278 const struct valids mdoc_valids[MDOC_MAX] = { |
|
Line 266 const struct valids mdoc_valids[MDOC_MAX] = { |
|
{ NULL, NULL }, /* So */ |
{ NULL, NULL }, /* So */ |
{ NULL, NULL }, /* Sq */ |
{ NULL, NULL }, /* Sq */ |
{ NULL, posts_bool }, /* Sm */ |
{ NULL, posts_bool }, /* Sm */ |
{ NULL, posts_text }, /* Sx */ |
{ NULL, NULL }, /* Sx */ |
{ NULL, posts_text }, /* Sy */ |
{ NULL, NULL }, /* Sy */ |
{ NULL, posts_text }, /* Tn */ |
{ NULL, NULL }, /* Tn */ |
{ NULL, NULL }, /* Ux */ |
{ NULL, NULL }, /* Ux */ |
{ NULL, NULL }, /* Xc */ |
{ NULL, NULL }, /* Xc */ |
{ NULL, NULL }, /* Xo */ |
{ NULL, NULL }, /* Xo */ |
Line 296 const struct valids mdoc_valids[MDOC_MAX] = { |
|
Line 284 const struct valids mdoc_valids[MDOC_MAX] = { |
|
{ NULL, posts_eoln }, /* Ud */ |
{ NULL, posts_eoln }, /* Ud */ |
{ NULL, posts_lb }, /* Lb */ |
{ NULL, posts_lb }, /* Lb */ |
{ NULL, posts_notext }, /* Lp */ |
{ NULL, posts_notext }, /* Lp */ |
{ NULL, posts_text }, /* Lk */ |
{ NULL, NULL }, /* Lk */ |
{ NULL, posts_defaults }, /* Mt */ |
{ NULL, posts_defaults }, /* Mt */ |
{ NULL, NULL }, /* Brq */ |
{ NULL, NULL }, /* Brq */ |
{ NULL, NULL }, /* Bro */ |
{ NULL, NULL }, /* Bro */ |
Line 339 mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n) |
|
Line 327 mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n) |
|
int line, pos; |
int line, pos; |
char *tp; |
char *tp; |
|
|
if (MDOC_TEXT == n->type) { |
switch (n->type) { |
|
case (MDOC_TEXT): |
tp = n->string; |
tp = n->string; |
line = n->line; |
line = n->line; |
pos = n->pos; |
pos = n->pos; |
check_text(mdoc, line, pos, tp); |
check_text(mdoc, line, pos, tp); |
|
/* FALLTHROUGH */ |
|
case (MDOC_TBL): |
|
/* FALLTHROUGH */ |
|
case (MDOC_ROOT): |
return(1); |
return(1); |
|
default: |
|
break; |
} |
} |
|
|
check_args(mdoc, n); |
check_args(mdoc, n); |
Line 367 mdoc_valid_post(struct mdoc *mdoc) |
|
Line 362 mdoc_valid_post(struct mdoc *mdoc) |
|
return(1); |
return(1); |
mdoc->last->flags |= MDOC_VALID; |
mdoc->last->flags |= MDOC_VALID; |
|
|
if (MDOC_TEXT == mdoc->last->type) |
switch (mdoc->last->type) { |
|
case (MDOC_TEXT): |
|
/* FALLTHROUGH */ |
|
case (MDOC_TBL): |
return(1); |
return(1); |
if (MDOC_ROOT == mdoc->last->type) |
case (MDOC_ROOT): |
return(post_root(mdoc)); |
return(post_root(mdoc)); |
|
default: |
|
break; |
|
} |
|
|
if (NULL == mdoc_valids[mdoc->last->tok].post) |
if (NULL == mdoc_valids[mdoc->last->tok].post) |
return(1); |
return(1); |
Line 386 check_count(struct mdoc *m, enum mdoc_type type, |
|
Line 387 check_count(struct mdoc *m, enum mdoc_type type, |
|
enum check_lvl lvl, enum check_ineq ineq, int val) |
enum check_lvl lvl, enum check_ineq ineq, int val) |
{ |
{ |
const char *p; |
const char *p; |
|
enum mandocerr t; |
|
|
if (m->last->type != type) |
if (m->last->type != type) |
return(1); |
return(1); |
Line 397 check_count(struct mdoc *m, enum mdoc_type type, |
|
Line 399 check_count(struct mdoc *m, enum mdoc_type type, |
|
return(1); |
return(1); |
break; |
break; |
case (CHECK_GT): |
case (CHECK_GT): |
p = "greater than "; |
p = "more than "; |
if (m->last->nchild > val) |
if (m->last->nchild > val) |
return(1); |
return(1); |
break; |
break; |
Line 411 check_count(struct mdoc *m, enum mdoc_type type, |
|
Line 413 check_count(struct mdoc *m, enum mdoc_type type, |
|
/* NOTREACHED */ |
/* NOTREACHED */ |
} |
} |
|
|
if (CHECK_WARN == lvl) { |
t = lvl == CHECK_WARN ? MANDOCERR_ARGCWARN : MANDOCERR_ARGCOUNT; |
return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT, |
|
m->last->line, m->last->pos, |
|
"want %s%d children (have %d)", |
|
p, val, m->last->nchild)); |
|
} |
|
|
|
/* FIXME: THIS IS THE SAME AS THE ABOVE. */ |
return(mdoc_vmsg(m, t, m->last->line, m->last->pos, |
|
"want %s%d children (have %d)", |
return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT, |
|
m->last->line, m->last->pos, |
|
"require %s%d children (have %d)", |
|
p, val, m->last->nchild)); |
p, val, m->last->nchild)); |
} |
} |
|
|
|
|
berr_ge1(POST_ARGS) |
berr_ge1(POST_ARGS) |
{ |
{ |
|
|
return(check_count(mdoc, MDOC_BODY, CHECK_FATAL, CHECK_GT, 0)); |
return(check_count(mdoc, MDOC_BODY, CHECK_ERROR, CHECK_GT, 0)); |
} |
} |
|
|
static int |
static int |
Line 440 bwarn_ge1(POST_ARGS) |
|
Line 434 bwarn_ge1(POST_ARGS) |
|
} |
} |
|
|
static int |
static int |
eerr_eq0(POST_ARGS) |
ewarn_eq0(POST_ARGS) |
{ |
{ |
return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_EQ, 0)); |
return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0)); |
} |
} |
|
|
static int |
static int |
eerr_eq1(POST_ARGS) |
ewarn_eq1(POST_ARGS) |
{ |
{ |
return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_EQ, 1)); |
return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 1)); |
} |
} |
|
|
static int |
static int |
eerr_ge1(POST_ARGS) |
|
{ |
|
return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_GT, 0)); |
|
} |
|
|
|
static int |
|
eerr_le1(POST_ARGS) |
|
{ |
|
return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_LT, 2)); |
|
} |
|
|
|
static int |
|
ewarn_eq0(POST_ARGS) |
|
{ |
|
return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0)); |
|
} |
|
|
|
static int |
|
ewarn_ge1(POST_ARGS) |
ewarn_ge1(POST_ARGS) |
{ |
{ |
return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0)); |
return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0)); |
} |
} |
|
|
static int |
static int |
herr_eq0(POST_ARGS) |
ewarn_le1(POST_ARGS) |
{ |
{ |
return(check_count(mdoc, MDOC_HEAD, CHECK_FATAL, CHECK_EQ, 0)); |
return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_LT, 2)); |
} |
} |
|
|
static int |
static int |
herr_ge1(POST_ARGS) |
|
{ |
|
return(check_count(mdoc, MDOC_HEAD, CHECK_FATAL, CHECK_GT, 0)); |
|
} |
|
|
|
static int |
|
hwarn_eq0(POST_ARGS) |
hwarn_eq0(POST_ARGS) |
{ |
{ |
return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0)); |
return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0)); |
Line 500 hwarn_eq1(POST_ARGS) |
|
Line 470 hwarn_eq1(POST_ARGS) |
|
} |
} |
|
|
static int |
static int |
|
hwarn_ge1(POST_ARGS) |
|
{ |
|
return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_GT, 0)); |
|
} |
|
|
|
static int |
hwarn_le1(POST_ARGS) |
hwarn_le1(POST_ARGS) |
{ |
{ |
return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_LT, 2)); |
return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_LT, 2)); |
Line 619 pre_bl(PRE_ARGS) |
|
Line 595 pre_bl(PRE_ARGS) |
|
assert(np); |
assert(np); |
assert(MDOC_BLOCK == np->type); |
assert(MDOC_BLOCK == np->type); |
assert(MDOC_Bl == np->tok); |
assert(MDOC_Bl == np->tok); |
NORM_BUMP(n, np); |
|
return(1); |
return(1); |
} |
} |
|
|
NORM_ALLOC(n); |
|
|
|
/* |
/* |
* First figure out which kind of list to use: bind ourselves to |
* First figure out which kind of list to use: bind ourselves to |
* the first mentioned list type and warn about any remaining |
* the first mentioned list type and warn about any remaining |
Line 673 pre_bl(PRE_ARGS) |
|
Line 646 pre_bl(PRE_ARGS) |
|
break; |
break; |
/* Set list arguments. */ |
/* Set list arguments. */ |
case (MDOC_Compact): |
case (MDOC_Compact): |
dup = n->norm->d.Bl.comp; |
dup = n->norm->Bl.comp; |
comp = 1; |
comp = 1; |
break; |
break; |
case (MDOC_Width): |
case (MDOC_Width): |
dup = (NULL != n->norm->d.Bl.width); |
dup = (NULL != n->norm->Bl.width); |
width = n->args->argv[i].value[0]; |
width = n->args->argv[i].value[0]; |
break; |
break; |
case (MDOC_Offset): |
case (MDOC_Offset): |
/* NB: this can be empty! */ |
/* NB: this can be empty! */ |
if (n->args->argv[i].sz) { |
if (n->args->argv[i].sz) { |
offs = n->args->argv[i].value[0]; |
offs = n->args->argv[i].value[0]; |
dup = (NULL != n->norm->d.Bl.offs); |
dup = (NULL != n->norm->Bl.offs); |
break; |
break; |
} |
} |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
Line 699 pre_bl(PRE_ARGS) |
|
Line 672 pre_bl(PRE_ARGS) |
|
mdoc_nmsg(mdoc, n, MANDOCERR_ARGVREP); |
mdoc_nmsg(mdoc, n, MANDOCERR_ARGVREP); |
|
|
if (comp && ! dup) |
if (comp && ! dup) |
n->norm->d.Bl.comp = comp; |
n->norm->Bl.comp = comp; |
if (offs && ! dup) |
if (offs && ! dup) |
n->norm->d.Bl.offs = offs; |
n->norm->Bl.offs = offs; |
if (width && ! dup) |
if (width && ! dup) |
n->norm->d.Bl.width = width; |
n->norm->Bl.width = width; |
|
|
/* Check: multiple list types. */ |
/* Check: multiple list types. */ |
|
|
if (LIST__NONE != lt && n->norm->d.Bl.type != LIST__NONE) |
if (LIST__NONE != lt && n->norm->Bl.type != LIST__NONE) |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTREP); |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTREP); |
|
|
/* Assign list type. */ |
/* Assign list type. */ |
|
|
if (LIST__NONE != lt && n->norm->d.Bl.type == LIST__NONE) { |
if (LIST__NONE != lt && n->norm->Bl.type == LIST__NONE) { |
n->norm->d.Bl.type = lt; |
n->norm->Bl.type = lt; |
/* Set column information, too. */ |
/* Set column information, too. */ |
if (LIST_column == lt) { |
if (LIST_column == lt) { |
n->norm->d.Bl.ncols = |
n->norm->Bl.ncols = |
n->args->argv[i].sz; |
n->args->argv[i].sz; |
n->norm->d.Bl.cols = (const char **) |
n->norm->Bl.cols = (const char **) |
n->args->argv[i].value; |
n->args->argv[i].value; |
} |
} |
} |
} |
|
|
/* The list type should come first. */ |
/* The list type should come first. */ |
|
|
if (n->norm->d.Bl.type == LIST__NONE) |
if (n->norm->Bl.type == LIST__NONE) |
if (n->norm->d.Bl.width || |
if (n->norm->Bl.width || |
n->norm->d.Bl.offs || |
n->norm->Bl.offs || |
n->norm->d.Bl.comp) |
n->norm->Bl.comp) |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTFIRST); |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTFIRST); |
|
|
continue; |
continue; |
Line 736 pre_bl(PRE_ARGS) |
|
Line 709 pre_bl(PRE_ARGS) |
|
|
|
/* Allow lists to default to LIST_item. */ |
/* Allow lists to default to LIST_item. */ |
|
|
if (LIST__NONE == n->norm->d.Bl.type) { |
if (LIST__NONE == n->norm->Bl.type) { |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTTYPE); |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTTYPE); |
n->norm->d.Bl.type = LIST_item; |
n->norm->Bl.type = LIST_item; |
} |
} |
|
|
/* |
/* |
Line 747 pre_bl(PRE_ARGS) |
|
Line 720 pre_bl(PRE_ARGS) |
|
* and must also be warned. |
* and must also be warned. |
*/ |
*/ |
|
|
switch (n->norm->d.Bl.type) { |
switch (n->norm->Bl.type) { |
case (LIST_tag): |
case (LIST_tag): |
if (n->norm->d.Bl.width) |
if (n->norm->Bl.width) |
break; |
break; |
mdoc_nmsg(mdoc, n, MANDOCERR_NOWIDTHARG); |
mdoc_nmsg(mdoc, n, MANDOCERR_NOWIDTHARG); |
break; |
break; |
Line 762 pre_bl(PRE_ARGS) |
|
Line 735 pre_bl(PRE_ARGS) |
|
case (LIST_inset): |
case (LIST_inset): |
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case (LIST_item): |
case (LIST_item): |
if (n->norm->d.Bl.width) |
if (n->norm->Bl.width) |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
break; |
break; |
default: |
default: |
Line 791 pre_bd(PRE_ARGS) |
|
Line 764 pre_bd(PRE_ARGS) |
|
assert(np); |
assert(np); |
assert(MDOC_BLOCK == np->type); |
assert(MDOC_BLOCK == np->type); |
assert(MDOC_Bd == np->tok); |
assert(MDOC_Bd == np->tok); |
NORM_BUMP(n, np); |
|
return(1); |
return(1); |
} |
} |
|
|
NORM_ALLOC(n); |
|
|
|
/* LINTED */ |
/* LINTED */ |
for (i = 0; n->args && i < (int)n->args->argc; i++) { |
for (i = 0; n->args && i < (int)n->args->argc; i++) { |
dt = DISP__NONE; |
dt = DISP__NONE; |
Line 826 pre_bd(PRE_ARGS) |
|
Line 796 pre_bd(PRE_ARGS) |
|
/* NB: this can be empty! */ |
/* NB: this can be empty! */ |
if (n->args->argv[i].sz) { |
if (n->args->argv[i].sz) { |
offs = n->args->argv[i].value[0]; |
offs = n->args->argv[i].value[0]; |
dup = (NULL != n->norm->d.Bd.offs); |
dup = (NULL != n->norm->Bd.offs); |
break; |
break; |
} |
} |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
break; |
break; |
case (MDOC_Compact): |
case (MDOC_Compact): |
comp = 1; |
comp = 1; |
dup = n->norm->d.Bd.comp; |
dup = n->norm->Bd.comp; |
break; |
break; |
default: |
default: |
abort(); |
abort(); |
Line 848 pre_bd(PRE_ARGS) |
|
Line 818 pre_bd(PRE_ARGS) |
|
/* Make our auxiliary assignments. */ |
/* Make our auxiliary assignments. */ |
|
|
if (offs && ! dup) |
if (offs && ! dup) |
n->norm->d.Bd.offs = offs; |
n->norm->Bd.offs = offs; |
if (comp && ! dup) |
if (comp && ! dup) |
n->norm->d.Bd.comp = comp; |
n->norm->Bd.comp = comp; |
|
|
/* Check whether a type has already been assigned. */ |
/* Check whether a type has already been assigned. */ |
|
|
if (DISP__NONE != dt && n->norm->d.Bd.type != DISP__NONE) |
if (DISP__NONE != dt && n->norm->Bd.type != DISP__NONE) |
mdoc_nmsg(mdoc, n, MANDOCERR_DISPREP); |
mdoc_nmsg(mdoc, n, MANDOCERR_DISPREP); |
|
|
/* Make our type assignment. */ |
/* Make our type assignment. */ |
|
|
if (DISP__NONE != dt && n->norm->d.Bd.type == DISP__NONE) |
if (DISP__NONE != dt && n->norm->Bd.type == DISP__NONE) |
n->norm->d.Bd.type = dt; |
n->norm->Bd.type = dt; |
} |
} |
|
|
if (DISP__NONE == n->norm->d.Bd.type) { |
if (DISP__NONE == n->norm->Bd.type) { |
mdoc_nmsg(mdoc, n, MANDOCERR_DISPTYPE); |
mdoc_nmsg(mdoc, n, MANDOCERR_DISPTYPE); |
n->norm->d.Bd.type = DISP_ragged; |
n->norm->Bd.type = DISP_ragged; |
} |
} |
|
|
return(1); |
return(1); |
Line 910 pre_an(PRE_ARGS) |
|
Line 880 pre_an(PRE_ARGS) |
|
{ |
{ |
int i; |
int i; |
|
|
NORM_ALLOC(n); |
|
|
|
if (NULL == n->args) |
if (NULL == n->args) |
return(1); |
return(1); |
|
|
Line 920 pre_an(PRE_ARGS) |
|
Line 888 pre_an(PRE_ARGS) |
|
n->args->argv[i].pos, MANDOCERR_IGNARGV); |
n->args->argv[i].pos, MANDOCERR_IGNARGV); |
|
|
if (MDOC_Split == n->args->argv[0].arg) |
if (MDOC_Split == n->args->argv[0].arg) |
n->norm->d.An.auth = AUTH_split; |
n->norm->An.auth = AUTH_split; |
else if (MDOC_Nosplit == n->args->argv[0].arg) |
else if (MDOC_Nosplit == n->args->argv[0].arg) |
n->norm->d.An.auth = AUTH_nosplit; |
n->norm->An.auth = AUTH_nosplit; |
else |
else |
abort(); |
abort(); |
|
|
Line 1004 post_bf(POST_ARGS) |
|
Line 972 post_bf(POST_ARGS) |
|
assert(np); |
assert(np); |
assert(MDOC_HEAD == np->type); |
assert(MDOC_HEAD == np->type); |
assert(MDOC_Bf == np->tok); |
assert(MDOC_Bf == np->tok); |
NORM_BUMP(mdoc->last, np); |
|
return(1); |
return(1); |
} |
} |
|
|
np = mdoc->last; |
np = mdoc->last; |
assert(MDOC_BLOCK == np->parent->type); |
assert(MDOC_BLOCK == np->parent->type); |
assert(MDOC_Bf == np->parent->tok); |
assert(MDOC_Bf == np->parent->tok); |
NORM_ALLOC(np); |
|
|
|
/* |
/* |
* Cannot have both argument and parameter. |
* Cannot have both argument and parameter. |
Line 1031 post_bf(POST_ARGS) |
|
Line 997 post_bf(POST_ARGS) |
|
if (np->parent->args) { |
if (np->parent->args) { |
arg = np->parent->args->argv[0].arg; |
arg = np->parent->args->argv[0].arg; |
if (MDOC_Emphasis == arg) |
if (MDOC_Emphasis == arg) |
np->norm->d.Bf.font = FONT_Em; |
np->norm->Bf.font = FONT_Em; |
else if (MDOC_Literal == arg) |
else if (MDOC_Literal == arg) |
np->norm->d.Bf.font = FONT_Li; |
np->norm->Bf.font = FONT_Li; |
else if (MDOC_Symbolic == arg) |
else if (MDOC_Symbolic == arg) |
np->norm->d.Bf.font = FONT_Sy; |
np->norm->Bf.font = FONT_Sy; |
else |
else |
abort(); |
abort(); |
return(1); |
return(1); |
Line 1044 post_bf(POST_ARGS) |
|
Line 1010 post_bf(POST_ARGS) |
|
/* Extract parameter into data. */ |
/* Extract parameter into data. */ |
|
|
if (0 == strcmp(np->child->string, "Em")) |
if (0 == strcmp(np->child->string, "Em")) |
np->norm->d.Bf.font = FONT_Em; |
np->norm->Bf.font = FONT_Em; |
else if (0 == strcmp(np->child->string, "Li")) |
else if (0 == strcmp(np->child->string, "Li")) |
np->norm->d.Bf.font = FONT_Li; |
np->norm->Bf.font = FONT_Li; |
else if (0 == strcmp(np->child->string, "Sy")) |
else if (0 == strcmp(np->child->string, "Sy")) |
np->norm->d.Bf.font = FONT_Sy; |
np->norm->Bf.font = FONT_Sy; |
else |
else |
mdoc_nmsg(mdoc, np, MANDOCERR_FONTTYPE); |
mdoc_nmsg(mdoc, np, MANDOCERR_FONTTYPE); |
|
|
Line 1062 post_lb(POST_ARGS) |
|
Line 1028 post_lb(POST_ARGS) |
|
char *buf; |
char *buf; |
size_t sz; |
size_t sz; |
|
|
|
check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 1); |
|
|
assert(mdoc->last->child); |
assert(mdoc->last->child); |
assert(MDOC_TEXT == mdoc->last->child->type); |
assert(MDOC_TEXT == mdoc->last->child->type); |
|
|
Line 1105 post_vt(POST_ARGS) |
|
Line 1073 post_vt(POST_ARGS) |
|
/* |
/* |
* The Vt macro comes in both ELEM and BLOCK form, both of which |
* The Vt macro comes in both ELEM and BLOCK form, both of which |
* have different syntaxes (yet more context-sensitive |
* have different syntaxes (yet more context-sensitive |
* behaviour). ELEM types must have a child; BLOCK types, |
* behaviour). ELEM types must have a child, which is already |
|
* guaranteed by the in_line parsing routine; BLOCK types, |
* specifically the BODY, should only have TEXT children. |
* specifically the BODY, should only have TEXT children. |
*/ |
*/ |
|
|
if (MDOC_ELEM == mdoc->last->type) |
|
return(eerr_ge1(mdoc)); |
|
if (MDOC_BODY != mdoc->last->type) |
if (MDOC_BODY != mdoc->last->type) |
return(1); |
return(1); |
|
|
Line 1254 post_an(POST_ARGS) |
|
Line 1221 post_an(POST_ARGS) |
|
struct mdoc_node *np; |
struct mdoc_node *np; |
|
|
np = mdoc->last; |
np = mdoc->last; |
if (AUTH__NONE != np->norm->d.An.auth && np->child) |
if (AUTH__NONE == np->norm->An.auth) { |
return(eerr_eq0(mdoc)); |
if (0 == np->child) |
|
check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0); |
|
} else if (np->child) |
|
check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0); |
|
|
/* |
|
* FIXME: make this ewarn and make sure that the front-ends |
|
* don't print the arguments. |
|
*/ |
|
if (AUTH__NONE != np->norm->d.An.auth || np->child) |
|
return(1); |
|
|
|
mdoc_nmsg(mdoc, np, MANDOCERR_NOARGS); |
|
return(1); |
return(1); |
} |
} |
|
|
Line 1281 post_it(POST_ARGS) |
|
Line 1243 post_it(POST_ARGS) |
|
return(1); |
return(1); |
|
|
n = mdoc->last->parent->parent; |
n = mdoc->last->parent->parent; |
lt = n->norm->d.Bl.type; |
lt = n->norm->Bl.type; |
|
|
if (LIST__NONE == lt) { |
if (LIST__NONE == lt) { |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_LISTTYPE); |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_LISTTYPE); |
Line 1320 post_it(POST_ARGS) |
|
Line 1282 post_it(POST_ARGS) |
|
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_ARGSLOST); |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_ARGSLOST); |
break; |
break; |
case (LIST_column): |
case (LIST_column): |
cols = (int)n->norm->d.Bl.ncols; |
cols = (int)n->norm->Bl.ncols; |
|
|
assert(NULL == mdoc->last->head->child); |
assert(NULL == mdoc->last->head->child); |
|
|
Line 1364 post_bl_block(POST_ARGS) |
|
Line 1326 post_bl_block(POST_ARGS) |
|
|
|
n = mdoc->last; |
n = mdoc->last; |
|
|
if (LIST_tag == n->norm->d.Bl.type && |
if (LIST_tag == n->norm->Bl.type && |
NULL == n->norm->d.Bl.width) { |
NULL == n->norm->Bl.width) { |
if ( ! post_bl_block_tag(mdoc)) |
if ( ! post_bl_block_tag(mdoc)) |
return(0); |
return(0); |
} else if (NULL != n->norm->d.Bl.width) { |
} else if (NULL != n->norm->Bl.width) { |
if ( ! post_bl_block_width(mdoc)) |
if ( ! post_bl_block_width(mdoc)) |
return(0); |
return(0); |
} else |
} else |
return(1); |
return(1); |
|
|
assert(n->norm->d.Bl.width); |
assert(n->norm->Bl.width); |
return(1); |
return(1); |
} |
} |
|
|
Line 1398 post_bl_block_width(POST_ARGS) |
|
Line 1360 post_bl_block_width(POST_ARGS) |
|
* the macro's width as set in share/tmac/mdoc/doc-common. |
* the macro's width as set in share/tmac/mdoc/doc-common. |
*/ |
*/ |
|
|
if (0 == strcmp(n->norm->d.Bl.width, "Ds")) |
if (0 == strcmp(n->norm->Bl.width, "Ds")) |
width = 6; |
width = 6; |
else if (MDOC_MAX == (tok = mdoc_hash_find(n->norm->d.Bl.width))) |
else if (MDOC_MAX == (tok = mdoc_hash_find(n->norm->Bl.width))) |
return(1); |
return(1); |
else if (0 == (width = mdoc_macro2len(tok))) { |
else if (0 == (width = mdoc_macro2len(tok))) { |
mdoc_nmsg(mdoc, n, MANDOCERR_BADWIDTH); |
mdoc_nmsg(mdoc, n, MANDOCERR_BADWIDTH); |
Line 1422 post_bl_block_width(POST_ARGS) |
|
Line 1384 post_bl_block_width(POST_ARGS) |
|
n->args->argv[i].value[0] = mandoc_strdup(buf); |
n->args->argv[i].value[0] = mandoc_strdup(buf); |
|
|
/* Set our width! */ |
/* Set our width! */ |
n->norm->d.Bl.width = n->args->argv[i].value[0]; |
n->norm->Bl.width = n->args->argv[i].value[0]; |
return(1); |
return(1); |
} |
} |
|
|
Line 1488 post_bl_block_tag(POST_ARGS) |
|
Line 1450 post_bl_block_tag(POST_ARGS) |
|
n->args->argv[i].value[0] = mandoc_strdup(buf); |
n->args->argv[i].value[0] = mandoc_strdup(buf); |
|
|
/* Set our width! */ |
/* Set our width! */ |
n->norm->d.Bl.width = n->args->argv[i].value[0]; |
n->norm->Bl.width = n->args->argv[i].value[0]; |
return(1); |
return(1); |
} |
} |
|
|
Line 1499 post_bl_head(POST_ARGS) |
|
Line 1461 post_bl_head(POST_ARGS) |
|
struct mdoc_node *np, *nn, *nnp; |
struct mdoc_node *np, *nn, *nnp; |
int i, j; |
int i, j; |
|
|
if (LIST_column != mdoc->last->norm->d.Bl.type) |
if (LIST_column != mdoc->last->norm->Bl.type) |
/* FIXME: this should be ERROR class... */ |
/* FIXME: this should be ERROR class... */ |
return(hwarn_eq0(mdoc)); |
return(hwarn_eq0(mdoc)); |
|
|
Line 1516 post_bl_head(POST_ARGS) |
|
Line 1478 post_bl_head(POST_ARGS) |
|
* lists, but I'll leave that for another day. |
* lists, but I'll leave that for another day. |
*/ |
*/ |
|
|
if (mdoc->last->norm->d.Bl.ncols && mdoc->last->nchild) { |
if (mdoc->last->norm->Bl.ncols && mdoc->last->nchild) { |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_COLUMNS); |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_COLUMNS); |
return(0); |
return(0); |
} else if (NULL == mdoc->last->child) |
} else if (NULL == mdoc->last->child) |
Line 1542 post_bl_head(POST_ARGS) |
|
Line 1504 post_bl_head(POST_ARGS) |
|
np->args->argv[j].value = mandoc_malloc |
np->args->argv[j].value = mandoc_malloc |
((size_t)mdoc->last->nchild * sizeof(char *)); |
((size_t)mdoc->last->nchild * sizeof(char *)); |
|
|
mdoc->last->norm->d.Bl.ncols = np->args->argv[j].sz; |
mdoc->last->norm->Bl.ncols = np->args->argv[j].sz; |
mdoc->last->norm->d.Bl.cols = (const char **)np->args->argv[j].value; |
mdoc->last->norm->Bl.cols = (const char **)np->args->argv[j].value; |
|
|
for (i = 0, nn = mdoc->last->child; nn; i++) { |
for (i = 0, nn = mdoc->last->child; nn; i++) { |
np->args->argv[j].value[i] = nn->string; |
np->args->argv[j].value[i] = nn->string; |
|
|
ebool(struct mdoc *mdoc) |
ebool(struct mdoc *mdoc) |
{ |
{ |
|
|
if (NULL == mdoc->last->child) |
if (NULL == mdoc->last->child) { |
|
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_MACROEMPTY); |
|
mdoc_node_delete(mdoc, mdoc->last); |
return(1); |
return(1); |
|
} |
|
check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 1); |
|
|
assert(MDOC_TEXT == mdoc->last->child->type); |
assert(MDOC_TEXT == mdoc->last->child->type); |
|
|
Line 1647 post_root(POST_ARGS) |
|
Line 1613 post_root(POST_ARGS) |
|
static int |
static int |
post_st(POST_ARGS) |
post_st(POST_ARGS) |
{ |
{ |
const char *p; |
struct mdoc_node *ch; |
|
const char *p; |
|
|
assert(MDOC_TEXT == mdoc->last->child->type); |
if (NULL == (ch = mdoc->last->child)) { |
|
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_MACROEMPTY); |
|
mdoc_node_delete(mdoc, mdoc->last); |
|
return(1); |
|
} |
|
|
p = mdoc_a2st(mdoc->last->child->string); |
assert(MDOC_TEXT == ch->type); |
|
|
if (p == NULL) { |
if (NULL == (p = mdoc_a2st(ch->string))) { |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADSTANDARD); |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADSTANDARD); |
mdoc_node_delete(mdoc, mdoc->last); |
mdoc_node_delete(mdoc, mdoc->last); |
} else { |
} else { |
free(mdoc->last->child->string); |
free(ch->string); |
mdoc->last->child->string = mandoc_strdup(p); |
ch->string = mandoc_strdup(p); |
} |
} |
|
|
return(1); |
return(1); |
Line 1670 post_rs(POST_ARGS) |
|
Line 1641 post_rs(POST_ARGS) |
|
struct mdoc_node *nn, *next, *prev; |
struct mdoc_node *nn, *next, *prev; |
int i, j; |
int i, j; |
|
|
if (MDOC_BODY != mdoc->last->type) |
switch (mdoc->last->type) { |
|
case (MDOC_HEAD): |
|
check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0); |
return(1); |
return(1); |
|
case (MDOC_BODY): |
|
if (mdoc->last->child) |
|
break; |
|
check_count(mdoc, MDOC_BODY, CHECK_WARN, CHECK_GT, 0); |
|
return(1); |
|
default: |
|
return(1); |
|
} |
|
|
/* |
/* |
* Make sure only certain types of nodes are allowed within the |
* Make sure only certain types of nodes are allowed within the |
Line 1686 post_rs(POST_ARGS) |
|
Line 1667 post_rs(POST_ARGS) |
|
break; |
break; |
|
|
if (i < RSORD_MAX) { |
if (i < RSORD_MAX) { |
|
if (MDOC__J == rsord[i] || MDOC__B == rsord[i]) |
|
mdoc->last->norm->Rs.quote_T++; |
next = nn->next; |
next = nn->next; |
continue; |
continue; |
} |
} |
Line 1925 pre_par(PRE_ARGS) |
|
Line 1908 pre_par(PRE_ARGS) |
|
|
|
if (MDOC_Pp != mdoc->last->tok && MDOC_Lp != mdoc->last->tok) |
if (MDOC_Pp != mdoc->last->tok && MDOC_Lp != mdoc->last->tok) |
return(1); |
return(1); |
if (MDOC_Bl == n->tok && n->norm->d.Bl.comp) |
if (MDOC_Bl == n->tok && n->norm->Bl.comp) |
return(1); |
return(1); |
if (MDOC_Bd == n->tok && n->norm->d.Bd.comp) |
if (MDOC_Bd == n->tok && n->norm->Bd.comp) |
return(1); |
return(1); |
if (MDOC_It == n->tok && n->parent->norm->d.Bl.comp) |
if (MDOC_It == n->tok && n->parent->norm->Bl.comp) |
return(1); |
return(1); |
|
|
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_IGNPAR); |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_IGNPAR); |
Line 1954 pre_literal(PRE_ARGS) |
|
Line 1937 pre_literal(PRE_ARGS) |
|
mdoc->flags |= MDOC_LITERAL; |
mdoc->flags |= MDOC_LITERAL; |
break; |
break; |
case (MDOC_Bd): |
case (MDOC_Bd): |
if (DISP_literal == n->norm->d.Bd.type) |
if (DISP_literal == n->norm->Bd.type) |
mdoc->flags |= MDOC_LITERAL; |
mdoc->flags |= MDOC_LITERAL; |
if (DISP_unfilled == n->norm->d.Bd.type) |
if (DISP_unfilled == n->norm->Bd.type) |
mdoc->flags |= MDOC_LITERAL; |
mdoc->flags |= MDOC_LITERAL; |
break; |
break; |
default: |
default: |
Line 2114 post_prol(POST_ARGS) |
|
Line 2097 post_prol(POST_ARGS) |
|
mdoc_node_delete(mdoc, mdoc->last); |
mdoc_node_delete(mdoc, mdoc->last); |
if (mdoc->meta.title && mdoc->meta.date && mdoc->meta.os) |
if (mdoc->meta.title && mdoc->meta.date && mdoc->meta.os) |
mdoc->flags |= MDOC_PBODY; |
mdoc->flags |= MDOC_PBODY; |
|
|
|
return(1); |
|
} |
|
|
|
static int |
|
post_bx(POST_ARGS) |
|
{ |
|
struct mdoc_node *n; |
|
|
|
/* |
|
* Make `Bx's second argument always start with an uppercase |
|
* letter. Groff checks if it's an "accepted" term, but we just |
|
* uppercase blindly. |
|
*/ |
|
|
|
n = mdoc->last->child; |
|
if (n && NULL != (n = n->next)) |
|
*n->string = toupper((unsigned char)*n->string); |
|
|
return(1); |
return(1); |
} |
} |