init.cpp

Go to the documentation of this file.

#include <../../nmodlconf.h>
/* /local/src/master/nrn/src/nmodl/init.c,v 4.5 1998/03/25 14:33:42 hines Exp */
 
#include "modl.h"
#include "parse1.hpp"
 
extern List* firstlist;
extern List* syminorder;
Symbol *semi, *beginblk, *endblk;
List* intoken;
char buf[NRN_BUFSIZE]; /* volatile temporary buffer */
 
static struct { /* Keywords */
    char* name;
    short kval;
} keywords[] = {"VERBATIM",
                VERBATIM,
                "COMMENT",
                COMMENT,
                "TITLE",
                MODEL,
                "CONSTANT",
                CONSTANT,
                "PARAMETER",
                PARAMETER,
                "INDEPENDENT",
                INDEPENDENT,
                "ASSIGNED",
                DEPENDENT,
                "INITIAL",
                INITIAL1,
                "TERMINAL",
                TERMINAL,
                "DERIVATIVE",
                DERIVATIVE,
                "EQUATION",
                EQUATION,
                "BREAKPOINT",
                BREAKPOINT,
                "CONDUCTANCE",
                CONDUCTANCE,
                "SOLVE",
                SOLVE,
                "STATE",
                STATE,
                "STEPPED",
                STEPPED,
                "LINEAR",
                LINEAR,
                "NONLINEAR",
                NONLINEAR,
                "DISCRETE",
                DISCRETE,
                "FUNCTION",
                FUNCTION1,
                "FUNCTION_TABLE",
                FUNCTION_TABLE,
                "PROCEDURE",
                PROCEDURE,
                "PARTIAL",
                PARTIAL,
                "INT",
                INT,
                "DEL2",
                DEL2,
                "DEL",
                DEL,
                "LOCAL",
                LOCAL,
                "METHOD",
                USING,
                "STEADYSTATE",
                USING,
                "SENS",
                SENS,
                "STEP",
                STEP,
                "WITH",
                WITH,
                "FROM",
                FROM,
                "FORALL",
                FORALL1,
                "TO",
                TO,
                "BY",
                BY,
                "if",
                IF,
                "else",
                ELSE,
                "while",
                WHILE,
                "START",
                START1,
                "DEFINE",
                DEFINE1,
                "KINETIC",
                KINETIC,
                "CONSERVE",
                CONSERVE,
                "PLOT",
                PLOT,
                "VS",
                VS,
                "LAG",
                LAG,
                "RESET",
                RESET,
                "MATCH",
                MATCH,
                "MODEL_LEVEL",
                MODEL_LEVEL, /* inserted by merge */
                "SWEEP",
                SWEEP,
                "FIRST",
                FIRST,
                "LAST",
                LAST,
                "COMPARTMENT",
                COMPARTMENT,
                "LONGITUDINAL_DIFFUSION",
                LONGDIFUS,
                "PUTQ",
                PUTQ,
                "GETQ",
                GETQ,
                "IFERROR",
                IFERROR,
                "SOLVEFOR",
                SOLVEFOR,
                "UNITS",
                UNITS,
                "UNITSON",
                UNITSON,
                "UNITSOFF",
                UNITSOFF,
                "TABLE",
                TABLE,
                "DEPEND",
                DEPEND,
                "NEURON",
                NEURON,
                "SUFFIX",
                SUFFIX,
                "POINT_PROCESS",
                SUFFIX,
                "ARTIFICIAL_CELL",
                SUFFIX,
                "NONSPECIFIC_CURRENT",
                NONSPECIFIC,
                "ELECTRODE_CURRENT",
                ELECTRODE_CURRENT,
                "SECTION",
                SECTION,
                "RANGE",
                RANGE,
                "USEION",
                USEION,
                "READ",
                READ,
                "WRITE",
                WRITE,
                "VALENCE",
                VALENCE,
                "CHARGE",
                VALENCE,
                "GLOBAL",
                GLOBAL,
                "POINTER",
                POINTER,
                "BBCOREPOINTER",
                BBCOREPOINTER,
                "EXTERNAL",
                EXTERNAL,
                "INCLUDE",
                INCLUDE1,
                "CONSTRUCTOR",
                CONSTRUCTOR,
                "DESTRUCTOR",
                DESTRUCTOR,
                "NET_RECEIVE",
                NETRECEIVE,
                "BEFORE",
                BEFORE, /* before NEURON sets up cy' = f(y,t) */
                "AFTER",
                AFTER, /* after NEURON solves cy' = f(y, t) */
                "WATCH",
                WATCH,
                "FOR_NETCONS",
                FOR_NETCONS,
                "THREADSAFE",
                THREADSAFE,
                "PROTECT",
                PROTECT,
                "MUTEXLOCK",
                NRNMUTEXLOCK,
                "MUTEXUNLOCK",
                NRNMUTEXUNLOCK,
                "REPRESENTS",
                REPRESENTS,
                0,
                0};
 
/*
 * the following special output tokens are used to make the .c file barely
 * readable
 */
static struct { /* special output tokens */
    char* name;
    short subtype;
    Symbol** p;
} special[] = {";", SEMI, &semi, "{", BEGINBLK, &beginblk, "}", ENDBLK, &endblk, 0, 0, 0};
 
static struct { /* numerical methods */
    char* name;
    long subtype; /* All the types that will work with this */
    short varstep;
} methods[] = {"adams",
               DERF | KINF,
               0,
               "runge",
               DERF | KINF,
               0,
               "euler",
               DERF | KINF,
               0,
               "adeuler",
               DERF | KINF,
               1,
               "heun",
               DERF | KINF,
               0,
               "adrunge",
               DERF | KINF,
               1,
               "gear",
               DERF | KINF,
               1,
               "newton",
               NLINF,
               0,
               "simplex",
               NLINF,
               0,
               "simeq",
               LINF,
               0,
               "seidel",
               LINF,
               0,
               "_advance",
               KINF,
               0,
               "sparse",
               KINF,
               0,
               "derivimplicit",
               DERF,
               0, /* name hard wired in deriv.c */
               "cnexp",
               DERF,
               0, /* see solve.c */
               "clsoda",
               DERF | KINF,
               1, /* Tolerance built in to scopgear.c */
               "after_cvode",
               0,
               0,
               "cvode_t",
               0,
               0,
               "cvode_t_v",
               0,
               0,
               0,
               0,
               0};
 
static char* extdef[] = {/* external names that can be used as doubles
                          * without giving an error message */
#include "extdef.h"
                         0};
 
static char* extdef2[] = {/* external function names that can be used
                           * with array and function name arguments  */
#include "extdef2.h"
                          0};
 
static char* extdef3[] = {/* function names that get two reset arguments
                           * added */
                          "threshold",
                          "squarewave",
                          "sawtooth",
                          "revsawtooth",
                          "ramp",
                          "pulse",
                          "perpulse",
                          "step",
                          "perstep",
                          "stepforce",
                          "schedule",
                          0};
 
static char* extdef4[] = {/* functions that need a first arg of NrnThread* */
                          "at_time",
                          0};
 
static char* extdef5[] = {/* the extdef names that are not threadsafe */
#include "extdef5.h"
                          0};
 
List *constructorfunc, *destructorfunc;
 
void init() {
    int i;
    Symbol* s;
 
    symbol_init();
    for (i = 0; keywords[i].name; i++) {
        s = install(keywords[i].name, keywords[i].kval);
        s->subtype = KEYWORD;
    }
    for (i = 0; methods[i].name; i++) {
        s = install(methods[i].name, METHOD);
        s->subtype = methods[i].subtype;
        s->u.i = methods[i].varstep;
    }
    for (i = 0; special[i].name; i++) {
        s = install(special[i].name, SPECIAL);
        *(special[i].p) = s;
        s->subtype = special[i].subtype;
    }
    for (i = 0; extdef[i]; i++) {
        s = install(extdef[i], NAME);
        s->subtype = EXTDEF;
    }
    for (i = 0; extdef2[i]; i++) {
        s = install(extdef2[i], NAME);
        s->subtype = EXTDEF2;
    }
    for (i = 0; extdef3[i]; i++) {
        s = lookup(extdef3[i]);
        assert(s && (s->subtype & EXTDEF));
        s->subtype |= EXTDEF3;
    }
    for (i = 0; extdef4[i]; i++) {
        s = lookup(extdef4[i]);
        assert(s && (s->subtype & EXTDEF));
        s->subtype |= EXTDEF4;
    }
    for (i = 0; extdef5[i]; i++) {
        s = lookup(extdef5[i]);
        assert(s);
        s->subtype |= EXTDEF5;
    }
    intoken = newlist();
    initfunc = newlist();
    modelfunc = newlist();
    termfunc = newlist();
    procfunc = newlist();
    initlist = newlist();
    firstlist = newlist();
    syminorder = newlist();
    plotlist = newlist();
    constructorfunc = newlist();
    destructorfunc = newlist();
#if NMODL
    nrninit();
#endif
}