cpitf.c File Reference

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

Include dependency graph for cpitf.c:

Go to the source code of this file.

Functions
static bool	testv ()
void	ft_cpinit ()
bool	cp_istrue (wordlist *wl)
static bool	testv (struct dvec *v)
void	cp_periodic ()
void	cp_doquit ()
bool	cp_oddcomm (char *s, wordlist *wl)
bool	cp_block (char *s)
void	cp_bind (char *name)
void	cp_unbind (char *name)

Function Documentation

void cp_bind

(

char *

name

)

Definition at line 386 of file cpitf.c.

{
    if (ft_curckt) {
        if (name)
            ft_curckt->ci_contblk = copy(name);
        else
            ft_curckt->ci_contblk = NULL;
    }
    else {
        if (!ft_nutmeg)
            (void)fprintf(cp_err,"Error: no current circuit.\n");
    }
}

bool cp_block

(

char *

s

)

Definition at line 367 of file cpitf.c.

{
    FILE *fp;
    char buf[128];

    if (fp = inp_pathopen(s, "r")) {
        (void) fclose(fp);
        strcpy(buf,s);
        strcat(buf," -n");
        inp_source(buf);
        return (true);
    }
    return (false);
}

void cp_doquit

(

)

Definition at line 329 of file cpitf.c.

{
    com_quit((wordlist *) NULL);
    return;
}

bool cp_istrue

(

wordlist *

wl

)

Definition at line 256 of file cpitf.c.

{
    struct dvec *v;
    struct pnode *pn;
    struct dvlist *dl;

    /* First do all the csh-type stuff here... */
    wl = wl_copy(wl);
    cp_variablesubst(&wl);
    cp_bquote(&wl);
    cp_striplist(wl);

    pn = ft_getpnames(wl, true);
    wl_free(wl);
    if (pn == NULL)
        return (false);
    v = ft_evaluate(pn);
    inp_pnfree(pn);

    if (v->v_link2) {
        /* It makes no sense to say while (all), but what the heck... */
        for (dl = v->v_link2; dl; dl = dl->dl_next) {
            if (testv(dl->dl_dvec))
                return (true);
        }
    }
    else {
        if (testv(v))
            return (true);
    }
    return (false);
}

bool cp_oddcomm	(	char *	s,
		wordlist *	wl
	)

Definition at line 342 of file cpitf.c.

{
    FILE *fp;

    if (fp = inp_pathopen(s, "r")) {
        (void) fclose(fp);
        cp_pusharg(wl);
        inp_source(s);
        cp_poparg();
        return (true);
    }
    if (strchr(wl->wl_word,'=') ||
        (wl->wl_next && *wl->wl_next->wl_word == '=')) {
        com_let(wl);
        return (true);
    }
    return (false);
}

void cp_periodic

(

)

Definition at line 318 of file cpitf.c.

{
    ft_setflag = ft_intrpt = false;
    ft_ckspace();
    ft_checkkids();
    vec_gc();
    return;
}

void cp_unbind

(

char *

name

)

Definition at line 404 of file cpitf.c.

{
    struct circ *ct;

    for (ct = ft_circuits; ct; ct = ct->ci_next) {
        if (ct->ci_contblk && eq(ct->ci_contblk,name))
            tfree(ct->ci_contblk);
    }
}

void ft_cpinit

(

)

Definition at line 21 of file cpitf.c.

{
    wordlist *wl;
    wordlist wl1, wl2, wl3;
    bool found = false, t = true;
    char buf[BSIZE_SP], **x, *s, *r;
    struct comm *c;
    int i;
    FILE *fp;
    double dv;
    static char *predefs[] = {
        "yes",      "1",
        "true",     "1",
        "no",       "0",
        "false",    "0",
        "pi",       "3.14159265358979323846",
        "e",        "2.71828182844590452353",
        "c",        "2.997925e8",
        "i",        "0,1",
        "kelvin",   "-273.15",
        "echarge",  "1.60219e-19",
        "boltz",    "1.38062e-23",
        "planck",   "6.62620e-34"
    } ;
    static char *udfs[] = {
        "max(x,y)", "(x gt y) * x + (x le y) * y",
        "min(x,y)", "(x lt y) * x + (x ge y) * y",
        "vdb(x)",   "db(v(x))",
        "vdb(x,y)", "db(v(x) - v(y))",
        "vi(x)",    "im(v(x))",
        "vi(x,y)",  "im(v(x) - v(y))",
        "vm(x)",    "mag(v(x))",
        "vm(x,y)",  "mag(v(x) - v(y))",
        "vp(x)",    "ph(v(x))",
        "vp(x,y)",  "ph(v(x) - v(y))",
        "vr(x)",    "re(v(x))",
        "vr(x,y)",  "re(v(x) - v(y))"
    } ;

    cp_ccon(true);  /* So the user can type ahead... */
    cp_init();

    if (!cp_nocc) {
        /* Add commands... */
        for (c = cp_coms; c->co_func; c++) {
            if (c->co_spiceonly && ft_nutmeg)
                continue;
            cp_addcomm(c->co_comname, c->co_cctypes[0],
                    c->co_cctypes[1], c->co_cctypes[2],
                    c->co_cctypes[3]);
            cp_addkword(CT_COMMANDS, c->co_comname);
        }
        /* And keywords... These are the ones that are constant... */
        if (!ft_nutmeg) {
            cp_addkword(CT_LISTINGARGS, "deck");
            cp_addkword(CT_LISTINGARGS, "logical");
            cp_addkword(CT_LISTINGARGS, "physical");
            cp_addkword(CT_LISTINGARGS, "expand");

            cp_addkword(CT_STOPARGS, "when");
            cp_addkword(CT_STOPARGS, "after");
        }

        cp_addkword(CT_PLOT, "new");

        cp_addkword(CT_PLOTKEYWORDS, "combplot");
        cp_addkword(CT_PLOTKEYWORDS, "lingrid");
        cp_addkword(CT_PLOTKEYWORDS, "linplot");
        cp_addkword(CT_PLOTKEYWORDS, "loglog");
        cp_addkword(CT_PLOTKEYWORDS, "nogrid");
        cp_addkword(CT_PLOTKEYWORDS, "nointerp");
        cp_addkword(CT_PLOTKEYWORDS, "pointplot");
        cp_addkword(CT_PLOTKEYWORDS, "polar");
        cp_addkword(CT_PLOTKEYWORDS, "samep");
        cp_addkword(CT_PLOTKEYWORDS, "smith");
        cp_addkword(CT_PLOTKEYWORDS, "title");
        cp_addkword(CT_PLOTKEYWORDS, "vs");
        cp_addkword(CT_PLOTKEYWORDS, "xcomp");
        cp_addkword(CT_PLOTKEYWORDS, "xcompress");
        cp_addkword(CT_PLOTKEYWORDS, "xdel");
        cp_addkword(CT_PLOTKEYWORDS, "xdelta");
        cp_addkword(CT_PLOTKEYWORDS, "xind");
        cp_addkword(CT_PLOTKEYWORDS, "xindices");
        cp_addkword(CT_PLOTKEYWORDS, "xlabel");
        cp_addkword(CT_PLOTKEYWORDS, "xlimit");
        cp_addkword(CT_PLOTKEYWORDS, "xlog");
        cp_addkword(CT_PLOTKEYWORDS, "ydel");
        cp_addkword(CT_PLOTKEYWORDS, "ydelta");
        cp_addkword(CT_PLOTKEYWORDS, "ylabel");
        cp_addkword(CT_PLOTKEYWORDS, "ylimit");
        cp_addkword(CT_PLOTKEYWORDS, "ylog");

        cp_addkword(CT_RUSEARGS, "accept");
        cp_addkword(CT_RUSEARGS, "all");
        cp_addkword(CT_RUSEARGS, "elapsed");
        cp_addkword(CT_RUSEARGS, "everything");
        cp_addkword(CT_RUSEARGS, "faults");
        cp_addkword(CT_RUSEARGS, "fillin");
        cp_addkword(CT_RUSEARGS, "loadtime");
        cp_addkword(CT_RUSEARGS, "lutime");
        cp_addkword(CT_RUSEARGS, "matsize");
        cp_addkword(CT_RUSEARGS, "nonzero");
        cp_addkword(CT_RUSEARGS, "rejected");
        cp_addkword(CT_RUSEARGS, "solvetime");
        cp_addkword(CT_RUSEARGS, "space");
        cp_addkword(CT_RUSEARGS, "time");
        cp_addkword(CT_RUSEARGS, "totaltime");
        cp_addkword(CT_RUSEARGS, "totiter");
        cp_addkword(CT_RUSEARGS, "traniter");
        cp_addkword(CT_RUSEARGS, "tranpoints");
        cp_addkword(CT_RUSEARGS, "transolvetime");
        cp_addkword(CT_RUSEARGS, "trantime");

        cp_addkword(CT_VECTOR, "all");

        for (i = 0; ; i++) {
            if (!(s = ft_typenames(i)))
                break;
            cp_addkword(CT_TYPENAMES, s);
        }
    }

    cp_vset("program", VT_STRING, cp_program);

    /* Make the prompt use only the last component of the path... */

    if (DIR_TERM) {
        for (s = cp_program; s && *s; s++)
            ;
        s--;
        while ((s > cp_program) && (*s != DIR_TERM))
            s--;
        if (*s == DIR_TERM)
            s++;
        (void) strcpy(buf, s);
        for (s = buf; *s && (*s != '.'); s++)
            ;
        *s = '\0';
        (void) strcat(buf, " ! -> ");
    }
    else
        (void) sprintf(buf, "%s ! -> ", cp_program);

    cp_vset("prompt", VT_STRING, buf);
    cp_vset("noglob", VT_BOOL, (char *) &t);

    /* set these to a default (used in decks for loop and check
     * commands)
     */
    dv = 0.0;
    cp_vset("value1", VT_REAL, (char*)&dv);
    cp_vset("value2", VT_REAL, (char*)&dv);

    /* Now do a bunch of things that used to be in the spiceinit file
     * but were too slow to read in...
     */
    wl1.wl_next = &wl2;
    wl1.wl_prev = NULL;
    wl2.wl_next = NULL;
    wl2.wl_prev = &wl1;
    wl1.wl_word = "if";
    wl2.wl_word = "1";
    cp_setalias("begin", &wl1);
    wl1.wl_next = NULL;
    wl1.wl_word = "end";
    cp_setalias("endif", &wl1);
    cp_setalias("endwhile", &wl1);
    cp_setalias("endforeach", &wl1);
    cp_setalias("endrepeat", &wl1);
    cp_setalias("enddowhile", &wl1);
    wl1.wl_word = "help";
    cp_setalias("?", &wl1);

    wl1.wl_next = &wl2;
    wl2.wl_next = &wl3;
    wl2.wl_prev = &wl1;
    wl3.wl_prev = &wl2;
    wl3.wl_next = NULL;
    wl2.wl_word = "=";
    for (i = 0; i < sizeof (predefs) / sizeof (char *); i += 2) {
        wl1.wl_word = predefs[i];
        wl3.wl_word = predefs[i + 1];
        com_let(&wl1);
    }

    wl2.wl_next = NULL;
    for (i = 0; i < sizeof (udfs) / sizeof (char *); i += 2) {
        wl1.wl_word = udfs[i];
        wl2.wl_word = udfs[i + 1];
        com_define(&wl1);
    }

    /* Reset this for the front end. */
    cp_hash = '*';

    if (Lib_Path && *Lib_Path) {
        (void) sprintf(buf, "sourcepath = ( %s %s )", DIR_CWD, Lib_Path);
        wl = cp_lexer(buf);
        cp_doglob(&wl);
        cp_striplist(wl);
        com_set(wl);
        wl_free(wl);

        /* Now source the standard startup file. */
        s = Lib_Path;
        while (*s) {
            while (isspace(*s))
                s++;
            for (r = buf; *s && !isspace(*s); r++, s++)
                *r = *s;
            *r++ = '/';
            (void) strcpy(r, "spinit");
            cp_pathfix(buf);
            if (fp = fopen(buf, "r")) {
                cp_interactive = false;
                inp_spsource(fp, true, buf);
                cp_interactive = true;
                (void) fclose(fp);
                found = true;
                break;
            }
            else if (ft_controldb)
                fprintf(cp_err, "Note: can't open \"%s\".\n", buf);
        }
        if (!found)
            fprintf(cp_err, "Note: can't find init file.\n");
    }

    return;
}

static bool testv ( )

static

static bool testv ( struct dvec *  v )

static

Definition at line 293 of file cpitf.c.

{
    int i;

    if (isreal(v)) {
        for (i = 0; i < v->v_length; i++)
            if (v->v_realdata[i] != 0.0) {
                return (true);
            }
    }
    else {
        for (i = 0; i < v->v_length; i++)
            if ((realpart(&v->v_compdata[i]) != 0.0) ||
                (imagpart(&v->v_compdata[i]) != 0.0)) {
                return (true);
            }
    }
    return (false);
}