hocdec.h

Go to the documentation of this file.

#ifndef hocdec_h
#define hocdec_h
#define INCLUDEHOCH 1
#define OOP 1


#include    <stdio.h>
#include    "nrnapi.h"
#include    "hocassrt.h" /* hoc_execerror instead of abort */
#include "nrnassrt.h" /* assert in case of side effects (eg. scanf) */
#include    <string.h>

#define gargstr hoc_gargstr
#define getarg hoc_getarg

/* the dec alpha cxx doesn't understand struct foo* inside a struct */

#if defined(__cplusplus)
#define HocStruct /**/
#define HocTypedef /**/
#define HocUnion /**/
union Inst;
struct Symbol;
struct Arrayinfo;
struct Proc;
struct Symlist;
union Datum;
struct cTemplate;
union Objectdata;
struct Object;
struct hoc_Item;
#else
#define HocStruct struct
#define HocUnion union
#define HocTypedef typedef
#endif

typedef int (*Pfri)(void);
typedef void    (*Pfrv)(void);
typedef double  (*Pfrd)(void);
typedef struct Object** (*Pfro)(void);
typedef const char** (*Pfrs)(void);

typedef int (*Pfri_vp)(void*);
typedef void    (*Pfrv_vp)(void*);
typedef double  (*Pfrd_vp)(void*);
typedef struct Object** (*Pfro_vp)(void*);
typedef const char** (*Pfrs_vp)(void*);

typedef union Inst { /* machine instruction list type */
    Pfrv    pf;
    Pfrd    pfd;
    Pfro    pfo;
    Pfrs    pfs;
    Pfrv_vp pfv_vp;
    Pfrd_vp pfd_vp;
    Pfro_vp pfo_vp;
    Pfrs_vp pfs_vp;
    HocUnion Inst   *in;
    HocStruct Symbol    *sym;
    void*   ptr;
    int i;
} Inst;

#define STOP    (Inst *)0

typedef struct Arrayinfo  { /* subscript info for arrays */
    unsigned *a_varn;   /* dependent variable number for array elms */
    int nsub;       /* number of subscripts */
    int refcount;   /* because one object always uses symbol's */
    int sub[1];     /* subscript range */
} Arrayinfo;

typedef struct Proc {
    Inst    defn;   /* FUNCTION, PROCEDURE, FUN_BLTIN */
    unsigned long size; /* length of instruction list */
    HocStruct Symlist   *list;  /* For constants and strings */
                /* not used by FUN_BLTIN */
    int nauto;      /* total # local variables */
    int nobjauto;   /* the last of these are pointers to objects */
} Proc;

typedef struct Symlist {
    HocStruct Symbol *first;
    HocStruct Symbol *last;
}Symlist;

typedef char    *Upoint;

# define    NOTUSER     0
# define    USERINT     1   /* For subtype */
# define    USERDOUBLE  2
#define     USERPROPERTY    3   /* for newcable non-range variables */
#define     USERFLOAT   4   /* John Miller's NEMO uses floats */
#if NEMO
#define     NEMONODE    5   /* looks syntactically like vector */
#define     NEMOAREA    6   /* looks like vector */
#endif
#define     SYMBOL      7   /* for stack type */
#define     OBJECTTMP   8   /* temporary object on stack */
#define     STKOBJ_UNREF    9   /* already unreffed temporary object on stack */
#define     DYNAMICUNITS    10  /* {modern, legacy} units pair */
#define     CPLUSOBJECT 16  /* c++ registered class */
#define     JAVAOBJECT  32  /* c++ registered class */
/* above two are bits, next must start at 64 */
#define OBJECTALIAS 1
#define VARALIAS 2

typedef struct HocSymExtension {
    float *parmlimits;  /* some variables have suggested bounds */
    char* units;
    float tolerance;    /* some states have cvode absolute tolerance */
}HocSymExtension;

typedef struct Symbol { /* symbol table entry */
    char    *name;
    short   type;
    short   subtype;    /* Flag for user integers */
/**
 * Note: `public` is a reserved keyword. Keeping following __cplusplus comments a bit longer
 * for future reference,  with upcoming work for NMODL + eventual mod files to support cpp.
 */
//#if defined(__cplusplus)
    short   cpublic;        /* flag set public variable */
//#else
//  short   public;     /* flag set public variable */
//#endif
    short   defined_on_the_fly;/* moved here because otherwize gcc and borland do not align the same way */
    union {
        int oboff;  /* offset into object data pointer space */
#if 0 /* these are now found via oboff. */
        char    *str;       /* STRING */
        HocStruct Object **objvar; /* possibly an array of object variables */
#endif
        double  *pval;      /* User defined doubles - also for alias to scalar */
        HocStruct Object* object_;  /* alias to an object */
        char    *cstr;      /* constant string */
        double  *pnum;      /* Numbers */
        int *pvalint;   /* User defined integers */
        float   *pvalfloat; /* User defined floats */
        int u_auto;     /* stack offset # for AUTO variable */
        double  (*ptr)(double); /* if BLTIN */ //TODO: double as parameter?
        Proc    *u_proc;
        struct {
            short type; /* Membrane type to find Prop */
            int index;  /* prop->param[index] */
        }rng;
        HocStruct Symbol **ppsym;   /* Pointer to symbol pointer array */
//#if defined(__cplusplus)
        HocStruct cTemplate *ctemplate;
//#else
//      HocStruct cTemplate *template;
//#endif
        HocStruct Symbol* sym;  /* for external */
    } u;
    unsigned   s_varn;  /* dependent variable number - 0 means indep */
    Arrayinfo *arayinfo;    /* ARRAY information if null then scalar */
    HocSymExtension* extra; /* additions to symbol allow compatibility
                    with old nmodl dll's */
    HocStruct Symbol    *next;  /* to link to another */
} Symbol;
#define ISARRAY(arg)    (arg->arayinfo != (Arrayinfo *)0)


#ifndef hoc_list_h
#if defined(__cplusplus)
#define hoc_List struct hoc_Item
#else
typedef struct hoc_Item hoc_List;
#define List hoc_List
#define Item hoc_Item
#endif
#endif

typedef union Datum {   /* interpreter stack type */
    double  val;
    Symbol  *sym;
    int i;
    double  *pval;  /* first used with Eion in NEURON */
    HocStruct Object **pobj;
    HocStruct Object *obj;  /* sections keep this to construct a name */
    char    **pstr;
    HocStruct hoc_Item* itm;
    hoc_List* lst;
    void* _pvoid;   /* not used on stack, see nrnoc/point.cpp */
} Datum;

#if OOP
//#if defined(__cplusplus)
typedef struct cTemplate {
//#else
//typedef struct Template {
//#endif
    Symbol *sym;
    Symlist *symtable;
    int dataspace_size;
    int is_point_; /* actually the pointtype > 0 if a point process */
    Symbol *init;   /* null if there is no initialization function */
    Symbol *unref;  /* null if there is no function to call when refcount is decremented */
    int index;  /* next  unique integer used for name for section */
    int count;  /* how many of this kind of object */
    hoc_List* olist;    /* list of all instances */
    int id;
    void* observers;    /* hook to c++ ClassObservable */
    void* (*constructor)(struct Object*);
    void (*destructor)(void*);
    void (*steer)(void*);   /* normally nil */
    int (*checkpoint)(void**);
//#if defined(__cplusplus)
} cTemplate;
//#else
//}
//#endif

typedef union Objectdata{
    double *pval;   /* pointer to array of doubles, usually just 1 */
    char **ppstr;   /* pointer to pointer to string ,allows vectors someday*/
    HocStruct Object **pobj;    /* pointer to array of object pointers, usually just 1*/
    HocStruct hoc_Item** psecitm;   /* array of pointers to section items, usually just 1 */
    hoc_List** plist;   /* array of pointers to linked lists */
    Arrayinfo* arayinfo;
    void* _pvoid;       /* Point_process */
}Objectdata;

typedef struct Object {
    int refcount;       /* how many object variables point to this */
    int index;      /* unique integer used for names of sections */
    union {
    Objectdata *dataspace;  /* Points to beginning of object's data */
    void* this_pointer; /* the c++ object */
    }u;
#if defined(__cplusplus)
    cTemplate *ctemplate;
#else
    cTemplate *template;
#endif
    void* aliases;  /* more convenient names for e.g. Vector or List elements dynamically created by this object*/
    HocStruct hoc_Item* itm_me;/* this object in the template list */
    HocStruct hoc_Item* secelm_; /* last of a set of contiguous section_list items used by forall */
    void* observers;    /* hook to c++ ObjObservable */
    short recurse;      /* to stop infinite recursions */
    short unref_recurse_cnt; /* free only after last return from unref callback */
} Object;
#endif

typedef struct {        /* User Functions */
    const char  *name;
    void    (*func)(void);
} VoidFunc;

typedef struct {        /* User Double Scalars */
    const char  *name;
    double  *pdoub;
} DoubScal;

typedef struct {        /* User Vectors */
    const char  *name;
    double  *pdoub;
    int index1;
} DoubVec;

typedef struct {        /* recommended limits for symbol values */
    const char  *name;
    float   bnd[2];
} HocParmLimits;

typedef struct {        /* recommended tolerance for CVODE */
    const char  *name;
    float tolerance;
} HocStateTolerance;

typedef struct {        /* units for symbol values */
    const char  *name;
    char    *units;
} HocParmUnits;

#include "oc_ansi.h"

#if defined(__cplusplus)
extern "C" {
#endif

extern void* emalloc(size_t n);
extern void* ecalloc(size_t n, size_t size);
extern void* erealloc(void* ptr, size_t n);

#if defined(__cplusplus)
}
#endif


extern  Inst *hoc_progp, *hoc_progbase, *hoc_prog, *hoc_prog_parse_recover;
extern Inst *hoc_pc;

extern Objectdata *hoc_objectdata;
extern Objectdata *hoc_top_level_data;
extern Object* hoc_thisobject;
extern Symlist* hoc_symlist;
extern Symlist* hoc_top_level_symlist;
extern Symlist* hoc_built_in_symlist;
extern Objectdata *hoc_objectdata_save(void);
extern Objectdata* hoc_objectdata_restore(Objectdata*);
#define OPVAL(sym) hoc_objectdata[sym->u.oboff].pval
#define OPSTR(sym) hoc_objectdata[sym->u.oboff].ppstr
#define OPOBJ(sym) hoc_objectdata[sym->u.oboff].pobj
#define OPSECITM(sym) hoc_objectdata[sym->u.oboff].psecitm
#define OPLIST(sym) hoc_objectdata[sym->u.oboff].plist
#define OPARINFO(sym) hoc_objectdata[sym->u.oboff + 1].arayinfo

#if LINT
#undef assert
#define assert(arg) {if (arg) ;}    /* so fprintf doesn't give lint */
#undef IGNORE
#define IGNORE(arg) {if(arg);}
#define LINTUSE(arg)    {if(arg);}
char    *cplint;
int ilint;
#define Strcat          cplint = strcat
#define Strncat         cplint = strncat
#define Strcpy          cplint = strcpy
#define Strncpy         cplint = strncpy
#define Sprintf         cplint = sprintf
#define Printf      ilint = printf
#else
#if defined(__TURBOC__)
#undef IGNORE
#define IGNORE
#else
#undef IGNORE
#define IGNORE(arg) arg
#endif
#define LINTUSE(arg)
#define Strcat          strcat
#define Strncat         strncat
#define Strcpy          strcpy
#define Strncpy         strncpy
#define Sprintf         sprintf
#define Printf      nrnpy_pr
#endif

/* EINTR handling for LINDA */
#if LINDA
#include <errno.h>
#define ERRCHK(c1) {errno=EINTR;while(errno==EINTR){errno=0;c1}}

#else
#define ERRCHK(c1) c1
#endif

#define IFGUI if (hoc_usegui){
#define ENDGUI }

extern int hoc_usegui; /* when 0 does not make interviews calls */
extern int nrn_istty_;
extern int parallel_sub; /* for use with parallel neuron (see parallel.cl) */

#define NOT_PARALLEL_SUB(c1)  {if (!parallel_sub) c1}

/* Enter handling for PVM  NJP 11/21/94 */
#ifdef PVM
extern int init_parallel( );
int num_procs;
int *tids;
int node_num;
int mytid;
#endif


#endif