hoc_oop.cpp

Go to the documentation of this file.

#include <../../nrnconf.h>
#include <cstdlib>
#include <vector>
 
#include "utils/formatting.hpp"
 
 
#include "classreg.h"
#include "neuronapi.h"
 
#include "hocstr.h"
#include "parse.hpp"
#include "hocparse.h"
#include "code.h"
#include "cabcode.h"
#include "hocassrt.h"
#include "hoclist.h"
#include "nrn_ansi.h"
#include "nrnmpi.h"
#include "nrnpy.h"
#include "nrnfilewrap.h"
#include "ocfunc.h"
 
#define PDEBUG 0
 
Symbol* nrnpy_pyobj_sym_{};
#include "section.h"
#include "nrniv_mf.h"
int section_object_seen;
struct Section* nrn_sec_pop();
static int connect_obsec_;
 
#define PUBLIC_TYPE   1
#define EXTERNAL_TYPE 2
static void call_constructor(Object*, Symbol*, int);
static void free_objectdata(Objectdata*, cTemplate*);
 
std::vector<const char*> py_exposed_classes{};
 
int hoc_print_first_instance = 1;
int hoc_max_builtin_class_id = -1;
 
static Symbol* hoc_obj_;
 
int (*nrnpy_call_obj_method)(Object* obj, const char* method, Object* obj2) = nullptr;
int (*nrnpy_call_obj_method_double)(Object* obj, const char* method, double value) = nullptr;
 
 
void hoc_install_hoc_obj(void) {
    /* see void hoc_objvardecl(void) */
    Object** pobj;
    Symbol* s = hoc_install("_pysec", OBJECTVAR, 0.0, &hoc_top_level_symlist);
    hoc_install_object_data_index(s);
    hoc_objectdata[s->u.oboff].pobj = pobj = (Object**) emalloc(sizeof(Object*));
    pobj[0] = nullptr;
 
    auto const code = hoc_oc("objref hoc_obj_[2]\n");
    assert(code == 0);
    hoc_obj_ = hoc_lookup("hoc_obj_");
}
 
Object* hoc_obj_get(int i) {
    Object** p = hoc_objectdata[hoc_obj_->u.oboff].pobj;
    if (p) {
        return p[i];
    } else {
        return nullptr;
    }
}
 
void hoc_obj_set(int i, Object* obj) {
    Object** p = hoc_objectdata[hoc_obj_->u.oboff].pobj;
    hoc_obj_ref(obj);
    hoc_dec_refcount(p + i);
    p[i] = obj;
}
 
char* hoc_object_name(Object* ob) {
    static char s[100];
    if (ob) {
        Sprintf(s, "%s[%d]", ob->ctemplate->sym->name, ob->index);
    } else {
        Sprintf(s, "NULLobject");
    }
    return s;
}
 
size_t hoc_total_array(Symbol* s) /* total number of elements in array pointer */
{
    int total = 1, i;
    Arrayinfo* a = OPARINFO(s);
    if (a) {
        for (i = a->nsub - 1; i >= 0; --i) {
            total *= a->sub[i];
        }
    }
    return total;
}
 
size_t hoc_total_array_data(const Symbol* s,
                            Objectdata* obd) /* total number of elements in array pointer */
{
    Arrayinfo* a;
    int total = 1, i;
 
    if (!obd) {
        a = s->arayinfo;
    } else
        switch (s->type) {
        case RANGEVAR:
            a = s->arayinfo;
            break;
        default:
            a = obd[s->u.oboff + 1].arayinfo;
            break;
        }
    if (a) {
        for (i = a->nsub - 1; i >= 0; --i) {
            total *= a->sub[i];
        }
    }
    return total;
}
 
static int icntobjectdata = 0;
Object* hoc_thisobject;
Objectdata* hoc_objectdata = (Objectdata*) 0;
Objectdata* hoc_top_level_data;
static int icnttoplevel;
int hoc_in_template = 0;
 
 
void hoc_push_current_object(void) {
    hoc_push_object(hoc_thisobject);
}
 
Objectdata* hoc_objectdata_save(void) {
    /* hoc_top_level_data changes when new vars are introduced */
    if (hoc_objectdata == hoc_top_level_data) {
        /* a template starts out its Objectdata as 0. */
        return (Objectdata*) 1;
    } else {
        return hoc_objectdata;
    }
}
 
Objectdata* hoc_objectdata_restore(Objectdata* obdsav) {
    if (obdsav == (Objectdata*) 1) {
        return hoc_top_level_data;
        ;
    } else {
        return obdsav;
    }
}
 
void hoc_obvar_declare(Symbol* sym, int type, int pmes) {
    if (sym->type != UNDEF) {
        return;
    }
    assert(sym->cpublic != 2);
    if (pmes && hoc_symlist == hoc_top_level_symlist) {
        int b = 0;
        b = (hoc_fin == stdin);
        if (nrnmpi_myid_world == 0 && (hoc_print_first_instance && b)) {
            Printf("first instance of %s\n", sym->name);
        }
        sym->defined_on_the_fly = 1;
    }
    hoc_install_object_data_index(sym);
    sym->type = type;
    switch (type) {
    case VAR:
        /*printf("hoc_obvar_declare %s\n", sym->name);*/
        OPVAL(sym) = (double*) ecalloc(1, sizeof(double));
        break;
    case STRING:
        OPSTR(sym) = (char**) 0;
        break;
    case OBJECTVAR:
        break;
    case SECTION:
        OPSECITM(sym) = nullptr;  // TODO: whaa? (struct Item**)0;
        break;
    default:
        hoc_execerror_fmt("'{}' can't declare this in obvar_declare", sym->name);
        break;
    }
}
 
/*-----------------------------------------------*/
 
/* template stack so nested templates are ok */
typedef union {
    Symbol* sym;
    Symlist* symlist;
    Objectdata* odata;
    Object* o;
    int i;
} Templatedatum;
#define NTEMPLATESTACK 20
static Templatedatum templatestack[NTEMPLATESTACK];
static Templatedatum* templatestackp = templatestack;
 
static Templatedatum* poptemplate(void) {
    if (templatestackp == templatestack) {
        hoc_execerror("templatestack underflow", nullptr);
    }
    return (--templatestackp);
}
 
#define pushtemplatesym(arg) \
    chktemplate();           \
    (templatestackp++)->sym = arg
#define pushtemplatesymlist(arg) \
    chktemplate();               \
    (templatestackp++)->symlist = arg
#define pushtemplatei(arg) \
    chktemplate();         \
    (templatestackp++)->i = arg
#define pushtemplateodata(arg) \
    chktemplate();             \
    (templatestackp++)->odata = arg
#define pushtemplateo(arg) \
    chktemplate();         \
    (templatestackp++)->o = arg
 
static void chktemplate(void) {
    if (templatestackp == templatestack + NTEMPLATESTACK) {
        templatestackp = templatestack;
        hoc_execerror("templatestack overflow", nullptr);
    }
}
/*------------------------------------------------*/
 
/* mostly to allow saving of objects */
 
#define OBJ_STACK_SIZE 10
static Object* obj_stack_[OBJ_STACK_SIZE + 1]; /* +1 so we can see the most recent pushed */
static int obj_stack_loc;
 
void hoc_object_push(void) {
    Object* ob = *hoc_objgetarg(1);
    if (ob->ctemplate->constructor) {
        hoc_execerror("Can't do object_push for built-in class", nullptr);
    }
    if (obj_stack_loc >= OBJ_STACK_SIZE) {
        hoc_execerror("too many object context stack depth", nullptr);
    }
    obj_stack_[obj_stack_loc++] = hoc_thisobject;
    obj_stack_[obj_stack_loc] = ob;
    hoc_thisobject = ob;
    if (ob) {
        hoc_symlist = ob->ctemplate->symtable;
        hoc_objectdata = ob->u.dataspace;
    } else {
        hoc_symlist = hoc_top_level_symlist;
        hoc_objectdata = hoc_top_level_data;
    }
    hoc_ret();
    hoc_pushx(0.);
}
 
void hoc_object_pushed(void) {
    Object* ob;
    int i = chkarg(1, 0., (double) obj_stack_loc);
    ob = obj_stack_[obj_stack_loc - i];
    hoc_ret();
    hoc_push_object(ob);
}
 
void hoc_object_pop(void) {
    Object* ob;
    if (obj_stack_loc < 1) {
        hoc_execerror("object context stack underflow", nullptr);
    }
    obj_stack_[obj_stack_loc] = nullptr;
    ob = obj_stack_[--obj_stack_loc];
    hoc_thisobject = ob;
    if (ob) {
        hoc_symlist = ob->ctemplate->symtable;
        hoc_objectdata = ob->u.dataspace;
    } else {
        hoc_symlist = hoc_top_level_symlist;
        hoc_objectdata = hoc_top_level_data;
    }
    hoc_ret();
    hoc_pushx(0.);
}
/*-----------------------------------------------*/
int hoc_resize_toplevel(int more) {
    if (more > 0) {
        icnttoplevel += more;
        hoc_top_level_data = (Objectdata*) erealloc((char*) hoc_top_level_data,
                                                    icnttoplevel * sizeof(Objectdata));
        if (templatestackp == templatestack) {
            hoc_objectdata = hoc_top_level_data;
        }
    }
    return icnttoplevel;
}
 
void hoc_install_object_data_index(Symbol* sp) {
    if (!hoc_objectdata) {
        icntobjectdata = 0;
    }
    sp->u.oboff = icntobjectdata;
    icntobjectdata += 2; /* data pointer and Arrayinfo */
    hoc_objectdata = (Objectdata*) erealloc((char*) hoc_objectdata,
                                            icntobjectdata * sizeof(Objectdata));
    hoc_objectdata[icntobjectdata - 1].arayinfo = sp->arayinfo;
    if (sp->arayinfo) {
        ++sp->arayinfo->refcount;
    }
    if (templatestackp == templatestack) {
        hoc_top_level_data = hoc_objectdata;
        icnttoplevel = icntobjectdata;
    }
}
 
int hoc_obj_run(const char* cmd, Object* ob) {
    int err;
    Object* objsave;
    Objectdata* obdsave;
    Symlist* slsave;
    int osloc;
    objsave = hoc_thisobject;
    obdsave = hoc_objectdata_save();
    slsave = hoc_symlist;
    osloc = obj_stack_loc;
 
    if (ob) {
        if (ob->ctemplate->constructor) {
            hoc_execerror("Can't execute in a built-in class context", nullptr);
        }
        hoc_thisobject = ob;
        hoc_objectdata = ob->u.dataspace;
        hoc_symlist = ob->ctemplate->symtable;
    } else {
        hoc_thisobject = 0;
        hoc_objectdata = hoc_top_level_data;
        hoc_symlist = hoc_top_level_symlist;
    }
 
    err = hoc_oc(cmd);
 
    hoc_thisobject = objsave;
    hoc_objectdata = hoc_objectdata_restore(obdsave);
    hoc_symlist = slsave;
    obj_stack_loc = osloc;
 
    return err;
}
 
void hoc_exec_cmd(void) { /* execute string from top level or within an object context */
    int err;
    char* cmd;
    char buf[256];
    char* pbuf;
    Object* ob = 0;
    HocStr* hs = 0;
    cmd = gargstr(1);
    pbuf = buf;
    auto pbuf_size = 256;
    if (strlen(cmd) > 256 - 10) {
        hs = hocstr_create(strlen(cmd) + 10);
        pbuf = hs->buf;
        pbuf_size = hs->size + 1;
    }
    if (cmd[0] == '~') {
        std::snprintf(pbuf, pbuf_size, "%s\n", cmd + 1);
    } else {
        std::snprintf(pbuf, pbuf_size, "{%s}\n", cmd);
    }
    if (ifarg(2)) {
        ob = *hoc_objgetarg(2);
    }
    err = hoc_obj_run(pbuf, ob);
    if (err) {
        hoc_execerror_fmt("execute error:{}", cmd);
    }
    if (pbuf != buf) {
        hocstr_delete(hs);
    }
    hoc_ret();
    hoc_pushx((double) (err));
}
 
/* call a function within the context of an object. Args must be on stack */
double hoc_call_objfunc(Symbol* s, int narg, Object* ob) {
    double d;  //, hoc_call_func();
    Object* objsave;
    Objectdata* obdsave;
    Symlist* slsave;
    objsave = hoc_thisobject;
    obdsave = hoc_objectdata_save();
    slsave = hoc_symlist;
 
    if (ob) {
        hoc_thisobject = ob;
        hoc_objectdata = ob->u.dataspace;
        hoc_symlist = ob->ctemplate->symtable;
    } else {
        hoc_thisobject = 0;
        hoc_objectdata = hoc_top_level_data;
        hoc_symlist = hoc_top_level_symlist;
    }
 
    d = hoc_call_func(s, narg);
 
    hoc_thisobject = objsave;
    hoc_objectdata = hoc_objectdata_restore(obdsave);
    hoc_symlist = slsave;
 
    return d;
}
 
void hoc_oop_initaftererror(void) {
    hoc_symlist = hoc_top_level_symlist;
    templatestackp = templatestack;
    icntobjectdata = icnttoplevel;
    hoc_objectdata = hoc_top_level_data;
    hoc_thisobject = nullptr;
    obj_stack_loc = 0;
    hoc_in_template = 0;
    connect_obsec_ = 0;
}
 
void oc_save_hoc_oop(Object** a1,
                     Objectdata** a2,
                     // a3 is missing, do not add it
                     int* a4,
                     Symlist** a5) {
    *a1 = hoc_thisobject;
    /* same style as hoc_objectdata_sav */
    if (hoc_objectdata == hoc_top_level_data) {
        *a2 = (Objectdata*) 1;
    } else {
        *a2 = hoc_objectdata;
    }
    *a4 = obj_stack_loc;
    *a5 = hoc_symlist;
}
 
void oc_restore_hoc_oop(Object** a1, Objectdata** a2, int* a4, Symlist** a5) {
    hoc_thisobject = *a1;
    if (*a2 == (Objectdata*) 1) {
        hoc_objectdata = hoc_top_level_data;
    } else {
        hoc_objectdata = *a2;
    }
    obj_stack_loc = *a4;
    hoc_symlist = *a5;
}
 
Object* hoc_new_object(Symbol* symtemp, void* v) {
    Object* ob;
#if PDEBUG
    printf("new object from template %s created.\n", symtemp->name);
#endif
    ob = (Object*) emalloc(sizeof(Object));
    ob->recurse = 0;
    ob->unref_recurse_cnt = 0;
    ob->refcount = 1; /* so template notify will not delete */
    ob->observers = nullptr;
    ob->ctemplate = symtemp->u.ctemplate;
    ob->aliases = nullptr;
    ob->itm_me = hoc_l_lappendobj(ob->ctemplate->olist, ob);
    ob->secelm_ = (hoc_Item*) 0;
    ob->ctemplate->count++;
    ob->index = ob->ctemplate->index++;
    if (symtemp->subtype & (CPLUSOBJECT | JAVAOBJECT)) {
        ob->u.this_pointer = v;
        if (v) {
            hoc_template_notify(ob, 1);
        }
    } else {
        ob->u.dataspace = 0;
    }
    ob->refcount = 0;
    return ob;
}
 
void hoc_new_object_asgn(Object** obp, Symbol* st, void* v) {
    hoc_dec_refcount(obp);
    *obp = hoc_new_object(st, v);
    hoc_obj_ref(*obp);
}
 
Object** hoc_temp_objvar(Symbol* symtemp, void* v) {
    return hoc_temp_objptr(hoc_new_object(symtemp, v));
}
 
struct guard_t {
    ~guard_t() {
        if (ob) {
            hoc_obj_unref(ob);
        }
    }
    Object* ob{};
};
 
Object* hoc_newobj1(Symbol* sym, int narg) {
    Object* ob;
    Objectdata* obd;
    Symbol* s;
    int i, total;
 
    guard_t guard{};  // unref the object we're creating if there is an exception before the end of
                      // this method
    guard.ob = ob = hoc_new_object(sym, nullptr);
    ob->refcount = 1;
    if (sym->subtype & (CPLUSOBJECT | JAVAOBJECT)) {
        call_constructor(ob, sym, narg);
    } else {
        ob->u.dataspace = obd = (Objectdata*) ecalloc(ob->ctemplate->dataspace_size,
                                                      sizeof(Objectdata));
        for (s = ob->ctemplate->symtable->first; s; s = s->next) {
            if (s->cpublic != 2) {
                switch (s->type) {
                case VAR:
                    if ((obd[s->u.oboff + 1].arayinfo = s->arayinfo) != (Arrayinfo*) 0) {
                        ++s->arayinfo->refcount;
                    }
                    total = hoc_total_array_data(s, obd);
                    obd[s->u.oboff].pval = (double*) emalloc(total * sizeof(double));
                    for (i = 0; i < total; i++) {
                        (obd[s->u.oboff].pval)[i] = 0.;
                    }
                    break;
                case STRING:
                    obd[s->u.oboff + 1].arayinfo = (Arrayinfo*) 0;
                    obd[s->u.oboff].ppstr = (char**) emalloc(sizeof(char*));
                    *obd[s->u.oboff].ppstr = (char*) emalloc(sizeof(char));
                    **(obd[s->u.oboff].ppstr) = '\0';
                    break;
                case OBJECTVAR:
                    if ((obd[s->u.oboff + 1].arayinfo = s->arayinfo) != (Arrayinfo*) 0) {
                        ++s->arayinfo->refcount;
                    }
                    total = hoc_total_array_data(s, obd);
                    obd[s->u.oboff].pobj = (Object**) emalloc(total * sizeof(Object*));
                    for (i = 0; i < total; i++) {
                        (obd[s->u.oboff].pobj)[i] = (Object*) 0;
                    }
                    if (strcmp(s->name, "this") == 0) {
                        obd[s->u.oboff].pobj[0] = ob;
                    }
                    break;
                case SECTION:
                    if ((obd[s->u.oboff + 1].arayinfo = s->arayinfo) != (Arrayinfo*) 0) {
                        ++s->arayinfo->refcount;
                    }
                    total = hoc_total_array_data(s, obd);
                    obd[s->u.oboff].psecitm = (hoc_Item**) emalloc(total * sizeof(hoc_Item*));
                    new_sections(ob, s, obd[s->u.oboff].psecitm, total);
                    break;
                }
            }
        }
        if (ob->ctemplate->is_point_) {
            hoc_construct_point(ob, narg);
        }
        if (ob->ctemplate->init) {
            hoc_call_ob_proc(ob, ob->ctemplate->init, narg);
        } else {
            for (i = 0; i < narg; ++i) {
                hoc_nopop();
            }
        }
    }
    hoc_template_notify(ob, 1);
    guard.ob = nullptr;  // do not unref, disable the guard
    return ob;
}
 
void hoc_newobj_arg(void) {
    Object* ob;
    Symbol* sym;
    int narg;
    sym = (pc++)->sym;
    narg = (pc++)->i;
    ob = hoc_newobj1(sym, narg);
    --ob->refcount; /*not necessarily 0 since init may reference 'this' */
    hoc_pushobj(hoc_temp_objptr(ob));
}
 
void hoc_newobj_ret(void) {
    hoc_newobj_arg();
}
 
void hoc_newobj(void) { /* template at pc+1 */
    Symbol* sym = (pc++)->sym;
    int narg = (pc++)->i;
#if USE_PYTHON
    /* look inside stack because of limited number of temporary objects? */
    /* whatever. we will keep the strategy */
    if (hoc_inside_stacktype(narg) == OBJECTVAR) {
#endif
        Object** obp = hoc_look_inside_stack<Object**>(narg);
        Object* ob = hoc_newobj1(sym, narg);
        hoc_nopop(); /* the object pointer */
        hoc_dec_refcount(obp);
        *(obp) = ob;
        hoc_pushobj(obp);
#if USE_PYTHON
    } else { /* Assignment to OBJECTTMP not allowed */
        hoc_obj_look_inside_stack(narg);
        hoc_execerror("Assignment to $o only allowed if caller arg was declared as objref",
                      nullptr);
    }
#endif
}
 
static void call_constructor(Object* ob, Symbol* sym, int narg) {
    Inst* pcsav;
    Symlist* slsav;
    Objectdata* obdsav;
    Object* obsav;
 
    slsav = hoc_symlist;
    obdsav = hoc_objectdata_save();
    obsav = hoc_thisobject;
    pcsav = pc;
 
    hoc_push_frame(sym, narg);
    ob->u.this_pointer = neuron::oc::invoke_method_that_may_throw(
        [ob]() -> std::string {
            std::string rval{hoc_object_name(ob)};
            rval.append(" constructor");
            return rval;
        },
        ob->ctemplate->constructor,
        ob);
    hoc_pop_frame();
 
    pc = pcsav;
    hoc_symlist = slsav;
    hoc_objectdata = hoc_objectdata_restore(obdsav);
    hoc_thisobject = obsav;
}
 
/* When certain methods of some Objects are called, the gui-redirect macros
   need Object* instead of Object*->u.this_pointer. Not worth changing the
   prototype of the call as it is used in so many places. So store the Object*
   to be obtained if needed.
*/
 
static Object* gui_redirect_obj_;
Object* nrn_get_gui_redirect_obj() {
    return gui_redirect_obj_;
}
 
void hoc_call_ob_proc(Object* ob, Symbol* sym, int narg) {
    Inst *pcsav, callcode[4];
    Symlist* slsav;
    Objectdata* obdsav;
    Object* obsav;
 
    slsav = hoc_symlist;
    obdsav = hoc_objectdata_save();
    obsav = hoc_thisobject;
    pcsav = pc;
 
    if (ob->ctemplate->sym->subtype & CPLUSOBJECT) {
        hoc_thisobject = ob;
        gui_redirect_obj_ = ob;
        hoc_push_frame(sym, narg);
        hoc_thisobject = obsav;
        auto const error_prefix_generator = [ob, sym]() {
            std::string rval{hoc_object_name(ob)};
            rval.append(2, ':');
            rval.append(sym->name);
            return rval;
        };
        if (sym->type == OBFUNCTION) {
            auto* const o = neuron::oc::invoke_method_that_may_throw(error_prefix_generator,
                                                                     sym->u.u_proc->defn.pfo_vp,
                                                                     ob->u.this_pointer);
            if (*o) {
                ++(*o)->refcount;
            } /* in case unreffed below */
            hoc_pop_frame();
            if (*o) {
                --(*o)->refcount;
            }
            hoc_pushobj(o);
        } else if (sym->type == STRFUNCTION) {
            auto* const s = const_cast<char**>(neuron::oc::invoke_method_that_may_throw(
                error_prefix_generator, sym->u.u_proc->defn.pfs_vp, ob->u.this_pointer));
            hoc_pop_frame();
            hoc_pushstr(s);
        } else {
            auto x = neuron::oc::invoke_method_that_may_throw(error_prefix_generator,
                                                              sym->u.u_proc->defn.pfd_vp,
                                                              ob->u.this_pointer);
            hoc_pop_frame();
            hoc_pushx(x);
        }
    } else if (ob->ctemplate->is_point_ && special_pnt_call(ob, sym, narg)) {
        ; /*empty since special_pnt_call did the work for get_loc, has_loc, and loc*/
    } else {
        callcode[0].pf = hoc_call;
        callcode[1].sym = sym;
        callcode[2].i = narg;
        callcode[3].in = STOP;
 
        hoc_objectdata = ob->u.dataspace;
        hoc_thisobject = ob;
        hoc_symlist = ob->ctemplate->symtable;
        hoc_execute(callcode);
        if (sym->type == PROCEDURE) {
            hoc_nopop();
        }
    }
    if (hoc_errno_check()) {
        char str[200];
        Sprintf(str, "%s.%s", hoc_object_name(ob), sym->name);
        hoc_warning("errno set during call of", str);
    }
    pc = pcsav;
    hoc_symlist = slsav;
    hoc_objectdata = hoc_objectdata_restore(obdsav);
    hoc_thisobject = obsav;
}
 
static void call_ob_iter(Object* ob, Symbol* sym, int narg) {
    Symlist* slsav;
    Objectdata* obdsav;
    Object* obsav;
    Object* stmtobj;
    Inst *stmtbegin, *stmtend;
 
    slsav = hoc_symlist;
    obdsav = hoc_objectdata_save();
    obsav = hoc_thisobject;
 
    hoc_objectdata = ob->u.dataspace;
    hoc_thisobject = ob;
    hoc_symlist = ob->ctemplate->symtable;
 
    stmtobj = hoc_look_inside_stack<Object*>(narg + 1);
    stmtbegin = pc + pc->i;
    pc++;
    stmtend = pc + pc->i;
    hoc_iterator_object(sym, narg, stmtbegin, stmtend, stmtobj);
 
    /* the stack was popped by hoc_iterator_object
    hoc_nopop();
    */
 
    hoc_symlist = slsav;
    hoc_objectdata = hoc_objectdata_restore(obdsav);
    hoc_thisobject = obsav;
}
 
void hoc_objvardecl(void) { /* symbol at pc+1, number of indices at pc+2 */
    Symbol* sym;
    int nsub, size, i;
    Object** pobj;
 
    sym = (pc++)->sym;
#if PDEBUG
    printf("declareing %s as objectvar\n", sym->name);
#endif
    if (sym->type == OBJECTVAR) {
        int total, i;
        total = hoc_total_array(sym);
        for (i = 0; i < total; i++) {
            hoc_dec_refcount((OPOBJ(sym)) + i);
        }
        free(hoc_objectdata[sym->u.oboff].pobj);
        hoc_freearay(sym);
    } else {
        sym->type = OBJECTVAR;
        hoc_install_object_data_index(sym);
    }
    nsub = (pc++)->i;
    if (nsub) {
        size = hoc_arayinfo_install(sym, nsub);
    } else {
        size = 1;
    }
    hoc_objectdata[sym->u.oboff].pobj = pobj = (Object**) emalloc(size * sizeof(Object*));
    for (i = 0; i < size; i++) {
        pobj[i] = (Object*) 0;
    }
}
 
void hoc_cmp_otype(void) { /* NUMBER, OBJECTVAR, or STRING must be the type */
    ++pc;
}
 
void hoc_known_type(void) {
    ++pc;
}
 
void hoc_objectvar(void) { /* object variable symbol at pc+1. */
                           /* pointer to correct object left on stack */
    Objectdata* odsav;
    Object* obsav = 0;
    Symlist* slsav;
    Symbol* obs;
    Object** obp;
#if PDEBUG
    printf("code for hoc_objectvar()\n");
#endif
    obs = (pc++)->sym;
    if (obs->cpublic == 2) {
        obs = obs->u.sym;
        odsav = hoc_objectdata_save();
        obsav = hoc_thisobject;
        slsav = hoc_symlist;
        hoc_objectdata = hoc_top_level_data;
        hoc_thisobject = 0;
        hoc_symlist = hoc_top_level_symlist;
    }
    obp = OPOBJ(obs);
    if (is_array(*obs)) {
        hoc_pushobj(obp + hoc_araypt(obs, OBJECTVAR));
    } else {
        hoc_pushobj(obp);
    }
    if (obsav) {
        hoc_objectdata = hoc_objectdata_restore(odsav);
        hoc_thisobject = obsav;
        hoc_symlist = slsav;
    }
}
 
void hoc_objectarg(void) { /* object arg index at pc+1. */
                           /* pointer to correct object left on stack */
    int i;
    Object** obp;
#if PDEBUG
    printf("code for hoc_objectarg()\n");
#endif
    i = (pc++)->i;
    if (i == 0) {
        i = hoc_argindex();
    }
    obp = hoc_objgetarg(i);
    hoc_pushobj(obp);
}
 
void hoc_constobject(void) { /* template at pc, index at pc+1, objpointer left on stack*/
    char buf[200];
    Object* obj;
    hoc_Item* q;
    cTemplate* t = (pc++)->sym->u.ctemplate;
    int index = (int) hoc_xpop();
    ITERATE(q, t->olist) {
        obj = OBJ(q);
        if (obj->index == index) {
            hoc_pushobj(hoc_temp_objptr(obj));
            return;
        } else if (obj->index > index) {
            break;
        }
    }
    Sprintf(buf, "%s[%d]\n", t->sym->name, index);
    hoc_execerror("Object ID doesn't exist '{}'", buf);
}
 
Object* hoc_name2obj(const char* name, int index) {
    char buf[200];
    Object* obj;
    hoc_Item* q;
    cTemplate* t;
    Symbol* sym;
    sym = hoc_table_lookup(name, hoc_top_level_symlist);
    if (!sym) {
        sym = hoc_table_lookup(name, hoc_built_in_symlist);
    }
    if (!sym || sym->type != TEMPLATE) {
        hoc_execerror_fmt("'{}' is not a template", name);
    }
    t = sym->u.ctemplate;
    ITERATE(q, t->olist) {
        obj = OBJ(q);
        if (obj->index == index) {
            return obj;
        } else if (obj->index > index) {
            break;
        }
    }
    return nullptr;
}
 
void hoc_object_id(void) {
    Object* ob;
 
    ob = *(hoc_objgetarg(1));
    if (ifarg(2) && chkarg(2, 0., 1.) == 1.) {
        hoc_ret();
        if (ob) {
            hoc_pushx((double) ob->index);
        } else {
            hoc_pushx(-1.);
        }
    } else {
        hoc_ret();
        hoc_pushx((double) ((size_t) ob));
    }
}
 
static void range_suffix(Symbol* sym, int nindex, int narg) {
    int bdim = 0;
    if (is_array(*sym)) {
        if (nindex != sym->arayinfo->nsub) {
            bdim = 1;
        }
        /*
         It is a bit more difficult to push ndim here since the arc length, if
         specified, is top of stack before the index. However, waiting to fix up
         the stack til just before range_vec_indx calls hoc_araypt seems ill
         advised since range_vec_indx is called 6 places. And who knows what
         kinds of user errors are possible that we want to catch.
         So fix up below.
        */
    } else {
        if (nindex != 0) {
            bdim = 1;
        }
    }
    if (bdim) {
        hoc_execerror_fmt("'{}' wrong number of array dimensions", sym->name);
    }
 
    if (sym->type == RANGEVAR) {
        if (is_array(*sym)) {  // fixup ndim here
            double x = -1.0;
            if (narg) {  // need to pop the arc length to push ndim
                if (narg > 1) {
                    hoc_execerror_fmt("'{}' range variable can have only one arc length parameter",
                                      sym->name);
                }
                x = xpop();
            }
            if (!hoc_stack_type_is_ndim()) {
                hoc_push_ndim(nindex);
            }
            if (narg) {  // push back the arc length
                hoc_pushx(x);
            }
        }
        hoc_pushi(narg);
        hoc_pushs(sym);
    } else if (sym->subtype == USERPROPERTY) {
        if (narg) {
            hoc_execerror_fmt("'{}' section property can't have argument", sym->name);
        }
        hoc_pushs(sym);
    } else if (sym->type == RANGEOBJ) {
        // must return NMODLObject on stack
        assert(sym->subtype == NMODLRANDOM);  // the only possibility at the moment
        double x{0.5};
        if (narg) {
            if (narg > 1) {
                hoc_execerror_fmt("'{}' range object can have only one arg length parameter",
                                  sym->name);
            }
            x = xpop();
        }
        Section* sec{nrn_sec_pop()};
        auto const i = node_index(sec, x);
        Prop* m = nrn_mechanism_check(sym->u.rng.type, sec, i);
        Object* ob = nrn_nmodlrandom_wrap(m, sym);
        hoc_push_object(ob);
    } else {
        hoc_execerror_fmt("'{}' suffix not a range variable or section property", sym->name);
    }
}
 
void connect_obsec_syntax(void) {
    connect_obsec_ = 1;
}
 
// number of indices at pc+2, number of args at pc+3, symbol at pc+1
// object pointer on stack after indices
// if component turns out to be an object then make sure pointer to correct
// object, symbol, etc is left on stack for evaluation, assignment, etc.
void hoc_object_component() {
    Symbol *sym0, *sym = 0;
    int nindex, narg, cplus, isfunc;
    Object *obp, *obsav;
    Objectdata* psav;
    int* ptid;
    Symbol** psym;
 
#if PDEBUG
    printf("code for hoc_object_component()\n");
#endif
    sym0 = (pc++)->sym;
    nindex = (pc++)->i;
    narg = (pc++)->i;
    ptid = &(pc++)->i;
    psym = &(pc++)->sym;
    isfunc = (pc++)->i;
 
    if (section_object_seen) {
        section_object_seen = 0;
        range_suffix(sym0, nindex, narg);
        return;
    }
    if (connect_obsec_) {
        narg += nindex;
        nindex = 0;
    }
    int expect_stack_nsub{0};
    if (nindex) {
        if (narg) {
            hoc_execerror("[...](...) syntax only allowed for array range variables:", sym0->name);
        }
        if (!hoc_stack_type_is_ndim()) {
            hoc_push_ndim(nindex);
        }
        expect_stack_nsub = 1;
    } else {
        nindex = narg;
    }
    obp = hoc_obj_look_inside_stack(nindex + expect_stack_nsub);
    if (obp) {
#if USE_PYTHON
        if (obp->ctemplate->sym == nrnpy_pyobj_sym_) {
            if (isfunc & 2) {
                /* this is the final left hand side of an
                assignment to the method of a PythonObject
                and we need to put the PythonObject and the
                method with all its info onto the stack so that
                a proper __setattro__ or __setitem__ can be
                accomplished in the next hoc_object_asgn
                */
                if (isfunc & 1) {
                    hoc_execerror_fmt("Cannot assign to a PythonObject function call '{}'",
                                      sym0->name);
                }
                hoc_pushi(nindex);
                hoc_pushs(sym0);
                hoc_push_object(obp);
                /* note obp is now on stack twice */
                /* hpoasgn will pop both */
            } else {
                neuron::python::methods.py2n_component(obp, sym0, nindex, isfunc);
            }
            return;
        }
#endif
        if (obp->ctemplate->id == *ptid) {
            sym = *psym;
        } else {
            if (obp->aliases == 0 || (sym = ivoc_alias_lookup(sym0->name, obp)) == 0) {
                /* lookup only has to be done once if the name is not an alias
                and the ptid of the object is still the same. */
                sym = hoc_table_lookup(sym0->name, obp->ctemplate->symtable);
                if (!sym || sym->cpublic != PUBLIC_TYPE) {
                    auto err = fmt::format("'{}' not a public member of '{}'",
                                           sym0->name,
                                           obp->ctemplate->sym->name);
                    Fprintf(stderr, fmt::format("{}\n", err).c_str());
                    hoc_execerror(err.c_str(), nullptr);
                }
                *ptid = obp->ctemplate->id;
                *psym = sym;
            }
        }
    } else {
        hoc_execerror_fmt("'{}' object prefix is nullptr", sym0->name);
    }
 
    psav = hoc_objectdata_save();
    obsav = hoc_thisobject;
    cplus = (obp->ctemplate->sym->subtype & (CPLUSOBJECT | JAVAOBJECT));
    if (!cplus) { /* c++ classes don't have a hoc dataspace */
        hoc_objectdata = obp->u.dataspace;
        hoc_thisobject = obp;
    }
    switch (sym->type) {
    case OBJECTVAR:
        if (nindex) {
            if (!is_array(*sym) || OPARINFO(sym)->nsub != nindex) {
                hoc_execerror_fmt("'{}' not right number of subscripts", sym->name);
            }
            nindex = hoc_araypt(sym, OBJECTVAR);
        }
        hoc_pop_defer();
        hoc_pushobj(OPOBJ(sym) + nindex);
        break;
    case VAR:
        if (cplus) {
            if (nindex) {
                if (!is_array(*sym) || sym->arayinfo->nsub != nindex) {
                    hoc_execerror_fmt("'{}' not right number of subscripts", sym->name);
                }
                if (narg) {
                    // there are 25 modeldb examples that use (index) instead
                    // of [index] syntax for an array in this context. So we
                    // have decided to keep allowing this legacy syntax for one
                    // dimensional arrays.
                    extern Symbol* nrn_matrix_sym;
                    if (narg == 1) {
                        hoc_push_ndim(1);
                    } else if (narg == 2 && obp->ctemplate->sym == nrn_matrix_sym) {
                        // Allow legacy syntax Matrix.x(i, j)
                        hoc_push_ndim(2);
                    } else {
                        hoc_execerror_fmt("'{}.{}' is array not function. Use '{}[...]' syntax",
                                          hoc_object_name(obp),
                                          sym->name,
                                          sym->name);
                    }
                }
            }
            hoc_pushs(sym);
            (*obp->ctemplate->steer)(obp->u.this_pointer);
            double* pd = hoc_pxpop();
            /* cannot pop a temporary object til after the pd is used in
            case (e.g. Vector.x) the pointer is a field in the object
            (often the pd has nothing to do with the object)*/
            hoc_pop_defer(); /* corresponding unref_defer soon */
            hoc_pushpx(pd);
        } else {
            if (nindex) {
                if (!is_array(*sym) || OPARINFO(sym)->nsub != nindex) {
                    hoc_execerror_fmt("'{}' not right number of subscripts", sym->name);
                }
                if (narg) {
                    // there are a few modeldb examples that use (index) instead
                    // of [index] syntax for an array in this context. So we
                    // have decided to keep allowing this legacy syntax for one
                    // dimensional arrays.
                    if (narg == 1) {
                        hoc_push_ndim(1);
                    } else {
                        hoc_execerror_fmt("'{}.{}' is array not function. Use '{}[...]' syntax",
                                          hoc_object_name(obp),
                                          sym->name,
                                          sym->name);
                    }
                }
                nindex = hoc_araypt(sym, OBJECTVAR);
            }
            hoc_pop_defer(); /*finally get rid of symbol */
            hoc_pushpx(OPVAL(sym) + nindex);
        }
        break;
    case STRING:
        if (nindex) {
            hoc_execerror_fmt("'{}' string can't have function arguments or array indices",
                              sym->name);
        }
        hoc_pop_defer();
        hoc_pushstr(OPSTR(sym));
        break;
    case PROCEDURE:
    case FUNCTION: {
        if (expect_stack_nsub) {
            hoc_pop_ndim();
            hoc_execerror_fmt("'{}' is a function not a {}-dim array", sym->name, nindex);
        }
        double d = 0.;
        hoc_call_ob_proc(obp, sym, nindex);
        if (hoc_returning) {
            break;
        }
        if (sym->type == FUNCTION) {
            d = hoc_xpop();
        }
        hoc_pop_defer();
        hoc_pushx(d);
        break;
    }
    case HOCOBJFUNCTION:
    case OBFUNCTION: {
        Object** d;
        if (expect_stack_nsub) {
            hoc_pop_ndim();
            // for legacy reasons allow single arg [] format.
            // E.g. occasionally seen for List.object[index]
            if (nindex > 1) {
                hoc_execerror_fmt("'{}' is a function not a {}-dim array", sym->name, nindex);
            }
        }
        hoc_call_ob_proc(obp, sym, nindex);
        if (hoc_returning) {
            break;
        }
        d = hoc_objpop();
        if (*d) {
            (*d)->refcount++;
        } /* nopop may unref if temp obj.*/
        hoc_pop_defer();
        hoc_pushobj(d);
        if (*d) {
            (*d)->refcount--;
        } /* see the nopop may unref comment */
        hoc_tobj_unref(d);
        break;
    }
    case STRFUNCTION: {
        char** d;
        hoc_call_ob_proc(obp, sym, nindex);
        if (hoc_returning) {
            break;
        }
        d = hoc_strpop();
        hoc_pop_defer();
        hoc_pushstr(d);
        break;
    }
    case SECTIONREF: {
        extern Symbol* nrn_sec_sym;
        Section* sec;
        extern Section* nrn_sectionref_steer(Section * sec, Symbol * sym, int* pnindex);
        section_object_seen = 1;
        sec = (Section*) obp->u.this_pointer;
        if (sym != nrn_sec_sym) {
            sec = nrn_sectionref_steer(sec, sym, &nindex);
        }
        if (nrn_inpython_ == 2) {
            section_object_seen = 0;
            hoc_pop_defer();
            hoc_objectdata = hoc_objectdata_restore(psav);
            hoc_thisobject = obsav;
            return;
        }
        if (connect_obsec_) {
            double x = 0.0;
            connect_obsec_ = 0;
            if (nindex != 1) {
                hoc_execerror_fmt("'{}' bad connect syntax", sym->name);
            }
            x = hoc_xpop();
            hoc_pop_defer();
            hoc_pushx(x);
        } else {
            if (nindex) {
                hoc_execerror_fmt("'{}' no subscript allowed", sym->name);
            }
            hoc_pop_defer();
        }
        if (!sec->prop) {
            hoc_execerror("Section was deleted", nullptr);
        }
        nrn_pushsec(sec);
        break;
    }
    case SECTION: {
        double x = 0.0;
        section_object_seen = 1;
        if (connect_obsec_) {
            x = hoc_xpop();
            if (!nindex) {
                hoc_execerror_fmt("'{}' bad connect syntax", sym->name);
            }
            --nindex;
        }
        if (nindex) {
            if (!is_array(*sym) || OPARINFO(sym)->nsub != nindex) {
                hoc_execerror_fmt("'{}' not right number of subscripts", sym->name);
            }
            if (!hoc_stack_type_is_ndim()) {
                hoc_push_ndim(nindex);
            }
            nindex = hoc_araypt(sym, OBJECTVAR);
        }
        hoc_pop_defer();
        if (connect_obsec_) {
            hoc_pushx(x);
            connect_obsec_ = 0;
        }
        ob_sec_access_push(*(OPSECITM(sym) + nindex));
        break;
    }
    case ITERATOR: {
        if ((pc++)->i != ITERATOR) {
            hoc_execerror_fmt("'{}' ITERATOR can only be used in a for statement", sym->name);
        }
        call_ob_iter(obp, sym, nindex);
        if (hoc_returning) {
            break;
        }
        hoc_pop_defer();
        hoc_nopop(); /* get rid of iterator statement context */
        break;
    }
    case RANGEOBJ: {
        assert(sym->subtype == NMODLRANDOM);
        if (sym->subtype == NMODLRANDOM) {  // NMODL NEURON block RANDOM var
            // RANGE type. The void* is a nrnran123_State*. Wrap in a
            // NMODLRandom and push_object
            Object* o = nrn_pntproc_nmodlrandom_wrap(obp->u.this_pointer, sym);
            hoc_pop_defer();
            hoc_push_object(o);
        }
        break;
    }
    default:
        if (cplus) {
            if (nindex) {
                if (!is_array(*sym) || sym->arayinfo->nsub != nindex) {
                    hoc_execerror_fmt("'{}' not right number of subscripts", sym->name);
                }
                if (narg) {
                    // there are a few modeldb examples that use (index) instead
                    // of [index] syntax for an array in this context. So we
                    // have decided to keep allowing this legacy syntax for one
                    // dimensional arrays.
                    if (narg == 1) {
                        hoc_push_ndim(1);
                    } else {
                        hoc_execerror_fmt("'{}.{}' is array not function. Use '{}[...]' syntax",
                                          hoc_object_name(obp),
                                          sym->name,
                                          sym->name);
                    }
                }
            }
            hoc_pushs(sym);
            (*obp->ctemplate->steer)(obp->u.this_pointer);
            auto dh = hoc_pop_handle<double>();
            hoc_pop_defer();
            hoc_push(std::move(dh));
        } else {
            hoc_execerror_fmt("{}: can't push that type onto stack", sym->name);
        }
        break;
    case OBJECTALIAS:
        if (nindex) {
            hoc_execerror_fmt("{}: is an alias and cannot have subscripts", sym->name);
        }
        hoc_pop_defer();
        hoc_push_object(sym->u.object_);
        break;
    case VARALIAS:
        if (nindex) {
            hoc_execerror_fmt("{}: is an alias and cannot have subscripts", sym->name);
        }
        hoc_pop_defer();
        hoc_pushpx(sym->u.pval);
        break;
    }
    hoc_objectdata = hoc_objectdata_restore(psav);
    hoc_thisobject = obsav;
}
 
void hoc_object_eval(void) {
    int type;
#if PDEBUG
    printf("code for hoc_object_eval\n");
#endif
    type = hoc_stacktype();
    if (type == VAR) {
        hoc_pushx(*(hoc_pxpop()));
    } else if (type == SYMBOL) {
        auto* d_sym = hoc_look_inside_stack<Symbol*>(0);
        if (d_sym->type == RANGEVAR) {
            Symbol* sym = hoc_spop();
            int narg = hoc_ipop();
            struct Section* sec = nrn_sec_pop();
            double x;
            if (narg) {
                x = hoc_xpop();
            } else {
                x = .5;
            }
            hoc_pushx(*(nrn_rangepointer(sec, sym, x)));
        } else if (d_sym->type == VAR && d_sym->subtype == USERPROPERTY) {
            hoc_pushx(cable_prop_eval(hoc_spop()));
        }
    }
}
 
void hoc_ob_pointer(void) {
#if PDEBUG
    printf("code for hoc_ob_pointer\n");
#endif
    int type = hoc_stacktype();
    if (type == VAR) {
    } else if (type == SYMBOL) {
        auto* d_sym = hoc_look_inside_stack<Symbol*>(0);
        if (d_sym->type == RANGEVAR) {
            Symbol* sym = hoc_spop();
            int nindex = hoc_ipop();
            Section* sec = nrn_sec_pop();
            double x = nindex ? hoc_xpop() : .5;
            hoc_push(nrn_rangepointer(sec, sym, x));
        } else if (d_sym->type == VAR && d_sym->subtype == USERPROPERTY) {
            hoc_pushpx(cable_prop_eval_pointer(hoc_spop()));
        } else {
            hoc_execerror("Not a double pointer", nullptr);
        }
    } else {
        hoc_execerror("Not a double pointer", nullptr);
    }
}
 
void hoc_asgn_obj_to_str(void) { /* string on stack */
    char *d, **pstr;
    d = *(hoc_strpop());
    pstr = hoc_strpop();
    hoc_assign_str(pstr, d);
}
 
void hoc_object_asgn() {
    int op = (pc++)->i;
    int type1 = hoc_stacktype();          // type of top entry
    int type2 = hoc_inside_stacktype(1);  // type of second-top entry
    if (type2 == SYMBOL) {
        auto* sym = hoc_look_inside_stack<Symbol*>(1);
        if (sym->type == RANGEVAR) {
            type2 = RANGEVAR;
        } else if (sym->type == VAR && sym->subtype == USERPROPERTY) {
            type2 = USERPROPERTY;
        }
    }
    if (type2 == RANGEVAR && type1 == NUMBER) {
        double d = hoc_xpop();
        Symbol* sym = hoc_spop();
        int nindex = hoc_ipop();
        Section* sec = nrn_sec_pop();
        if (nindex) {
            auto pd = nrn_rangepointer(sec, sym, hoc_xpop());
            if (op) {
                d = hoc_opasgn(op, *pd, d);
            }
            *pd = d;
        } else {
            nrn_rangeconst(sec,
                           sym,
                           neuron::container::data_handle<double>{neuron::container::do_not_search,
                                                                  &d},
                           op);
        }
        hoc_pushx(d);
        return;
    } else if (type2 == USERPROPERTY && type1 == NUMBER) {
        double d = hoc_xpop();
        cable_prop_assign(hoc_spop(), &d, op);
        hoc_pushx(d);
        return;
    }
    switch (type2) {
    case VAR: {
        double d, *pd;
        d = hoc_xpop();
        pd = hoc_pxpop();
        if (op) {
            d = hoc_opasgn(op, *pd, d);
        }
        *pd = d;
        hoc_pushx(d);
    } break;
    case OBJECTVAR: {
        if (op) {
            hoc_execerror("Invalid assignment operator for object", nullptr);
        }
        Object** d = hoc_objpop();
        Object** pd = hoc_objpop();
        if (d != pd) {
            Object* tobj = *d;
            if (tobj) {
                (tobj)->refcount++;
            }
            hoc_tobj_unref(d);
            hoc_dec_refcount(pd);
            *pd = tobj;
        }
        hoc_pushobj(pd);
    } break;
    case STRING: {
        if (op) {
            hoc_execerror("Invalid assignment operator for string", nullptr);
        }
        char* d = *(hoc_strpop());
        char** pd = hoc_strpop();
        hoc_assign_str(pd, d);
        hoc_pushstr(pd);
    } break;
#if USE_PYTHON
    case OBJECTTMP: { /* should be PythonObject */
        Object* o = hoc_obj_look_inside_stack(1);
        assert(o->ctemplate->sym == nrnpy_pyobj_sym_);
        if (op) {
            hoc_execerror("Invalid assignment operator for PythonObject", nullptr);
        }
        neuron::python::methods.hpoasgn(o, type1);
    } break;
#endif
    default:
        hoc_execerror("Cannot assign to left hand side", nullptr);
    }
}
 
/* if the name isn't a template then look in the top level symbol table.
This allows objects to create objects of any class defined at the top level
*/
Symbol* hoc_which_template(Symbol* s) {
    if (s->type != TEMPLATE) {
        Symbol* s1;
        s1 = hoc_table_lookup(s->name, hoc_top_level_symlist);
        if (!s1 || s1->type != TEMPLATE) {
            hoc_execerror(s->name, "is not a template");
        }
        s = s1;
    }
    return s;
}
 
/* pushes old symtable and template name on template stack.
And creates new symtable. The new symtable
is used for all non-builtin names until an endtemplate is reached
*/
static int template_id;
 
void hoc_begintemplate(Symbol* t1) {
    Symbol* t;
    int type;
    t = hoc_decl(t1);
 
#if PDEBUG
    printf("begin template %s\n", t->name);
#endif
    type = t->type;
    if (type == TEMPLATE) {
        hoc_execerror(t->name, ": a template cannot be redefined");
        extern void hoc_free_symspace(Symbol*);
        hoc_free_symspace(t);
    } else if (type != UNDEF) {
        hoc_execerror(t->name, "already used as something besides template");
    }
    t->u.ctemplate = (cTemplate*) emalloc(sizeof(cTemplate));
    t->type = TEMPLATE;
    t->u.ctemplate->sym = t;
    t->u.ctemplate->symtable = (Symlist*) 0;
    t->u.ctemplate->dataspace_size = 0;
    t->u.ctemplate->constructor = 0;
    t->u.ctemplate->destructor = 0;
    t->u.ctemplate->is_point_ = 0;
    t->u.ctemplate->steer = 0;
    t->u.ctemplate->id = ++template_id;
    pushtemplatei(icntobjectdata);
    pushtemplateodata(hoc_objectdata);
    pushtemplatei(hoc_in_template);
    pushtemplateo(hoc_thisobject);
    pushtemplatesymlist(hoc_symlist);
    pushtemplatesym(t);
    hoc_in_template = 1;
    hoc_objectdata = (Objectdata*) 0;
    hoc_thisobject = nullptr;
    hoc_symlist = t->u.ctemplate->symtable;
}
 
void hoc_endtemplate(Symbol* t) {
    Symbol *ts, *s;
#if PDEBUG
    printf("end template %s\n", t->name);
#endif
    ts = (poptemplate())->sym;
    if (strcmp(ts->name, t->name) != 0) {
        hoc_execerror(t->name, "- end template mismatched with begin");
    }
    ts->u.ctemplate->dataspace_size = icntobjectdata;
    ts->u.ctemplate->symtable = hoc_symlist;
    ts->u.ctemplate->count = 0;
    ts->u.ctemplate->index = 0;
    ts->u.ctemplate->olist = hoc_l_newlist();
    ts->u.ctemplate->observers = nullptr;
    hoc_symlist = (poptemplate())->symlist;
    free_objectdata(hoc_objectdata, ts->u.ctemplate);
    hoc_thisobject = (poptemplate())->o;
    hoc_in_template = (poptemplate())->i;
    hoc_objectdata = (poptemplate())->odata;
    icntobjectdata = (poptemplate())->i;
    ts->u.ctemplate->init = s = hoc_table_lookup("init", ts->u.ctemplate->symtable);
    if (s && s->type != PROCEDURE) {
        hoc_execerror("'init' can only be used as the initialization procedure for new objects",
                      nullptr);
    }
    ts->u.ctemplate->unref = s = hoc_table_lookup("unref", ts->u.ctemplate->symtable);
    if (s && s->type != PROCEDURE) {
        hoc_execerror(
            "'unref' can only be used as the callback procedure when the reference count is "
            "decremented",
            nullptr);
    }
}
 
void class2oc_base(const char* name,
                   ctor_f* cons,
                   dtor_f* destruct,
                   Member_func* m,
                   Member_ret_obj_func* mobjret,
                   Member_ret_str_func* strret) {
    extern int hoc_main1_inited_;
    Symbol *tsym, *s;
    cTemplate* t;
    int i;
 
    if (hoc_lookup(name)) {
        hoc_execerror(name, "already being used as a name");
    }
 
    tsym = hoc_install(name, UNDEF, 0.0, &hoc_symlist);
    tsym->subtype = CPLUSOBJECT;
    hoc_begintemplate(tsym);
    t = tsym->u.ctemplate;
    if (!hoc_main1_inited_ && t->id > hoc_max_builtin_class_id) {
        hoc_max_builtin_class_id = t->id;
    }
    t->constructor = cons;
    t->destructor = destruct;
    t->steer = 0;
 
    if (m)
        for (i = 0; m[i].name; ++i) {
            s = hoc_install(m[i].name, FUNCTION, 0.0, &hoc_symlist);
            s->u.u_proc->defn.pfd_vp = m[i].member;
            hoc_add_publiclist(s);
        }
    if (mobjret)
        for (i = 0; mobjret[i].name; ++i) {
            s = hoc_install(mobjret[i].name, OBFUNCTION, 0.0, &hoc_symlist);
            s->u.u_proc->defn.pfo_vp = mobjret[i].member;
            hoc_add_publiclist(s);
        }
    if (strret)
        for (i = 0; strret[i].name; ++i) {
            s = hoc_install(strret[i].name, STRFUNCTION, 0.0, &hoc_symlist);
            s->u.u_proc->defn.pfs_vp = strret[i].member;
            hoc_add_publiclist(s);
        }
    hoc_endtemplate(tsym);
}
 
 
void class2oc(const char* name,
              ctor_f* cons,
              dtor_f* destruct,
              Member_func* m,
              Member_ret_obj_func* mobjret,
              Member_ret_str_func* strret) {
    class2oc_base(name, cons, destruct, m, mobjret, strret);
    py_exposed_classes.push_back(name);
}
 
Symbol* hoc_decl(Symbol* s) {
    Symbol* ss;
    if (templatestackp == templatestack) {
        if (s == hoc_table_lookup(s->name, hoc_built_in_symlist)) {
            hoc_execerror(s->name, ": Redeclaring at top level");
        }
        return s;
    }
    ss = hoc_table_lookup(s->name, hoc_symlist);
    if (!ss) {
        ss = hoc_install(s->name, UNDEF, 0.0, &hoc_symlist);
    }
    return ss;
}
 
void hoc_add_publiclist(Symbol* s) {
    Symbol* ss;
#if PDEBUG
    printf("public name %s with type %d\n", s->name, s->type);
#endif
    if (templatestackp == templatestack) {
        hoc_execerror("Not in a template\n", 0);
    }
    ss = hoc_decl(s);
    ss->cpublic = PUBLIC_TYPE;
}
 
void hoc_external_var(Symbol* s) {
    Symbol* s0;
    if (templatestackp == templatestack) {
        hoc_execerror("Not in a template\n", 0);
    }
    if (s->cpublic == PUBLIC_TYPE) {
        hoc_execerror(s->name, "can't be public and external");
    }
    s->cpublic = EXTERNAL_TYPE;
    s0 = hoc_table_lookup(s->name, hoc_top_level_symlist);
    if (!s0) {
        hoc_execerror(s->name, "not declared at the top level");
    }
    s->type = s0->type;
    s->subtype = s0->subtype;
    switch (s->type) {
    case FUNCTION:
    case PROCEDURE:
    case ITERATOR:
    case HOCOBJFUNCTION:
        s->u.u_proc = s0->u.u_proc;
        break;
    case TEMPLATE:
        s->u.ctemplate = s0->u.ctemplate;
        break;
    case STRING:
    case OBJECTVAR:
    case VAR:
    case SECTION:
        s->arayinfo = s0->arayinfo;
        s->u.sym = s0;
        break;
    default:
        hoc_execerror(s->name, "type is not allowed external");
        break;
    }
}
 
void hoc_ob_check(int type) {
    int t;
    t = hoc_ipop();
    if (type == -1) {
        if (t == OBJECTVAR) { /* don't bother to check */
            hoc_Code(hoc_cmp_otype);
            hoc_codei(0);
        }
    } else if (type) {
        if (t == OBJECTVAR) { /* must check dynamically */
#if PDEBUG
            printf("dymnamic checking of type=%d\n", type);
#endif
            hoc_Code(hoc_cmp_otype);
            hoc_codei(type);
        } else if (type != t) { /* static check */
            hoc_execerror("Type mismatch", (char*) 0);
        }
    } else {
        if (t != OBJECTVAR) {
            hoc_Code(hoc_known_type);
            hoc_codei(t);
        }
    }
}
 
void hoc_free_allobjects(cTemplate* ctemplate, Symlist* sl, Objectdata* data) {
    /* look in all object variables that point to
        objects with this template and null them */
    Symbol* s;
    int total, i;
    Object** obp;
 
    if (sl)
        for (s = sl->first; s; s = s->next) {
            if (s->type == OBJECTVAR && s->cpublic != 2) {
                total = hoc_total_array_data(s, data);
                for (i = 0; i < total; i++) {
                    obp = data[s->u.oboff].pobj + i;
                    if (*obp) {
#if 1
                        if ((*obp)->ctemplate == ctemplate) {
                            hoc_dec_refcount(obp);
                        } else if (s->subtype != CPLUSOBJECT) {
                            /* descend to look for more */
                            hoc_free_allobjects(ctemplate,
                                                (*obp)->ctemplate->symtable,
                                                (*obp)->u.dataspace);
                        }
#else
                        if (s->subtype != CPLUSOBJECT) {
                            /* descend to look for more */
                            hoc_free_allobjects(ctemplate,
                                                (*obp)->ctemplate->symtable,
                                                (*obp)->u.dataspace);
                        }
                        if ((*obp)->ctemplate == ctemplate) {
                            hoc_dec_refcount(obp);
                        }
#endif
                    }
                }
            }
        }
}
 
#define objectpath  hoc_objectpath_impl
#define pathprepend hoc_path_prepend
 
constexpr std::size_t hoc_object_pathname_bufsize = 512;
void pathprepend(char* path, const char* name, const char* indx) {
    char buf[200];
    if (path[0]) {
        strcpy(buf, path);
        std::snprintf(path, hoc_object_pathname_bufsize, "%s%s.%s", name, indx, buf);
    } else {
        std::snprintf(path, hoc_object_pathname_bufsize, "%s%s", name, indx);
    }
}
 
int objectpath(Object* ob, Object* oblook, char* path, int depth) {
    /* recursively build the pathname to the object */
    Symbol* s;
    Symlist* sl;
    int total, i;
    Objectdata* od;
    Object** obp;
 
    if (ob == oblook) {
        return 1;
    }
    if (oblook) {
        if (depth++ > 5) {
            hoc_warning("objectpath depth > 4 for", oblook->ctemplate->sym->name);
            return 0;
        }
        if (oblook->ctemplate->constructor) {
            return ivoc_list_look(ob, oblook, path, depth);
        } else {
            od = oblook->u.dataspace;
            sl = oblook->ctemplate->symtable;
        }
    } else {
        od = hoc_top_level_data;
        sl = hoc_top_level_symlist;
    }
    if (sl)
        for (s = sl->first; s; s = s->next) {
            if (s->type == OBJECTVAR && s->cpublic != 2) {
                total = hoc_total_array_data(s, od);
                for (i = 0; i < total; i++) {
                    obp = od[s->u.oboff].pobj + i;
                    if (*obp && *obp != oblook && objectpath(ob, *obp, path, depth)) {
                        pathprepend(path, s->name, hoc_araystr(s, i, od));
                        return 1;
                    }
                }
            }
        }
    return 0;
}
 
char* hoc_object_pathname(Object* ob) {
    static char path[hoc_object_pathname_bufsize];
    path[0] = '\0';
    if (objectpath(ob, nullptr, path, 0)) {
        return path;
    } else {
#if 0
        hoc_warning("Couldn't find a pathname to the object pointer",
            ob->ctemplate->sym->name);
        return (char*)0;
#else
        return hoc_object_name(ob);
#endif
    }
}
 
void hoc_obj_ref(Object* obj) {
    if (obj) {
        ++obj->refcount;
    }
}
 
void hoc_dec_refcount(Object** pobj) {
    Object* obj;
 
    obj = *pobj;
    if (obj == (Object*) 0) {
        return;
    }
    *pobj = (Object*) 0;
    assert(obj->refcount > 0);
    hoc_obj_unref(obj);
}
 
namespace {
struct helper_in_case_dtor_throws {
    helper_in_case_dtor_throws(Object* obj)
        : m_obj{obj} {}
    ~helper_in_case_dtor_throws() {
        if (--m_obj->ctemplate->count <= 0) {
            m_obj->ctemplate->index = 0;
        }
        m_obj->ctemplate = nullptr;
        /* for testing purposes we don't free the object in order
        to make sure no object variable ever uses a freed object */
        hoc_free_object(m_obj);
    }
 
  private:
    Object* m_obj;
};
}  // namespace
 
void hoc_obj_unref(Object* obj) {
    Object* obsav;
 
    if (!obj) {
        return;
    }
#if 0
printf("unreffing %s with refcount %d\n", hoc_object_name(obj), obj->refcount);
#endif
    --obj->refcount;
    if (obj->ctemplate->unref) {
        int i = obj->refcount;
        hoc_pushx((double) i);
        ++obj->unref_recurse_cnt;
        hoc_call_ob_proc(obj, obj->ctemplate->unref, 1);
        --obj->unref_recurse_cnt;
    }
    if (obj->refcount <= 0 && obj->unref_recurse_cnt == 0) {
        if (obj->aliases) {
            ivoc_free_alias(obj);
        }
        if (obj->observers) {
            hoc_obj_disconnect(obj);
        }
        hoc_l_delete(obj->itm_me);
        if (obj->ctemplate->observers) {
            hoc_template_notify(obj, 0);
        }
        // make sure that dereffing happens even if the destructor throws
        helper_in_case_dtor_throws _{obj};
        if (obj->ctemplate->sym->subtype & (CPLUSOBJECT | JAVAOBJECT)) {
            if (auto* const tp = obj->u.this_pointer; tp) {
                neuron::oc::invoke_method_that_may_throw(
                    [obj]() {
                        std::string rval{hoc_object_name(obj)};
                        rval.append(" destructor");
                        return rval;
                    },
                    obj->ctemplate->destructor,
                    tp);
            }
        } else {
            obsav = hoc_thisobject;
            hoc_thisobject = obj;
            free_objectdata(obj->u.dataspace, obj->ctemplate);
            obj->u.dataspace = (Objectdata*) 0;
            hoc_thisobject = obsav;
        }
    }
}
 
static void free_objectdata(Objectdata* od, cTemplate* ctemplate) {
    Symbol* s;
    int i, total;
    Objectdata* psav;
    Object** objp;
 
    psav = hoc_objectdata;
    hoc_objectdata = od;
    if (ctemplate->symtable)
        for (s = ctemplate->symtable->first; s; s = s->next) {
            if (s->cpublic != 2) {
                switch (s->type) {
                case VAR:
                    /*printf("free_objectdata %s\n", s->name);*/
                    hoc_free_val_array(OPVAL(s), hoc_total_array(s));
                    hoc_free_arrayinfo(OPARINFO(s));
                    break;
                case STRING:
                    hoc_free_pstring(OPSTR(s));
                    hoc_free_arrayinfo(OPARINFO(s));
                    break;
                case OBJECTVAR:
                    objp = OPOBJ(s);
                    if (strcmp("this", s->name) != 0) {
                        total = hoc_total_array(s);
                        for (i = 0; i < total; i++) {
                            hoc_dec_refcount(objp + i);
                        }
                    }
                    hoc_free_arrayinfo(OPARINFO(s));
                    free(objp);
                    break;
                case SECTION:
                    total = hoc_total_array(s);
                    for (i = 0; i < total; ++i) {
                        sec_free(*(OPSECITM(s) + i));
                    }
                    free(OPSECITM(s));
                    hoc_free_arrayinfo(OPARINFO(s));
                    break;
                }
            }
        }
    if (ctemplate->is_point_) {
        void* v = od[ctemplate->dataspace_size - 1]._pvoid;
        if (v) {
            /*          printf("Free point process\n");*/
            destroy_point_process(v);
        }
    }
    hoc_objectdata = psav;
    if (od) {
        free((char*) od);
    }
}
 
 
static void hoc_allobjects1(Symlist* sl, int nspace);
static void hoc_allobjects2(Symbol* s, int nspace);
 
void hoc_allobjects(void) {
    int n = 0;
    if (ifarg(1)) {
        if (hoc_is_str_arg(1)) {
            hoc_allobjects2(hoc_lookup(gargstr(1)), 0);
        } else {
            Object** o = hoc_objgetarg(1);
            if (*o) {
                n = (*o)->refcount;
            }
        }
    } else {
        hoc_allobjects1(hoc_built_in_symlist, 0);
        hoc_allobjects1(hoc_top_level_symlist, 0);
    }
    hoc_ret();
    hoc_pushx((double) n);
}
 
void hoc_allobjects1(Symlist* sl, int nspace) {
    Symbol* s;
    cTemplate* t;
    Object* o;
    hoc_Item* q;
    int i;
    if (sl)
        for (s = sl->first; s; s = s->next) {
            if (s->type == TEMPLATE) {
                t = s->u.ctemplate;
                ITERATE(q, t->olist) {
                    o = OBJ(q);
                    for (i = 0; i < nspace; ++i) {
                        Printf("   ");
                    }
                    Printf("%s with %d refs\n", hoc_object_name(o), o->refcount);
                }
                hoc_allobjects1(t->symtable, nspace + 1);
            }
        }
}
 
void hoc_allobjects2(Symbol* s, int nspace) {
    cTemplate* t;
    Object* o;
    hoc_Item* q;
    int i;
    if (s && s->type == TEMPLATE) {
        t = s->u.ctemplate;
        ITERATE(q, t->olist) {
            o = OBJ(q);
            for (i = 0; i < nspace; ++i) {
                Printf("   ");
            }
            Printf("%s with %d refs\n", hoc_object_name(o), o->refcount);
        }
    }
}
 
static void hoc_list_allobjref(Symlist*, Objectdata*, int);
 
void hoc_allobjectvars(void) {
    hoc_list_allobjref(hoc_top_level_symlist, hoc_top_level_data, 0);
    hoc_ret();
    hoc_pushx(0.);
}
 
static void hoc_list_allobjref(Symlist* sl, Objectdata* data, int depth) {
    /* look in all object variables that point to
        objects and print them */
    Symbol* s;
    int total, i, id;
    Object** obp;
 
    if (sl)
        for (s = sl->first; s; s = s->next) {
            if (s->type == OBJECTVAR && s->cpublic != 2) {
                total = hoc_total_array_data(s, data);
                for (i = 0; i < total; i++) {
                    obp = data[s->u.oboff].pobj + i;
                    for (id = 0; id < depth; id++) {
                        Printf("   ");
                    }
                    if (*obp) {
                        Printf("obp %s[%d] -> %s with %d refs.\n",
                               s->name,
                               i,
                               hoc_object_name(*obp),
                               (*obp)->refcount);
                    } else {
                        Printf("obp %s[%d] -> NULL\n", s->name, i);
                    }
                    if (*obp && !(*obp)->recurse && s->subtype != CPLUSOBJECT &&
                        (*obp)->u.dataspace != data /* not this */
                    ) {
                        /* descend to look for more */
                        (*obp)->recurse = 1;
                        hoc_list_allobjref((*obp)->ctemplate->symtable,
                                           (*obp)->u.dataspace,
                                           depth + 1);
                        (*obp)->recurse = 0;
                    }
                }
            }
        }
}
 
void check_obj_type(Object* obj, const char* type_name) {
    char buf[100];
    if (!obj || strcmp(obj->ctemplate->sym->name, type_name) != 0) {
        if (obj) {
            Sprintf(buf, "object type is %s instead of", obj->ctemplate->sym->name);
        } else {
            Sprintf(buf, "object type is nullptr instead of");
        }
        hoc_execerror(buf, type_name);
    }
}
 
int is_obj_type(Object* obj, const char* type_name) {
    if (obj && strcmp(obj->ctemplate->sym->name, type_name) == 0) {
        return 1;
    } else {
        return 0;
    }
}
 
 
void* nrn_opaque_obj2pyobj(Object* ho) {
    // The PyObject* reference is not incremented. Use only as last resort
    if (neuron::python::methods.opaque_obj2pyobj) {
        return neuron::python::methods.opaque_obj2pyobj(ho);
    }
    return nullptr;
}
 
// Helper functions for object arithmetic operations
 
// Helper for object-object binary operations
static void hoc_object_binary_op_helper(const char* method_name) {
    Object** obj2_ptr = hoc_objpop();  // Second operand
    Object** obj1_ptr = hoc_objpop();  // First operand (the one that has the method)
 
    Object* obj1 = *obj1_ptr;
    Object* obj2 = *obj2_ptr;
 
    if (!obj1) {
        hoc_execerror("Object arithmetic: first operand is null", nullptr);
    }
 
    // Try Python first if available
    if (nrnpy_call_obj_method && nrnpy_call_obj_method(obj1, method_name, obj2) != 0) {
        // Python handled the operation, result is on the stack
        hoc_tobj_unref(obj1_ptr);
        hoc_tobj_unref(obj2_ptr);
        return;
    }
 
    // Look up the method
    Symbol* method_sym = nrn_method_symbol(obj1, method_name);
    if (!method_sym) {
        hoc_execerror_fmt("Object arithmetic: method '{}' not found in object '{}'",
                          method_name,
                          obj1->ctemplate->sym->name);
    }
 
    // Call the HOC method: obj1.method(obj2)
    hoc_pushobj(obj2_ptr);
    nrn_method_call(obj1, method_sym, 1);
 
    // Clean up temporary object references
    hoc_tobj_unref(obj1_ptr);
    hoc_tobj_unref(obj2_ptr);
}
 
// Helper for object-number binary operations (object op number)
static void hoc_object_number_binary_op_helper(const char* method_name) {
    double d = hoc_xpop();            // Second operand (number)
    Object** obj_ptr = hoc_objpop();  // First operand (object)
 
    Object* obj = *obj_ptr;
    if (!obj) {
        hoc_execerror("Object arithmetic: object operand is null", nullptr);
    }
 
    // Try Python first if available
    if (nrnpy_call_obj_method_double && nrnpy_call_obj_method_double(obj, method_name, d) != 0) {
        // Python handled the operation, result is on the stack
        hoc_tobj_unref(obj_ptr);
        return;
    }
 
    Symbol* method_sym = nrn_method_symbol(obj, method_name);
    if (!method_sym) {
        hoc_execerror_fmt("Object arithmetic: method '{}' not found in object '{}'",
                          method_name,
                          obj->ctemplate->sym->name);
    }
 
    // Push the number as argument for the method call
    hoc_pushx(d);
 
    // Call the method: obj.method(number)
    nrn_method_call(obj, method_sym, 1);
    hoc_tobj_unref(obj_ptr);
}
 
// Helper for number-object binary operations (number op object)
// This uses the reverse magic method (e.g., __radd__ for addition)
static void hoc_number_object_binary_op_helper(const char* method_name) {
    Object** obj_ptr = hoc_objpop();  // Second operand (object)
    double d = hoc_xpop();            // First operand (number)
 
    Object* obj = *obj_ptr;
    if (!obj) {
        hoc_execerror("Object arithmetic: object operand is null", nullptr);
    }
 
    // Try Python first if available
    if (nrnpy_call_obj_method_double && nrnpy_call_obj_method_double(obj, method_name, d) != 0) {
        // Python handled the operation, result is on the stack
        hoc_tobj_unref(obj_ptr);
        return;
    }
 
    Symbol* method_sym = nrn_method_symbol(obj, method_name);
    if (!method_sym) {
        hoc_execerror_fmt("Object arithmetic: method '{}' not found in object '{}'",
                          method_name,
                          obj->ctemplate->sym->name);
    }
 
    // Push the number as argument for the method call
    hoc_pushx(d);
 
    // Call the method: obj.method(number)
    nrn_method_call(obj, method_sym, 1);
    hoc_tobj_unref(obj_ptr);
}
 
// Object arithmetic functions that call HOC object methods
void hoc_object_add() {
    hoc_object_binary_op_helper("__add__");
}
 
void hoc_object_sub() {
    hoc_object_binary_op_helper("__sub__");
}
 
void hoc_object_mul() {
    hoc_object_binary_op_helper("__mul__");
}
 
void hoc_object_div() {
    hoc_object_binary_op_helper("__div__");
}
 
void hoc_object_pow() {
    hoc_object_binary_op_helper("__pow__");
}
 
// Helper for comparison operations
// Handles common setup, null checks, and Python attempts
// Returns true if the operation was handled (caller should return)
// Returns false if caller needs to handle HOC method lookup
static bool hoc_object_comparison_setup(Object**& obj1_ptr,
                                        Object**& obj2_ptr,
                                        Object*& obj1,
                                        Object*& obj2,
                                        const char* method_name,
                                        bool is_equality) {
    obj2_ptr = hoc_objpop();  // Second operand
    obj1_ptr = hoc_objpop();  // First operand
 
    obj1 = *obj1_ptr;
    obj2 = *obj2_ptr;
 
    // Handle null object cases with pointer comparison fallback
    if (!obj1 || !obj2) {
        double result = is_equality ? ((*obj1_ptr == *obj2_ptr) ? 1.0 : 0.0)
                                    : ((*obj1_ptr != *obj2_ptr) ? 1.0 : 0.0);
        hoc_tobj_unref(obj1_ptr);
        hoc_tobj_unref(obj2_ptr);
        hoc_pushx(result);
        return true;  // Handled
    }
 
    // Try Python first if available
    if (nrnpy_call_obj_method && nrnpy_call_obj_method(obj1, method_name, obj2) != 0) {
        // Python handled the operation, result is on the stack
        hoc_tobj_unref(obj1_ptr);
        hoc_tobj_unref(obj2_ptr);
        return true;  // Handled
    }
 
    return false;  // Not handled, caller should proceed with HOC method lookup
}
 
// Helper to call a comparison method and cleanup
static void hoc_object_comparison_call(Object** obj1_ptr,
                                       Object** obj2_ptr,
                                       Object* obj1,
                                       Symbol* method_sym) {
    hoc_pushobj(obj2_ptr);
    nrn_method_call(obj1, method_sym, 1);
    hoc_tobj_unref(obj1_ptr);
    hoc_tobj_unref(obj2_ptr);
}
 
// Helper for pointer comparison fallback
static void hoc_object_comparison_fallback(Object** obj1_ptr, Object** obj2_ptr, bool is_equality) {
    double result = is_equality ? ((*obj1_ptr == *obj2_ptr) ? 1.0 : 0.0)
                                : ((*obj1_ptr != *obj2_ptr) ? 1.0 : 0.0);
    hoc_tobj_unref(obj1_ptr);
    hoc_tobj_unref(obj2_ptr);
    hoc_pushx(result);
}
 
void hoc_object_eq() {
    Object** obj1_ptr;
    Object** obj2_ptr;
    Object* obj1;
    Object* obj2;
 
    if (hoc_object_comparison_setup(obj1_ptr, obj2_ptr, obj1, obj2, "__eq__", true)) {
        return;  // Already handled by setup (Python or null case)
    }
 
    // Look up the __eq__ method
    Symbol* method_sym = nrn_method_symbol(obj1, "__eq__");
    if (!method_sym) {
        // No __eq__ method found, fall back to pointer equality
        hoc_object_comparison_fallback(obj1_ptr, obj2_ptr, true);
        return;
    }
 
    // Call the method and cleanup
    hoc_object_comparison_call(obj1_ptr, obj2_ptr, obj1, method_sym);
}
 
void hoc_object_ne() {
    Object** obj1_ptr;
    Object** obj2_ptr;
    Object* obj1;
    Object* obj2;
 
    if (hoc_object_comparison_setup(obj1_ptr, obj2_ptr, obj1, obj2, "__ne__", false)) {
        return;  // Already handled by setup (Python or null case)
    }
 
    // Look up the __ne__ method first
    Symbol* method_sym = nrn_method_symbol(obj1, "__ne__");
    if (method_sym) {
        hoc_object_comparison_call(obj1_ptr, obj2_ptr, obj1, method_sym);
        return;
    }
 
    // No __ne__ method, try __eq__ method and negate result
    method_sym = nrn_method_symbol(obj1, "__eq__");
    if (method_sym) {
        hoc_pushobj(obj2_ptr);
        nrn_method_call(obj1, method_sym, 1);
        // Negate the result
        double eq_result = hoc_xpop();
        hoc_tobj_unref(obj1_ptr);
        hoc_tobj_unref(obj2_ptr);
        hoc_pushx(eq_result ? 0.0 : 1.0);
        return;
    }
 
    // No magic methods found, fall back to pointer inequality
    hoc_object_comparison_fallback(obj1_ptr, obj2_ptr, false);
}
 
// Mixed-type arithmetic functions (object with number)
void hoc_object_add_number() {
    hoc_object_number_binary_op_helper("__add__");
}
 
void hoc_number_add_object() {
    hoc_number_object_binary_op_helper("__radd__");
}
 
void hoc_object_sub_number() {
    hoc_object_number_binary_op_helper("__sub__");
}
 
void hoc_number_sub_object() {
    hoc_number_object_binary_op_helper("__rsub__");
}
 
void hoc_object_mul_number() {
    hoc_object_number_binary_op_helper("__mul__");
}
 
void hoc_number_mul_object() {
    hoc_number_object_binary_op_helper("__rmul__");
}
 
void hoc_object_div_number() {
    hoc_object_number_binary_op_helper("__div__");
}
 
void hoc_number_div_object() {
    hoc_number_object_binary_op_helper("__rdiv__");
}
 
void hoc_object_pow_number() {
    hoc_object_number_binary_op_helper("__pow__");
}
 
void hoc_number_pow_object() {
    hoc_number_object_binary_op_helper("__rpow__");
}