cmd/eqn/lookup.c

	lookup.c revision b5cda42e4451eb63c27c9fb170e50e628aa89257
/*
 * 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);
}