version 1.22, 2011/07/22 00:16:37 |
version 1.27, 2011/07/22 13:40:15 |
|
|
EQN_EOF |
EQN_EOF |
}; |
}; |
|
|
|
enum eqn_symt { |
|
EQNSYM_alpha, |
|
EQNSYM_beta, |
|
EQNSYM_chi, |
|
EQNSYM_delta, |
|
EQNSYM_epsilon, |
|
EQNSYM_eta, |
|
EQNSYM_gamma, |
|
EQNSYM_iota, |
|
EQNSYM_kappa, |
|
EQNSYM_lambda, |
|
EQNSYM_mu, |
|
EQNSYM_nu, |
|
EQNSYM_omega, |
|
EQNSYM_omicron, |
|
EQNSYM_phi, |
|
EQNSYM_pi, |
|
EQNSYM_ps, |
|
EQNSYM_rho, |
|
EQNSYM_sigma, |
|
EQNSYM_tau, |
|
EQNSYM_theta, |
|
EQNSYM_upsilon, |
|
EQNSYM_xi, |
|
EQNSYM_zeta, |
|
EQNSYM_DELTA, |
|
EQNSYM_GAMMA, |
|
EQNSYM_LAMBDA, |
|
EQNSYM_OMEGA, |
|
EQNSYM_PHI, |
|
EQNSYM_PI, |
|
EQNSYM_PSI, |
|
EQNSYM_SIGMA, |
|
EQNSYM_THETA, |
|
EQNSYM_UPSILON, |
|
EQNSYM_XI, |
|
EQNSYM__MAX |
|
}; |
|
|
struct eqnstr { |
struct eqnstr { |
const char *name; |
const char *name; |
size_t sz; |
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 eqnpart { |
struct eqnstr str; |
struct eqnstr str; |
int (*fp)(struct eqn_node *); |
int (*fp)(struct eqn_node *); |
}; |
}; |
|
|
|
struct eqnsym { |
|
struct eqnstr str; |
|
char sym; |
|
}; |
|
|
enum eqnpartt { |
enum eqnpartt { |
EQN_DEFINE = 0, |
EQN_DEFINE = 0, |
EQN_SET, |
EQN_SET, |
|
|
EQN__MAX |
EQN__MAX |
}; |
}; |
|
|
|
static enum eqn_rest eqn_box(struct eqn_node *, struct eqn_box *); |
static struct eqn_box *eqn_box_alloc(struct eqn_box *); |
static struct eqn_box *eqn_box_alloc(struct eqn_box *); |
static void eqn_box_free(struct eqn_box *); |
static void eqn_box_free(struct eqn_box *); |
static struct eqn_def *eqn_def_find(struct eqn_node *, |
static struct eqn_def *eqn_def_find(struct eqn_node *, |
Line 63 static struct eqn_def *eqn_def_find(struct eqn_node *, |
|
Line 113 static struct eqn_def *eqn_def_find(struct eqn_node *, |
|
static int eqn_do_define(struct eqn_node *); |
static int eqn_do_define(struct eqn_node *); |
static int eqn_do_set(struct eqn_node *); |
static int eqn_do_set(struct eqn_node *); |
static int eqn_do_undef(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 const char *eqn_nexttok(struct eqn_node *, size_t *); |
static const char *eqn_nexttok(struct eqn_node *, size_t *); |
static const char *eqn_nextrawtok(struct eqn_node *, size_t *); |
static const char *eqn_nextrawtok(struct eqn_node *, size_t *); |
static const char *eqn_next(struct eqn_node *, |
static const char *eqn_next(struct eqn_node *, |
char, size_t *, int); |
char, size_t *, int); |
static void eqn_rewind(struct eqn_node *); |
static void eqn_rewind(struct eqn_node *); |
static enum eqn_rest eqn_eqn(struct eqn_node *, struct eqn_box *); |
|
static enum eqn_rest eqn_box(struct eqn_node *, struct eqn_box *); |
|
|
|
static const struct eqnpart eqnparts[EQN__MAX] = { |
static const struct eqnpart eqnparts[EQN__MAX] = { |
{ { "define", 6 }, eqn_do_define }, /* EQN_DEFINE */ |
{ { "define", 6 }, eqn_do_define }, /* EQN_DEFINE */ |
Line 112 static const struct eqnstr eqnpiles[EQNPILE__MAX] = { |
|
Line 162 static const struct eqnstr eqnpiles[EQNPILE__MAX] = { |
|
{ "lpile", 5 }, /* EQNPILE_LPILE */ |
{ "lpile", 5 }, /* EQNPILE_LPILE */ |
}; |
}; |
|
|
|
static const struct eqnsym eqnsyms[EQNSYM__MAX] = { |
|
{ { "alpha", 5 }, 'a' }, /* EQNSYM_alpha */ |
|
{ { "beta", 4 }, 'b' }, /* EQNSYM_beta */ |
|
{ { "chi", 3 }, 'x' }, /* EQNSYM_chi */ |
|
{ { "delta", 5 }, 'd' }, /* EQNSYM_delta */ |
|
{ { "epsilon", 7 }, 'e' }, /* EQNSYM_epsilon */ |
|
{ { "eta", 3 }, 'y' }, /* EQNSYM_eta */ |
|
{ { "gamma", 5 }, 'g' }, /* EQNSYM_gamma */ |
|
{ { "iota", 4 }, 'i' }, /* EQNSYM_iota */ |
|
{ { "kappa", 5 }, 'k' }, /* EQNSYM_kappa */ |
|
{ { "lambda", 6 }, 'l' }, /* EQNSYM_lambda */ |
|
{ { "mu", 2 }, 'm' }, /* EQNSYM_mu */ |
|
{ { "nu", 2 }, 'n' }, /* EQNSYM_nu */ |
|
{ { "omega", 5 }, 'w' }, /* EQNSYM_omega */ |
|
{ { "omicron", 7 }, 'o' }, /* EQNSYM_omicron */ |
|
{ { "phi", 3 }, 'f' }, /* EQNSYM_phi */ |
|
{ { "pi", 2 }, 'p' }, /* EQNSYM_pi */ |
|
{ { "psi", 2 }, 'q' }, /* EQNSYM_psi */ |
|
{ { "rho", 3 }, 'r' }, /* EQNSYM_rho */ |
|
{ { "sigma", 5 }, 's' }, /* EQNSYM_sigma */ |
|
{ { "tau", 3 }, 't' }, /* EQNSYM_tau */ |
|
{ { "theta", 5 }, 'h' }, /* EQNSYM_theta */ |
|
{ { "upsilon", 7 }, 'u' }, /* EQNSYM_upsilon */ |
|
{ { "xi", 2 }, 'c' }, /* EQNSYM_xi */ |
|
{ { "zeta", 4 }, 'z' }, /* EQNSYM_zeta */ |
|
{ { "DELTA", 5 }, 'D' }, /* EQNSYM_DELTA */ |
|
{ { "GAMMA", 5 }, 'G' }, /* EQNSYM_GAMMA */ |
|
{ { "LAMBDA", 6 }, 'L' }, /* EQNSYM_LAMBDA */ |
|
{ { "OMEGA", 5 }, 'W' }, /* EQNSYM_OMEGA */ |
|
{ { "PHI", 3 }, 'F' }, /* EQNSYM_PHI */ |
|
{ { "PI", 2 }, 'P' }, /* EQNSYM_PI */ |
|
{ { "PSI", 3 }, 'Q' }, /* EQNSYM_PSI */ |
|
{ { "SIGMA", 5 }, 'S' }, /* EQNSYM_SIGMA */ |
|
{ { "THETA", 5 }, 'H' }, /* EQNSYM_THETA */ |
|
{ { "UPSILON", 7 }, 'U' }, /* EQNSYM_UPSILON */ |
|
{ { "XI", 2 }, 'C' }, /* EQNSYM_XI */ |
|
}; |
|
|
/* ARGSUSED */ |
/* ARGSUSED */ |
enum rofferr |
enum rofferr |
eqn_read(struct eqn_node **epp, int ln, |
eqn_read(struct eqn_node **epp, int ln, |
Line 204 eqn_eqn(struct eqn_node *ep, struct eqn_box *last) |
|
Line 292 eqn_eqn(struct eqn_node *ep, struct eqn_box *last) |
|
} |
} |
|
|
static enum eqn_rest |
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(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; |
|
bp->last->above = 1; |
|
} |
|
|
|
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) |
eqn_box(struct eqn_node *ep, struct eqn_box *last) |
{ |
{ |
size_t sz; |
size_t sz; |
const char *start; |
const char *start; |
char *left; |
char *left; |
|
char sym[5]; |
enum eqn_rest c; |
enum eqn_rest c; |
int i, size; |
int i, size; |
struct eqn_box *bp; |
struct eqn_box *bp; |
Line 216 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
Line 350 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
if (NULL == (start = eqn_nexttok(ep, &sz))) |
if (NULL == (start = eqn_nexttok(ep, &sz))) |
return(EQN_EOF); |
return(EQN_EOF); |
|
|
if (1 == sz && 0 == strncmp("}", start, 1)) |
if (STRNEQ(start, sz, "}", 1)) |
return(EQN_DESCOPE); |
return(EQN_DESCOPE); |
else if (5 == sz && 0 == strncmp("right", start, 5)) |
else if (STRNEQ(start, sz, "right", 5)) |
return(EQN_DESCOPE); |
return(EQN_DESCOPE); |
else if (5 == sz && 0 == strncmp("above", start, 5)) |
else if (STRNEQ(start, sz, "above", 5)) |
return(EQN_DESCOPE); |
return(EQN_DESCOPE); |
|
|
for (i = 0; i < (int)EQN__MAX; i++) { |
for (i = 0; i < (int)EQN__MAX; i++) { |
if (eqnparts[i].str.sz != sz) |
if ( ! EQNSTREQ(&eqnparts[i].str, start, sz)) |
continue; |
continue; |
if (strncmp(eqnparts[i].str.name, start, sz)) |
|
continue; |
|
return((*eqnparts[i].fp)(ep) ? EQN_OK : EQN_ERR); |
return((*eqnparts[i].fp)(ep) ? EQN_OK : EQN_ERR); |
} |
} |
|
|
if (1 == sz && 0 == strncmp("{", start, 1)) { |
if (STRNEQ(start, sz, "{", 1)) { |
if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) { |
if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) { |
if (EQN_ERR != c) |
if (EQN_ERR != c) |
EQN_MSG(MANDOCERR_EQNSCOPE, ep); |
EQN_MSG(MANDOCERR_EQNSCOPE, ep); |
Line 240 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
Line 372 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
eqn_rewind(ep); |
eqn_rewind(ep); |
start = eqn_nexttok(ep, &sz); |
start = eqn_nexttok(ep, &sz); |
assert(start); |
assert(start); |
if (1 == sz && 0 == strncmp("}", start, 1)) |
if (STRNEQ(start, sz, "}", 1)) |
return(EQN_OK); |
return(EQN_OK); |
EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); |
EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); |
return(EQN_ERR); |
return(EQN_ERR); |
} |
} |
|
|
for (i = 0; i < (int)EQNPILE__MAX; i++) { |
for (i = 0; i < (int)EQNPILE__MAX; i++) { |
if (eqnpiles[i].sz != sz) |
if ( ! EQNSTREQ(&eqnpiles[i], start, sz)) |
continue; |
continue; |
if (strncmp(eqnpiles[i].name, start, sz)) |
if (EQN_OK == (c = eqn_list(ep, last))) |
continue; |
|
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
|
EQN_MSG(MANDOCERR_EQNEOF, ep); |
|
return(EQN_ERR); |
|
} |
|
if (1 != sz || strncmp("{", start, 1)) { |
|
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
|
return(EQN_ERR); |
|
} |
|
|
|
while (EQN_DESCOPE == (c = eqn_eqn(ep, last))) { |
|
assert(last->last); |
|
last->last->pile = (enum eqn_pilet)i; |
last->last->pile = (enum eqn_pilet)i; |
eqn_rewind(ep); |
return(c); |
start = eqn_nexttok(ep, &sz); |
|
assert(start); |
|
if (5 != sz || strncmp("above", start, 5)) |
|
break; |
|
last->last->above = 1; |
|
} |
|
|
|
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 (1 == sz && 0 == strncmp("}", start, 1)) |
|
return(EQN_OK); |
|
|
|
EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); |
|
return(EQN_ERR); |
|
} |
} |
|
|
if (4 == sz && 0 == strncmp("left", start, 4)) { |
if (STRNEQ(start, sz, "left", 4)) { |
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
return(EQN_ERR); |
return(EQN_ERR); |
} |
} |
left = mandoc_strndup(start, sz); |
left = mandoc_strndup(start, sz); |
if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) |
c = eqn_eqn(ep, last); |
|
if (last->last) |
|
last->last->left = left; |
|
else |
|
free(left); |
|
if (EQN_DESCOPE != c) |
return(c); |
return(c); |
assert(last->last); |
assert(last->last); |
last->last->left = left; |
|
eqn_rewind(ep); |
eqn_rewind(ep); |
start = eqn_nexttok(ep, &sz); |
start = eqn_nexttok(ep, &sz); |
assert(start); |
assert(start); |
if (5 != sz || strncmp("right", start, 5)) |
if ( ! STRNEQ(start, sz, "right", 5)) |
return(EQN_DESCOPE); |
return(EQN_DESCOPE); |
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
Line 311 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
Line 414 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
} |
} |
|
|
for (i = 0; i < (int)EQNPOS__MAX; i++) { |
for (i = 0; i < (int)EQNPOS__MAX; i++) { |
if (eqnposs[i].sz != sz) |
if ( ! EQNSTREQ(&eqnposs[i], start, sz)) |
continue; |
continue; |
if (strncmp(eqnposs[i].name, start, sz)) |
|
continue; |
|
if (NULL == last->last) { |
if (NULL == last->last) { |
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
return(EQN_ERR); |
return(EQN_ERR); |
Line 328 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
Line 429 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
} |
} |
|
|
for (i = 0; i < (int)EQNMARK__MAX; i++) { |
for (i = 0; i < (int)EQNMARK__MAX; i++) { |
if (eqnmarks[i].sz != sz) |
if ( ! EQNSTREQ(&eqnmarks[i], start, sz)) |
continue; |
continue; |
if (strncmp(eqnmarks[i].name, start, sz)) |
|
continue; |
|
if (NULL == last->last) { |
if (NULL == last->last) { |
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
EQN_MSG(MANDOCERR_EQNSYNT, ep); |
return(EQN_ERR); |
return(EQN_ERR); |
Line 345 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
Line 444 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
} |
} |
|
|
for (i = 0; i < (int)EQNFONT__MAX; i++) { |
for (i = 0; i < (int)EQNFONT__MAX; i++) { |
if (eqnfonts[i].sz != sz) |
if ( ! EQNSTREQ(&eqnfonts[i], start, sz)) |
continue; |
continue; |
if (strncmp(eqnfonts[i].name, start, sz)) |
|
continue; |
|
if (EQN_EOF == (c = eqn_box(ep, last))) { |
if (EQN_EOF == (c = eqn_box(ep, last))) { |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
return(EQN_ERR); |
return(EQN_ERR); |
Line 357 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
Line 454 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
return(c); |
return(c); |
} |
} |
|
|
if (4 == sz && 0 == strncmp("size", start, 4)) { |
if (STRNEQ(start, sz, "size", 4)) { |
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
if (NULL == (start = eqn_nexttok(ep, &sz))) { |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
EQN_MSG(MANDOCERR_EQNEOF, ep); |
return(EQN_ERR); |
return(EQN_ERR); |
Line 373 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
Line 470 eqn_box(struct eqn_node *ep, struct eqn_box *last) |
|
|
|
bp = eqn_box_alloc(last); |
bp = eqn_box_alloc(last); |
bp->type = EQN_TEXT; |
bp->type = EQN_TEXT; |
|
for (i = 0; i < (int)EQNSYM__MAX; i++) |
|
if (EQNSTREQ(&eqnsyms[i].str, start, sz)) { |
|
sym[0] = '\\'; |
|
sym[1] = '('; |
|
sym[2] = '*'; |
|
sym[3] = eqnsyms[i].sym; |
|
sym[4] = '\0'; |
|
bp->text = mandoc_strdup(sym); |
|
return(EQN_OK); |
|
} |
|
|
bp->text = mandoc_strndup(start, sz); |
bp->text = mandoc_strndup(start, sz); |
return(EQN_OK); |
return(EQN_OK); |
} |
} |
Line 628 eqn_def_find(struct eqn_node *ep, const char *key, siz |
|
Line 736 eqn_def_find(struct eqn_node *ep, const char *key, siz |
|
int i; |
int i; |
|
|
for (i = 0; i < (int)ep->defsz; i++) |
for (i = 0; i < (int)ep->defsz; i++) |
if (ep->defs[i].keysz && ep->defs[i].keysz == sz && |
if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key, |
0 == strncmp(ep->defs[i].key, key, sz)) |
ep->defs[i].keysz, key, sz)) |
return(&ep->defs[i]); |
return(&ep->defs[i]); |
|
|
return(NULL); |
return(NULL); |