version 1.43, 2014/07/04 16:12:08 |
version 1.67, 2017/06/22 00:30:20 |
|
|
/* $Id$ */ |
/* $Id$ |
/* |
/* |
* Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv> |
* Copyright (c) 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv> |
|
* Copyright (c) 2014, 2015, 2017 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 |
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
*/ |
*/ |
#ifdef HAVE_CONFIG_H |
|
#include "config.h" |
#include "config.h" |
#endif |
|
|
|
|
#include <sys/types.h> |
|
|
#include <assert.h> |
#include <assert.h> |
|
#include <ctype.h> |
#include <limits.h> |
#include <limits.h> |
#include <stdio.h> |
#include <stdio.h> |
#include <stdlib.h> |
#include <stdlib.h> |
|
|
#include "libroff.h" |
#include "libroff.h" |
|
|
#define EQN_NEST_MAX 128 /* maximum nesting of defines */ |
#define EQN_NEST_MAX 128 /* maximum nesting of defines */ |
#define EQN_MSG(t, x) mandoc_msg((t), (x)->parse, (x)->eqn.ln, (x)->eqn.pos, NULL) |
#define STRNEQ(p1, sz1, p2, sz2) \ |
|
((sz1) == (sz2) && 0 == strncmp((p1), (p2), (sz1))) |
|
|
enum eqn_rest { |
enum eqn_tok { |
EQN_DESCOPE, |
EQN_TOK_DYAD = 0, |
EQN_ERR, |
EQN_TOK_VEC, |
EQN_OK, |
EQN_TOK_UNDER, |
EQN_EOF |
EQN_TOK_BAR, |
|
EQN_TOK_TILDE, |
|
EQN_TOK_HAT, |
|
EQN_TOK_DOT, |
|
EQN_TOK_DOTDOT, |
|
EQN_TOK_FWD, |
|
EQN_TOK_BACK, |
|
EQN_TOK_DOWN, |
|
EQN_TOK_UP, |
|
EQN_TOK_FAT, |
|
EQN_TOK_ROMAN, |
|
EQN_TOK_ITALIC, |
|
EQN_TOK_BOLD, |
|
EQN_TOK_SIZE, |
|
EQN_TOK_SUB, |
|
EQN_TOK_SUP, |
|
EQN_TOK_SQRT, |
|
EQN_TOK_OVER, |
|
EQN_TOK_FROM, |
|
EQN_TOK_TO, |
|
EQN_TOK_BRACE_OPEN, |
|
EQN_TOK_BRACE_CLOSE, |
|
EQN_TOK_GSIZE, |
|
EQN_TOK_GFONT, |
|
EQN_TOK_MARK, |
|
EQN_TOK_LINEUP, |
|
EQN_TOK_LEFT, |
|
EQN_TOK_RIGHT, |
|
EQN_TOK_PILE, |
|
EQN_TOK_LPILE, |
|
EQN_TOK_RPILE, |
|
EQN_TOK_CPILE, |
|
EQN_TOK_MATRIX, |
|
EQN_TOK_CCOL, |
|
EQN_TOK_LCOL, |
|
EQN_TOK_RCOL, |
|
EQN_TOK_DELIM, |
|
EQN_TOK_DEFINE, |
|
EQN_TOK_TDEFINE, |
|
EQN_TOK_NDEFINE, |
|
EQN_TOK_UNDEF, |
|
EQN_TOK_ABOVE, |
|
EQN_TOK__MAX, |
|
EQN_TOK_FUNC, |
|
EQN_TOK_QUOTED, |
|
EQN_TOK_SYM, |
|
EQN_TOK_EOF |
}; |
}; |
|
|
|
static const char *eqn_toks[EQN_TOK__MAX] = { |
|
"dyad", /* EQN_TOK_DYAD */ |
|
"vec", /* EQN_TOK_VEC */ |
|
"under", /* EQN_TOK_UNDER */ |
|
"bar", /* EQN_TOK_BAR */ |
|
"tilde", /* EQN_TOK_TILDE */ |
|
"hat", /* EQN_TOK_HAT */ |
|
"dot", /* EQN_TOK_DOT */ |
|
"dotdot", /* EQN_TOK_DOTDOT */ |
|
"fwd", /* EQN_TOK_FWD * */ |
|
"back", /* EQN_TOK_BACK */ |
|
"down", /* EQN_TOK_DOWN */ |
|
"up", /* EQN_TOK_UP */ |
|
"fat", /* EQN_TOK_FAT */ |
|
"roman", /* EQN_TOK_ROMAN */ |
|
"italic", /* EQN_TOK_ITALIC */ |
|
"bold", /* EQN_TOK_BOLD */ |
|
"size", /* EQN_TOK_SIZE */ |
|
"sub", /* EQN_TOK_SUB */ |
|
"sup", /* EQN_TOK_SUP */ |
|
"sqrt", /* EQN_TOK_SQRT */ |
|
"over", /* EQN_TOK_OVER */ |
|
"from", /* EQN_TOK_FROM */ |
|
"to", /* EQN_TOK_TO */ |
|
"{", /* EQN_TOK_BRACE_OPEN */ |
|
"}", /* EQN_TOK_BRACE_CLOSE */ |
|
"gsize", /* EQN_TOK_GSIZE */ |
|
"gfont", /* EQN_TOK_GFONT */ |
|
"mark", /* EQN_TOK_MARK */ |
|
"lineup", /* EQN_TOK_LINEUP */ |
|
"left", /* EQN_TOK_LEFT */ |
|
"right", /* EQN_TOK_RIGHT */ |
|
"pile", /* EQN_TOK_PILE */ |
|
"lpile", /* EQN_TOK_LPILE */ |
|
"rpile", /* EQN_TOK_RPILE */ |
|
"cpile", /* EQN_TOK_CPILE */ |
|
"matrix", /* EQN_TOK_MATRIX */ |
|
"ccol", /* EQN_TOK_CCOL */ |
|
"lcol", /* EQN_TOK_LCOL */ |
|
"rcol", /* EQN_TOK_RCOL */ |
|
"delim", /* EQN_TOK_DELIM */ |
|
"define", /* EQN_TOK_DEFINE */ |
|
"tdefine", /* EQN_TOK_TDEFINE */ |
|
"ndefine", /* EQN_TOK_NDEFINE */ |
|
"undef", /* EQN_TOK_UNDEF */ |
|
"above", /* EQN_TOK_ABOVE */ |
|
}; |
|
|
|
static const char *const eqn_func[] = { |
|
"acos", "acsc", "and", "arc", "asec", "asin", "atan", |
|
"cos", "cosh", "coth", "csc", "det", "exp", "for", |
|
"if", "lim", "ln", "log", "max", "min", |
|
"sec", "sin", "sinh", "tan", "tanh", "Im", "Re", |
|
}; |
|
|
enum eqn_symt { |
enum eqn_symt { |
EQNSYM_alpha, |
EQNSYM_alpha, |
EQNSYM_beta, |
EQNSYM_beta, |
|
|
EQNSYM_equiv, |
EQNSYM_equiv, |
EQNSYM_lessequal, |
EQNSYM_lessequal, |
EQNSYM_moreequal, |
EQNSYM_moreequal, |
|
EQNSYM_minus, |
EQNSYM__MAX |
EQNSYM__MAX |
}; |
}; |
|
|
enum eqnpartt { |
|
EQN_DEFINE = 0, |
|
EQN_NDEFINE, |
|
EQN_TDEFINE, |
|
EQN_SET, |
|
EQN_UNDEF, |
|
EQN_GFONT, |
|
EQN_GSIZE, |
|
EQN_BACK, |
|
EQN_FWD, |
|
EQN_UP, |
|
EQN_DOWN, |
|
EQN__MAX |
|
}; |
|
|
|
struct eqnstr { |
|
const char *name; |
|
size_t sz; |
|
}; |
|
|
|
#define STRNEQ(p1, sz1, p2, sz2) \ |
|
((sz1) == (sz2) && 0 == strncmp((p1), (p2), (sz1))) |
|
#define EQNSTREQ(x, p, sz) \ |
|
STRNEQ((x)->name, (x)->sz, (p), (sz)) |
|
|
|
struct eqnpart { |
|
struct eqnstr str; |
|
int (*fp)(struct eqn_node *); |
|
}; |
|
|
|
struct eqnsym { |
struct eqnsym { |
struct eqnstr str; |
const char *str; |
const char *sym; |
const char *sym; |
}; |
}; |
|
|
static enum eqn_rest eqn_box(struct eqn_node *, struct eqn_box *); |
|
static struct eqn_box *eqn_box_alloc(struct eqn_node *, |
|
struct eqn_box *); |
|
static void eqn_box_free(struct eqn_box *); |
|
static struct eqn_def *eqn_def_find(struct eqn_node *, |
|
const char *, size_t); |
|
static int eqn_do_gfont(struct eqn_node *); |
|
static int eqn_do_gsize(struct eqn_node *); |
|
static int eqn_do_define(struct eqn_node *); |
|
static int eqn_do_ign1(struct eqn_node *); |
|
static int eqn_do_ign2(struct eqn_node *); |
|
static int eqn_do_tdefine(struct eqn_node *); |
|
static int eqn_do_undef(struct eqn_node *); |
|
static enum eqn_rest eqn_eqn(struct eqn_node *, struct eqn_box *); |
|
static enum eqn_rest eqn_list(struct eqn_node *, struct eqn_box *); |
|
static enum eqn_rest eqn_matrix(struct eqn_node *, struct eqn_box *); |
|
static const char *eqn_nexttok(struct eqn_node *, size_t *); |
|
static const char *eqn_nextrawtok(struct eqn_node *, size_t *); |
|
static const char *eqn_next(struct eqn_node *, |
|
char, size_t *, int); |
|
static void eqn_rewind(struct eqn_node *); |
|
|
|
static const struct eqnpart eqnparts[EQN__MAX] = { |
|
{ { "define", 6 }, eqn_do_define }, /* EQN_DEFINE */ |
|
{ { "ndefine", 7 }, eqn_do_define }, /* EQN_NDEFINE */ |
|
{ { "tdefine", 7 }, eqn_do_tdefine }, /* EQN_TDEFINE */ |
|
{ { "set", 3 }, eqn_do_ign2 }, /* EQN_SET */ |
|
{ { "undef", 5 }, eqn_do_undef }, /* EQN_UNDEF */ |
|
{ { "gfont", 5 }, eqn_do_gfont }, /* EQN_GFONT */ |
|
{ { "gsize", 5 }, eqn_do_gsize }, /* EQN_GSIZE */ |
|
{ { "back", 4 }, eqn_do_ign1 }, /* EQN_BACK */ |
|
{ { "fwd", 3 }, eqn_do_ign1 }, /* EQN_FWD */ |
|
{ { "up", 2 }, eqn_do_ign1 }, /* EQN_UP */ |
|
{ { "down", 4 }, eqn_do_ign1 }, /* EQN_DOWN */ |
|
}; |
|
|
|
static const struct eqnstr eqnmarks[EQNMARK__MAX] = { |
|
{ "", 0 }, /* EQNMARK_NONE */ |
|
{ "dot", 3 }, /* EQNMARK_DOT */ |
|
{ "dotdot", 6 }, /* EQNMARK_DOTDOT */ |
|
{ "hat", 3 }, /* EQNMARK_HAT */ |
|
{ "tilde", 5 }, /* EQNMARK_TILDE */ |
|
{ "vec", 3 }, /* EQNMARK_VEC */ |
|
{ "dyad", 4 }, /* EQNMARK_DYAD */ |
|
{ "bar", 3 }, /* EQNMARK_BAR */ |
|
{ "under", 5 }, /* EQNMARK_UNDER */ |
|
}; |
|
|
|
static const struct eqnstr eqnfonts[EQNFONT__MAX] = { |
|
{ "", 0 }, /* EQNFONT_NONE */ |
|
{ "roman", 5 }, /* EQNFONT_ROMAN */ |
|
{ "bold", 4 }, /* EQNFONT_BOLD */ |
|
{ "fat", 3 }, /* EQNFONT_FAT */ |
|
{ "italic", 6 }, /* EQNFONT_ITALIC */ |
|
}; |
|
|
|
static const struct eqnstr eqnposs[EQNPOS__MAX] = { |
|
{ "", 0 }, /* EQNPOS_NONE */ |
|
{ "over", 4 }, /* EQNPOS_OVER */ |
|
{ "sup", 3 }, /* EQNPOS_SUP */ |
|
{ "sub", 3 }, /* EQNPOS_SUB */ |
|
{ "to", 2 }, /* EQNPOS_TO */ |
|
{ "from", 4 }, /* EQNPOS_FROM */ |
|
}; |
|
|
|
static const struct eqnstr eqnpiles[EQNPILE__MAX] = { |
|
{ "", 0 }, /* EQNPILE_NONE */ |
|
{ "pile", 4 }, /* EQNPILE_PILE */ |
|
{ "cpile", 5 }, /* EQNPILE_CPILE */ |
|
{ "rpile", 5 }, /* EQNPILE_RPILE */ |
|
{ "lpile", 5 }, /* EQNPILE_LPILE */ |
|
{ "col", 3 }, /* EQNPILE_COL */ |
|
{ "ccol", 4 }, /* EQNPILE_CCOL */ |
|
{ "rcol", 4 }, /* EQNPILE_RCOL */ |
|
{ "lcol", 4 }, /* EQNPILE_LCOL */ |
|
}; |
|
|
|
static const struct eqnsym eqnsyms[EQNSYM__MAX] = { |
static const struct eqnsym eqnsyms[EQNSYM__MAX] = { |
{ { "alpha", 5 }, "*a" }, /* EQNSYM_alpha */ |
{ "alpha", "*a" }, /* EQNSYM_alpha */ |
{ { "beta", 4 }, "*b" }, /* EQNSYM_beta */ |
{ "beta", "*b" }, /* EQNSYM_beta */ |
{ { "chi", 3 }, "*x" }, /* EQNSYM_chi */ |
{ "chi", "*x" }, /* EQNSYM_chi */ |
{ { "delta", 5 }, "*d" }, /* EQNSYM_delta */ |
{ "delta", "*d" }, /* EQNSYM_delta */ |
{ { "epsilon", 7 }, "*e" }, /* EQNSYM_epsilon */ |
{ "epsilon", "*e" }, /* EQNSYM_epsilon */ |
{ { "eta", 3 }, "*y" }, /* EQNSYM_eta */ |
{ "eta", "*y" }, /* EQNSYM_eta */ |
{ { "gamma", 5 }, "*g" }, /* EQNSYM_gamma */ |
{ "gamma", "*g" }, /* EQNSYM_gamma */ |
{ { "iota", 4 }, "*i" }, /* EQNSYM_iota */ |
{ "iota", "*i" }, /* EQNSYM_iota */ |
{ { "kappa", 5 }, "*k" }, /* EQNSYM_kappa */ |
{ "kappa", "*k" }, /* EQNSYM_kappa */ |
{ { "lambda", 6 }, "*l" }, /* EQNSYM_lambda */ |
{ "lambda", "*l" }, /* EQNSYM_lambda */ |
{ { "mu", 2 }, "*m" }, /* EQNSYM_mu */ |
{ "mu", "*m" }, /* EQNSYM_mu */ |
{ { "nu", 2 }, "*n" }, /* EQNSYM_nu */ |
{ "nu", "*n" }, /* EQNSYM_nu */ |
{ { "omega", 5 }, "*w" }, /* EQNSYM_omega */ |
{ "omega", "*w" }, /* EQNSYM_omega */ |
{ { "omicron", 7 }, "*o" }, /* EQNSYM_omicron */ |
{ "omicron", "*o" }, /* EQNSYM_omicron */ |
{ { "phi", 3 }, "*f" }, /* EQNSYM_phi */ |
{ "phi", "*f" }, /* EQNSYM_phi */ |
{ { "pi", 2 }, "*p" }, /* EQNSYM_pi */ |
{ "pi", "*p" }, /* EQNSYM_pi */ |
{ { "psi", 2 }, "*q" }, /* EQNSYM_psi */ |
{ "psi", "*q" }, /* EQNSYM_psi */ |
{ { "rho", 3 }, "*r" }, /* EQNSYM_rho */ |
{ "rho", "*r" }, /* EQNSYM_rho */ |
{ { "sigma", 5 }, "*s" }, /* EQNSYM_sigma */ |
{ "sigma", "*s" }, /* EQNSYM_sigma */ |
{ { "tau", 3 }, "*t" }, /* EQNSYM_tau */ |
{ "tau", "*t" }, /* EQNSYM_tau */ |
{ { "theta", 5 }, "*h" }, /* EQNSYM_theta */ |
{ "theta", "*h" }, /* EQNSYM_theta */ |
{ { "upsilon", 7 }, "*u" }, /* EQNSYM_upsilon */ |
{ "upsilon", "*u" }, /* EQNSYM_upsilon */ |
{ { "xi", 2 }, "*c" }, /* EQNSYM_xi */ |
{ "xi", "*c" }, /* EQNSYM_xi */ |
{ { "zeta", 4 }, "*z" }, /* EQNSYM_zeta */ |
{ "zeta", "*z" }, /* EQNSYM_zeta */ |
{ { "DELTA", 5 }, "*D" }, /* EQNSYM_DELTA */ |
{ "DELTA", "*D" }, /* EQNSYM_DELTA */ |
{ { "GAMMA", 5 }, "*G" }, /* EQNSYM_GAMMA */ |
{ "GAMMA", "*G" }, /* EQNSYM_GAMMA */ |
{ { "LAMBDA", 6 }, "*L" }, /* EQNSYM_LAMBDA */ |
{ "LAMBDA", "*L" }, /* EQNSYM_LAMBDA */ |
{ { "OMEGA", 5 }, "*W" }, /* EQNSYM_OMEGA */ |
{ "OMEGA", "*W" }, /* EQNSYM_OMEGA */ |
{ { "PHI", 3 }, "*F" }, /* EQNSYM_PHI */ |
{ "PHI", "*F" }, /* EQNSYM_PHI */ |
{ { "PI", 2 }, "*P" }, /* EQNSYM_PI */ |
{ "PI", "*P" }, /* EQNSYM_PI */ |
{ { "PSI", 3 }, "*Q" }, /* EQNSYM_PSI */ |
{ "PSI", "*Q" }, /* EQNSYM_PSI */ |
{ { "SIGMA", 5 }, "*S" }, /* EQNSYM_SIGMA */ |
{ "SIGMA", "*S" }, /* EQNSYM_SIGMA */ |
{ { "THETA", 5 }, "*H" }, /* EQNSYM_THETA */ |
{ "THETA", "*H" }, /* EQNSYM_THETA */ |
{ { "UPSILON", 7 }, "*U" }, /* EQNSYM_UPSILON */ |
{ "UPSILON", "*U" }, /* EQNSYM_UPSILON */ |
{ { "XI", 2 }, "*C" }, /* EQNSYM_XI */ |
{ "XI", "*C" }, /* EQNSYM_XI */ |
{ { "inter", 5 }, "ca" }, /* EQNSYM_inter */ |
{ "inter", "ca" }, /* EQNSYM_inter */ |
{ { "union", 5 }, "cu" }, /* EQNSYM_union */ |
{ "union", "cu" }, /* EQNSYM_union */ |
{ { "prod", 4 }, "product" }, /* EQNSYM_prod */ |
{ "prod", "product" }, /* EQNSYM_prod */ |
{ { "int", 3 }, "integral" }, /* EQNSYM_int */ |
{ "int", "integral" }, /* EQNSYM_int */ |
{ { "sum", 3 }, "sum" }, /* EQNSYM_sum */ |
{ "sum", "sum" }, /* EQNSYM_sum */ |
{ { "grad", 4 }, "gr" }, /* EQNSYM_grad */ |
{ "grad", "gr" }, /* EQNSYM_grad */ |
{ { "del", 3 }, "gr" }, /* EQNSYM_del */ |
{ "del", "gr" }, /* EQNSYM_del */ |
{ { "times", 5 }, "mu" }, /* EQNSYM_times */ |
{ "times", "mu" }, /* EQNSYM_times */ |
{ { "cdot", 4 }, "pc" }, /* EQNSYM_cdot */ |
{ "cdot", "pc" }, /* EQNSYM_cdot */ |
{ { "nothing", 7 }, "&" }, /* EQNSYM_nothing */ |
{ "nothing", "&" }, /* EQNSYM_nothing */ |
{ { "approx", 6 }, "~~" }, /* EQNSYM_approx */ |
{ "approx", "~~" }, /* EQNSYM_approx */ |
{ { "prime", 5 }, "aq" }, /* EQNSYM_prime */ |
{ "prime", "fm" }, /* EQNSYM_prime */ |
{ { "half", 4 }, "12" }, /* EQNSYM_half */ |
{ "half", "12" }, /* EQNSYM_half */ |
{ { "partial", 7 }, "pd" }, /* EQNSYM_partial */ |
{ "partial", "pd" }, /* EQNSYM_partial */ |
{ { "inf", 3 }, "if" }, /* EQNSYM_inf */ |
{ "inf", "if" }, /* EQNSYM_inf */ |
{ { ">>", 2 }, ">>" }, /* EQNSYM_muchgreat */ |
{ ">>", ">>" }, /* EQNSYM_muchgreat */ |
{ { "<<", 2 }, "<<" }, /* EQNSYM_muchless */ |
{ "<<", "<<" }, /* EQNSYM_muchless */ |
{ { "<-", 2 }, "<-" }, /* EQNSYM_larrow */ |
{ "<-", "<-" }, /* EQNSYM_larrow */ |
{ { "->", 2 }, "->" }, /* EQNSYM_rarrow */ |
{ "->", "->" }, /* EQNSYM_rarrow */ |
{ { "+-", 2 }, "+-" }, /* EQNSYM_pm */ |
{ "+-", "+-" }, /* EQNSYM_pm */ |
{ { "!=", 2 }, "!=" }, /* EQNSYM_nequal */ |
{ "!=", "!=" }, /* EQNSYM_nequal */ |
{ { "==", 2 }, "==" }, /* EQNSYM_equiv */ |
{ "==", "==" }, /* EQNSYM_equiv */ |
{ { "<=", 2 }, "<=" }, /* EQNSYM_lessequal */ |
{ "<=", "<=" }, /* EQNSYM_lessequal */ |
{ { ">=", 2 }, ">=" }, /* EQNSYM_moreequal */ |
{ ">=", ">=" }, /* EQNSYM_moreequal */ |
|
{ "-", "mi" }, /* EQNSYM_minus */ |
}; |
}; |
|
|
|
static struct eqn_box *eqn_box_alloc(struct eqn_node *, struct eqn_box *); |
|
static void eqn_box_free(struct eqn_box *); |
|
static struct eqn_box *eqn_box_makebinary(struct eqn_node *, |
|
enum eqn_post, struct eqn_box *); |
|
static void eqn_def(struct eqn_node *); |
|
static struct eqn_def *eqn_def_find(struct eqn_node *, const char *, size_t); |
|
static void eqn_delim(struct eqn_node *); |
|
static const char *eqn_next(struct eqn_node *, char, size_t *, int); |
|
static const char *eqn_nextrawtok(struct eqn_node *, size_t *); |
|
static const char *eqn_nexttok(struct eqn_node *, size_t *); |
|
static enum rofferr eqn_parse(struct eqn_node *, struct eqn_box *); |
|
static enum eqn_tok eqn_tok_parse(struct eqn_node *, char **); |
|
static void eqn_undef(struct eqn_node *); |
|
|
|
|
enum rofferr |
enum rofferr |
eqn_read(struct eqn_node **epp, int ln, |
eqn_read(struct eqn_node **epp, int ln, |
const char *p, int pos, int *offs) |
const char *p, int pos, int *offs) |
Line 299 eqn_read(struct eqn_node **epp, int ln, |
|
Line 312 eqn_read(struct eqn_node **epp, int ln, |
|
while (' ' == *p || '\t' == *p) |
while (' ' == *p || '\t' == *p) |
p++; |
p++; |
if ('\0' == *p) |
if ('\0' == *p) |
return(er); |
return er; |
mandoc_vmsg(MANDOCERR_ARG_SKIP, ep->parse, |
mandoc_vmsg(MANDOCERR_ARG_SKIP, ep->parse, |
ln, pos, "EN %s", p); |
ln, pos, "EN %s", p); |
return(er); |
return er; |
} |
} |
|
|
/* |
/* |
Line 321 eqn_read(struct eqn_node **epp, int ln, |
|
Line 334 eqn_read(struct eqn_node **epp, int ln, |
|
ep->sz += sz; |
ep->sz += sz; |
strlcat(ep->data, p + pos, ep->sz + 1); |
strlcat(ep->data, p + pos, ep->sz + 1); |
strlcat(ep->data, " ", ep->sz + 1); |
strlcat(ep->data, " ", ep->sz + 1); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
struct eqn_node * |
struct eqn_node * |
eqn_alloc(const char *name, int pos, int line, struct mparse *parse) |
eqn_alloc(int pos, int line, struct mparse *parse) |
{ |
{ |
struct eqn_node *p; |
struct eqn_node *p; |
size_t sz; |
|
const char *end; |
|
|
|
p = mandoc_calloc(1, sizeof(struct eqn_node)); |
p = mandoc_calloc(1, sizeof(struct eqn_node)); |
|
|
if (name && '\0' != *name) { |
|
sz = strlen(name); |
|
assert(sz); |
|
do { |
|
sz--; |
|
end = name + (int)sz; |
|
} while (' ' == *end || '\t' == *end); |
|
p->eqn.name = mandoc_strndup(name, sz + 1); |
|
} |
|
|
|
p->parse = parse; |
p->parse = parse; |
p->eqn.ln = line; |
p->eqn.ln = line; |
p->eqn.pos = pos; |
p->eqn.pos = pos; |
p->gsize = EQN_DEFSIZE; |
p->gsize = EQN_DEFSIZE; |
|
|
return(p); |
return p; |
} |
} |
|
|
enum rofferr |
/* |
eqn_end(struct eqn_node **epp) |
* Find the key "key" of the give size within our eqn-defined values. |
|
*/ |
|
static struct eqn_def * |
|
eqn_def_find(struct eqn_node *ep, const char *key, size_t sz) |
{ |
{ |
struct eqn_node *ep; |
|
struct eqn_box *root; |
|
enum eqn_rest c; |
|
|
|
ep = *epp; |
|
*epp = NULL; |
|
|
|
ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box)); |
|
|
|
root = ep->eqn.root; |
|
root->type = EQN_ROOT; |
|
|
|
if (0 == ep->sz) |
|
return(ROFF_IGN); |
|
|
|
if (EQN_DESCOPE == (c = eqn_eqn(ep, root))) { |
|
EQN_MSG(MANDOCERR_EQNNSCOPE, ep); |
|
c = EQN_ERR; |
|
} |
|
|
|
return(EQN_EOF == c ? ROFF_EQN : ROFF_IGN); |
|
} |
|
|
|
static enum eqn_rest |
|
eqn_eqn(struct eqn_node *ep, struct eqn_box *last) |
|
{ |
|
struct eqn_box *bp; |
|
enum eqn_rest c; |
|
|
|
bp = eqn_box_alloc(ep, last); |
|
bp->type = EQN_SUBEXPR; |
|
|
|
while (EQN_OK == (c = eqn_box(ep, bp))) |
|
/* Spin! */ ; |
|
|
|
return(c); |
|
} |
|
|
|
static enum eqn_rest |
|
eqn_matrix(struct eqn_node *ep, struct eqn_box *last) |
|
{ |
|
struct eqn_box *bp; |
|
const char *start; |
|
size_t sz; |
|
enum eqn_rest c; |
|
|
|
bp = eqn_box_alloc(ep, last); |
|
bp->type = EQN_MATRIX; |
|
|
|
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
if ( ! STRNEQ(start, sz, "{", 1)) { |
|
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
|
return(EQN_ERR); |
|
} |
|
|
|
while (EQN_OK == (c = eqn_box(ep, bp))) |
|
switch (bp->last->pile) { |
|
case EQNPILE_LCOL: |
|
/* FALLTHROUGH */ |
|
case EQNPILE_CCOL: |
|
/* FALLTHROUGH */ |
|
case EQNPILE_RCOL: |
|
continue; |
|
default: |
|
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
|
return(EQN_ERR); |
|
}; |
|
|
|
if (EQN_DESCOPE != c) { |
|
if (EQN_EOF == c) |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
|
|
eqn_rewind(ep); |
|
start = eqn_nexttok(ep, &sz); |
|
assert(start); |
|
if (STRNEQ(start, sz, "}", 1)) |
|
return(EQN_OK); |
|
|
|
EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); |
|
return(EQN_ERR); |
|
} |
|
|
|
static enum eqn_rest |
|
eqn_list(struct eqn_node *ep, struct eqn_box *last) |
|
{ |
|
struct eqn_box *bp; |
|
const char *start; |
|
size_t sz; |
|
enum eqn_rest c; |
|
|
|
bp = eqn_box_alloc(ep, last); |
|
bp->type = EQN_LIST; |
|
|
|
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
if ( ! STRNEQ(start, sz, "{", 1)) { |
|
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
|
return(EQN_ERR); |
|
} |
|
|
|
while (EQN_DESCOPE == (c = eqn_eqn(ep, bp))) { |
|
eqn_rewind(ep); |
|
start = eqn_nexttok(ep, &sz); |
|
assert(start); |
|
if ( ! STRNEQ(start, sz, "above", 5)) |
|
break; |
|
} |
|
|
|
if (EQN_DESCOPE != c) { |
|
if (EQN_ERR != c) |
|
EQN_MSG(MANDOCERR_EQNSCOPE, ep); |
|
return(EQN_ERR); |
|
} |
|
|
|
eqn_rewind(ep); |
|
start = eqn_nexttok(ep, &sz); |
|
assert(start); |
|
if (STRNEQ(start, sz, "}", 1)) |
|
return(EQN_OK); |
|
|
|
EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); |
|
return(EQN_ERR); |
|
} |
|
|
|
static enum eqn_rest |
|
eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
{ |
|
size_t sz; |
|
const char *start; |
|
char *left; |
|
char sym[64]; |
|
enum eqn_rest c; |
|
int i, size; |
|
struct eqn_box *bp; |
|
|
|
if (NULL == (start = eqn_nexttok(ep, &sz))) |
|
return(EQN_EOF); |
|
|
|
if (STRNEQ(start, sz, "}", 1)) |
|
return(EQN_DESCOPE); |
|
else if (STRNEQ(start, sz, "right", 5)) |
|
return(EQN_DESCOPE); |
|
else if (STRNEQ(start, sz, "above", 5)) |
|
return(EQN_DESCOPE); |
|
else if (STRNEQ(start, sz, "mark", 4)) |
|
return(EQN_OK); |
|
else if (STRNEQ(start, sz, "lineup", 6)) |
|
return(EQN_OK); |
|
|
|
for (i = 0; i < (int)EQN__MAX; i++) { |
|
if ( ! EQNSTREQ(&eqnparts[i].str, start, sz)) |
|
continue; |
|
return((*eqnparts[i].fp)(ep) ? EQN_OK : EQN_ERR); |
|
} |
|
|
|
if (STRNEQ(start, sz, "{", 1)) { |
|
if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) { |
|
if (EQN_ERR != c) |
|
EQN_MSG(MANDOCERR_EQNSCOPE, ep); |
|
return(EQN_ERR); |
|
} |
|
eqn_rewind(ep); |
|
start = eqn_nexttok(ep, &sz); |
|
assert(start); |
|
if (STRNEQ(start, sz, "}", 1)) |
|
return(EQN_OK); |
|
EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); |
|
return(EQN_ERR); |
|
} |
|
|
|
for (i = 0; i < (int)EQNPILE__MAX; i++) { |
|
if ( ! EQNSTREQ(&eqnpiles[i], start, sz)) |
|
continue; |
|
if (EQN_OK == (c = eqn_list(ep, last))) |
|
last->last->pile = (enum eqn_pilet)i; |
|
return(c); |
|
} |
|
|
|
if (STRNEQ(start, sz, "matrix", 6)) |
|
return(eqn_matrix(ep, last)); |
|
|
|
if (STRNEQ(start, sz, "left", 4)) { |
|
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
left = mandoc_strndup(start, sz); |
|
c = eqn_eqn(ep, last); |
|
if (last->last) |
|
last->last->left = left; |
|
else |
|
free(left); |
|
if (EQN_DESCOPE != c) |
|
return(c); |
|
assert(last->last); |
|
eqn_rewind(ep); |
|
start = eqn_nexttok(ep, &sz); |
|
assert(start); |
|
if ( ! STRNEQ(start, sz, "right", 5)) |
|
return(EQN_DESCOPE); |
|
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
last->last->right = mandoc_strndup(start, sz); |
|
return(EQN_OK); |
|
} |
|
|
|
for (i = 0; i < (int)EQNPOS__MAX; i++) { |
|
if ( ! EQNSTREQ(&eqnposs[i], start, sz)) |
|
continue; |
|
if (NULL == last->last) { |
|
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
|
return(EQN_ERR); |
|
} |
|
last->last->pos = (enum eqn_post)i; |
|
if (EQN_EOF == (c = eqn_box(ep, last))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
return(c); |
|
} |
|
|
|
for (i = 0; i < (int)EQNMARK__MAX; i++) { |
|
if ( ! EQNSTREQ(&eqnmarks[i], start, sz)) |
|
continue; |
|
if (NULL == last->last) { |
|
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
|
return(EQN_ERR); |
|
} |
|
last->last->mark = (enum eqn_markt)i; |
|
if (EQN_EOF == (c = eqn_box(ep, last))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
return(c); |
|
} |
|
|
|
for (i = 0; i < (int)EQNFONT__MAX; i++) { |
|
if ( ! EQNSTREQ(&eqnfonts[i], start, sz)) |
|
continue; |
|
if (EQN_EOF == (c = eqn_box(ep, last))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} else if (EQN_OK == c) |
|
last->last->font = (enum eqn_fontt)i; |
|
return(c); |
|
} |
|
|
|
if (STRNEQ(start, sz, "size", 4)) { |
|
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
size = mandoc_strntoi(start, sz, 10); |
|
if (EQN_EOF == (c = eqn_box(ep, last))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} else if (EQN_OK != c) |
|
return(c); |
|
last->last->size = size; |
|
} |
|
|
|
bp = eqn_box_alloc(ep, last); |
|
bp->type = EQN_TEXT; |
|
for (i = 0; i < (int)EQNSYM__MAX; i++) |
|
if (EQNSTREQ(&eqnsyms[i].str, start, sz)) { |
|
sym[63] = '\0'; |
|
(void)snprintf(sym, 62, "\\[%s]", eqnsyms[i].sym); |
|
bp->text = mandoc_strdup(sym); |
|
return(EQN_OK); |
|
} |
|
|
|
bp->text = mandoc_strndup(start, sz); |
|
return(EQN_OK); |
|
} |
|
|
|
void |
|
eqn_free(struct eqn_node *p) |
|
{ |
|
int i; |
int i; |
|
|
eqn_box_free(p->eqn.root); |
for (i = 0; i < (int)ep->defsz; i++) |
|
if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key, |
|
ep->defs[i].keysz, key, sz)) |
|
return &ep->defs[i]; |
|
|
for (i = 0; i < (int)p->defsz; i++) { |
return NULL; |
free(p->defs[i].key); |
|
free(p->defs[i].val); |
|
} |
|
|
|
free(p->eqn.name); |
|
free(p->data); |
|
free(p->defs); |
|
free(p); |
|
} |
} |
|
|
static struct eqn_box * |
/* |
eqn_box_alloc(struct eqn_node *ep, struct eqn_box *parent) |
* Get the next token from the input stream using the given quote |
{ |
* character. |
struct eqn_box *bp; |
* Optionally make any replacements. |
|
*/ |
bp = mandoc_calloc(1, sizeof(struct eqn_box)); |
|
bp->parent = parent; |
|
bp->size = ep->gsize; |
|
|
|
if (NULL == parent->first) |
|
parent->first = bp; |
|
else |
|
parent->last->next = bp; |
|
|
|
parent->last = bp; |
|
return(bp); |
|
} |
|
|
|
static void |
|
eqn_box_free(struct eqn_box *bp) |
|
{ |
|
|
|
if (bp->first) |
|
eqn_box_free(bp->first); |
|
if (bp->next) |
|
eqn_box_free(bp->next); |
|
|
|
free(bp->text); |
|
free(bp->left); |
|
free(bp->right); |
|
free(bp); |
|
} |
|
|
|
static const char * |
static const char * |
eqn_nextrawtok(struct eqn_node *ep, size_t *sz) |
|
{ |
|
|
|
return(eqn_next(ep, '"', sz, 0)); |
|
} |
|
|
|
static const char * |
|
eqn_nexttok(struct eqn_node *ep, size_t *sz) |
|
{ |
|
|
|
return(eqn_next(ep, '"', sz, 1)); |
|
} |
|
|
|
static void |
|
eqn_rewind(struct eqn_node *ep) |
|
{ |
|
|
|
ep->cur = ep->rew; |
|
} |
|
|
|
static const char * |
|
eqn_next(struct eqn_node *ep, char quote, size_t *sz, int repl) |
eqn_next(struct eqn_node *ep, char quote, size_t *sz, int repl) |
{ |
{ |
|
static size_t last_len; |
|
static int lim; |
|
|
char *start, *next; |
char *start, *next; |
int q, diff, lim; |
int q, diff; |
size_t ssz, dummy; |
size_t ssz, dummy; |
struct eqn_def *def; |
struct eqn_def *def; |
|
|
if (NULL == sz) |
if (NULL == sz) |
sz = &dummy; |
sz = &dummy; |
|
|
lim = 0; |
if (ep->cur >= last_len) |
|
lim = 0; |
ep->rew = ep->cur; |
ep->rew = ep->cur; |
again: |
again: |
/* Prevent self-definitions. */ |
/* Prevent self-definitions. */ |
|
|
if (lim >= EQN_NEST_MAX) { |
if (lim >= EQN_NEST_MAX) { |
EQN_MSG(MANDOCERR_ROFFLOOP, ep); |
mandoc_msg(MANDOCERR_ROFFLOOP, ep->parse, |
return(NULL); |
ep->eqn.ln, ep->eqn.pos, NULL); |
|
return NULL; |
} |
} |
|
|
ep->cur = ep->rew; |
ep->cur = ep->rew; |
|
|
q = 0; |
q = 0; |
|
|
if ('\0' == *start) |
if ('\0' == *start) |
return(NULL); |
return NULL; |
|
|
if (quote == *start) { |
if (quote == *start) { |
ep->cur++; |
ep->cur++; |
|
|
ep->cur++; |
ep->cur++; |
} else { |
} else { |
if (q) |
if (q) |
EQN_MSG(MANDOCERR_BADQUOTE, ep); |
mandoc_msg(MANDOCERR_ARG_QUOTE, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, NULL); |
next = strchr(start, '\0'); |
next = strchr(start, '\0'); |
*sz = (size_t)(next - start); |
*sz = (size_t)(next - start); |
ep->cur += *sz; |
ep->cur += *sz; |
|
|
/* Quotes aren't expanded for values. */ |
/* Quotes aren't expanded for values. */ |
|
|
if (q || ! repl) |
if (q || ! repl) |
return(start); |
return start; |
|
|
if (NULL != (def = eqn_def_find(ep, start, *sz))) { |
if (NULL != (def = eqn_def_find(ep, start, *sz))) { |
diff = def->valsz - *sz; |
diff = def->valsz - *sz; |
|
|
memmove(start + *sz + diff, start + *sz, |
memmove(start + *sz + diff, start + *sz, |
(strlen(start) - *sz) + 1); |
(strlen(start) - *sz) + 1); |
memcpy(start, def->val, def->valsz); |
memcpy(start, def->val, def->valsz); |
|
last_len = start - ep->data + def->valsz; |
|
lim++; |
goto again; |
goto again; |
} |
} |
|
|
return(start); |
return start; |
} |
} |
|
|
static int |
/* |
eqn_do_ign1(struct eqn_node *ep) |
* Get the next delimited token using the default current quote |
|
* character. |
|
*/ |
|
static const char * |
|
eqn_nexttok(struct eqn_node *ep, size_t *sz) |
{ |
{ |
|
|
if (NULL == eqn_nextrawtok(ep, NULL)) |
return eqn_next(ep, '"', sz, 1); |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
} |
else |
|
return(1); |
|
|
|
return(0); |
/* |
|
* Get next token without replacement. |
|
*/ |
|
static const char * |
|
eqn_nextrawtok(struct eqn_node *ep, size_t *sz) |
|
{ |
|
|
|
return eqn_next(ep, '"', sz, 0); |
} |
} |
|
|
static int |
/* |
eqn_do_ign2(struct eqn_node *ep) |
* Parse a token from the stream of text. |
|
* A token consists of one of the recognised eqn(7) strings. |
|
* Strings are separated by delimiting marks. |
|
* This returns EQN_TOK_EOF when there are no more tokens. |
|
* If the token is an unrecognised string literal, then it returns |
|
* EQN_TOK__MAX and sets the "p" pointer to an allocated, nil-terminated |
|
* string. |
|
* This must be later freed with free(3). |
|
*/ |
|
static enum eqn_tok |
|
eqn_tok_parse(struct eqn_node *ep, char **p) |
{ |
{ |
|
const char *start; |
|
size_t i, sz; |
|
int quoted; |
|
|
if (NULL == eqn_nextrawtok(ep, NULL)) |
if (p != NULL) |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
*p = NULL; |
else if (NULL == eqn_nextrawtok(ep, NULL)) |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
else |
|
return(1); |
|
|
|
return(0); |
quoted = ep->data[ep->cur] == '"'; |
|
|
|
if ((start = eqn_nexttok(ep, &sz)) == NULL) |
|
return EQN_TOK_EOF; |
|
|
|
if (quoted) { |
|
if (p != NULL) |
|
*p = mandoc_strndup(start, sz); |
|
return EQN_TOK_QUOTED; |
|
} |
|
|
|
for (i = 0; i < EQN_TOK__MAX; i++) |
|
if (STRNEQ(start, sz, eqn_toks[i], strlen(eqn_toks[i]))) |
|
return i; |
|
|
|
for (i = 0; i < EQNSYM__MAX; i++) { |
|
if (STRNEQ(start, sz, |
|
eqnsyms[i].str, strlen(eqnsyms[i].str))) { |
|
mandoc_asprintf(p, "\\[%s]", eqnsyms[i].sym); |
|
return EQN_TOK_SYM; |
|
} |
|
} |
|
|
|
if (p != NULL) |
|
*p = mandoc_strndup(start, sz); |
|
|
|
for (i = 0; i < sizeof(eqn_func)/sizeof(*eqn_func); i++) |
|
if (STRNEQ(start, sz, eqn_func[i], strlen(eqn_func[i]))) |
|
return EQN_TOK_FUNC; |
|
|
|
return EQN_TOK__MAX; |
} |
} |
|
|
static int |
static void |
eqn_do_tdefine(struct eqn_node *ep) |
eqn_box_free(struct eqn_box *bp) |
{ |
{ |
|
|
if (NULL == eqn_nextrawtok(ep, NULL)) |
if (bp->first) |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
eqn_box_free(bp->first); |
else if (NULL == eqn_next(ep, ep->data[(int)ep->cur], NULL, 0)) |
if (bp->next) |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
eqn_box_free(bp->next); |
else |
|
return(1); |
|
|
|
return(0); |
free(bp->text); |
|
free(bp->left); |
|
free(bp->right); |
|
free(bp->top); |
|
free(bp->bottom); |
|
free(bp); |
} |
} |
|
|
static int |
/* |
eqn_do_define(struct eqn_node *ep) |
* Allocate a box as the last child of the parent node. |
|
*/ |
|
static struct eqn_box * |
|
eqn_box_alloc(struct eqn_node *ep, struct eqn_box *parent) |
{ |
{ |
|
struct eqn_box *bp; |
|
|
|
bp = mandoc_calloc(1, sizeof(struct eqn_box)); |
|
bp->parent = parent; |
|
bp->parent->args++; |
|
bp->expectargs = UINT_MAX; |
|
bp->size = ep->gsize; |
|
|
|
if (NULL != parent->first) { |
|
parent->last->next = bp; |
|
bp->prev = parent->last; |
|
} else |
|
parent->first = bp; |
|
|
|
parent->last = bp; |
|
return bp; |
|
} |
|
|
|
/* |
|
* Reparent the current last node (of the current parent) under a new |
|
* EQN_SUBEXPR as the first element. |
|
* Then return the new parent. |
|
* The new EQN_SUBEXPR will have a two-child limit. |
|
*/ |
|
static struct eqn_box * |
|
eqn_box_makebinary(struct eqn_node *ep, |
|
enum eqn_post pos, struct eqn_box *parent) |
|
{ |
|
struct eqn_box *b, *newb; |
|
|
|
assert(NULL != parent->last); |
|
b = parent->last; |
|
if (parent->last == parent->first) |
|
parent->first = NULL; |
|
parent->args--; |
|
parent->last = b->prev; |
|
b->prev = NULL; |
|
newb = eqn_box_alloc(ep, parent); |
|
newb->pos = pos; |
|
newb->type = EQN_SUBEXPR; |
|
newb->expectargs = 2; |
|
newb->args = 1; |
|
newb->first = newb->last = b; |
|
newb->first->next = NULL; |
|
b->parent = newb; |
|
return newb; |
|
} |
|
|
|
/* |
|
* Parse the "delim" control statement. |
|
*/ |
|
static void |
|
eqn_delim(struct eqn_node *ep) |
|
{ |
const char *start; |
const char *start; |
size_t sz; |
size_t sz; |
|
|
|
if ((start = eqn_nextrawtok(ep, &sz)) == NULL) |
|
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, "delim"); |
|
else if (strncmp(start, "off", 3) == 0) |
|
ep->delim = 0; |
|
else if (strncmp(start, "on", 2) == 0) { |
|
if (ep->odelim && ep->cdelim) |
|
ep->delim = 1; |
|
} else if (start[1] != '\0') { |
|
ep->odelim = start[0]; |
|
ep->cdelim = start[1]; |
|
ep->delim = 1; |
|
} |
|
} |
|
|
|
/* |
|
* Undefine a previously-defined string. |
|
*/ |
|
static void |
|
eqn_undef(struct eqn_node *ep) |
|
{ |
|
const char *start; |
struct eqn_def *def; |
struct eqn_def *def; |
|
size_t sz; |
|
|
|
if ((start = eqn_nextrawtok(ep, &sz)) == NULL) { |
|
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, "undef"); |
|
return; |
|
} |
|
if ((def = eqn_def_find(ep, start, sz)) == NULL) |
|
return; |
|
free(def->key); |
|
free(def->val); |
|
def->key = def->val = NULL; |
|
def->keysz = def->valsz = 0; |
|
} |
|
|
|
static void |
|
eqn_def(struct eqn_node *ep) |
|
{ |
|
const char *start; |
|
size_t sz; |
|
struct eqn_def *def; |
int i; |
int i; |
|
|
if (NULL == (start = eqn_nextrawtok(ep, &sz))) { |
if ((start = eqn_nextrawtok(ep, &sz)) == NULL) { |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, |
return(0); |
ep->eqn.ln, ep->eqn.pos, "define"); |
|
return; |
} |
} |
|
|
/* |
/* |
* Search for a key that already exists. |
* Search for a key that already exists. |
* Create a new key if none is found. |
* Create a new key if none is found. |
*/ |
*/ |
|
|
if (NULL == (def = eqn_def_find(ep, start, sz))) { |
if (NULL == (def = eqn_def_find(ep, start, sz))) { |
/* Find holes in string array. */ |
/* Find holes in string array. */ |
for (i = 0; i < (int)ep->defsz; i++) |
for (i = 0; i < (int)ep->defsz; i++) |
Line 870 eqn_do_define(struct eqn_node *ep) |
|
Line 693 eqn_do_define(struct eqn_node *ep) |
|
ep->defs[i].key = ep->defs[i].val = NULL; |
ep->defs[i].key = ep->defs[i].val = NULL; |
} |
} |
|
|
ep->defs[i].keysz = sz; |
def = ep->defs + i; |
ep->defs[i].key = mandoc_realloc( |
free(def->key); |
ep->defs[i].key, sz + 1); |
def->key = mandoc_strndup(start, sz); |
|
def->keysz = sz; |
memcpy(ep->defs[i].key, start, sz); |
|
ep->defs[i].key[(int)sz] = '\0'; |
|
def = &ep->defs[i]; |
|
} |
} |
|
|
start = eqn_next(ep, ep->data[(int)ep->cur], &sz, 0); |
start = eqn_next(ep, ep->data[(int)ep->cur], &sz, 0); |
|
if (start == NULL) { |
if (NULL == start) { |
mandoc_vmsg(MANDOCERR_REQ_EMPTY, ep->parse, |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
ep->eqn.ln, ep->eqn.pos, "define %s", def->key); |
return(0); |
free(def->key); |
|
free(def->val); |
|
def->key = def->val = NULL; |
|
def->keysz = def->valsz = 0; |
|
return; |
} |
} |
|
free(def->val); |
|
def->val = mandoc_strndup(start, sz); |
def->valsz = sz; |
def->valsz = sz; |
def->val = mandoc_realloc(def->val, sz + 1); |
|
memcpy(def->val, start, sz); |
|
def->val[(int)sz] = '\0'; |
|
return(1); |
|
} |
} |
|
|
static int |
/* |
eqn_do_gfont(struct eqn_node *ep) |
* Recursively parse an eqn(7) expression. |
|
*/ |
|
static enum rofferr |
|
eqn_parse(struct eqn_node *ep, struct eqn_box *parent) |
{ |
{ |
|
char sym[64]; |
|
struct eqn_box *cur, *fontp, *nbox; |
|
const char *cp, *cpn, *start; |
|
char *p; |
|
size_t sz; |
|
enum eqn_tok tok, subtok; |
|
enum eqn_post pos; |
|
int size; |
|
|
if (NULL == eqn_nextrawtok(ep, NULL)) { |
assert(parent != NULL); |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(0); |
|
} |
|
return(1); |
|
} |
|
|
|
static int |
/* |
eqn_do_gsize(struct eqn_node *ep) |
* Empty equation. |
{ |
* Do not add it to the high-level syntax tree. |
const char *start; |
*/ |
size_t sz; |
|
|
|
if (NULL == (start = eqn_nextrawtok(ep, &sz))) { |
if (ep->data == NULL) |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
return ROFF_IGN; |
return(0); |
|
|
next_tok: |
|
tok = eqn_tok_parse(ep, &p); |
|
|
|
this_tok: |
|
switch (tok) { |
|
case EQN_TOK_UNDEF: |
|
eqn_undef(ep); |
|
break; |
|
case EQN_TOK_NDEFINE: |
|
case EQN_TOK_DEFINE: |
|
eqn_def(ep); |
|
break; |
|
case EQN_TOK_TDEFINE: |
|
if (eqn_nextrawtok(ep, NULL) == NULL || |
|
eqn_next(ep, ep->data[(int)ep->cur], NULL, 0) == NULL) |
|
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, "tdefine"); |
|
break; |
|
case EQN_TOK_DELIM: |
|
eqn_delim(ep); |
|
break; |
|
case EQN_TOK_GFONT: |
|
if (eqn_nextrawtok(ep, NULL) == NULL) |
|
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
break; |
|
case EQN_TOK_MARK: |
|
case EQN_TOK_LINEUP: |
|
/* Ignore these. */ |
|
break; |
|
case EQN_TOK_DYAD: |
|
case EQN_TOK_VEC: |
|
case EQN_TOK_UNDER: |
|
case EQN_TOK_BAR: |
|
case EQN_TOK_TILDE: |
|
case EQN_TOK_HAT: |
|
case EQN_TOK_DOT: |
|
case EQN_TOK_DOTDOT: |
|
if (parent->last == NULL) { |
|
mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
cur = eqn_box_alloc(ep, parent); |
|
cur->type = EQN_TEXT; |
|
cur->text = mandoc_strdup(""); |
|
} |
|
parent = eqn_box_makebinary(ep, EQNPOS_NONE, parent); |
|
parent->type = EQN_LISTONE; |
|
parent->expectargs = 1; |
|
switch (tok) { |
|
case EQN_TOK_DOTDOT: |
|
strlcpy(sym, "\\[ad]", sizeof(sym)); |
|
break; |
|
case EQN_TOK_VEC: |
|
strlcpy(sym, "\\[->]", sizeof(sym)); |
|
break; |
|
case EQN_TOK_DYAD: |
|
strlcpy(sym, "\\[<>]", sizeof(sym)); |
|
break; |
|
case EQN_TOK_TILDE: |
|
strlcpy(sym, "\\[a~]", sizeof(sym)); |
|
break; |
|
case EQN_TOK_UNDER: |
|
strlcpy(sym, "\\[ul]", sizeof(sym)); |
|
break; |
|
case EQN_TOK_BAR: |
|
strlcpy(sym, "\\[rl]", sizeof(sym)); |
|
break; |
|
case EQN_TOK_DOT: |
|
strlcpy(sym, "\\[a.]", sizeof(sym)); |
|
break; |
|
case EQN_TOK_HAT: |
|
strlcpy(sym, "\\[ha]", sizeof(sym)); |
|
break; |
|
default: |
|
abort(); |
|
} |
|
|
|
switch (tok) { |
|
case EQN_TOK_DOTDOT: |
|
case EQN_TOK_VEC: |
|
case EQN_TOK_DYAD: |
|
case EQN_TOK_TILDE: |
|
case EQN_TOK_BAR: |
|
case EQN_TOK_DOT: |
|
case EQN_TOK_HAT: |
|
parent->top = mandoc_strdup(sym); |
|
break; |
|
case EQN_TOK_UNDER: |
|
parent->bottom = mandoc_strdup(sym); |
|
break; |
|
default: |
|
abort(); |
|
} |
|
parent = parent->parent; |
|
break; |
|
case EQN_TOK_FWD: |
|
case EQN_TOK_BACK: |
|
case EQN_TOK_DOWN: |
|
case EQN_TOK_UP: |
|
subtok = eqn_tok_parse(ep, NULL); |
|
if (subtok != EQN_TOK__MAX) { |
|
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
tok = subtok; |
|
goto this_tok; |
|
} |
|
break; |
|
case EQN_TOK_FAT: |
|
case EQN_TOK_ROMAN: |
|
case EQN_TOK_ITALIC: |
|
case EQN_TOK_BOLD: |
|
while (parent->args == parent->expectargs) |
|
parent = parent->parent; |
|
/* |
|
* These values apply to the next word or sequence of |
|
* words; thus, we mark that we'll have a child with |
|
* exactly one of those. |
|
*/ |
|
parent = eqn_box_alloc(ep, parent); |
|
parent->type = EQN_LISTONE; |
|
parent->expectargs = 1; |
|
switch (tok) { |
|
case EQN_TOK_FAT: |
|
parent->font = EQNFONT_FAT; |
|
break; |
|
case EQN_TOK_ROMAN: |
|
parent->font = EQNFONT_ROMAN; |
|
break; |
|
case EQN_TOK_ITALIC: |
|
parent->font = EQNFONT_ITALIC; |
|
break; |
|
case EQN_TOK_BOLD: |
|
parent->font = EQNFONT_BOLD; |
|
break; |
|
default: |
|
abort(); |
|
} |
|
break; |
|
case EQN_TOK_SIZE: |
|
case EQN_TOK_GSIZE: |
|
/* Accept two values: integral size and a single. */ |
|
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
|
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
break; |
|
} |
|
size = mandoc_strntoi(start, sz, 10); |
|
if (-1 == size) { |
|
mandoc_msg(MANDOCERR_IT_NONUM, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
break; |
|
} |
|
if (EQN_TOK_GSIZE == tok) { |
|
ep->gsize = size; |
|
break; |
|
} |
|
parent = eqn_box_alloc(ep, parent); |
|
parent->type = EQN_LISTONE; |
|
parent->expectargs = 1; |
|
parent->size = size; |
|
break; |
|
case EQN_TOK_FROM: |
|
case EQN_TOK_TO: |
|
case EQN_TOK_SUB: |
|
case EQN_TOK_SUP: |
|
/* |
|
* We have a left-right-associative expression. |
|
* Repivot under a positional node, open a child scope |
|
* and keep on reading. |
|
*/ |
|
if (parent->last == NULL) { |
|
mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
cur = eqn_box_alloc(ep, parent); |
|
cur->type = EQN_TEXT; |
|
cur->text = mandoc_strdup(""); |
|
} |
|
/* Handle the "subsup" and "fromto" positions. */ |
|
if (EQN_TOK_SUP == tok && parent->pos == EQNPOS_SUB) { |
|
parent->expectargs = 3; |
|
parent->pos = EQNPOS_SUBSUP; |
|
break; |
|
} |
|
if (EQN_TOK_TO == tok && parent->pos == EQNPOS_FROM) { |
|
parent->expectargs = 3; |
|
parent->pos = EQNPOS_FROMTO; |
|
break; |
|
} |
|
switch (tok) { |
|
case EQN_TOK_FROM: |
|
pos = EQNPOS_FROM; |
|
break; |
|
case EQN_TOK_TO: |
|
pos = EQNPOS_TO; |
|
break; |
|
case EQN_TOK_SUP: |
|
pos = EQNPOS_SUP; |
|
break; |
|
case EQN_TOK_SUB: |
|
pos = EQNPOS_SUB; |
|
break; |
|
default: |
|
abort(); |
|
} |
|
parent = eqn_box_makebinary(ep, pos, parent); |
|
break; |
|
case EQN_TOK_SQRT: |
|
while (parent->args == parent->expectargs) |
|
parent = parent->parent; |
|
/* |
|
* Accept a left-right-associative set of arguments just |
|
* like sub and sup and friends but without rebalancing |
|
* under a pivot. |
|
*/ |
|
parent = eqn_box_alloc(ep, parent); |
|
parent->type = EQN_SUBEXPR; |
|
parent->pos = EQNPOS_SQRT; |
|
parent->expectargs = 1; |
|
break; |
|
case EQN_TOK_OVER: |
|
/* |
|
* We have a right-left-associative fraction. |
|
* Close out anything that's currently open, then |
|
* rebalance and continue reading. |
|
*/ |
|
if (parent->last == NULL) { |
|
mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
cur = eqn_box_alloc(ep, parent); |
|
cur->type = EQN_TEXT; |
|
cur->text = mandoc_strdup(""); |
|
} |
|
while (EQN_SUBEXPR == parent->type) |
|
parent = parent->parent; |
|
parent = eqn_box_makebinary(ep, EQNPOS_OVER, parent); |
|
break; |
|
case EQN_TOK_RIGHT: |
|
case EQN_TOK_BRACE_CLOSE: |
|
/* |
|
* Close out the existing brace. |
|
* FIXME: this is a shitty sentinel: we should really |
|
* have a native EQN_BRACE type or whatnot. |
|
*/ |
|
for (cur = parent; cur != NULL; cur = cur->parent) |
|
if (cur->type == EQN_LIST && |
|
(tok == EQN_TOK_BRACE_CLOSE || |
|
cur->left != NULL)) |
|
break; |
|
if (cur == NULL) { |
|
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
break; |
|
} |
|
parent = cur; |
|
if (EQN_TOK_RIGHT == tok) { |
|
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
|
mandoc_msg(MANDOCERR_REQ_EMPTY, |
|
ep->parse, ep->eqn.ln, |
|
ep->eqn.pos, eqn_toks[tok]); |
|
break; |
|
} |
|
/* Handling depends on right/left. */ |
|
if (STRNEQ(start, sz, "ceiling", 7)) { |
|
strlcpy(sym, "\\[rc]", sizeof(sym)); |
|
parent->right = mandoc_strdup(sym); |
|
} else if (STRNEQ(start, sz, "floor", 5)) { |
|
strlcpy(sym, "\\[rf]", sizeof(sym)); |
|
parent->right = mandoc_strdup(sym); |
|
} else |
|
parent->right = mandoc_strndup(start, sz); |
|
} |
|
parent = parent->parent; |
|
if (tok == EQN_TOK_BRACE_CLOSE && |
|
(parent->type == EQN_PILE || |
|
parent->type == EQN_MATRIX)) |
|
parent = parent->parent; |
|
/* Close out any "singleton" lists. */ |
|
while (parent->type == EQN_LISTONE && |
|
parent->args == parent->expectargs) |
|
parent = parent->parent; |
|
break; |
|
case EQN_TOK_BRACE_OPEN: |
|
case EQN_TOK_LEFT: |
|
/* |
|
* If we already have something in the stack and we're |
|
* in an expression, then rewind til we're not any more |
|
* (just like with the text node). |
|
*/ |
|
while (parent->args == parent->expectargs) |
|
parent = parent->parent; |
|
if (EQN_TOK_LEFT == tok && |
|
(start = eqn_nexttok(ep, &sz)) == NULL) { |
|
mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
break; |
|
} |
|
parent = eqn_box_alloc(ep, parent); |
|
parent->type = EQN_LIST; |
|
if (EQN_TOK_LEFT == tok) { |
|
if (STRNEQ(start, sz, "ceiling", 7)) { |
|
strlcpy(sym, "\\[lc]", sizeof(sym)); |
|
parent->left = mandoc_strdup(sym); |
|
} else if (STRNEQ(start, sz, "floor", 5)) { |
|
strlcpy(sym, "\\[lf]", sizeof(sym)); |
|
parent->left = mandoc_strdup(sym); |
|
} else |
|
parent->left = mandoc_strndup(start, sz); |
|
} |
|
break; |
|
case EQN_TOK_PILE: |
|
case EQN_TOK_LPILE: |
|
case EQN_TOK_RPILE: |
|
case EQN_TOK_CPILE: |
|
case EQN_TOK_CCOL: |
|
case EQN_TOK_LCOL: |
|
case EQN_TOK_RCOL: |
|
while (parent->args == parent->expectargs) |
|
parent = parent->parent; |
|
parent = eqn_box_alloc(ep, parent); |
|
parent->type = EQN_PILE; |
|
parent->expectargs = 1; |
|
break; |
|
case EQN_TOK_ABOVE: |
|
for (cur = parent; cur != NULL; cur = cur->parent) |
|
if (cur->type == EQN_PILE) |
|
break; |
|
if (cur == NULL) { |
|
mandoc_msg(MANDOCERR_IT_STRAY, ep->parse, |
|
ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); |
|
break; |
|
} |
|
parent = eqn_box_alloc(ep, cur); |
|
parent->type = EQN_LIST; |
|
break; |
|
case EQN_TOK_MATRIX: |
|
while (parent->args == parent->expectargs) |
|
parent = parent->parent; |
|
parent = eqn_box_alloc(ep, parent); |
|
parent->type = EQN_MATRIX; |
|
parent->expectargs = 1; |
|
break; |
|
case EQN_TOK_EOF: |
|
/* |
|
* End of file! |
|
* TODO: make sure we're not in an open subexpression. |
|
*/ |
|
return ROFF_EQN; |
|
case EQN_TOK__MAX: |
|
case EQN_TOK_FUNC: |
|
case EQN_TOK_QUOTED: |
|
case EQN_TOK_SYM: |
|
assert(p != NULL); |
|
/* |
|
* If we already have something in the stack and we're |
|
* in an expression, then rewind til we're not any more. |
|
*/ |
|
while (parent->args == parent->expectargs) |
|
parent = parent->parent; |
|
/* |
|
* Wrap well-known function names in a roman box, |
|
* unless they already are in roman context. |
|
*/ |
|
for (fontp = parent; fontp != NULL; fontp = fontp->parent) |
|
if (fontp->font != EQNFONT_NONE) |
|
break; |
|
if (tok == EQN_TOK_FUNC && |
|
(fontp == NULL || fontp->font != EQNFONT_ROMAN)) { |
|
parent = fontp = eqn_box_alloc(ep, parent); |
|
parent->type = EQN_LISTONE; |
|
parent->font = EQNFONT_ROMAN; |
|
parent->expectargs = 1; |
|
} |
|
cur = eqn_box_alloc(ep, parent); |
|
cur->type = EQN_TEXT; |
|
cur->text = p; |
|
/* |
|
* If not inside any explicit font context, |
|
* quoted strings become italic, and every letter |
|
* of a bare string gets its own italic box. |
|
*/ |
|
do { |
|
if (fontp != NULL || *p == '\0' || |
|
tok == EQN_TOK_SYM) |
|
break; |
|
if (tok == EQN_TOK_QUOTED) { |
|
cur->font = EQNFONT_ITALIC; |
|
break; |
|
} |
|
cp = p; |
|
for (;;) { |
|
if (isalpha((unsigned char)*cp)) |
|
cur->font = EQNFONT_ITALIC; |
|
cpn = cp + 1; |
|
if (*cp == '\\') |
|
mandoc_escape(&cpn, NULL, NULL); |
|
if (*cpn == '\0') |
|
break; |
|
if (cur->font != EQNFONT_ITALIC && |
|
isalpha((unsigned char)*cpn) == 0) { |
|
cp = cpn; |
|
continue; |
|
} |
|
nbox = eqn_box_alloc(ep, parent); |
|
nbox->type = EQN_TEXT; |
|
nbox->text = mandoc_strdup(cpn); |
|
p = mandoc_strndup(cur->text, |
|
cpn - cur->text); |
|
free(cur->text); |
|
cur->text = p; |
|
cur = nbox; |
|
cp = nbox->text; |
|
} |
|
} while (0); |
|
/* |
|
* Post-process list status. |
|
*/ |
|
while (parent->type == EQN_LISTONE && |
|
parent->args == parent->expectargs) |
|
parent = parent->parent; |
|
break; |
|
default: |
|
abort(); |
} |
} |
ep->gsize = mandoc_strntoi(start, sz, 10); |
goto next_tok; |
return(1); |
|
} |
} |
|
|
static int |
enum rofferr |
eqn_do_undef(struct eqn_node *ep) |
eqn_end(struct eqn_node **epp) |
{ |
{ |
const char *start; |
struct eqn_node *ep; |
struct eqn_def *def; |
|
size_t sz; |
|
|
|
if (NULL == (start = eqn_nextrawtok(ep, &sz))) { |
ep = *epp; |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
*epp = NULL; |
return(0); |
|
} else if (NULL != (def = eqn_def_find(ep, start, sz))) |
|
def->keysz = 0; |
|
|
|
return(1); |
ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box)); |
|
ep->eqn.root->expectargs = UINT_MAX; |
|
return eqn_parse(ep, ep->eqn.root); |
} |
} |
|
|
static struct eqn_def * |
void |
eqn_def_find(struct eqn_node *ep, const char *key, size_t sz) |
eqn_free(struct eqn_node *p) |
{ |
{ |
int i; |
int i; |
|
|
for (i = 0; i < (int)ep->defsz; i++) |
eqn_box_free(p->eqn.root); |
if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key, |
|
ep->defs[i].keysz, key, sz)) |
|
return(&ep->defs[i]); |
|
|
|
return(NULL); |
for (i = 0; i < (int)p->defsz; i++) { |
|
free(p->defs[i].key); |
|
free(p->defs[i].val); |
|
} |
|
|
|
free(p->data); |
|
free(p->defs); |
|
free(p); |
} |
} |