cmd/eqn/lookup.c

	lookup.c revision 779fc935796a940997d18b31d64a9fec9c6b40f6
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved. The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include "e.h"
#include "e.def"
#include <locale.h>

#define TBLSIZE 100

tbl *keytbl[TBLSIZE];   /* key words */
tbl *restbl[TBLSIZE];   /* reserved words */
tbl *deftbl[TBLSIZE];   /* user-defined names */

struct {
    char    *key;
    int keyval;
} keyword[] = {
    "sub",  SUB,
    "sup",  SUP,
    ".EN",  EOF,
    "from",     FROM,
    "to",   TO,
    "sum",  SUM,
    "hat",  HAT,
    "vec", VEC,
    "dyad", DYAD,
    "dot",  DOT,
    "dotdot",   DOTDOT,
    "bar",  BAR,
    "tilde",    TILDE,
    "under",    UNDER,
    "prod",     PROD,
    "int",  INT,
    "integral",     INT,
    "union",    UNION,
    "inter",    INTER,
    "pile",     PILE,
    "lpile",    LPILE,
    "cpile",    CPILE,
    "rpile",    RPILE,
    "over",     OVER,
    "sqrt",     SQRT,
    "above",    ABOVE,
    "size",     SIZE,
    "font",     FONT,
    "fat", FAT,
    "roman",    ROMAN,
    "italic",   ITALIC,
    "bold",     BOLD,
    "left",     LEFT,
    "right",    RIGHT,
    "delim",    DELIM,
    "define",   DEFINE,

#ifdef  NEQN    /* make ndefine synonym for define, tdefine a no-op */

    "tdefine",  TDEFINE,
    "ndefine",  DEFINE,

#else       /* tdefine = define, ndefine = no-op */

    "tdefine",  DEFINE,
    "ndefine",  NDEFINE,

#endif

    "gsize",    GSIZE,
    ".gsize",   GSIZE,
    "gfont",    GFONT,
    "include",  INCLUDE,
    "up",   UP,
    "down",     DOWN,
    "fwd",  FWD,
    "back",     BACK,
    "mark",     MARK,
    "lineup",   LINEUP,
    "matrix",   MATRIX,
    "col",  COL,
    "lcol",     LCOL,
    "ccol",     CCOL,
    "rcol",     RCOL,
    0,  0
};

struct {
    char    *res;
    char    *resval;
} resword[] = {
    ">=",   "\\(>=",
    "<=",   "\\(<=",
    "==",   "\\(==",
    "!=",   "\\(!=",
    "+-",   "\\(+-",
    "->",   "\\(->",
    "<-",   "\\(<-",
    "inf",  "\\(if",
    "infinity", "\\(if",
    "partial",  "\\(pd",
    "half", "\\f1\\(12\\fP",
    "prime",    "\\f1\\(fm\\fP",
    "dollar",   "\\f1$\\fP",
    "nothing",  "",
    "times",    "\\(mu",
    "del",  "\\(gr",
    "grad", "\\(gr",
#ifdef  NEQN
    "<<",   "<<",
    ">>",   ">>",
    "approx",   "~\b\\d~\\u",
    "cdot", "\\v'-.5'.\\v'.5'",
    "...",  "...",
    ",...,",    ",...,",
#else
    "<<",   "<\\h'-.3m'<",
    ">>",   ">\\h'-.3m'>",
    "approx",   "\\v'-.2m'\\z\\(ap\\v'.25m'\\(ap\\v'-.05m'",
    "cdot", "\\v'-.3m'.\\v'.3m'",
    "...",  "\\v'-.3m'\\ .\\ .\\ .\\ \\v'.3m'",
    ",...,",    ",\\ .\\ .\\ .\\ ,\\|",
#endif

    "alpha",    "\\(*a",
    "beta", "\\(*b",
    "gamma",    "\\(*g",
    "GAMMA",    "\\(*G",
    "delta",    "\\(*d",
    "DELTA",    "\\(*D",
    "epsilon",  "\\(*e",
    "EPSILON",  "\\f1E\\fP",
    "omega",    "\\(*w",
    "OMEGA",    "\\(*W",
    "lambda",   "\\(*l",
    "LAMBDA",   "\\(*L",
    "mu",   "\\(*m",
    "nu",   "\\(*n",
    "theta",    "\\(*h",
    "THETA",    "\\(*H",
    "phi",  "\\(*f",
    "PHI",  "\\(*F",
    "pi",   "\\(*p",
    "PI",   "\\(*P",
    "sigma",    "\\(*s",
    "SIGMA",    "\\(*S",
    "xi",   "\\(*c",
    "XI",   "\\(*C",
    "zeta", "\\(*z",
    "iota", "\\(*i",
    "eta",  "\\(*y",
    "kappa",    "\\(*k",
    "rho",  "\\(*r",
    "tau",  "\\(*t",
    "omicron",  "\\(*o",
    "upsilon",  "\\(*u",
    "UPSILON",  "\\(*U",
    "psi",  "\\(*q",
    "PSI",  "\\(*Q",
    "chi",  "\\(*x",
    "and",  "\\f1and\\fP",
    "for",  "\\f1for\\fP",
    "if",   "\\f1if\\fP",
    "Re",   "\\f1Re\\fP",
    "Im",   "\\f1Im\\fP",
    "sin",  "\\f1sin\\fP",
    "cos",  "\\f1cos\\fP",
    "tan",  "\\f1tan\\fP",
    "sec",  "\\f1sec\\fP",
    "csc",  "\\f1csc\\fP",
    "arc",  "\\f1arc\\fP",
    "asin", "\\f1asin\\fP",
    "acos", "\\f1acos\\fP",
    "atan", "\\f1atan\\fP",
    "asec", "\\f1asec\\fP",
    "acsc", "\\f1acsc\\fP",
    "sinh", "\\f1sinh\\fP",
    "coth", "\\f1coth\\fP",
    "tanh", "\\f1tanh\\fP",
    "cosh", "\\f1cosh\\fP",
    "lim",  "\\f1lim\\fP",
    "log",  "\\f1log\\fP",
    "max",  "\\f1max\\fP",
    "min",  "\\f1min\\fP",
    "ln",   "\\f1ln\\fP",
    "exp",  "\\f1exp\\fP",
    "det",  "\\f1det\\fP",
    0,  0
};

/* find name in tbl. if defn non-null, install */
tbl *
lookup(tbl **tblp, char *name, char *defn)
{
    tbl *p;
    int h;
    unsigned char *s = (unsigned char *)name;
    char *malloc();

    for (h = 0; *s != '\0'; )
        h += *s++;
    h %= TBLSIZE;

    for (p = tblp[h]; p != NULL; p = p->next)
        if (strcmp(name, p->name) == 0) {   /* found it */
            if (defn != NULL)
                p->defn = defn;
            return (p);
        }
    /* didn't find it */
    if (defn == NULL)
        return (NULL);
    p = (tbl *) malloc(sizeof (tbl));
    if (p == NULL)
        error(FATAL, gettext("out of space in lookup"), NULL);
    p->name = name;
    p->defn = defn;
    p->next = tblp[h];
    tblp[h] = p;
    return (p);
}

void
init_tbl(void)  /* initialize all tables */
{
    int i;

    for (i = 0; keyword[i].key != NULL; i++)
        lookup(keytbl, keyword[i].key, (char *)keyword[i].keyval);
    for (i = 0; resword[i].res != NULL; i++)
        lookup(restbl, resword[i].res, resword[i].resval);
}