-/* $Id: man_macro.c,v 1.96 2015/02/06 08:28:35 schwarze Exp $ */
+/* $Id: man_macro.c,v 1.102 2015/04/02 22:48:17 schwarze Exp $ */
/*
* Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
* Copyright (c) 2012, 2013, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
#include <stdlib.h>
#include <string.h>
-#include "man.h"
#include "mandoc.h"
+#include "roff.h"
+#include "man.h"
#include "libmandoc.h"
#include "libman.h"
static int man_args(struct man *, int,
int *, char *, char **);
-static void rew_scope(enum man_type,
- struct man *, enum mant);
-static enum rew rew_dohalt(enum mant, enum man_type,
- const struct man_node *);
-static enum rew rew_block(enum mant, enum man_type,
- const struct man_node *);
+static void rew_scope(enum roff_type, struct man *, int);
+static enum rew rew_dohalt(int, enum roff_type,
+ const struct roff_node *);
+static enum rew rew_block(int, enum roff_type,
+ const struct roff_node *);
const struct man_macro __man_macros[MAN_MAX] = {
{ in_line_eoln, MAN_NSCOPED }, /* br */
{ in_line_eoln, MAN_BSCOPE }, /* TH */
{ blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* SH */
{ blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* SS */
- { blk_imp, MAN_BSCOPE | MAN_SCOPED | MAN_FSCOPED }, /* TP */
+ { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* TP */
{ blk_imp, MAN_BSCOPE }, /* LP */
{ blk_imp, MAN_BSCOPE }, /* PP */
{ blk_imp, MAN_BSCOPE }, /* P */
{ in_line_eoln, MAN_BSCOPE }, /* nf */
{ in_line_eoln, MAN_BSCOPE }, /* fi */
{ blk_close, MAN_BSCOPE }, /* RE */
- { blk_exp, MAN_BSCOPE | MAN_EXPLICIT }, /* RS */
+ { blk_exp, MAN_BSCOPE }, /* RS */
{ in_line_eoln, 0 }, /* DT */
{ in_line_eoln, 0 }, /* UC */
- { in_line_eoln, 0 }, /* PD */
+ { in_line_eoln, MAN_NSCOPED }, /* PD */
{ in_line_eoln, 0 }, /* AT */
{ in_line_eoln, 0 }, /* in */
{ in_line_eoln, 0 }, /* ft */
{ in_line_eoln, 0 }, /* OP */
{ in_line_eoln, MAN_BSCOPE }, /* EX */
{ in_line_eoln, MAN_BSCOPE }, /* EE */
- { blk_exp, MAN_BSCOPE | MAN_EXPLICIT }, /* UR */
+ { blk_exp, MAN_BSCOPE }, /* UR */
{ blk_close, MAN_BSCOPE }, /* UE */
{ in_line_eoln, 0 }, /* ll */
};
void
-man_unscope(struct man *man, const struct man_node *to)
+man_unscope(struct man *man, const struct roff_node *to)
{
- struct man_node *n;
+ struct roff_node *n;
to = to->parent;
n = man->last;
if (man->flags & MAN_ELINE)
man->flags &= ~MAN_ELINE;
else {
- assert(n->type == MAN_HEAD);
+ assert(n->type == ROFFT_HEAD);
n = n->parent;
man->flags &= ~MAN_BLINE;
}
man_node_delete(man, man->last);
continue;
}
- if (n->type == MAN_BLOCK &&
- man_macros[n->tok].flags & MAN_EXPLICIT)
+ if (n->type == ROFFT_BLOCK &&
+ man_macros[n->tok].fp == blk_exp)
mandoc_msg(MANDOCERR_BLK_NOEND,
man->parse, n->line, n->pos,
man_macronames[n->tok]);
}
static enum rew
-rew_block(enum mant ntok, enum man_type type, const struct man_node *n)
+rew_block(int ntok, enum roff_type type, const struct roff_node *n)
{
- if (type == MAN_BLOCK && ntok == n->parent->tok &&
- n->parent->type == MAN_BODY)
+ if (type == ROFFT_BLOCK && n->parent->tok == ntok &&
+ n->parent->type == ROFFT_BODY)
return(REW_REWIND);
return(ntok == n->tok ? REW_HALT : REW_NOHALT);
}
* sections and subsections).
*/
static enum rew
-rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n)
+rew_dohalt(int tok, enum roff_type type, const struct roff_node *n)
{
enum rew c;
/* We cannot progress beyond the root ever. */
- if (MAN_ROOT == n->type)
+ if (n->type == ROFFT_ROOT)
return(REW_HALT);
assert(n->parent);
/* Normal nodes shouldn't go to the level of the root. */
- if (MAN_ROOT == n->parent->type)
+ if (n->parent->type == ROFFT_ROOT)
return(REW_REWIND);
/* Already-validated nodes should be closed out. */
/* First: rewind to ourselves. */
if (type == n->type && tok == n->tok) {
- if (MAN_EXPLICIT & man_macros[n->tok].flags)
+ if (man_macros[n->tok].fp == blk_exp)
return(REW_HALT);
else
return(REW_REWIND);
* scopes. When a scope is closed, it must be validated and actioned.
*/
static void
-rew_scope(enum man_type type, struct man *man, enum mant tok)
+rew_scope(enum roff_type type, struct man *man, int tok)
{
- struct man_node *n;
+ struct roff_node *n;
enum rew c;
for (n = man->last; n; n = n->parent) {
void
blk_close(MACRO_PROT_ARGS)
{
- enum mant ntok;
- const struct man_node *nn;
+ int ntok;
+ const struct roff_node *nn;
char *p;
int nrew, target;
if ( ! man_args(man, line, pos, buf, &p))
break;
for (nn = man->last->parent; nn; nn = nn->parent)
- if (nn->tok == ntok && nn->type == MAN_BLOCK)
+ if (nn->tok == ntok && nn->type == ROFFT_BLOCK)
nrew++;
target = strtol(p, &p, 10);
if (*p != '\0')
}
for (nn = man->last->parent; nn; nn = nn->parent)
- if (nn->tok == ntok && nn->type == MAN_BLOCK && ! --nrew)
+ if (nn->tok == ntok && nn->type == ROFFT_BLOCK && ! --nrew)
break;
if (nn == NULL) {
mandoc_msg(MANDOCERR_BLK_NOTOPEN, man->parse,
line, ppos, man_macronames[tok]);
- rew_scope(MAN_BLOCK, man, MAN_PP);
+ rew_scope(ROFFT_BLOCK, man, MAN_PP);
} else {
line = man->last->line;
ppos = man->last->pos;
void
blk_exp(MACRO_PROT_ARGS)
{
- struct man_node *n;
- int la;
+ struct roff_node *head;
char *p;
+ int la;
- rew_scope(MAN_BLOCK, man, tok);
+ rew_scope(ROFFT_BLOCK, man, tok);
man_block_alloc(man, line, ppos, tok);
man_head_alloc(man, line, ppos, tok);
+ head = man->last;
- for (;;) {
- la = *pos;
- if ( ! man_args(man, line, pos, buf, &p))
- break;
+ la = *pos;
+ if (man_args(man, line, pos, buf, &p))
man_word_alloc(man, line, la, p);
- }
- assert(man);
- assert(tok != MAN_MAX);
-
- for (n = man->last; n; n = n->parent)
- if (n->tok == tok) {
- assert(n->type == MAN_HEAD);
- man_unscope(man, n);
- break;
- }
+ if (buf[*pos] != '\0')
+ mandoc_vmsg(MANDOCERR_ARG_EXCESS,
+ man->parse, line, *pos, "%s ... %s",
+ man_macronames[tok], buf + *pos);
+ man_unscope(man, head);
man_body_alloc(man, line, ppos, tok);
}
/*
- * Parse an implicit-block macro. These contain a MAN_HEAD and a
- * MAN_BODY contained within a MAN_BLOCK. Rules for closing out other
+ * Parse an implicit-block macro. These contain a ROFFT_HEAD and a
+ * ROFFT_BODY contained within a ROFFT_BLOCK. Rules for closing out other
* scopes, such as `SH' closing out an `SS', are defined in the rew
* routines.
*/
{
int la;
char *p;
- struct man_node *n;
+ struct roff_node *n;
- rew_scope(MAN_BODY, man, tok);
- rew_scope(MAN_BLOCK, man, tok);
+ rew_scope(ROFFT_BODY, man, tok);
+ rew_scope(ROFFT_BLOCK, man, tok);
man_block_alloc(man, line, ppos, tok);
man_head_alloc(man, line, ppos, tok);
n = man->last;
man_word_alloc(man, line, la, p);
}
- /* Close out head and open body (unless MAN_SCOPE). */
+ /*
+ * For macros having optional next-line scope,
+ * keep the head open if there were no arguments.
+ * For `TP', always keep the head open.
+ */
- if (man_macros[tok].flags & MAN_SCOPED) {
- /* If we're forcing scope (`TP'), keep it open. */
- if (man_macros[tok].flags & MAN_FSCOPED) {
- man->flags |= MAN_BLINE;
- return;
- } else if (n == man->last) {
- man->flags |= MAN_BLINE;
- return;
- }
+ if (man_macros[tok].flags & MAN_SCOPED &&
+ (tok == MAN_TP || n == man->last)) {
+ man->flags |= MAN_BLINE;
+ return;
}
- rew_scope(MAN_HEAD, man, tok);
+
+ /* Close out the head and open the body. */
+
+ rew_scope(ROFFT_HEAD, man, tok);
man_body_alloc(man, line, ppos, tok);
}
{
int la;
char *p;
- struct man_node *n;
+ struct roff_node *n;
man_elem_alloc(man, line, ppos, tok);
n = man->last;
man_macronames[tok], buf + *pos);
break;
}
+ if (buf[*pos] != '\0' && man->last != n &&
+ (tok == MAN_PD || tok == MAN_ft || tok == MAN_sp)) {
+ mandoc_vmsg(MANDOCERR_ARG_EXCESS,
+ man->parse, line, *pos, "%s ... %s",
+ man_macronames[tok], buf + *pos);
+ break;
+ }
la = *pos;
if ( ! man_args(man, line, pos, buf, &p))
break;
if (man_macros[tok].flags & MAN_JOIN &&
- man->last->type == MAN_TEXT)
+ man->last->type == ROFFT_TEXT)
man_word_append(man, p);
else
man_word_alloc(man, line, la, p);
return;
}
- assert(man->last->type != MAN_ROOT);
+ assert(man->last->type != ROFFT_ROOT);
man->next = MAN_NEXT_SIBLING;
/*
for ( ; man->last; man->last = man->last->parent) {
if (man->last == n)
break;
- if (man->last->type == MAN_ROOT)
+ if (man->last->type == ROFFT_ROOT)
break;
man_valid_post(man);
}
* Same here regarding whether we're back at the root.
*/
- if (man->last->type != MAN_ROOT)
+ if (man->last->type != ROFFT_ROOT)
man_valid_post(man);
}
git.ckatri.com / mandoc.git / blobdiff