version 1.140, 2010/12/15 23:39:40 |
version 1.149, 2010/12/25 23:25:53 |
Line 170 static v_pre pres_dd[] = { pre_dd, NULL }; |
|
Line 170 static v_pre pres_dd[] = { pre_dd, NULL }; |
|
static v_pre pres_dt[] = { pre_dt, NULL }; |
static v_pre pres_dt[] = { pre_dt, NULL }; |
static v_pre pres_er[] = { NULL, NULL }; |
static v_pre pres_er[] = { NULL, NULL }; |
static v_pre pres_fd[] = { NULL, NULL }; |
static v_pre pres_fd[] = { NULL, NULL }; |
static v_pre pres_it[] = { pre_it, NULL }; |
static v_pre pres_it[] = { pre_it, pre_par, NULL }; |
static v_pre pres_os[] = { pre_os, NULL }; |
static v_pre pres_os[] = { pre_os, NULL }; |
static v_pre pres_pp[] = { pre_par, NULL }; |
static v_pre pres_pp[] = { pre_par, NULL }; |
static v_pre pres_sh[] = { pre_sh, NULL }; |
static v_pre pres_sh[] = { pre_sh, NULL }; |
Line 609 pre_bl(PRE_ARGS) |
|
Line 609 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); |
assert(np->data.Bl); |
|
n->data.Bl = np->data.Bl; |
|
return(1); |
return(1); |
} |
} |
|
|
Line 620 pre_bl(PRE_ARGS) |
|
Line 618 pre_bl(PRE_ARGS) |
|
* ones. If we find no list type, we default to LIST_item. |
* ones. If we find no list type, we default to LIST_item. |
*/ |
*/ |
|
|
assert(NULL == n->data.Bl); |
|
n->data.Bl = mandoc_calloc(1, sizeof(struct mdoc_bl)); |
|
|
|
/* LINTED */ |
/* LINTED */ |
for (i = 0; n->args && i < (int)n->args->argc; i++) { |
for (i = 0; n->args && i < (int)n->args->argc; i++) { |
lt = LIST__NONE; |
lt = LIST__NONE; |
Line 665 pre_bl(PRE_ARGS) |
|
Line 660 pre_bl(PRE_ARGS) |
|
break; |
break; |
/* Set list arguments. */ |
/* Set list arguments. */ |
case (MDOC_Compact): |
case (MDOC_Compact): |
dup = n->data.Bl->comp; |
dup = n->norm->Bl.comp; |
comp = 1; |
comp = 1; |
break; |
break; |
case (MDOC_Width): |
case (MDOC_Width): |
dup = (NULL != n->data.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->data.Bl->offs); |
dup = (NULL != n->norm->Bl.offs); |
break; |
break; |
} |
} |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
Line 691 pre_bl(PRE_ARGS) |
|
Line 686 pre_bl(PRE_ARGS) |
|
mdoc_nmsg(mdoc, n, MANDOCERR_ARGVREP); |
mdoc_nmsg(mdoc, n, MANDOCERR_ARGVREP); |
|
|
if (comp && ! dup) |
if (comp && ! dup) |
n->data.Bl->comp = comp; |
n->norm->Bl.comp = comp; |
if (offs && ! dup) |
if (offs && ! dup) |
n->data.Bl->offs = offs; |
n->norm->Bl.offs = offs; |
if (width && ! dup) |
if (width && ! dup) |
n->data.Bl->width = width; |
n->norm->Bl.width = width; |
|
|
/* Check: multiple list types. */ |
/* Check: multiple list types. */ |
|
|
if (LIST__NONE != lt && n->data.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->data.Bl->type == LIST__NONE) { |
if (LIST__NONE != lt && n->norm->Bl.type == LIST__NONE) { |
n->data.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->data.Bl->ncols = |
n->norm->Bl.ncols = |
n->args->argv[i].sz; |
n->args->argv[i].sz; |
n->data.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->data.Bl->type == LIST__NONE) |
if (n->norm->Bl.type == LIST__NONE) |
if (n->data.Bl->width || |
if (n->norm->Bl.width || |
n->data.Bl->offs || |
n->norm->Bl.offs || |
n->data.Bl->comp) |
n->norm->Bl.comp) |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTFIRST); |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTFIRST); |
|
|
continue; |
continue; |
Line 728 pre_bl(PRE_ARGS) |
|
Line 723 pre_bl(PRE_ARGS) |
|
|
|
/* Allow lists to default to LIST_item. */ |
/* Allow lists to default to LIST_item. */ |
|
|
if (LIST__NONE == n->data.Bl->type) { |
if (LIST__NONE == n->norm->Bl.type) { |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTTYPE); |
mdoc_nmsg(mdoc, n, MANDOCERR_LISTTYPE); |
n->data.Bl->type = LIST_item; |
n->norm->Bl.type = LIST_item; |
} |
} |
|
|
/* |
/* |
Line 739 pre_bl(PRE_ARGS) |
|
Line 734 pre_bl(PRE_ARGS) |
|
* and must also be warned. |
* and must also be warned. |
*/ |
*/ |
|
|
switch (n->data.Bl->type) { |
switch (n->norm->Bl.type) { |
case (LIST_tag): |
case (LIST_tag): |
if (n->data.Bl->width) |
if (n->norm->Bl.width) |
break; |
break; |
mdoc_nmsg(mdoc, n, MANDOCERR_NOWIDTHARG); |
mdoc_nmsg(mdoc, n, MANDOCERR_NOWIDTHARG); |
break; |
break; |
Line 754 pre_bl(PRE_ARGS) |
|
Line 749 pre_bl(PRE_ARGS) |
|
case (LIST_inset): |
case (LIST_inset): |
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case (LIST_item): |
case (LIST_item): |
if (n->data.Bl->width) |
if (n->norm->Bl.width) |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
mdoc_nmsg(mdoc, n, MANDOCERR_IGNARGV); |
break; |
break; |
default: |
default: |
Line 783 pre_bd(PRE_ARGS) |
|
Line 778 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); |
assert(np->data.Bd); |
|
n->data.Bd = np->data.Bd; |
|
return(1); |
return(1); |
} |
} |
|
|
assert(NULL == n->data.Bd); |
|
n->data.Bd = mandoc_calloc(1, sizeof(struct mdoc_bd)); |
|
|
|
/* 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 820 pre_bd(PRE_ARGS) |
|
Line 810 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->data.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->data.Bd->comp; |
dup = n->norm->Bd.comp; |
break; |
break; |
default: |
default: |
abort(); |
abort(); |
Line 842 pre_bd(PRE_ARGS) |
|
Line 832 pre_bd(PRE_ARGS) |
|
/* Make our auxiliary assignments. */ |
/* Make our auxiliary assignments. */ |
|
|
if (offs && ! dup) |
if (offs && ! dup) |
n->data.Bd->offs = offs; |
n->norm->Bd.offs = offs; |
if (comp && ! dup) |
if (comp && ! dup) |
n->data.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->data.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->data.Bd->type == DISP__NONE) |
if (DISP__NONE != dt && n->norm->Bd.type == DISP__NONE) |
n->data.Bd->type = dt; |
n->norm->Bd.type = dt; |
} |
} |
|
|
if (DISP__NONE == n->data.Bd->type) { |
if (DISP__NONE == n->norm->Bd.type) { |
mdoc_nmsg(mdoc, n, MANDOCERR_DISPTYPE); |
mdoc_nmsg(mdoc, n, MANDOCERR_DISPTYPE); |
n->data.Bd->type = DISP_ragged; |
n->norm->Bd.type = DISP_ragged; |
} |
} |
|
|
return(1); |
return(1); |
Line 912 pre_an(PRE_ARGS) |
|
Line 902 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->data.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->data.An.auth = AUTH_nosplit; |
n->norm->An.auth = AUTH_nosplit; |
else |
else |
abort(); |
abort(); |
|
|
Line 996 post_bf(POST_ARGS) |
|
Line 986 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); |
assert(np->data.Bf); |
|
mdoc->last->data.Bf = np->data.Bf; |
|
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); |
np->data.Bf = mandoc_calloc(1, sizeof(struct mdoc_bf)); |
|
|
|
/* |
/* |
* Cannot have both argument and parameter. |
* Cannot have both argument and parameter. |
Line 1024 post_bf(POST_ARGS) |
|
Line 1011 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->data.Bf->font = FONT_Em; |
np->norm->Bf.font = FONT_Em; |
else if (MDOC_Literal == arg) |
else if (MDOC_Literal == arg) |
np->data.Bf->font = FONT_Li; |
np->norm->Bf.font = FONT_Li; |
else if (MDOC_Symbolic == arg) |
else if (MDOC_Symbolic == arg) |
np->data.Bf->font = FONT_Sy; |
np->norm->Bf.font = FONT_Sy; |
else |
else |
abort(); |
abort(); |
return(1); |
return(1); |
Line 1037 post_bf(POST_ARGS) |
|
Line 1024 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->data.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->data.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->data.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 1247 post_an(POST_ARGS) |
|
Line 1234 post_an(POST_ARGS) |
|
struct mdoc_node *np; |
struct mdoc_node *np; |
|
|
np = mdoc->last; |
np = mdoc->last; |
if (AUTH__NONE != np->data.An.auth && np->child) |
if (AUTH__NONE != np->norm->An.auth && np->child) |
return(eerr_eq0(mdoc)); |
return(eerr_eq0(mdoc)); |
|
|
/* |
/* |
* FIXME: make this ewarn and make sure that the front-ends |
* FIXME: make this ewarn and make sure that the front-ends |
* don't print the arguments. |
* don't print the arguments. |
*/ |
*/ |
if (AUTH__NONE != np->data.An.auth || np->child) |
if (AUTH__NONE != np->norm->An.auth || np->child) |
return(1); |
return(1); |
|
|
mdoc_nmsg(mdoc, np, MANDOCERR_NOARGS); |
mdoc_nmsg(mdoc, np, MANDOCERR_NOARGS); |
Line 1274 post_it(POST_ARGS) |
|
Line 1261 post_it(POST_ARGS) |
|
return(1); |
return(1); |
|
|
n = mdoc->last->parent->parent; |
n = mdoc->last->parent->parent; |
assert(n->data.Bl); |
lt = n->norm->Bl.type; |
lt = n->data.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 1314 post_it(POST_ARGS) |
|
Line 1300 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->data.Bl->ncols; |
cols = (int)n->norm->Bl.ncols; |
|
|
assert(NULL == mdoc->last->head->child); |
assert(NULL == mdoc->last->head->child); |
|
|
Line 1358 post_bl_block(POST_ARGS) |
|
Line 1344 post_bl_block(POST_ARGS) |
|
|
|
n = mdoc->last; |
n = mdoc->last; |
|
|
if (LIST_tag == n->data.Bl->type && |
if (LIST_tag == n->norm->Bl.type && |
NULL == n->data.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->data.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->data.Bl->width); |
assert(n->norm->Bl.width); |
return(1); |
return(1); |
} |
} |
|
|
Line 1392 post_bl_block_width(POST_ARGS) |
|
Line 1378 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->data.Bl->width, "Ds")) |
if (0 == strcmp(n->norm->Bl.width, "Ds")) |
width = 6; |
width = 6; |
else if (MDOC_MAX == (tok = mdoc_hash_find(n->data.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 1416 post_bl_block_width(POST_ARGS) |
|
Line 1402 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->data.Bl->width = n->args->argv[i].value[0]; |
n->norm->Bl.width = n->args->argv[i].value[0]; |
return(1); |
return(1); |
} |
} |
|
|
Line 1482 post_bl_block_tag(POST_ARGS) |
|
Line 1468 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->data.Bl->width = n->args->argv[i].value[0]; |
n->norm->Bl.width = n->args->argv[i].value[0]; |
return(1); |
return(1); |
} |
} |
|
|
Line 1493 post_bl_head(POST_ARGS) |
|
Line 1479 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->data.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 1510 post_bl_head(POST_ARGS) |
|
Line 1496 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->data.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 1536 post_bl_head(POST_ARGS) |
|
Line 1522 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->data.Bl->ncols = np->args->argv[j].sz; |
mdoc->last->norm->Bl.ncols = np->args->argv[j].sz; |
mdoc->last->data.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; |
Line 1564 post_bl(POST_ARGS) |
|
Line 1550 post_bl(POST_ARGS) |
|
return(post_bl_block(mdoc)); |
return(post_bl_block(mdoc)); |
if (MDOC_BODY != mdoc->last->type) |
if (MDOC_BODY != mdoc->last->type) |
return(1); |
return(1); |
if (NULL == mdoc->last->child) |
|
return(1); |
|
|
|
/* |
|
* We only allow certain children of `Bl'. This is usually on |
|
* `It', but apparently `Sm' occurs here and there, so we let |
|
* that one through, too. |
|
*/ |
|
|
|
/* LINTED */ |
|
for (n = mdoc->last->child; n; n = n->next) { |
for (n = mdoc->last->child; n; n = n->next) { |
if (MDOC_BLOCK == n->type && MDOC_It == n->tok) |
switch (n->tok) { |
|
case (MDOC_Lp): |
|
/* FALLTHROUGH */ |
|
case (MDOC_Pp): |
|
mdoc_nmsg(mdoc, n, MANDOCERR_CHILD); |
|
/* FALLTHROUGH */ |
|
case (MDOC_It): |
|
/* FALLTHROUGH */ |
|
case (MDOC_Sm): |
continue; |
continue; |
if (MDOC_Sm == n->tok) |
default: |
continue; |
break; |
|
} |
|
|
mdoc_nmsg(mdoc, n, MANDOCERR_SYNTCHILD); |
mdoc_nmsg(mdoc, n, MANDOCERR_SYNTCHILD); |
return(0); |
return(0); |
} |
} |
Line 1679 post_rs(POST_ARGS) |
|
Line 1666 post_rs(POST_ARGS) |
|
break; |
break; |
|
|
if (i < RSORD_MAX) { |
if (i < RSORD_MAX) { |
|
if (MDOC__J == rsord[i]) |
|
mdoc->last->norm->Rs.child_J = nn; |
next = nn->next; |
next = nn->next; |
continue; |
continue; |
} |
} |
Line 1908 pre_par(PRE_ARGS) |
|
Line 1897 pre_par(PRE_ARGS) |
|
|
|
if (NULL == mdoc->last) |
if (NULL == mdoc->last) |
return(1); |
return(1); |
|
if (MDOC_ELEM != n->type && MDOC_BLOCK != n->type) |
|
return(1); |
|
|
/* |
/* |
* Don't allow prior `Lp' or `Pp' prior to a paragraph-type |
* Don't allow prior `Lp' or `Pp' prior to a paragraph-type |
Line 1916 pre_par(PRE_ARGS) |
|
Line 1907 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->Bl.comp) |
if (MDOC_Bl == n->tok && n->data.Bl->comp) |
|
return(1); |
return(1); |
if (MDOC_Bd == n->tok && n->data.Bd->comp) |
if (MDOC_Bd == n->tok && n->norm->Bd.comp) |
return(1); |
return(1); |
|
if (MDOC_It == n->tok && n->parent->norm->Bl.comp) |
|
return(1); |
|
|
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_IGNPAR); |
mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_IGNPAR); |
mdoc_node_delete(mdoc, mdoc->last); |
mdoc_node_delete(mdoc, mdoc->last); |
Line 1944 pre_literal(PRE_ARGS) |
|
Line 1936 pre_literal(PRE_ARGS) |
|
mdoc->flags |= MDOC_LITERAL; |
mdoc->flags |= MDOC_LITERAL; |
break; |
break; |
case (MDOC_Bd): |
case (MDOC_Bd): |
assert(n->data.Bd); |
if (DISP_literal == n->norm->Bd.type) |
if (DISP_literal == n->data.Bd->type) |
|
mdoc->flags |= MDOC_LITERAL; |
mdoc->flags |= MDOC_LITERAL; |
if (DISP_unfilled == n->data.Bd->type) |
if (DISP_unfilled == n->norm->Bd.type) |
mdoc->flags |= MDOC_LITERAL; |
mdoc->flags |= MDOC_LITERAL; |
break; |
break; |
default: |
default: |