postcoms.c File Reference

#include "spice.h"
#include "ftedefs.h"
#include "scedio.h"

Include dependency graph for postcoms.c:

Go to the source code of this file.

Functions
static struct dvec *	copyvec ()
static void	pvec ()
static int	dcomp ()
void	com_let (wordlist *wl)
void	com_unlet (wordlist *wl)
void	com_load (wordlist *wl)
void	com_print (wordlist *wl)
void	com_write (wordlist *wl)
static struct dvec *	copyvec (struct dvec *d)
void	com_display (wordlist *wl)
static void	pvec (struct dvec *d)
void	com_splot (wordlist *wl)
static int	dcomp (struct dvec **v1, struct dvec **v2)
void	com_cross (wordlist *wl)
void	com_destroy (wordlist *wl)

Function Documentation

void com_cross

(

wordlist *

wl

)

Definition at line 1127 of file postcoms.c.

{
    char *newvec, *s;
    struct dvec *n, *v;
    struct pnode *pn, *p0;
    struct dvlist *dl, *tl, *dl0;
    int i, ind;
    bool comp = false;
    double *d;

    newvec = wl->wl_word;
    wl = wl->wl_next;
    s = wl->wl_word;
    if (!(d = ft_numparse(&s, false))) {
        fprintf(cp_err, "Error: bad number %s\n", wl->wl_word);
        return;
    }
    if ((ind = *d) < 0) {
        fprintf(cp_err, "Error: bad index %d\n", ind);
        return;
    }
    wl = wl->wl_next;
    p0 = ft_getpnames(wl, true);
    if (p0 == NULL)
        return;

    dl0 = NULL;
    for (pn = p0; pn; pn = pn->pn_next) {
        if ((n = ft_evaluate(pn)) == NULL) {
            inp_pnfree(p0);
            vec_dlfree(dl0);
            return;
        }
        if (!dl0)
            dl0 = dl = alloc(struct dvlist);
        else {
            dl->dl_next = alloc(struct dvlist);
            dl = dl->dl_next;
        }
        if (n->v_link2) {
            for (tl = n->v_link2; tl; tl = tl->dl_next) {
                dl->dl_dvec = tl->dl_dvec;
                if (tl->dl_next) {
                    dl->dl_next = alloc(struct dvlist);
                    dl = dl->dl_next;
                }
            }
        }
        else
            dl->dl_dvec = n;
    }
    inp_pnfree(p0);

    for (dl = dl0; dl; dl = dl->dl_next) {
        if (iscomplex(dl->dl_dvec))
            comp = true;
        i++;
    }
    
    vec_remove(newvec);
    v = alloc(struct dvec);
    v->v_name = copy(newvec);
    v->v_type = dl0->dl_dvec ? dl0->dl_dvec->v_type : SV_NOTYPE;
    v->v_length = i;
    v->v_flags = comp ? VF_COMPLEX : VF_REAL;
    vec_newperm(v);
    if (comp)
        v->v_compdata = (complex *) tmalloc(i * sizeof (complex));
    else
        v->v_realdata = (double *) tmalloc(i * sizeof (double));
    
    /* Now copy the ind'ths elements into this one. */
    for (dl = dl0, i = 0; dl; dl = dl->dl_next, i++) {
        n = dl->dl_dvec;
        if (n->v_length > ind) {
            if (comp) {
                realpart(&v->v_compdata[i]) =
                        realpart(&n->v_compdata[ind]);
                imagpart(&v->v_compdata[i]) =
                        imagpart(&n->v_compdata[ind]);
            }
            else
                v->v_realdata[i] = n->v_realdata[ind];
        }
        else {
            if (comp) {
                realpart(&v->v_compdata[i]) = 0.0;
                imagpart(&v->v_compdata[i]) = 0.0;
            }
            else
                v->v_realdata[i] = 0.0;
        }
    }
    cp_addkword(CT_VECTOR, v->v_name);
    vec_dlfree(dl0);
    return;
}

void com_destroy

(

wordlist *

wl

)

Definition at line 1229 of file postcoms.c.

{
    struct plot *pl, *npl = NULL;

    if (!wl) {
        if (!eq(plot_cur->pl_typename, "constants") && !plot_cur->pl_active)
            plot_delete(plot_cur);
    }
    else if (eq(wl->wl_word, "all")) {
        for (pl = plot_list; pl; pl = npl) {
            npl = pl->pl_next;
            if (!eq(pl->pl_typename, "constants") && !pl->pl_active)
                plot_delete(pl);
        }
    }
    else {
        while (wl) {
            for (pl = plot_list; pl; pl = pl->pl_next)
                if (eq(pl->pl_typename, wl->wl_word))
                    break;
            if (pl && !pl->pl_active)
                plot_delete(pl);
            else
                fprintf(cp_err, "Error: no such plot %s\n",
                        wl->wl_word);
            wl = wl->wl_next;
        }
    }
    return;
}

void com_display

(

wordlist *

wl

)

Definition at line 878 of file postcoms.c.

{
    struct dvec *d;
    struct dvlist *dl;
    wordlist *tl, *tl0;
    int len;
    bool b;
    char *s;
    extern char *kw_nosort;

    /* Maybe he wants to know about just a few vectors. */

    while (wl) {
        s = copy(wl->wl_word);
        cp_unquote(s);
        d = vec_get(s);
        tfree(s);
        if (d == NULL)
            fprintf(cp_err, "Error: no such vector as %s.\n", 
                wl->wl_word);
        else {
            if (d->v_link2) {
                for (dl = d->v_link2; dl; dl = dl->dl_next)
                    pvec(dl->dl_dvec);
            }
            else
                pvec(d);
        }
        if (wl->wl_next == NULL)
            return;
        wl = wl->wl_next;
    }
    if (!plot_cur) {
        fprintf(cp_err,"Error (internal): no current plot\n");
        return;
    }

    tl0 = (wordlist*)htab_wl(plot_cur->pl_hashtab);
    if (!tl0) {
        out_printf("There are no vectors currently active.\n");
        return;
    }
    if (!cp_getvar(kw_nosort, VT_BOOL, (char *) &b))
        wl_sort(tl0);
    out_printf("Here are the vectors currently active:\n\n");
    out_printf("Title: %s\n",  plot_cur->pl_title);
    out_printf("Name: %s (%s)\nDate: %s\n\n", 
        plot_cur->pl_typename, plot_cur->pl_name, 
        plot_cur->pl_date);

    /* list scale first */
    for (tl = tl0; tl; tl = tl->wl_next) {
        if (eq(tl->wl_word,plot_cur->pl_scale->v_name)) {
            d = (struct dvec*)htab_get(tl->wl_word,plot_cur->pl_hashtab);
            pvec(d);
            break;
        }
    }
    for (tl = tl0; tl; tl = tl->wl_next) {
        if (!eq(tl->wl_word,plot_cur->pl_scale->v_name)) {
            d = (struct dvec*)htab_get(tl->wl_word,plot_cur->pl_hashtab);
            pvec(d);
        }
    }
    wl_free(tl0);
    return;
}

void com_let

(

wordlist *

wl

)

Definition at line 28 of file postcoms.c.

{
    char *p, *q, *s;
    int indices[MAXDIMS];
    int numdims;
    wordlist word;
    int need_open, depth;
    int offset, size, rsize;
    struct pnode *nn;
    struct dvec *n, *t;
    int i, j;
    int d1, d2;
    char *rhs;

    word.wl_next = NULL;

    if (!wl) {
        com_display((wordlist *) NULL);
        return;
    }

    p = wl_flatten(wl);

    if (rhs = strchr(p, '=')) {
        *rhs++ = 0;
    }
    else {
        fprintf(cp_err, "Error: bad let syntax\n");
        goto quit;
    }

    /* sanity check */
    if (eq(p, "all") || strchr(p, '@')) {
        fprintf(cp_err, "Error: bad variable name %s\n", p);
        goto quit;
    }

    /* extract indices */
    numdims = 0;
    if (s = strchr(p, '[')) {
        need_open = 0;
        *s++ = 0;
        while (!need_open || *s == '[') {
            depth = 0;
            if (need_open)
                s++;
            for (q = s; *q && (*q != ']' && *q != ',' || depth > 0); q++) {
                switch (*q) {
                    case '[':
                        depth += 1;
                        break;
                    case ']':
                        depth -= 1;
                        break;
                }
            }

            if (depth != 0 || !*q) {
                printf("Error: bad syntax specifying index\n");
                goto quit;
            }

            if (*q == ']')
                need_open = 1;
            else
                need_open = 0;
            if (*q)
                *q++ = 0;

            /* evaluate expression between s and q */
            word.wl_word = s;
            if ((nn = ft_getpnames(&word, true)) == NULL)
                goto quit;
            if ((t = ft_evaluate(nn)) == NULL)
                goto quit;
            inp_pnfree(nn);

            if (!isreal(t) || t->v_link2 || t->v_length != 1 ||
                    !t->v_realdata) {
                fprintf(cp_err, "Error: index is not a scalar.\n");
                goto quit;
            }
            j = t->v_realdata[0]; /* ignore sanity checks for now */

            if (j < 0) {
                printf("Error: negative index (%d) is not allowed\n", j);
                goto quit;
            }

            indices[numdims++] = j;

            for (s = q; *s && isspace(*s); s++)
            ;
        }
    }
    /* vector name at p */

    for (q = p + strlen(p) - 1; *q <= ' ' && p <= q; q--)
    ;

    *++q = 0;

    /* evaluate rhs */
    word.wl_word = rhs;
    if ((nn = ft_getpnames(&word, true)) == NULL)
        goto quit;
    if ((t = ft_evaluate(nn)) == NULL)
        goto quit;
    inp_pnfree(nn);

    if (t->v_link2) {
        fprintf(cp_err, "Warning: extra wildcard values ignored\n");
        t = t->v_link2->dl_dvec;
    }

    /* make sure dims are ok for unit dimension */
    if (t->v_numdims <= 1) {
        t->v_numdims = 1;
        t->v_dims[0] = t->v_length;
    }
    if (numdims + t->v_numdims > MAXDIMS) {
        fprintf(cp_err,"Error: too many dimensions\n");
        goto quit;
    }

    n = vec_get(p);

    if (!n) {

        /* Create and assign a new vector. If a range was specified,
         * create a vector of the dimensionality and size to contain
         * the data.  The least significant dimension given is added
         * to the most significant dimension of the vector being assigned.
         * The entries not explicitly assigned are zero. E.g.,
         * let a[2] = b.  If b is a 1d vector of length n, a will be a
         * 1d vector of length n+2 with entries (0, 0, b[0], b[1], ...).
         * If b has dimensions [x][y][z], a will have dimensions
         * [x+2][y][z].  for let a[2][3] = b, a will have dimensions
         * [2+1][x+3][y][z], etc.
         */
        n = alloc(struct dvec);
        n->v_name = copy(p);
        n->v_type = t->v_type;
        n->v_flags = t->v_flags;
        n->v_defcolor = t->v_defcolor;
        n->v_gridtype = t->v_gridtype;
        n->v_plottype = t->v_plottype;

        vec_newperm(n);

        i = 0;
        if (numdims) {
            for ( ; i < numdims - 1; i++) {
                n->v_dims[i] = indices[i] + 1;
            }
            n->v_dims[numdims-1] = indices[numdims-1];
        }
        if (t->v_numdims <= 1) {
            n->v_dims[i] += t->v_length;
            n->v_numdims = numdims ? numdims : 1;
        }
        else {
            n->v_dims[i] += t->v_dims[0];
            for (i++,j = 1; j < t->v_numdims; i++,j++) {
                n->v_dims[i] = t->v_dims[j];
            }
            n->v_numdims = i;
        }

        size = 1;
        for (i = 0; i < n->v_numdims; i++)
            size *= n->v_dims[i];
        rsize = 1;
        for (i = 0; i < t->v_numdims; i++)
            rsize *= t->v_dims[i];
        /* rsize should be t->v_length, but maybe not... */
        offset = size - rsize;

        if (offset < 0 || rsize < t->v_length) {
            fprintf(cp_err, "Error: internal, bad length\n");
            vec_remove(n->v_name);
            goto quit;
        }

        n->v_length = size;
        if (isreal(t)) {
            n->v_realdata = (double *) tmalloc(size * sizeof(double));
            DCOPY(t->v_realdata,n->v_realdata + offset,t->v_length);
        }
        else {
            n->v_compdata = (complex *) tmalloc(size * sizeof(complex));
            CCOPY(t->v_compdata,n->v_compdata + offset,t->v_length);
        }
        cp_addkword(CT_VECTOR, n->v_name);
        goto quit;
    }

    if (numdims == 0) {
        /* reuse vector n, copy stuff from t */

        if (isreal(t)) {
            if (n->v_length != t->v_length || iscomplex(n)) {
                if (isreal(n))
                    txfree((char*)n->v_realdata);
                else
                    txfree((char*)n->v_compdata);
                n->v_realdata = (double *) tmalloc(sizeof (double) *
                    t->v_length);
            }
            DCOPY(t->v_realdata, n->v_realdata, t->v_length);
        }
        else {
            if (n->v_length != t->v_length || isreal(n)) {
                if (isreal(n))
                    txfree((char*)n->v_realdata);
                else
                    txfree((char*)n->v_compdata);
                n->v_compdata = (complex *) tmalloc(sizeof (complex) *
                    t->v_length);
            }
            CCOPY(t->v_compdata, n->v_compdata, t->v_length);
        }
        n->v_type = t->v_type;
        n->v_flags = t->v_flags;
        n->v_scale = t->v_scale;
        n->v_numdims = t->v_numdims;
        for (i = 0; i < t->v_numdims; i++)
            n->v_dims[i] = t->v_dims[i];
        n->v_length = t->v_length;
        goto quit;
    }

    /* make sure dims are ok for unit dimension */
    if (n->v_numdims <= 1) {
        n->v_numdims = 1;
        n->v_dims[0] = n->v_length;
    }

    /* Here we copy into an existing vector, expanding the size if
     * necessary. The given indices except the least significant must
     * be within the range of n, and "point" to a submatrix with the
     * same dimensionality as t.  However, if t is a 1-d vector,
     * t is copied into n at the index, if it will fit, but if n is
     * a 1-d vector n is extended if necessary. Values not explicitly
     * set remain as they were, and new values created are zero.
     */

    if (numdims > n->v_numdims || t->v_numdims > n->v_numdims) {
        fprintf(cp_err,"Error: can't set %s to higher dimension\n",
            n->v_name);
        goto quit;
    }
    for (i = 0; i < numdims-1; i++) {
        if (indices[i] >= n->v_dims[i]) {
            fprintf(cp_err,"Error: dimension spec. out of range for %s\n",
                n->v_name);
            goto quit;
        }
    }
    if (t->v_numdims > 1) {
        for (i = numdims, j = 1; j < t->v_numdims; i++,j++) {
            if (i >= n->v_numdims || n->v_dims[i] != t->v_dims[j]) {
                fprintf(cp_err,
                    "Error: subdimension of %s is incompatible with %s\n",
                    n->v_name,t->v_name);
                goto quit;
            }
        }
    }
    else if (n->v_numdims > 1) {
        if (n->v_numdims - numdims > 1) {
            fprintf(cp_err,"Error: too few dimensions specified\n");
            goto quit;
        }

        /* will t fit in block? */
        if (n->v_numdims == numdims)
            i = indices[numdims-1];
        else
            i = 0;

        if (t->v_dims[0] + i > n->v_dims[n->v_numdims-1]) {
            fprintf(cp_err,
                "Error: operation would overflow block in %s\n",
                n->v_name);
            goto quit;
        }
    }

    offset = 0;
    size = 1;
    for (i = n->v_numdims-1; i >= 0; i--) {
        if (i < numdims)
            offset += indices[i]*size;
        size *= n->v_dims[i];
    }
    rsize = 1;
    for (i = 0; i < t->v_numdims; i++)
        rsize *= t->v_dims[i];
    /* rsize should be t->v_length, but maybe not... */
    if (rsize < t->v_length) {
        fprintf(cp_err, "Error: internal, bad length\n");
        goto quit;
    }

    /* fix the dimension */
    j = numdims-1;
    i = indices[j];
    if (n->v_numdims > t->v_numdims)
        i++;
    else
        i += t->v_dims[0];
    if (n->v_dims[j] < i)
        n->v_dims[j] = i;

    if (offset + rsize > n->v_length) {
        /* have to allocate more space */
        n->v_length = offset + rsize;
        if (isreal(n))
            n->v_realdata = (double*)trealloc((char*)n->v_realdata,
                n->v_length*sizeof(double));
        else
            n->v_compdata = (complex*)trealloc((char*)n->v_compdata,
                n->v_length*sizeof(complex));
    }

    if (isreal(n)) {
        if (isreal(t)) {
            DCOPY(t->v_realdata,n->v_realdata + offset,t->v_length);
        }
        else {
            for (i = 0,j = offset; i < t->v_length; i++,j++)
                n->v_realdata[j] = realpart(&t->v_compdata[i]);
        }
    }
    else {
        if (isreal(t)) {
            for (i = 0,j = offset; i < t->v_length; i++,j++) {
                n->v_compdata[j].cx_real = t->v_realdata[i];
                n->v_compdata[j].cx_imag = 0.0;
            }
        }
        else {
            CCOPY(t->v_compdata,n->v_compdata + offset,t->v_length);
        }
    }

quit:
    txfree(p);
    return;
}

void com_load

(

wordlist *

wl

)

Definition at line 401 of file postcoms.c.

{

    if (!wl)
        ft_loadfile(ft_rawfile);
    else
        while (wl) {
            char *s = copy(wl->wl_word);
            cp_unquote(s);
            ft_loadfile(s);
            txfree(s);
            wl = wl->wl_next;
        }
    return;
}

void com_print

(

wordlist *

wl

)

Definition at line 421 of file postcoms.c.

{
    struct dvec *v, *bv;
    struct dvlist *tl, *bl, *dl, *dl0, xl;
    int i, j, ll, width = 0, height = 0, npoints, lineno;
    struct pnode *n0;
    struct plot *p;
    bool col = true, nobreak = false, noprintscale, plotnames = false;
    bool optgiven = false;
    char *s, buf[BSIZE_SP], buf2[BSIZE_SP];
    extern char *kw_nobreak, *kw_noprintscale;


    if (wl == NULL)
        return;
    if (eq(wl->wl_word, "col")) {
        col = true;
        optgiven = true;
        wl = wl->wl_next;
    }
    else if (eq(wl->wl_word, "line")) {
        col = false;
        optgiven = true;
        wl = wl->wl_next;
    }

    n0 = ft_getpnames(wl, true);
    if (n0 == NULL)
        return;
    dl0 = ft_dvlist(n0);
    if (dl0 == NULL)
        return;

    /* See whether we really have to print plot names. */
    p = dl0->dl_dvec->v_plot;
    for (dl = dl0->dl_next; dl; dl = dl->dl_next) {
        if (p != dl->dl_dvec->v_plot) {
            plotnames = true;
            break;
        }
    }
    
    if (!optgiven) {
        /* Figure out whether col or line should be used... */
        col = false;
        for (dl = dl0; dl; dl = dl->dl_next) {
            if (dl->dl_dvec->v_length > 1) {
                col = true;
                break;
            }
        }
    }

    out_send("\n");
    if (!col) {
        for (dl = dl0; dl; dl = dl->dl_next) {
            v = dl->dl_dvec;
            s = vec_basename(v);
            if (plotnames) {
                (void) sprintf(buf, "%s.%s", v->v_plot->pl_typename,s);
            }
            else {
                (void) strcpy(buf, s);
            }
            txfree(s);
            for (s = buf; *s; s++)
                ;
            s--;
            while (isspace(*s)) {
                *s = '\0';
                s--;
            }
            ll = 10;
            if (v->v_length == 1) {
                if (isreal(v)) {
                    out_printf("%s = %s\n", buf,
                        printnum(*v->v_realdata));
                }
                else {
                    out_printf("%s = %s",buf,
                        printnum(realpart(v->v_compdata)));
                    out_printf(",%s\n",
                        printnum(imagpart(v->v_compdata)));
                }
            }
            else {
                out_printf("%s = (  ", buf);
                for (i = 0; i < v->v_length; i++)
                    if (isreal(v)) {
                        (void) strcpy(buf,
                           printnum(v->v_realdata[i]));
                        out_send(buf);
                        ll += strlen(buf);
                        ll = (ll + 7) / 8;
                        ll = ll * 8 + 1;
                        if (ll > 60) {
                            out_send("\n\t");
                            ll = 9;
                        }
                        else
                            out_send("\t");
                    }
                    else {
                        (void) sprintf(buf, "%s",
                            printnum(realpart(&v->v_compdata[i])));
                        (void) sprintf(buf+strlen(buf), ",%s",
                            printnum(imagpart(&v->v_compdata[i])));
                        out_send(buf);
                        ll += strlen(buf);
                        ll = (ll + 7) / 8;
                        ll = ll * 8 + 1;
                        if (ll > 60) {
                            out_send("\n\t");
                            ll = 9;
                        }
                        else
                            out_send("\t");
                    }
                out_send(")\n");
            }
        }
    }
    else {    /* Print in columns. */
        if (out_isatty)
            out_winsize(&width,&height);
        else {
            if (out_width > 0)
                width = out_width;
            else
                width = DEF_WIDTH;
            if (out_height > 0)
                height = out_height;
            else
                height = DEF_HEIGHT;
        }
        if (width < 40)
            width = 40;
        if (height < 20)
            height = 20;
        if (!cp_getvar(kw_nobreak, VT_BOOL, (char *) &nobreak) &&
                !ft_nopage && !out_isatty)
            nobreak = false;
        else
            nobreak = true;
        (void) cp_getvar(kw_noprintscale, VT_BOOL, (char *) 
                &noprintscale);

        bv = dl0->dl_dvec;
        bl = dl0;
nextpage:
        /* Make the first vector of every page be the scale... */

        if (!noprintscale && bv->v_plot->pl_ndims) {
            if (bv->v_plot->pl_scale && !vec_eq(bv, bv->v_plot->pl_scale)) {
                xl.dl_dvec = bv->v_plot->pl_scale;
                xl.dl_next = bl;
                bl = &xl;
                bv = xl.dl_dvec;
            }
        }
        ll = 8;
        for (dl = bl; dl; dl = dl->dl_next) {
            if (isreal(dl->dl_dvec))
                ll += 16;   /* Two tabs for real, */
            else
                ll += 32;   /* 4 for complex. */
            /* Make sure we have at least 2 vectors per page... */
            if ((ll > width) && (dl != bl) && (dl != bl->dl_next))
                break;
        }

        /* Print the header on the first page only. */
        p = bv->v_plot;
        j = (width - strlen(p->pl_title)) / 2;
        for (i = 0; i < j; i++)
            buf2[i] = ' ';
        buf2[j] = '\0';
        out_send(buf2);
        out_send(p->pl_title);
        out_send("\n");
        out_send(buf2);
        (void) sprintf(buf, "%s  %s", p->pl_name, p->pl_date);
        j = (width - strlen(buf)) / 2;
        out_send(buf);
        out_send("\n");
        for (i = 0; i < width; i++)
            buf2[i] = '-';
        buf2[width] = '\n';
        buf2[width+1] = '\0';
        out_send(buf2);
        (void) sprintf(buf, "Index   ");
        for (tl = bl; tl && tl != dl; tl = tl->dl_next) {
            v = tl->dl_dvec;
            if (isreal(v))
                (void) sprintf(buf2, "%-16.15s", v->v_name);
            else
                (void) sprintf(buf2, "%-32.31s", v->v_name);
            (void) strcat(buf, buf2);   
        }
        lineno = 3;
        j = 0;
        npoints = 0;
        for (tl = bl; tl && tl != dl; tl = tl->dl_next) {
            v = tl->dl_dvec;
            if (v->v_length > npoints)
                npoints = v->v_length;
        }
pbreak:
        /* New page. */
        out_send(buf);
        out_send("\n");
        for (i = 0; i < width; i++)
            buf2[i] = '-';
        buf2[width] = '\n';
        buf2[width+1] = '\0';
        out_send(buf2);
        lineno += 2;
loop:
        while ((j < npoints) && (lineno < height)) {
            out_printf("%d\t", j);
            for (tl = bl; tl && tl != dl; tl = tl->dl_next) {
                v = tl->dl_dvec;
                if (v->v_length <= j) {
                    if (isreal(v))
                        out_send("\t\t");
                    else
                        out_send("\t\t\t\t");
                }
                else {
                    if (isreal(v)) {
                        out_printf("%e\t",v->v_realdata[j]);
                    }
                    else {
                        out_printf("%e,\t%e\t",
                            realpart(&v->v_compdata[j]),
                            imagpart(&v->v_compdata[j]));
                    }
                }
            }
            out_send("\n");
            j++;
            lineno++;
        }
        if ((j == npoints) && (dl == NULL)) /* No more to print. */
            goto done;
        if (j == npoints) { /* More vectors to print. */
            bl = dl;
            bv = bl->dl_dvec;
            out_send("\f\n");   /* Form feed. */
            goto nextpage;
        }

        /* Otherwise go to a new page. */
        lineno = 0;
        if (nobreak)
            goto loop;
        else
            out_send("\f\n");   /* Form feed. */
        goto pbreak;
    }
done:
    out_send("\n");
    vec_dlfree(dl0);
    return;
}

void com_splot

(

wordlist *

wl

)

Definition at line 1032 of file postcoms.c.

{
    struct plot *p;
    char buf[BSIZE_SP], *s;
    char *zz = "Type the name of the desired plot: ";

    if (wl == NULL) {
        out_printf("        new        New plot\n");
        for (p = plot_list; p; p = p->pl_next) {
            if (plot_cur == p)
                out_printf("Current %-11s%-20s (%s)\n",
                p->pl_typename, p->pl_title, p->pl_name);
            else
                out_printf("        %-11s%-20s (%s)\n",
                    p->pl_typename, p->pl_title, p->pl_name);
        }
        out_send("\n");
        (void) SCEDfgets(buf,BSIZE_SP,cp_in,zz);

        for (s = buf; *s && !isspace(*s); s++)
            ;
        *s = '\0';
    }
    else {
        (void) strcpy(buf, wl->wl_word);
    }
    if (prefix("new", buf)) {
        p = plot_alloc("unknown");
        p->pl_title = copy("Anonymous");
        p->pl_name = copy("unknown");
        p->pl_next = plot_list;
        plot_list = p;
    }
    else {
        for (p = plot_list; p; p = p->pl_next)
            if (plot_prefix(buf, p->pl_typename))
                break;
        if (!p) {
            fprintf(cp_err, "Error: no such plot.\n");
            return;
        }
    }
    plot_cur->pl_ccom = cp_kwswitch(CT_VECTOR, p->pl_ccom);
    plot_cur = p;
    plot_docoms(plot_cur->pl_commands);
    if (wl)
        out_printf("%s %s (%s)\n", p->pl_typename, p->pl_title,
                p->pl_name);
    return;
}

void com_unlet

(

wordlist *

wl

)

Definition at line 386 of file postcoms.c.

{
    while (wl) {
        vec_remove(wl->wl_word);
        wl = wl->wl_next;
    }
    return;
}

void com_write

(

wordlist *

wl

)

Definition at line 699 of file postcoms.c.

{
    char *file, buf[BSIZE_SP];
    struct dvec *d, *vv;
    struct dvlist *dl, *dn, *dp, *dl0;
    struct pnode *names;
    struct plot *tpl, newplot;
    wordlist *wl0, *tl, *tll;
    bool oct = false;
    bool ascii = AsciiRawFile;
    bool scalefound, appendwrite;
    extern char *kw_filetype, *kw_appendwrite;

    if (wl) {
        file = wl->wl_word;
        wl = wl->wl_next;
    }
    else
        file = ft_rawfile;
    if (cp_getvar(kw_filetype, VT_STRING, buf)) {
        if (eq(buf, "binary"))
            ascii = false;
        else if(eq(buf,"oct")) 
            oct = true;
        else if (!eq(buf, "ascii"))
            fprintf(cp_err, "Warning: strange file type %s\n", buf);
    }
    (void) cp_getvar(kw_appendwrite, VT_BOOL, (char *) &appendwrite);

    if (!wl) {
        /* just dump the current plot */
        raw_write(file, plot_cur, appendwrite, ascii ? false : true);
        plot_cur->pl_written = true;
        return;
    }

    if ((names = ft_getpnames(wl, true)) == NULL)
        return;
    if ((dl0 = ft_dvlist(names)) == NULL)
        return;

    /* Now we have to write them out plot by plot. */

    while (dl0) {

        tpl = dl0->dl_dvec->v_plot;
        tpl->pl_written = true;
        bcopy((char *) tpl, (char *) &newplot, sizeof (struct plot));
        newplot.pl_dvecs = NULL;
        newplot.pl_hashtab = NULL;
        scalefound = false;

        /* Figure out how many vectors are in this plot. Also look
         * for the scale, or a copy of it, which may have a different
         * name.
         */
        for (dl = dl0; dl; dl = dl->dl_next) {
            d = dl->dl_dvec;
            if (d->v_plot == tpl) {
                vv = copyvec(d);
                txfree(vv->v_name);
                vv->v_name = vec_basename(d);
                if (newplot.pl_hashtab == NULL)
                    newplot.pl_hashtab = htab_init();
                htab_add(vv->v_name,(void*)vv,newplot.pl_hashtab);
                if (vec_eq(d, tpl->pl_scale)) {
                    newplot.pl_scale = vv;
                    scalefound = true;
                }
            }
        }

        /* Maybe we shouldn't make sure that the default scale is
         * present if nobody uses it.
         */
        if (!scalefound) {
            vv = copyvec(tpl->pl_scale);
            txfree(vv->v_name);
            vv->v_name = vec_basename(tpl->pl_scale);
            newplot.pl_scale = vv;
            htab_add(vv->v_name,(void*)vv,newplot.pl_hashtab);
        }

        /* Now let's go through and make sure that everything that 
         * has its own scale has it in the plot.
         */
        for (;;) {
            scalefound = false;
            wl0 = htab_wl(newplot.pl_hashtab);
            for (tl = wl0; tl; tl = tl->wl_next) {
                d = (struct dvec *)htab_get(tl->wl_word,newplot.pl_hashtab);
                if (d->v_scale) {
                    for (tll = wl0; tll; tll = tll->wl_next) {
                        vv = (struct dvec *)htab_get(tll->wl_word,
                            newplot.pl_hashtab);
                        if (vec_eq(vv, d->v_scale)) {
                            d->v_scale = vv;
                            break;
                        }
                    }
                    if (!tll) {
                        /* We have to grab it... */
                        vv = copyvec(d->v_scale);
                        txfree(vv->v_name);
                        vv->v_name = vec_basename(d->v_scale);
                        htab_add(vv->v_name,(void*)vv,newplot.pl_hashtab);
                        d->v_scale = vv;
                        scalefound = true;
                    }
                }
            }
            wl_free(wl0);
            if (!scalefound)
                break;
            /* Otherwise loop through again... */
        }

        raw_write(file, &newplot, appendwrite, ascii ? false : true);

        /* Now throw out the vectors we have written already... */
        for (dp = NULL, dl = dl0; dl; dl = dn) {
            dn = dl->dl_next;
            if (dl->dl_dvec->v_plot == tpl) {
                if (dp == NULL)
                    dl0 = dn;
                else
                    dp->dl_next = dl->dl_next;
                txfree((char*)dl);
            }
            else
                dp = dl;
        }
        wl0 = (wordlist*)htab_list(newplot.pl_hashtab);
        /* wl_word -> char[2] = (name,*dvec) */
        for (tl = wl0; tl; tl = tl->wl_next) {
            vv = (struct dvec *)((char**)tl->wl_word)[1];
            tfree(vv->v_name);
            tfree(vv);
        }
        wl_free(wl0);
        htab_free(newplot.pl_hashtab,false);
        txfree((char*)newplot.pl_hashtab);

        /* If there are more plots we want them appended... */
        appendwrite = true;
    }
}

static struct dvec* copyvec ( )

static

static struct dvec* copyvec ( struct dvec *  d )

static

Definition at line 852 of file postcoms.c.

{
    int ltmp;
    struct dvec *v;

    if (!d)
        return (struct dvec *) NULL;
    ltmp = d->v_length;
    d->v_length = 0;
    v = vec_copy(d);
    d->v_length = ltmp;
    v->v_length = ltmp;
    if (isreal(v))
        v->v_realdata = d->v_realdata;
    else
        v->v_compdata = d->v_compdata;
    return (v);
}

static int dcomp ( )

static

static int dcomp ( struct dvec **  v1, struct dvec **  v2  )

static

Definition at line 1089 of file postcoms.c.

{
    return (strcmp((*v1)->v_name, (*v2)->v_name));
}

static void pvec ( )

static

static void pvec ( struct dvec *  d )

static

Definition at line 950 of file postcoms.c.

{
    int i;
    char buf[BSIZE_SP], buf2[BSIZE_SP];

    sprintf(buf, "    %-20s: %s, %s, %d long", d->v_name,
            ft_typenames(d->v_type), isreal(d) ? "real" :
            "complex", d->v_length);
    if (d->v_flags & VF_MINGIVEN) {
        sprintf(buf2, ", min = %lg", d->v_minsignal);
        strcat(buf, buf2);
    }
    if (d->v_flags & VF_MAXGIVEN) {
        sprintf(buf, ", max = %lg", d->v_maxsignal);
        strcat(buf, buf2);
    }
    switch (d->v_gridtype) {

        case GRID_LOGLOG:
        strcat(buf, ", grid = loglog");
        break;

        case GRID_XLOG:
        strcat(buf, ", grid = xlog");
        break;

        case GRID_YLOG:
        strcat(buf, ", grid = ylog");
        break;

        case GRID_POLAR:
        strcat(buf, ", grid = polar");
        break;

        case GRID_SMITH:
        strcat(buf, ", grid = smith");
        break;
    }
    switch (d->v_plottype) {

        case PLOT_COMB:
        strcat(buf, ", plot = comb");
        break;

        case PLOT_POINT:
        strcat(buf, ", plot = point");
        break;

    }
    if (d->v_defcolor) {
        sprintf(buf2, ", color = %s", d->v_defcolor);
        strcat(buf, buf2);
    }
    if (d->v_scale) {
        sprintf(buf2, ", scale = %s", d->v_scale->v_name);
        strcat(buf, buf2);
    }
    if (d->v_numdims > 1) {
        sprintf(buf2, ", dims = [");
        strcat(buf, buf2);
        for (i = 0; i < d->v_numdims; i++) {
            sprintf(buf2, "%d%s", d->v_dims[i],
                (i < d->v_numdims - 1) ? ", " : "]");
            strcat(buf, buf2);
        }
    }
    if (d->v_plot->pl_scale == d) {
        strcat(buf, " [default scale]\n");
    }
    else {
        strcat(buf, "\n");
    }
    out_send(buf);
    return;
}