Return to eval.c CVS log

Up to [local] / OpenXM_contrib / gnuplot

Annotation of OpenXM_contrib/gnuplot/eval.c, Revision 1.1.1.1

1.1       maekawa     1: #ifndef lint
                      2: static char *RCSid = "$Id: eval.c,v 1.15 1998/03/22 22:31:30 drd Exp $";
                      3: #endif
                      4:
                      5: /* GNUPLOT - eval.c */
                      6:
                      7: /*[
                      8:  * Copyright 1986 - 1993, 1998   Thomas Williams, Colin Kelley
                      9:  *
                     10:  * Permission to use, copy, and distribute this software and its
                     11:  * documentation for any purpose with or without fee is hereby granted,
                     12:  * provided that the above copyright notice appear in all copies and
                     13:  * that both that copyright notice and this permission notice appear
                     14:  * in supporting documentation.
                     15:  *
                     16:  * Permission to modify the software is granted, but not the right to
                     17:  * distribute the complete modified source code.  Modifications are to
                     18:  * be distributed as patches to the released version.  Permission to
                     19:  * distribute binaries produced by compiling modified sources is granted,
                     20:  * provided you
                     21:  *   1. distribute the corresponding source modifications from the
                     22:  *    released version in the form of a patch file along with the binaries,
                     23:  *   2. add special version identification to distinguish your version
                     24:  *    in addition to the base release version number,
                     25:  *   3. provide your name and address as the primary contact for the
                     26:  *    support of your modified version, and
                     27:  *   4. retain our contact information in regard to use of the base
                     28:  *    software.
                     29:  * Permission to distribute the released version of the source code along
                     30:  * with corresponding source modifications in the form of a patch file is
                     31:  * granted with same provisions 2 through 4 for binary distributions.
                     32:  *
                     33:  * This software is provided "as is" without express or implied warranty
                     34:  * to the extent permitted by applicable law.
                     35: ]*/
                     36:
                     37:
                     38: #include "plot.h"
                     39:
                     40:
                     41: struct udvt_entry *
                     42:  add_udv(t_num)                        /* find or add value and return pointer */
                     43: int t_num;
                     44: {
                     45:     register struct udvt_entry **udv_ptr = &first_udv;
                     46:
                     47:     /* check if it's already in the table... */
                     48:
                     49:     while (*udv_ptr) {
                     50:        if (equals(t_num, (*udv_ptr)->udv_name))
                     51:            return (*udv_ptr);
                     52:        udv_ptr = &((*udv_ptr)->next_udv);
                     53:     }
                     54:
                     55:     *udv_ptr = (struct udvt_entry *)
                     56:        gp_alloc((unsigned long) sizeof(struct udvt_entry), "value");
                     57:     (*udv_ptr)->next_udv = NULL;
                     58:     copy_str((*udv_ptr)->udv_name, t_num, MAX_ID_LEN);
                     59:     (*udv_ptr)->udv_value.type = INTGR;                /* not necessary, but safe! */
                     60:     (*udv_ptr)->udv_undef = TRUE;
                     61:     return (*udv_ptr);
                     62: }
                     63:
                     64:
                     65: struct udft_entry *
                     66:  add_udf(t_num)                        /* find or add function and return pointer */
                     67: int t_num;                     /* index to token[] */
                     68: {
                     69:     register struct udft_entry **udf_ptr = &first_udf;
                     70:
                     71:     int i;
                     72:     while (*udf_ptr) {
                     73:        if (equals(t_num, (*udf_ptr)->udf_name))
                     74:            return (*udf_ptr);
                     75:        udf_ptr = &((*udf_ptr)->next_udf);
                     76:     }
                     77:
                     78:     /* get here => not found. udf_ptr points at first_udf or
                     79:      * next_udf field of last udf
                     80:      */
                     81:
                     82:     if (standard(t_num))
                     83:        int_warn("Warning : udf shadowed by built-in function of the same name", t_num);
                     84:
                     85:     /* create and return a new udf slot */
                     86:
                     87:     *udf_ptr = (struct udft_entry *)
                     88:        gp_alloc((unsigned long) sizeof(struct udft_entry), "function");
                     89:     (*udf_ptr)->next_udf = (struct udft_entry *) NULL;
                     90:     (*udf_ptr)->definition = NULL;
                     91:     (*udf_ptr)->at = NULL;
                     92:     copy_str((*udf_ptr)->udf_name, t_num, MAX_ID_LEN);
                     93:     for (i = 0; i < MAX_NUM_VAR; i++)
                     94:        (void) Ginteger(&((*udf_ptr)->dummy_values[i]), 0);
                     95:     return (*udf_ptr);
                     96: }
                     97:
                     98:
                     99: int standard(t_num)            /* return standard function index or 0 */
                    100: int t_num;
                    101: {
                    102:     register int i;
                    103:     for (i = (int) SF_START; ft[i].f_name != NULL; i++) {
                    104:        if (equals(t_num, ft[i].f_name))
                    105:            return (i);
                    106:     }
                    107:     return (0);
                    108: }
                    109:
                    110:
                    111:
                    112: void execute_at(at_ptr)
                    113: struct at_type *at_ptr;
                    114: {
                    115:     register int i, index, count, offset;
                    116:
                    117:     count = at_ptr->a_count;
                    118:     for (i = 0; i < count;) {
                    119:        index = (int) at_ptr->actions[i].index;
                    120:        offset = (*ft[index].func) (&(at_ptr->actions[i].arg));
                    121:        if (is_jump(index))
                    122:            i += offset;
                    123:        else
                    124:            i++;
                    125:     }
                    126: }
                    127:
                    128: /*
                    129:
                    130:    'ft' is a table containing C functions within this program.
                    131:
                    132:    An 'action_table' contains pointers to these functions and arguments to be
                    133:    passed to them.
                    134:
                    135:    at_ptr is a pointer to the action table which must be executed (evaluated)
                    136:
                    137:    so the iterated line exectues the function indexed by the at_ptr and
                    138:    passes the address of the argument which is pointed to by the arg_ptr
                    139:
                    140:  */