version 1.1, 2009/03/26 14:38:11 |
version 1.15, 2009/06/17 18:42:42 |
|
|
/* $Id$ */ |
/* $Id$ */ |
/* |
/* |
* Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org> |
* Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se> |
* |
* |
* 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 |
* purpose with or without fee is hereby granted, provided that the above |
* above copyright notice and this permission notice appear in all |
* copyright notice and this permission notice appear in all copies. |
* copies. |
|
* |
* |
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
* PERFORMANCE OF THIS SOFTWARE. |
|
*/ |
*/ |
#include <sys/types.h> |
#include <sys/types.h> |
|
|
Line 88 struct termpair { |
|
Line 86 struct termpair { |
|
struct termpair *ppair; |
struct termpair *ppair; |
int type; |
int type; |
#define TERMPAIR_FLAG (1 << 0) |
#define TERMPAIR_FLAG (1 << 0) |
int flag; |
int flag; /* Whether being used. */ |
size_t offset; |
size_t offset; /* Left margin. */ |
size_t rmargin; |
size_t rmargin; /* Right margin. */ |
int count; |
int count; /* Enum count. */ |
}; |
}; |
|
|
#define TERMPAIR_SETFLAG(termp, p, fl) \ |
#define TERMPAIR_SETFLAG(termp, p, fl) \ |
Line 185 struct termact { |
|
Line 183 struct termact { |
|
}; |
}; |
|
|
static const struct termact termacts[MDOC_MAX] = { |
static const struct termact termacts[MDOC_MAX] = { |
{ NULL, NULL }, /* \" */ |
{ termp_ap_pre, NULL }, /* Ap */ |
{ NULL, NULL }, /* Dd */ |
{ NULL, NULL }, /* Dd */ |
{ NULL, NULL }, /* Dt */ |
{ NULL, NULL }, /* Dt */ |
{ NULL, NULL }, /* Os */ |
{ NULL, NULL }, /* Os */ |
Line 292 static const struct termact termacts[MDOC_MAX] = { |
|
Line 290 static const struct termact termacts[MDOC_MAX] = { |
|
{ NULL, NULL }, /* Fr */ |
{ NULL, NULL }, /* Fr */ |
{ termp_ud_pre, NULL }, /* Ud */ |
{ termp_ud_pre, NULL }, /* Ud */ |
{ termp_lb_pre, termp_lb_post }, /* Lb */ |
{ termp_lb_pre, termp_lb_post }, /* Lb */ |
{ termp_ap_pre, NULL }, /* Lb */ |
{ termp_pp_pre, NULL }, /* Lp */ |
{ termp_pp_pre, NULL }, /* Pp */ |
|
{ termp_lk_pre, NULL }, /* Lk */ |
{ termp_lk_pre, NULL }, /* Lk */ |
{ termp_mt_pre, NULL }, /* Mt */ |
{ termp_mt_pre, NULL }, /* Mt */ |
{ termp_brq_pre, termp_brq_post }, /* Brq */ |
{ termp_brq_pre, termp_brq_post }, /* Brq */ |
Line 306 static const struct termact termacts[MDOC_MAX] = { |
|
Line 303 static const struct termact termacts[MDOC_MAX] = { |
|
{ NULL, NULL }, /* %Q */ |
{ NULL, NULL }, /* %Q */ |
}; |
}; |
|
|
|
#ifdef __linux__ |
|
extern size_t strlcpy(char *, const char *, size_t); |
|
extern size_t strlcat(char *, const char *, size_t); |
|
#endif |
|
|
static int arg_hasattr(int, const struct mdoc_node *); |
static int arg_hasattr(int, const struct mdoc_node *); |
static int arg_getattrs(const int *, int *, size_t, |
static int arg_getattrs(const int *, int *, size_t, |
const struct mdoc_node *); |
const struct mdoc_node *); |
Line 316 static int arg_listtype(const struct mdoc_node *); |
|
Line 318 static int arg_listtype(const struct mdoc_node *); |
|
static int fmt_block_vspace(struct termp *, |
static int fmt_block_vspace(struct termp *, |
const struct mdoc_node *, |
const struct mdoc_node *, |
const struct mdoc_node *); |
const struct mdoc_node *); |
static int print_node(DECL_ARGS); |
static void print_node(DECL_ARGS); |
static int print_head(struct termp *, |
static void print_head(struct termp *, |
const struct mdoc_meta *); |
const struct mdoc_meta *); |
static int print_body(DECL_ARGS); |
static void print_body(DECL_ARGS); |
static int print_foot(struct termp *, |
static void print_foot(struct termp *, |
const struct mdoc_meta *); |
const struct mdoc_meta *); |
static void sanity(const struct mdoc_node *); |
|
|
|
|
|
int |
int |
mdoc_run(struct termp *p, const struct mdoc *m) |
mdoc_run(struct termp *p, const struct mdoc *m) |
{ |
{ |
|
/* |
|
* Main output function. When this is called, assume that the |
|
* tree is properly formed. |
|
*/ |
|
|
if ( ! print_head(p, mdoc_meta(m))) |
print_head(p, mdoc_meta(m)); |
return(0); |
assert(mdoc_node(m)); |
if ( ! print_body(p, NULL, mdoc_meta(m), mdoc_node(m))) |
assert(MDOC_ROOT == mdoc_node(m)->type); |
return(0); |
if (mdoc_node(m)->child) |
return(print_foot(p, mdoc_meta(m))); |
print_body(p, NULL, mdoc_meta(m), mdoc_node(m)->child); |
|
print_foot(p, mdoc_meta(m)); |
|
return(1); |
} |
} |
|
|
|
|
static int |
static void |
print_body(DECL_ARGS) |
print_body(DECL_ARGS) |
{ |
{ |
|
|
if ( ! print_node(p, pair, meta, node)) |
print_node(p, pair, meta, node); |
return(0); |
|
if ( ! node->next) |
if ( ! node->next) |
return(1); |
return; |
return(print_body(p, pair, meta, node->next)); |
print_body(p, pair, meta, node->next); |
} |
} |
|
|
|
|
static int |
static void |
print_node(DECL_ARGS) |
print_node(DECL_ARGS) |
{ |
{ |
int dochild; |
int dochild; |
struct termpair npair; |
struct termpair npair; |
|
|
/* Some quick sanity-checking. */ |
|
|
|
sanity(node); |
|
|
|
/* Pre-processing. */ |
/* Pre-processing. */ |
|
|
dochild = 1; |
dochild = 1; |
Line 391 print_node(DECL_ARGS) |
|
Line 393 print_node(DECL_ARGS) |
|
if (MDOC_TEXT != node->type) |
if (MDOC_TEXT != node->type) |
if (termacts[node->tok].post) |
if (termacts[node->tok].post) |
(*termacts[node->tok].post)(p, &npair, meta, node); |
(*termacts[node->tok].post)(p, &npair, meta, node); |
|
|
return(1); |
|
} |
} |
|
|
|
|
static int |
static void |
print_foot(struct termp *p, const struct mdoc_meta *meta) |
print_foot(struct termp *p, const struct mdoc_meta *meta) |
{ |
{ |
struct tm *tm; |
struct tm *tm; |
char *buf, *os; |
char *buf, *os; |
|
|
|
/* |
|
* Output the footer in new-groff style, that is, three columns |
|
* with the middle being the manual date and flanking columns |
|
* being the operating system: |
|
* |
|
* SYSTEM DATE SYSTEM |
|
*/ |
|
|
if (NULL == (buf = malloc(p->rmargin))) |
if (NULL == (buf = malloc(p->rmargin))) |
err(1, "malloc"); |
err(1, "malloc"); |
if (NULL == (os = malloc(p->rmargin))) |
if (NULL == (os = malloc(p->rmargin))) |
Line 409 print_foot(struct termp *p, const struct mdoc_meta *me |
|
Line 417 print_foot(struct termp *p, const struct mdoc_meta *me |
|
|
|
tm = localtime(&meta->date); |
tm = localtime(&meta->date); |
|
|
#ifdef __OpenBSD__ |
|
if (NULL == strftime(buf, p->rmargin, "%B %d, %Y", tm)) |
|
#else |
|
if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm)) |
if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm)) |
#endif |
|
err(1, "strftime"); |
err(1, "strftime"); |
|
|
(void)strlcpy(os, meta->os, p->rmargin); |
(void)strlcpy(os, meta->os, p->rmargin); |
|
|
/* |
|
* This is /slightly/ different from regular groff output |
|
* because we don't have page numbers. Print the following: |
|
* |
|
* OS MDOCDATE |
|
*/ |
|
|
|
term_vspace(p); |
term_vspace(p); |
|
|
p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; |
|
p->rmargin = p->maxrmargin - strlen(buf); |
|
p->offset = 0; |
p->offset = 0; |
|
p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2; |
|
p->flags |= TERMP_NOSPACE | TERMP_NOBREAK; |
|
|
term_word(p, os); |
term_word(p, os); |
term_flushln(p); |
term_flushln(p); |
|
|
|
p->offset = p->rmargin; |
|
p->rmargin = p->maxrmargin - strlen(os); |
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; |
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; |
|
|
|
term_word(p, buf); |
|
term_flushln(p); |
|
|
p->offset = p->rmargin; |
p->offset = p->rmargin; |
p->rmargin = p->maxrmargin; |
p->rmargin = p->maxrmargin; |
p->flags &= ~TERMP_NOBREAK; |
p->flags &= ~TERMP_NOBREAK; |
|
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; |
|
|
term_word(p, buf); |
term_word(p, os); |
term_flushln(p); |
term_flushln(p); |
|
|
|
p->offset = 0; |
|
p->rmargin = p->maxrmargin; |
|
p->flags = 0; |
|
|
free(buf); |
free(buf); |
free(os); |
free(os); |
|
|
return(1); |
|
} |
} |
|
|
|
|
static int |
static void |
print_head(struct termp *p, const struct mdoc_meta *meta) |
print_head(struct termp *p, const struct mdoc_meta *meta) |
{ |
{ |
char *buf, *title; |
char *buf, *title; |
Line 488 print_head(struct termp *p, const struct mdoc_meta *me |
|
Line 494 print_head(struct termp *p, const struct mdoc_meta *me |
|
meta->title, meta->msec); |
meta->title, meta->msec); |
|
|
p->offset = 0; |
p->offset = 0; |
p->rmargin = (p->maxrmargin - strlen(buf)) / 2; |
p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2; |
p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; |
p->flags |= TERMP_NOBREAK | TERMP_NOSPACE; |
|
|
term_word(p, title); |
term_word(p, title); |
term_flushln(p); |
term_flushln(p); |
|
|
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; |
|
p->offset = p->rmargin; |
p->offset = p->rmargin; |
p->rmargin = p->maxrmargin - strlen(title); |
p->rmargin = p->maxrmargin - strlen(title); |
|
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE; |
|
|
term_word(p, buf); |
term_word(p, buf); |
term_flushln(p); |
term_flushln(p); |
Line 509 print_head(struct termp *p, const struct mdoc_meta *me |
|
Line 515 print_head(struct termp *p, const struct mdoc_meta *me |
|
term_word(p, title); |
term_word(p, title); |
term_flushln(p); |
term_flushln(p); |
|
|
p->rmargin = p->maxrmargin; |
|
p->offset = 0; |
p->offset = 0; |
|
p->rmargin = p->maxrmargin; |
p->flags &= ~TERMP_NOSPACE; |
p->flags &= ~TERMP_NOSPACE; |
|
|
free(title); |
free(title); |
free(buf); |
free(buf); |
|
|
return(1); |
|
} |
} |
|
|
|
|
static void |
|
sanity(const struct mdoc_node *n) |
|
{ |
|
char *p; |
|
|
|
p = "regular form violated"; |
|
|
|
switch (n->type) { |
|
case (MDOC_TEXT): |
|
if (n->child) |
|
errx(1, p); |
|
if (NULL == n->parent) |
|
errx(1, p); |
|
if (NULL == n->string) |
|
errx(1, p); |
|
switch (n->parent->type) { |
|
case (MDOC_TEXT): |
|
/* FALLTHROUGH */ |
|
case (MDOC_ROOT): |
|
errx(1, p); |
|
/* NOTREACHED */ |
|
default: |
|
break; |
|
} |
|
break; |
|
case (MDOC_ELEM): |
|
if (NULL == n->parent) |
|
errx(1, p); |
|
switch (n->parent->type) { |
|
case (MDOC_TAIL): |
|
/* FALLTHROUGH */ |
|
case (MDOC_BODY): |
|
/* FALLTHROUGH */ |
|
case (MDOC_HEAD): |
|
break; |
|
default: |
|
errx(1, p); |
|
/* NOTREACHED */ |
|
} |
|
if (n->child) switch (n->child->type) { |
|
case (MDOC_TEXT): |
|
break; |
|
default: |
|
errx(1, p); |
|
/* NOTREACHED */ |
|
} |
|
break; |
|
case (MDOC_HEAD): |
|
/* FALLTHROUGH */ |
|
case (MDOC_BODY): |
|
/* FALLTHROUGH */ |
|
case (MDOC_TAIL): |
|
if (NULL == n->parent) |
|
errx(1, p); |
|
if (MDOC_BLOCK != n->parent->type) |
|
errx(1, p); |
|
if (n->child) switch (n->child->type) { |
|
case (MDOC_BLOCK): |
|
/* FALLTHROUGH */ |
|
case (MDOC_ELEM): |
|
/* FALLTHROUGH */ |
|
case (MDOC_TEXT): |
|
break; |
|
default: |
|
errx(1, p); |
|
/* NOTREACHED */ |
|
} |
|
break; |
|
case (MDOC_BLOCK): |
|
if (NULL == n->parent) |
|
errx(1, p); |
|
if (NULL == n->child) |
|
errx(1, p); |
|
switch (n->parent->type) { |
|
case (MDOC_ROOT): |
|
/* FALLTHROUGH */ |
|
case (MDOC_HEAD): |
|
/* FALLTHROUGH */ |
|
case (MDOC_BODY): |
|
/* FALLTHROUGH */ |
|
case (MDOC_TAIL): |
|
break; |
|
default: |
|
errx(1, p); |
|
/* NOTREACHED */ |
|
} |
|
switch (n->child->type) { |
|
case (MDOC_ROOT): |
|
/* FALLTHROUGH */ |
|
case (MDOC_ELEM): |
|
errx(1, p); |
|
/* NOTREACHED */ |
|
default: |
|
break; |
|
} |
|
break; |
|
case (MDOC_ROOT): |
|
if (n->parent) |
|
errx(1, p); |
|
if (NULL == n->child) |
|
errx(1, p); |
|
switch (n->child->type) { |
|
case (MDOC_BLOCK): |
|
break; |
|
default: |
|
errx(1, p); |
|
/* NOTREACHED */ |
|
} |
|
break; |
|
} |
|
} |
|
|
|
|
|
static size_t |
static size_t |
arg_width(const struct mdoc_argv *arg, int pos) |
arg_width(const struct mdoc_argv *arg, int pos) |
{ |
{ |
Line 699 arg_listtype(const struct mdoc_node *n) |
|
Line 590 arg_listtype(const struct mdoc_node *n) |
|
break; |
break; |
} |
} |
|
|
|
/* FIXME: mandated by parser. */ |
|
|
errx(1, "list type not supported"); |
errx(1, "list type not supported"); |
/* NOTREACHED */ |
/* NOTREACHED */ |
} |
} |
Line 709 arg_offset(const struct mdoc_argv *arg) |
|
Line 602 arg_offset(const struct mdoc_argv *arg) |
|
{ |
{ |
|
|
assert(*arg->value); |
assert(*arg->value); |
|
if (0 == strcmp(*arg->value, "left")) |
|
return(0); |
if (0 == strcmp(*arg->value, "indent")) |
if (0 == strcmp(*arg->value, "indent")) |
return(INDENT); |
return(INDENT); |
if (0 == strcmp(*arg->value, "indent-two")) |
if (0 == strcmp(*arg->value, "indent-two")) |
return(INDENT * 2); |
return(INDENT * 2); |
|
|
|
/* FIXME: needs to support field-widths (10n, etc.). */ |
|
|
return(strlen(*arg->value)); |
return(strlen(*arg->value)); |
} |
} |
|
|
Line 816 termp_it_pre(DECL_ARGS) |
|
Line 714 termp_it_pre(DECL_ARGS) |
|
{ |
{ |
const struct mdoc_node *bl, *n; |
const struct mdoc_node *bl, *n; |
char buf[7]; |
char buf[7]; |
int i, type, keys[3], vals[3]; |
int i, type, keys[3], vals[3], sv; |
size_t width, offset; |
size_t width, offset; |
|
|
if (MDOC_BLOCK == node->type) |
if (MDOC_BLOCK == node->type) |
Line 1000 termp_it_pre(DECL_ARGS) |
|
Line 898 termp_it_pre(DECL_ARGS) |
|
|
|
/* |
/* |
* The dash, hyphen, bullet and enum lists all have a special |
* The dash, hyphen, bullet and enum lists all have a special |
* HEAD character. Print it now. |
* HEAD character (temporarily bold, in some cases). |
*/ |
*/ |
|
|
|
sv = p->flags; |
if (MDOC_HEAD == node->type) |
if (MDOC_HEAD == node->type) |
switch (type) { |
switch (type) { |
case (MDOC_Bullet): |
case (MDOC_Bullet): |
|
p->flags |= TERMP_BOLD; |
term_word(p, "\\[bu]"); |
term_word(p, "\\[bu]"); |
break; |
break; |
case (MDOC_Dash): |
case (MDOC_Dash): |
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case (MDOC_Hyphen): |
case (MDOC_Hyphen): |
|
p->flags |= TERMP_BOLD; |
term_word(p, "\\-"); |
term_word(p, "\\-"); |
break; |
break; |
case (MDOC_Enum): |
case (MDOC_Enum): |
Line 1023 termp_it_pre(DECL_ARGS) |
|
Line 924 termp_it_pre(DECL_ARGS) |
|
break; |
break; |
} |
} |
|
|
|
p->flags = sv; /* Restore saved flags. */ |
|
|
/* |
/* |
* If we're not going to process our children, indicate so here. |
* If we're not going to process our children, indicate so here. |
*/ |
*/ |
Line 1174 termp_rv_pre(DECL_ARGS) |
|
Line 1077 termp_rv_pre(DECL_ARGS) |
|
{ |
{ |
int i; |
int i; |
|
|
|
/* FIXME: mandated by parser. */ |
|
|
if (-1 == (i = arg_getattr(MDOC_Std, node))) |
if (-1 == (i = arg_getattr(MDOC_Std, node))) |
errx(1, "expected -std argument"); |
errx(1, "expected -std argument"); |
if (1 != node->args->argv[i].sz) |
if (1 != node->args->argv[i].sz) |
Line 1207 termp_ex_pre(DECL_ARGS) |
|
Line 1112 termp_ex_pre(DECL_ARGS) |
|
{ |
{ |
int i; |
int i; |
|
|
|
/* FIXME: mandated by parser? */ |
|
|
if (-1 == (i = arg_getattr(MDOC_Std, node))) |
if (-1 == (i = arg_getattr(MDOC_Std, node))) |
errx(1, "expected -std argument"); |
errx(1, "expected -std argument"); |
if (1 != node->args->argv[i].sz) |
if (1 != node->args->argv[i].sz) |
Line 1260 termp_xr_pre(DECL_ARGS) |
|
Line 1167 termp_xr_pre(DECL_ARGS) |
|
{ |
{ |
const struct mdoc_node *n; |
const struct mdoc_node *n; |
|
|
if (NULL == (n = node->child)) |
assert(node->child && MDOC_TEXT == node->child->type); |
errx(1, "expected text line argument"); |
n = node->child; |
|
|
term_word(p, n->string); |
term_word(p, n->string); |
if (NULL == (n = n->next)) |
if (NULL == (n = n->next)) |
return(0); |
return(0); |
Line 1395 termp_lb_pre(DECL_ARGS) |
|
Line 1303 termp_lb_pre(DECL_ARGS) |
|
{ |
{ |
const char *lb; |
const char *lb; |
|
|
if (NULL == node->child) |
assert(node->child && MDOC_TEXT == node->child->type); |
errx(1, "expected text line argument"); |
|
if ((lb = mdoc_a2lib(node->child->string))) { |
if ((lb = mdoc_a2lib(node->child->string))) { |
term_word(p, lb); |
term_word(p, lb); |
return(0); |
return(0); |
|
|
termp_d1_pre(DECL_ARGS) |
termp_d1_pre(DECL_ARGS) |
{ |
{ |
|
|
if (MDOC_BODY != node->type) |
if (MDOC_BLOCK != node->type) |
return(1); |
return(1); |
term_newln(p); |
term_newln(p); |
p->offset += (pair->offset = INDENT); |
p->offset += (pair->offset = INDENT); |
|
|
termp_d1_post(DECL_ARGS) |
termp_d1_post(DECL_ARGS) |
{ |
{ |
|
|
if (MDOC_BODY != node->type) |
if (MDOC_BLOCK != node->type) |
return; |
return; |
term_newln(p); |
term_newln(p); |
p->offset -= pair->offset; |
p->offset -= pair->offset; |
Line 1504 termp_fn_pre(DECL_ARGS) |
|
Line 1411 termp_fn_pre(DECL_ARGS) |
|
{ |
{ |
const struct mdoc_node *n; |
const struct mdoc_node *n; |
|
|
if (NULL == node->child) |
assert(node->child && MDOC_TEXT == node->child->type); |
errx(1, "expected text line arguments"); |
|
|
|
/* FIXME: can be "type funcname" "type varname"... */ |
/* FIXME: can be "type funcname" "type varname"... */ |
|
|
Line 1612 termp_bd_pre(DECL_ARGS) |
|
Line 1518 termp_bd_pre(DECL_ARGS) |
|
else if (MDOC_BODY != node->type) |
else if (MDOC_BODY != node->type) |
return(1); |
return(1); |
|
|
|
/* FIXME: display type should be mandated by parser. */ |
|
|
if (NULL == node->parent->args) |
if (NULL == node->parent->args) |
errx(1, "missing display type"); |
errx(1, "missing display type"); |
|
|
Line 1845 termp_ss_pre(DECL_ARGS) |
|
Line 1753 termp_ss_pre(DECL_ARGS) |
|
break; |
break; |
case (MDOC_HEAD): |
case (MDOC_HEAD): |
TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SSECTION]); |
TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SSECTION]); |
p->offset = INDENT / 2; |
p->offset = HALFINDENT; |
break; |
break; |
default: |
default: |
break; |
break; |
Line 2060 termp_fo_pre(DECL_ARGS) |
|
Line 1968 termp_fo_pre(DECL_ARGS) |
|
|
|
p->flags |= ttypes[TTYPE_FUNC_NAME]; |
p->flags |= ttypes[TTYPE_FUNC_NAME]; |
for (n = node->child; n; n = n->next) { |
for (n = node->child; n; n = n->next) { |
if (MDOC_TEXT != n->type) |
assert(MDOC_TEXT == n->type); |
errx(1, "expected text line argument"); |
|
term_word(p, n->string); |
term_word(p, n->string); |
} |
} |
p->flags &= ~ttypes[TTYPE_FUNC_NAME]; |
p->flags &= ~ttypes[TTYPE_FUNC_NAME]; |
Line 2105 termp_bf_pre(DECL_ARGS) |
|
Line 2012 termp_bf_pre(DECL_ARGS) |
|
return(1); |
return(1); |
} |
} |
|
|
if (MDOC_TEXT != n->type) |
assert(MDOC_TEXT == n->type); |
errx(1, "expected text line arguments"); |
|
|
|
if (0 == strcmp("Em", n->string)) |
if (0 == strcmp("Em", n->string)) |
TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]); |
TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]); |
else if (0 == strcmp("Sy", n->string)) |
else if (0 == strcmp("Sy", n->string)) |
|
|
termp_sm_pre(DECL_ARGS) |
termp_sm_pre(DECL_ARGS) |
{ |
{ |
|
|
if (NULL == node->child || MDOC_TEXT != node->child->type) |
assert(node->child && MDOC_TEXT == node->child->type); |
errx(1, "expected boolean line argument"); |
|
|
|
if (0 == strcmp("on", node->child->string)) { |
if (0 == strcmp("on", node->child->string)) { |
p->flags &= ~TERMP_NONOSPACE; |
p->flags &= ~TERMP_NONOSPACE; |
p->flags &= ~TERMP_NOSPACE; |
p->flags &= ~TERMP_NOSPACE; |
Line 2216 termp_lk_pre(DECL_ARGS) |
|
Line 2119 termp_lk_pre(DECL_ARGS) |
|
{ |
{ |
const struct mdoc_node *n; |
const struct mdoc_node *n; |
|
|
if (NULL == (n = node->child)) |
assert(node->child); |
errx(1, "expected line argument"); |
n = node->child; |
|
|
|
if (NULL == n->next) { |
|
TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK_ANCHOR]); |
|
return(1); |
|
} |
|
|
p->flags |= ttypes[TTYPE_LINK_ANCHOR]; |
p->flags |= ttypes[TTYPE_LINK_ANCHOR]; |
term_word(p, n->string); |
term_word(p, n->string); |
p->flags &= ~ttypes[TTYPE_LINK_ANCHOR]; |
|
p->flags |= TERMP_NOSPACE; |
p->flags |= TERMP_NOSPACE; |
term_word(p, ":"); |
term_word(p, ":"); |
|
p->flags &= ~ttypes[TTYPE_LINK_ANCHOR]; |
|
|
p->flags |= ttypes[TTYPE_LINK_TEXT]; |
p->flags |= ttypes[TTYPE_LINK_TEXT]; |
for ( ; n; n = n->next) { |
for (n = n->next; n; n = n->next) |
term_word(p, n->string); |
term_word(p, n->string); |
} |
|
p->flags &= ~ttypes[TTYPE_LINK_TEXT]; |
|
|
|
|
p->flags &= ~ttypes[TTYPE_LINK_TEXT]; |
return(0); |
return(0); |
} |
} |
|
|