void gtm_startup(struct startup_vector *svec)
/* Note: various references to data copied from *svec could profitably be referenced directly */
{
unsigned char *mstack_ptr;
void gtm_ret_code();
static readonly unsigned char init_break[1] = {'B'};
int4 lct;
int i;
static char other_mode_buf[] = "OTHER";
mstr log_name;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(INVALID_IMAGE != image_type);
assert(svec->argcnt == SIZEOF(*svec));
IA64_ONLY(init_xfer_table());
get_page_size();
cache_table_relobjs = &cache_table_rebuild;
ht_rhash_ch = &hashtab_rehash_ch;
jbxm_dump_ch = &jobexam_dump_ch;
heartbeat_timer_ptr = &heartbeat_timer;
stpgc_ch = &stp_gcol_ch;
rtn_fst_table = rtn_names = (rtn_tabent *)svec->rtn_start;
rtn_names_end = rtn_names_top = (rtn_tabent *)svec->rtn_end;
if (svec->user_stack_size < 4096)
svec->user_stack_size = 4096;
if (svec->user_stack_size > 8388608)
svec->user_stack_size = 8388608;
mstack_ptr = (unsigned char *)malloc(svec->user_stack_size);
msp = stackbase = mstack_ptr + svec->user_stack_size - mvs_size[MVST_STORIG];
/* mark the stack base so that if error occur during call-in gtm_init(), the unwind
* logic in gtmci_ch() will get rid of the stack completely
*/
fgncal_stack = stackbase;
mv_chain = (mv_stent *)msp;
mv_chain->mv_st_type = MVST_STORIG; /* Initialize first (anchor) mv_stent so doesn't do anything */
mv_chain->mv_st_next = 0;
mv_chain->mv_st_cont.mvs_storig = 0;
stacktop = mstack_ptr + 2 * mvs_size[MVST_NTAB];
stackwarn = stacktop + (16 * 1024);
break_message_mask = svec->break_message_mask;
if (svec->user_strpl_size < STP_INITSIZE)
svec->user_strpl_size = STP_INITSIZE;
else if (svec->user_strpl_size > STP_MAXINITSIZE)
svec->user_strpl_size = STP_MAXINITSIZE;
stp_init(svec->user_strpl_size);
if (svec->user_indrcache_size > MAX_INDIRECTION_NESTING || svec->user_indrcache_size < MIN_INDIRECTION_NESTING)
svec->user_indrcache_size = MIN_INDIRECTION_NESTING;
TREF(ind_result_array) = (mval **)malloc(SIZEOF(mval *) * svec->user_indrcache_size);
TREF(ind_source_array) = (mval **)malloc(SIZEOF(mval *) * svec->user_indrcache_size);
TREF(ind_result_sp) = TREF(ind_result_array);
TREF(ind_result_top) = TREF(ind_result_sp) + svec->user_indrcache_size;
TREF(ind_source_sp) = TREF(ind_source_array);
TREF(ind_source_top) = TREF(ind_source_sp) + svec->user_indrcache_size;
rts_stringpool = stringpool;
TREF(compile_time) = FALSE;
/* assert that is_replicator and run_time is properly set by gtm_imagetype_init invoked at process entry */
# ifdef DEBUG
switch (image_type)
{
case GTM_IMAGE:
case GTM_SVC_DAL_IMAGE:
assert(is_replicator && run_time);
break;
case MUPIP_IMAGE:
assert(!is_replicator && !run_time);
break;
default:
assert(FALSE);
}
# endif
gtm_utf8_init(); /* Initialize the runtime for Unicode */
/* Initialize alignment requirement for the runtime stringpool */
log_name.addr = DISABLE_ALIGN_STRINGS;
log_name.len = STR_LIT_LEN(DISABLE_ALIGN_STRINGS);
/* mstr_native_align = logical_truth_value(&log_name, FALSE, NULL) ? FALSE : TRUE; */
mstr_native_align = FALSE; /* TODO: remove this line and uncomment the above line */
getjobname();
INVOKE_INIT_SECSHR_ADDRS;
getzprocess();
getzmode();
geteditor();
zcall_init();
cmd_qlf.qlf = glb_cmd_qlf.qlf;
cache_init();
# ifdef __sun
if (NULL != GETENV(PACKAGE_ENV_TYPE)) /* chose xcall (default) or rpc zcall */
xfer_table[xf_fnfgncal] = (xfer_entry_t)op_fnfgncal_rpc; /* using RPC */
# endif
msp -= SIZEOF(stack_frame);
frame_pointer = (stack_frame *)msp;
memset(frame_pointer,0, SIZEOF(stack_frame));
frame_pointer->temps_ptr = (unsigned char *)frame_pointer;
frame_pointer->ctxt = GTM_CONTEXT(gtm_ret_code);
frame_pointer->mpc = CODE_ADDRESS(gtm_ret_code);
frame_pointer->type = SFT_COUNT;
frame_pointer->rvector = (rhdtyp*)malloc(SIZEOF(rhdtyp));
memset(frame_pointer->rvector, 0, SIZEOF(rhdtyp));
symbinit();
/* Variables for supporting $ZSEARCH sorting and wildcard expansion */
TREF(zsearch_var) = lv_getslot(curr_symval);
TREF(zsearch_dir1) = lv_getslot(curr_symval);
TREF(zsearch_dir2) = lv_getslot(curr_symval);
LVVAL_INIT((TREF(zsearch_var)), curr_symval);
LVVAL_INIT((TREF(zsearch_dir1)), curr_symval);
LVVAL_INIT((TREF(zsearch_dir2)), curr_symval);
/* Initialize global pointer to control-C handler. Also used in iott_use */
ctrlc_handler_ptr = &ctrlc_handler;
io_init(IS_MUPIP_IMAGE); /* starts with nocenable for GT.M runtime, enabled for MUPIP */
if (!IS_MUPIP_IMAGE)
{
sig_init(generic_signal_handler, ctrlc_handler_ptr, suspsigs_handler, continue_handler);
atexit(gtm_exit_handler);
cenable(); /* cenable unless the environment indicates otherwise - 2 steps because this can report errors */
}
jobinterrupt_init();
getzdir();
dpzgbini();
zco_init();
/* a base addr of 0 indicates a gtm_init call from an rpc server */
if ((GTM_IMAGE == image_type) && (NULL != svec->base_addr))
jobchild_init();
else
{ /* Trigger enabled utilities will enable through here */
(TREF(dollar_zmode)).mvtype = MV_STR;
(TREF(dollar_zmode)).str.addr = other_mode_buf;
(TREF(dollar_zmode)).str.len = SIZEOF(other_mode_buf) -1;
}
svec->frm_ptr = (unsigned char *)frame_pointer;
dollar_ztrap.mvtype = MV_STR;
dollar_ztrap.str.len = SIZEOF(init_break);
dollar_ztrap.str.addr = (char *)init_break;
dollar_zstatus.mvtype = MV_STR;
dollar_zstatus.str.len = 0;
dollar_zstatus.str.addr = NULL;
ecode_init();
zyerror_init();
ztrap_form_init();
ztrap_new_init();
zdate_form_init(svec);
dollar_system_init(svec);
init_callin_functable();
gtm_env_xlate_init();
SET_LATCH_GLOBAL(&defer_latch, LOCK_AVAILABLE);
curr_pattern = pattern_list = &mumps_pattern;
pattern_typemask = mumps_pattern.typemask;
initialize_pattern_table();
ce_init(); /* initialize compiler escape processing */
/* Initialize local collating sequence */
TREF(transform) = TRUE;
lct = find_local_colltype();
if (lct != 0)
{
TREF(local_collseq) = ready_collseq(lct);
if (!TREF(local_collseq))
{
exi_condition = -ERR_COLLATIONUNDEF;
gtm_putmsg(VARLSTCNT(3) ERR_COLLATIONUNDEF, 1, lct);
exit(exi_condition);
}
} else
TREF(local_collseq) = 0;
prealloc_gt_timers();
gt_timers_add_safe_hndlrs();
for (i = 0; FNPC_MAX > i; i++)
{ /* Initialize cache structure for $Piece function */
(TREF(fnpca)).fnpcs[i].pcoffmax = &(TREF(fnpca)).fnpcs[i].pstart[FNPC_ELEM_MAX];
(TREF(fnpca)).fnpcs[i].indx = i;
}
(TREF(fnpca)).fnpcsteal = (TREF(fnpca)).fnpcs; /* Starting place to look for cache reuse */
(TREF(fnpca)).fnpcmax = &(TREF(fnpca)).fnpcs[FNPC_MAX - 1]; /* The last element */
/* Initialize zwrite subsystem. Better to do it now when we have storage to allocate than
* if we fail and storage allocation may not be possible. To that end, pretend we have
* seen alias acitivity so those structures are initialized as well.
*/
assert(FALSE == curr_symval->alias_activity);
curr_symval->alias_activity = TRUE;
lvzwr_init((enum zwr_init_types)0, (mval *)NULL);
curr_symval->alias_activity = FALSE;
if ((NULL != (TREF(mprof_env_gbl_name)).str.addr))
turn_tracing_on(TADR(mprof_env_gbl_name), TRUE, (TREF(mprof_env_gbl_name)).str.len > 0);
return;
}
void op_svget(int varnum, mval *v)
{
io_log_name *tl;
int count;
gtm_uint64_t ucount;
char *c1, *c2;
mval *mvp;
# ifdef UNIX
d_rm_struct *d_rm;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
# if defined(UNIX) && defined(DEBUG)
if (gtm_white_box_test_case_enabled && (WBTEST_HUGE_ALLOC == gtm_white_box_test_case_number))
{
if (1 == gtm_white_box_test_case_count)
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xffff;
else if (2 == gtm_white_box_test_case_count)
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff;
else if (3 == gtm_white_box_test_case_count)
{
# ifdef GTM64
if (8 == SIZEOF(size_t))
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta
= totalUsed = totalUsedGta = 0xfffffffffffffff;
else
# endif
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed = totalUsedGta = 0xfffffff;
} else
totalAlloc = totalAllocGta = totalRmalloc = totalRallocGta = totalUsed
= totalUsedGta = GTM64_ONLY(SIZEOF(size_t)) NON_GTM64_ONLY(SIZEOF(size_t) > 4 ? 4 : SIZEOF(size_t));
}
# endif
switch (varnum)
{
case SV_HOROLOG:
op_horolog(v);
break;
case SV_ZGBLDIR:
v->mvtype = MV_STR;
v->str = dollar_zgbldir.str;
break;
case SV_PRINCIPAL:
tl = dollar_principal ? dollar_principal : io_root_log_name->iod->trans_name;
v->str.addr = tl->dollar_io;
v->str.len = tl->len;
/*** The following should be in the I/O code ***/
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
v->mvtype = MV_STR;
break;
case SV_ZIO:
v->mvtype = MV_STR;
/* NOTE: This is **NOT** equivalent to :
* io_curr_log_name->dollar_io
*/
v->str.addr = io_curr_device.in->trans_name->dollar_io;
v->str.len = io_curr_device.in->trans_name->len;
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
break;
case SV_JOB:
*v = dollar_job;
break;
case SV_REFERENCE:
get_reference(v);
break;
case SV_SYSTEM:
*v = dollar_system;
break;
case SV_STORAGE:
/* double2mval(v, getstorage()); Causes issues with unaligned stack on x86_64 - remove until fixed */
i2mval(v, getstorage());
break;
case SV_TLEVEL:
count = (int)dollar_tlevel;
MV_FORCE_MVAL(v, count);
break;
case SV_TRESTART:
MV_FORCE_MVAL(v, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart));
break;
case SV_X:
count = (int)io_curr_device.out->dollar.x;
MV_FORCE_MVAL(v, count);
break;
case SV_Y:
count = (int)io_curr_device.out->dollar.y;
MV_FORCE_MVAL(v, count);
break;
case SV_ZA:
count = (int)io_curr_device.in->dollar.za;
MV_FORCE_MVAL(v, count);
break;
case SV_ZB:
c1 = (char *)io_curr_device.in->dollar.zb;
c2 = c1 + SIZEOF(io_curr_device.in->dollar.zb);
ENSURE_STP_FREE_SPACE(SIZEOF(io_curr_device.in->dollar.zb));
v->mvtype = MV_STR;
v->str.addr = (char *)stringpool.free;
while (c1 < c2 && *c1)
*stringpool.free++ = *c1++;
v->str.len = INTCAST((char *)stringpool.free - v->str.addr);
break;
case SV_ZC: /****THESE ARE DUMMY VALUES ONLY!!!!!!!!!!!!!!!!!****/
MV_FORCE_MVAL(v, 0);
break;
case SV_ZCMDLINE:
get_command_line(v, TRUE); /* TRUE to indicate we want $ZCMDLINE
(i.e. processed not actual command line) */
break;
case SV_ZEOF:
# ifdef UNIX
if (rm == io_curr_device.in->type)
{
d_rm = (d_rm_struct *)io_curr_device.in->dev_sp;
if (RM_READ != d_rm->lastop)
{
*v = literal_zero;
break;
}
}
# endif
*v = io_curr_device.in->dollar.zeof ? literal_one : literal_zero;
break;
case SV_ZQUIT:
*v = dollar_zquit_anyway ? literal_one : literal_zero;
break;
case SV_IO:
v->str.addr = io_curr_device.in->name->dollar_io;
v->str.len = io_curr_device.in->name->len;
/*** The following should be in the I/O code ***/
if (ESC == *v->str.addr)
{
if (5 > v->str.len)
v->str.len = 0;
else
{
v->str.addr += ESC_OFFSET;
v->str.len -= ESC_OFFSET;
}
}
s2pool(&(v->str));
v->mvtype = MV_STR;
break;
case SV_PROMPT:
v->mvtype = MV_STR;
v->str.addr = (TREF(gtmprompt)).addr;
v->str.len = (TREF(gtmprompt)).len;
s2pool(&v->str);
break;
case SV_ZCOMPILE:
v->mvtype = MV_STR;
v->str = TREF(dollar_zcompile);
s2pool(&(v->str));
break;
case SV_ZDIR:
setzdir(NULL, v);
if (v->str.len != dollar_zdir.str.len || 0 != memcmp(v->str.addr, dollar_zdir.str.addr, v->str.len))
gtm_putmsg_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4, v->str.len, v->str.addr,
dollar_zdir.str.len, dollar_zdir.str.addr);
SKIP_DEVICE_IF_NOT_NEEDED(v);
s2pool(&(v->str));
break;
case SV_ZSTEP:
*v = dollar_zstep;
break;
case SV_ZMODE:
*v = TREF(dollar_zmode);
break;
case SV_ZMAXTPTIME:
i2mval(v, TREF(dollar_zmaxtptime));
break;
case SV_ZPOS:
getzposition(v);
break;
case SV_ZPROC:
getzprocess();
*v = dollar_zproc;
break;
case SV_ZLEVEL:
count = dollar_zlevel();
MV_FORCE_MVAL(v, count);
break;
case SV_ZROUTINES:
if (!TREF(zro_root))
zro_init();
v->mvtype = MV_STR;
v->str = TREF(dollar_zroutines);
s2pool(&(v->str));
break;
case SV_ZSOURCE:
v->mvtype = MV_STR;
v->str = dollar_zsource.str;
break;
case SV_ZSTATUS:
*v = dollar_zstatus;
s2pool(&(v->str));
break;
case SV_ZTRAP:
v->mvtype = MV_STR;
v->str = dollar_ztrap.str;
assert(!v->str.len || !ztrap_explicit_null);
s2pool(&(v->str));
break;
case SV_DEVICE:
get_dlr_device(v);
break;
case SV_KEY:
get_dlr_key(v);
break;
case SV_ZVERSION:
v->mvtype = MV_STR;
v->str.addr = (char *)gtm_release_name;
v->str.len = gtm_release_name_len;
break;
case SV_ZSYSTEM:
MV_FORCE_MVAL(v, dollar_zsystem);
break;
case SV_ZCSTATUS:
/* Maintain the external $ZCSTATUS == 1 for SUCCESS on UNIX while internal good is 0 */
MV_FORCE_MVAL(v, UNIX_ONLY((0 == TREF(dollar_zcstatus)) ? 1 : ) TREF(dollar_zcstatus));
break;
case SV_ZEDITOR:
MV_FORCE_MVAL(v, dollar_zeditor);
break;
case SV_QUIT:
MV_FORCE_MVAL(v, dollar_quit());
break;
case SV_ECODE:
ecode_get(-1, v);
break;
case SV_ESTACK:
count = (dollar_zlevel() - 1) - dollar_estack_delta.m[0];
MV_FORCE_MVAL(v, count);
break;
case SV_ETRAP:
v->mvtype = MV_STR;
v->str = dollar_etrap.str;
assert(!v->str.len || !ztrap_explicit_null);
s2pool(&(v->str));
break;
case SV_STACK:
count = (dollar_zlevel() - 1);
MV_FORCE_MVAL(v, count);
break;
case SV_ZERROR:
v->mvtype = MV_STR;
v->str = dollar_zerror.str;
s2pool(&(v->str));
break;
case SV_ZYERROR:
v->mvtype = MV_STR;
v->str = dollar_zyerror.str;
s2pool(&(v->str));
break;
case SV_ZINTERRUPT:
v->mvtype = MV_STR;
v->str = dollar_zinterrupt.str;
s2pool(&(v->str));
break;
case SV_ZININTERRUPT:
MV_FORCE_MVAL(v, dollar_zininterrupt);
break;
case SV_ZJOB:
MV_FORCE_UMVAL(v, dollar_zjob);
break;
case SV_ZDATE_FORM:
MV_FORCE_MVAL(v, TREF(zdate_form));
break;
case SV_ZTEXIT:
*v = dollar_ztexit;
break;
case SV_ZALLOCSTOR:
ucount = (gtm_uint64_t)totalAlloc + (gtm_uint64_t)totalAllocGta;
ui82mval(v, ucount);
break;
case SV_ZREALSTOR:
ucount = (gtm_uint64_t)totalRmalloc + (gtm_uint64_t)totalRallocGta;
ui82mval(v, ucount);
break;
case SV_ZUSEDSTOR:
ucount = (gtm_uint64_t)totalUsed + (gtm_uint64_t)totalUsedGta;
ui82mval(v, ucount);
break;
case SV_ZCHSET:
v->mvtype = MV_STR;
v->str = dollar_zchset;
break;
case SV_ZPATNUMERIC:
v->mvtype = MV_STR;
v->str = dollar_zpatnumeric;
break;
case SV_ZTNAME:
case SV_ZTCODE: /* deprecated */
# ifdef GTM_TRIGGER
if (NULL == dollar_ztname)
memcpy(v, &literal_null, SIZEOF(mval));
else
{
v->mvtype = MV_STR;
v->str.addr = dollar_ztname->addr;
v->str.len = dollar_ztname->len;
}
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTDATA:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but it might be numeric and need conversion to a string */
assert(!dollar_ztdata || MV_DEFINED(dollar_ztdata));
if (NULL != dollar_ztdata)
MV_FORCE_STR(dollar_ztdata);
memcpy(v, (NULL != dollar_ztdata) ? dollar_ztdata : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTDELIM:
# ifdef GTM_TRIGGER
assert(!dollar_ztdelim || MV_DEFINED(dollar_ztdelim));
if (NULL == dollar_ztdelim || !(MV_STR & dollar_ztdelim->mvtype) || (0 == dollar_ztdelim->str.len))
memcpy(v, &literal_null, SIZEOF(mval));
else
memcpy(v, dollar_ztdelim, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTOLDVAL:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but it might be numeric and need conversion to a string */
assert(!dollar_ztoldval || MV_DEFINED(dollar_ztoldval));
if (NULL != dollar_ztoldval)
MV_FORCE_STR(dollar_ztoldval);
memcpy(v, (NULL != dollar_ztoldval) ? dollar_ztoldval : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTRIGGEROP:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but assert it's a string */
assert(!dollar_ztriggerop || (MV_STR & dollar_ztriggerop->mvtype));
memcpy(v, (NULL != dollar_ztriggerop) ? dollar_ztriggerop : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTUPDATE:
# ifdef GTM_TRIGGER
/* Value comes from GT.M, but if there were no delims involved, the value will be undefined, and
* we return a "literal_null".
*/
memcpy(v, ((NULL != dollar_ztupdate && (MV_STR & dollar_ztupdate->mvtype)) ? dollar_ztupdate
: &literal_null), SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTVALUE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
assert(!dollar_ztvalue || MV_DEFINED(dollar_ztvalue));
if (NULL != dollar_ztvalue)
MV_FORCE_STR(dollar_ztvalue);
memcpy(v, (NULL != dollar_ztvalue) ? dollar_ztvalue : &literal_null, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTWORMHOLE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
mvp = &dollar_ztwormhole;
if (MV_DEFINED(mvp))
{
MV_FORCE_STR(mvp);
memcpy(v, mvp, SIZEOF(mval));
} else
memcpy(v, &literal_null, SIZEOF(mval));
ztwormhole_used = TRUE;
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTSLATE:
# ifdef GTM_TRIGGER
/* Value comes from user-land so make sure things are proper */
assert(MV_DEFINED((&dollar_ztslate)));
mvp = &dollar_ztslate;
MV_FORCE_STR(mvp);
memcpy(v, mvp, SIZEOF(mval));
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZTLEVEL:
# ifdef GTM_TRIGGER
MV_FORCE_MVAL(v, gtm_trigger_depth);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZONLNRLBK:
# ifdef UNIX
count = TREF(dollar_zonlnrlbk);
MV_FORCE_MVAL(v, count);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZCLOSE:
# ifdef UNIX
count = TREF(dollar_zclose);
MV_FORCE_MVAL(v, count);
break;
# else
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_UNIMPLOP);
# endif
case SV_ZKEY:
get_dlr_zkey(v);
break;
default:
assertpro(FALSE);
}
}
