void push_tval(bool arg1)
{
error_def(ERR_STACKOFLOW);
error_def(ERR_STACKCRIT);
PUSH_MV_STENT(MVST_TVAL);
mv_chain->mv_st_cont.mvs_tval = arg1;
return;
}
void ztrap_save_ctxt(void)
{
int level;
error_def(ERR_STACKOFLOW);
error_def(ERR_STACKCRIT);
level = dollar_zlevel();
if (level == MV_FORCE_INT(&ztrap_pop2level))
return;
PUSH_MV_STENT(MVST_MSAV);
mv_chain->mv_st_cont.mvs_msav.v = ztrap_pop2level;
mv_chain->mv_st_cont.mvs_msav.addr = &ztrap_pop2level;
MV_FORCE_MVAL(&ztrap_pop2level, level);
return;
}
void trans_code_finish(void)
{
mval dummy;
frame_pointer->type = proc_act_type;
proc_act_type = 0;
/* Save/restore restart_pc over dispatch of this error handler */
PUSH_MV_STENT(MVST_RSTRTPC);
mv_chain->mv_st_cont.mvs_rstrtpc.restart_pc_save = restart_pc;
mv_chain->mv_st_cont.mvs_rstrtpc.restart_ctxt_save = restart_ctxt;
if (0 != dollar_zyerror.str.len)
{
dummy.mvtype = MV_STR;
dummy.str = dollar_zyerror.str;
ESTABLISH(zyerr_ch);
op_commarg(&dummy, indir_do);
REVERT;
op_newintrinsic(SV_ZYERROR); /* for user's convenience */
assert(NULL == zyerr_frame);
zyerr_frame = frame_pointer;
}
return;
}
void op_indtext(mval *lab, mint offset, mval *rtn, mval *dst)
{
bool rval;
mstr *obj, object;
mval mv_off;
oprtype opt;
triple *ref;
icode_str indir_src;
error_def(ERR_INDMAXNEST);
error_def(ERR_STACKOFLOW);
error_def(ERR_STACKCRIT);
MV_FORCE_STR(lab);
indir_src.str.len = lab->str.len;
indir_src.str.len += SIZEOF("+^") - 1;
indir_src.str.len += MAX_NUM_SIZE;
indir_src.str.len += rtn->str.len;
ENSURE_STP_FREE_SPACE(indir_src.str.len);
DBG_MARK_STRINGPOOL_UNEXPANDABLE; /* Now that we have ensured enough space in the stringpool, we dont expect any more
* garbage collections or expansions until we are done with the below initialization.
*/
/* Push an mval pointing to the complete entry ref on to the stack so the string is valid even
* if garbage collection occurs before cache_put() */
PUSH_MV_STENT(MVST_MVAL);
mv_chain->mv_st_cont.mvs_mval.mvtype = 0; /* so stp_gcol (if invoked below) does not get confused by this otherwise
* incompletely initialized mval in the M-stack */
mv_chain->mv_st_cont.mvs_mval.str.addr = (char *)stringpool.free;
memcpy(stringpool.free, lab->str.addr, lab->str.len);
stringpool.free += lab->str.len;
*stringpool.free++ = '+';
MV_FORCE_MVAL(&mv_off, offset);
MV_FORCE_STRD(&mv_off); /* goes at stringpool.free. we already made enough space in the stp_gcol() call */
*stringpool.free++ = '^';
memcpy(stringpool.free, rtn->str.addr, rtn->str.len);
stringpool.free += rtn->str.len;
mv_chain->mv_st_cont.mvs_mval.str.len = INTCAST(stringpool.free - (unsigned char*)mv_chain->mv_st_cont.mvs_mval.str.addr);
mv_chain->mv_st_cont.mvs_mval.mvtype = MV_STR; /* initialize mvtype now that mval has been otherwise completely set up */
DBG_MARK_STRINGPOOL_EXPANDABLE; /* Now that we are done with stringpool.free initializations, mark as free for expansion */
indir_src.str = mv_chain->mv_st_cont.mvs_mval.str;
indir_src.code = indir_text;
if (NULL == (obj = cache_get(&indir_src)))
{
comp_init(&indir_src.str);
rval = f_text(&opt, OC_FNTEXT);
if (!comp_fini(rval, &object, OC_IRETMVAL, &opt, indir_src.str.len))
{
assert(mv_chain->mv_st_type == MVST_MVAL);
POP_MV_STENT();
return;
}
indir_src.str.addr = mv_chain->mv_st_cont.mvs_mval.str.addr;
cache_put(&indir_src, &object);
*ind_result_sp++ = dst;
if (ind_result_sp >= ind_result_top)
rts_error(VARLSTCNT(1) ERR_INDMAXNEST);
assert(mv_chain->mv_st_type == MVST_MVAL);
POP_MV_STENT(); /* unwind the mval entry before the new frame gets added by comp_indir below */
comp_indr(&object);
return;
}
*ind_result_sp++ = dst;
if (ind_result_sp >= ind_result_top)
rts_error(VARLSTCNT(1) ERR_INDMAXNEST);
assert(mv_chain->mv_st_type == MVST_MVAL);
POP_MV_STENT(); /* unwind the mval entry before the new frame gets added by comp_indir below */
comp_indr(obj);
return;
}
boolean_t iosocket_wait(io_desc *iod, int4 timepar)
{
struct timeval utimeout;
ABS_TIME cur_time, end_time;
struct sockaddr_storage peer; /* socket address + port */
fd_set tcp_fd;
d_socket_struct *dsocketptr;
socket_struct *socketptr, *newsocketptr;
socket_interrupt *sockintr;
char *errptr;
int4 errlen, ii, msec_timeout;
int rv, max_fd, len;
GTM_SOCKLEN_TYPE size;
boolean_t zint_restart;
mv_stent *mv_zintdev;
int retry_num;
struct sockaddr *peer_sa_ptr;
char port_buffer[NI_MAXSERV], ipaddr[SA_MAXLEN + 1];
int errcode;
/* check for validity */
assert(iod->type == gtmsocket);
dsocketptr = (d_socket_struct *)iod->dev_sp;
sockintr = &dsocketptr->sock_save_state;
peer_sa_ptr = ((struct sockaddr *)(&peer));
/* Check for restart */
if (!dsocketptr->mupintr)
/* Simple path, no worries*/
zint_restart = FALSE;
else
{ /* We have a pending wait restart of some sort - check we aren't recursing on this device */
if (sockwhich_invalid == sockintr->who_saved)
GTMASSERT; /* Interrupt should never have an invalid save state */
if (dollar_zininterrupt)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_ZINTRECURSEIO);
if (sockwhich_wait != sockintr->who_saved)
GTMASSERT; /* ZINTRECURSEIO should have caught */
DBGSOCK((stdout, "socwait: *#*#*#*#*#*#*# Restarted interrupted wait\n"));
mv_zintdev = io_find_mvstent(iod, FALSE);
if (mv_zintdev)
{
if (sockintr->end_time_valid)
/* Restore end_time for timeout */
end_time = sockintr->end_time;
/* Done with this mv_stent. Pop it off if we can, else mark it inactive. */
if (mv_chain == mv_zintdev)
POP_MV_STENT(); /* pop if top of stack */
else
{ /* else mark it unused */
mv_zintdev->mv_st_cont.mvs_zintdev.buffer_valid = FALSE;
mv_zintdev->mv_st_cont.mvs_zintdev.io_ptr = NULL;
}
zint_restart = TRUE;
DBGSOCK((stdout, "socwait: mv_stent found - endtime: %d/%d\n", end_time.at_sec, end_time.at_usec));
} else
DBGSOCK((stdout, "socwait: no mv_stent found !!\n"));
dsocketptr->mupintr = FALSE;
sockintr->who_saved = sockwhich_invalid;
}
/* check for events */
FD_ZERO(&tcp_fd);
while (TRUE)
{
max_fd = 0;
for (ii = 0; ii < dsocketptr->n_socket; ii++)
{
socketptr = dsocketptr->socket[ii];
if ((socket_listening == socketptr->state) || (socket_connected == socketptr->state))
{
FD_SET(socketptr->sd, &tcp_fd);
max_fd = MAX(max_fd, socketptr->sd);
}
}
utimeout.tv_sec = timepar;
utimeout.tv_usec = 0;
msec_timeout = timeout2msec(timepar);
sys_get_curr_time(&cur_time);
if (!zint_restart || !sockintr->end_time_valid)
add_int_to_abs_time(&cur_time, msec_timeout, &end_time);
else
{ /* end_time taken from restart data. Compute what msec_timeout should be so timeout timer
gets set correctly below.
*/
DBGSOCK((stdout, "socwait: Taking timeout end time from wait restart data\n"));
cur_time = sub_abs_time(&end_time, &cur_time);
if (0 > cur_time.at_sec)
{
msec_timeout = -1;
utimeout.tv_sec = 0;
utimeout.tv_usec = 0;
} else
{
msec_timeout = (int4)(cur_time.at_sec * 1000 + cur_time.at_usec / 1000);
utimeout.tv_sec = cur_time.at_sec;
utimeout.tv_usec = (gtm_tv_usec_t)cur_time.at_usec;
}
}
sockintr->end_time_valid = FALSE;
for ( ; ; )
{
rv = select(max_fd + 1, (void *)&tcp_fd, (void *)0, (void *)0,
(timepar == NO_M_TIMEOUT ? (struct timeval *)0 : &utimeout));
if (0 > rv && EINTR == errno)
{
if (0 != outofband)
{
DBGSOCK((stdout, "socwait: outofband interrupt received (%d) -- "
"queueing mv_stent for wait intr\n", outofband));
PUSH_MV_STENT(MVST_ZINTDEV);
mv_chain->mv_st_cont.mvs_zintdev.io_ptr = iod;
mv_chain->mv_st_cont.mvs_zintdev.buffer_valid = FALSE;
sockintr->who_saved = sockwhich_wait;
sockintr->end_time = end_time;
sockintr->end_time_valid = TRUE;
dsocketptr->mupintr = TRUE;
socketus_interruptus++;
DBGSOCK((stdout, "socwait: mv_stent queued - endtime: %d/%d interrupts: %d\n",
end_time.at_sec, end_time.at_usec, socketus_interruptus));
outofband_action(FALSE);
GTMASSERT; /* Should *never* return from outofband_action */
return FALSE; /* For the compiler.. */
}
sys_get_curr_time(&cur_time);
cur_time = sub_abs_time(&end_time, &cur_time);
if (0 > cur_time.at_sec)
{
rv = 0; /* time out */
break;
}
utimeout.tv_sec = cur_time.at_sec;
utimeout.tv_usec = (gtm_tv_usec_t)cur_time.at_usec;
} else
break; /* either other error or done */
}
if (rv == 0)
{
iod->dollar.key[0] = '\0';
return FALSE;
} else if (rv < 0)
{
errptr = (char *)STRERROR(errno);
errlen = STRLEN(errptr);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_SOCKWAIT, 0, ERR_TEXT, 2, errlen, errptr);
return FALSE;
}
/* find out which socket is ready */
for (ii = 0; ii < dsocketptr->n_socket; ii++)
{
socketptr = dsocketptr->socket[ii];
if (0 != FD_ISSET(socketptr->sd, &tcp_fd))
break;
}
assert(ii < dsocketptr->n_socket);
if (socket_listening == socketptr->state)
{
if (gtm_max_sockets <= dsocketptr->n_socket)
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_SOCKMAX, 1, gtm_max_sockets);
return FALSE;
}
size = SIZEOF(struct sockaddr_storage);
rv = tcp_routines.aa_accept(socketptr->sd, peer_sa_ptr, &size);
if (-1 == rv)
{
# ifdef __hpux
if (ENOBUFS == errno)
continue; /* On HP-UX, ENOBUFS may indicate a transient condition; retry */
# endif
errptr = (char *)STRERROR(errno);
errlen = STRLEN(errptr);
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(6) ERR_SOCKACPT, 0, ERR_TEXT, 2, errlen, errptr);
return FALSE;
}
SOCKET_DUP(socketptr, newsocketptr);
newsocketptr->sd = rv;
SOCKET_ADDR_COPY(newsocketptr->remote, peer_sa_ptr, size);
/* translate internal address to numeric ip address */
GETNAMEINFO(peer_sa_ptr, size, ipaddr, SA_MAXLEN, NULL, 0, NI_NUMERICHOST, errcode);
if (0 != errcode)
{
SOCKET_FREE(newsocketptr);
RTS_ERROR_ADDRINFO(NULL, ERR_GETNAMEINFO, errcode);
return FALSE;
}
if (NULL != newsocketptr->remote.saddr_ip)
free(newsocketptr->remote.saddr_ip);
STRNDUP(ipaddr, SA_MAXLEN, newsocketptr->remote.saddr_ip);
/* translate internal address to port number*/
GETNAMEINFO(peer_sa_ptr, size, NULL, 0, port_buffer, NI_MAXSERV, NI_NUMERICSERV, errcode);
if (0 != errcode)
{
SOCKET_FREE(newsocketptr);
RTS_ERROR_ADDRINFO(NULL, ERR_GETNAMEINFO, errcode);
return FALSE;
}
newsocketptr->remote.port = ATOI(port_buffer);
newsocketptr->state = socket_connected;
newsocketptr->passive = FALSE;
newsocketptr->first_read = newsocketptr->first_write = TRUE;
/* put the new-born socket to the list and create a handle for it */
iosocket_handle(newsocketptr->handle, &newsocketptr->handle_len, TRUE, dsocketptr);
dsocketptr->socket[dsocketptr->n_socket++] = newsocketptr;
dsocketptr->current_socket = dsocketptr->n_socket - 1;
len = SIZEOF(CONNECTED) - 1;
memcpy(&iod->dollar.key[0], CONNECTED, len);
iod->dollar.key[len++] = '|';
memcpy(&iod->dollar.key[len], newsocketptr->handle, newsocketptr->handle_len);
len += newsocketptr->handle_len;
iod->dollar.key[len++] = '|';
strncpy(&iod->dollar.key[len], newsocketptr->remote.saddr_ip, DD_BUFLEN - 1 - len);
iod->dollar.key[DD_BUFLEN-1] = '\0'; /* In case we fill the buffer */
} else
{
assert(socket_connected == socketptr->state);
dsocketptr->current_socket = ii;
len = SIZEOF(READ) - 1;
memcpy(&iod->dollar.key[0], READ, len);
iod->dollar.key[len++] = '|';
memcpy(&iod->dollar.key[len], socketptr->handle, socketptr->handle_len);
len += socketptr->handle_len;
iod->dollar.key[len++] = '|';
if (NULL != socketptr->remote.saddr_ip)
{
strncpy(&iod->dollar.key[len], socketptr->remote.saddr_ip, DD_BUFLEN - 1 - len);
iod->dollar.key[DD_BUFLEN-1] = '\0';
} else
iod->dollar.key[len] = '\0';
}
break;
}
/*
* -----------------------------------------------
* Maintain in parallel with op_zalloc2
* Arguments:
* timeout - max. time to wait for locks before giving up
* laflag - passed to gvcmx* routines as "laflag" argument;
* originally indicated the request was a Lock or
* zAllocate request (hence the name "laflag"), but
* now capable of holding more values signifying
* additional information
*
* Return:
* 1 - if not timeout specified
* if timeout specified:
* != 0 - all the locks int the list obtained, or
* 0 - blocked
* The return result is suited to be placed directly into
* the $T variable by the caller if timeout is specified.
* -----------------------------------------------
*/
int op_lock2(int4 timeout, unsigned char laflag) /* timeout is in seconds */
{
boolean_t blocked, timer_on;
signed char gotit;
unsigned short locks_bckout, locks_done;
int4 msec_timeout; /* timeout in milliseconds */
mlk_pvtblk *pvt_ptr1, *pvt_ptr2, **prior;
unsigned char action;
ABS_TIME cur_time, end_time, remain_time;
mv_stent *mv_zintcmd;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
gotit = -1;
cm_action = laflag;
out_of_time = FALSE;
if (timeout < 0)
timeout = 0;
else if (TREF(tpnotacidtime) < timeout)
TPNOTACID_CHECK(LOCKTIMESTR);
if (!(timer_on = (NO_M_TIMEOUT != timeout))) /* NOTE assignment */
msec_timeout = NO_M_TIMEOUT;
else
{
msec_timeout = timeout2msec(timeout);
if (0 == msec_timeout)
{
out_of_time = TRUE;
timer_on = FALSE;
} else
{
mv_zintcmd = find_mvstent_cmd(ZINTCMD_LOCK, restart_pc, restart_ctxt, FALSE);
if (mv_zintcmd)
{
remain_time = mv_zintcmd->mv_st_cont.mvs_zintcmd.end_or_remain;
if (0 <= remain_time.at_sec)
msec_timeout = (int4)(remain_time.at_sec * 1000 + remain_time.at_usec / 1000);
else
msec_timeout = 0;
TAREF1(zintcmd_active, ZINTCMD_LOCK).restart_pc_last
= mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_pc_prior;
TAREF1(zintcmd_active, ZINTCMD_LOCK).restart_ctxt_last
= mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_ctxt_prior;
TAREF1(zintcmd_active, ZINTCMD_LOCK).count--;
assert(0 <= TAREF1(zintcmd_active, ZINTCMD_LOCK).count);
if (mv_chain == mv_zintcmd)
POP_MV_STENT(); /* just pop if top of stack */
else
{ /* flag as not active */
mv_zintcmd->mv_st_cont.mvs_zintcmd.command = ZINTCMD_NOOP;
mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_pc_check = NULL;
}
}
if (0 < msec_timeout)
{
sys_get_curr_time(&cur_time);
add_int_to_abs_time(&cur_time, msec_timeout, &end_time);
start_timer((TID)&timer_on, msec_timeout, wake_alarm, 0, NULL);
} else
{
out_of_time = TRUE;
timer_on = FALSE;
}
}
}
lckclr();
for (blocked = FALSE; !blocked;)
{ /* if this is a request for a remote node */
if (remlkreq)
{
if (gotit >= 0)
gotit = gvcmx_resremlk(cm_action);
else
gotit = gvcmx_reqremlk(cm_action, msec_timeout); /* REQIMMED if 2nd arg == 0 */
if (!gotit)
{ /* only REQIMMED returns false */
blocked = TRUE;
break;
}
}
for (pvt_ptr1 = mlk_pvt_root, locks_done = 0; locks_done < lks_this_cmd; pvt_ptr1 = pvt_ptr1->next, locks_done++)
{ /* Go thru the list of all locks to be obtained attempting to lock
* each one. If any lock could not be obtained, break out of the loop
*/
if (!mlk_lock(pvt_ptr1, 0, TRUE))
{ /* If lock is obtained */
pvt_ptr1->granted = TRUE;
switch (laflag)
{
case CM_LOCKS:
pvt_ptr1->level = 1;
break;
case INCREMENTAL:
if (pvt_ptr1->level < 511) /* The same lock can not be incremented more than 511 times. */
pvt_ptr1->level += pvt_ptr1->translev;
else
level_err(pvt_ptr1);
break;
default:
GTMASSERT;
break;
}
} else
{
blocked = TRUE;
break;
}
}
/* If we did not get blocked, we are all done */
if (!blocked)
break;
/* We got blocked and need to keep retrying after some time interval */
if (remlkreq)
gvcmx_susremlk(cm_action);
switch (cm_action)
{
case CM_LOCKS:
action = LOCKED;
break;
case INCREMENTAL:
action = INCREMENTAL;
break;
default:
GTMASSERT;
break;
}
for (pvt_ptr2 = mlk_pvt_root, locks_bckout = 0; locks_bckout < locks_done;
pvt_ptr2 = pvt_ptr2->next, locks_bckout++)
{
assert(pvt_ptr2->granted && (pvt_ptr2 != pvt_ptr1));
mlk_bckout(pvt_ptr2, action);
}
if (dollar_tlevel && (CDB_STAGNATE <= t_tries))
{ /* upper TPNOTACID_CHECK conditioned on no short timeout; this one rel_crits to avoid potential deadlock */
assert(TREF(tpnotacidtime) >= timeout);
TPNOTACID_CHECK(LOCKTIMESTR);
}
for (;;)
{
if (out_of_time || outofband)
{ /* if time expired || control-c, tptimeout, or jobinterrupt encountered */
if (outofband || !lk_check_own(pvt_ptr1))
{ /* If CTL-C, check lock owner */
if (pvt_ptr1->nodptr) /* Get off pending list to be sent a wake */
mlk_unpend(pvt_ptr1);
/* Cancel all remote locks obtained so far */
if (remlkreq)
{
gvcmx_canremlk();
gvcmz_clrlkreq();
remlkreq = FALSE;
}
if (outofband)
{
if (timer_on && !out_of_time)
{
cancel_timer((TID)&timer_on);
timer_on = FALSE;
}
if (!out_of_time && (NO_M_TIMEOUT != timeout))
{ /* get remain = end_time - cur_time */
sys_get_curr_time(&cur_time);
remain_time = sub_abs_time(&end_time, &cur_time);
if (0 <= remain_time.at_sec)
msec_timeout = (int4)(remain_time.at_sec * 1000
+ remain_time.at_usec / 1000);
else
msec_timeout = 0; /* treat as out_of_time */
if (0 >= msec_timeout)
{
out_of_time = TRUE;
timer_on = FALSE; /* as if LOCK :0 */
break;
}
PUSH_MV_STENT(MVST_ZINTCMD);
mv_chain->mv_st_cont.mvs_zintcmd.end_or_remain = remain_time;
mv_chain->mv_st_cont.mvs_zintcmd.restart_ctxt_check = restart_ctxt;
mv_chain->mv_st_cont.mvs_zintcmd.restart_pc_check = restart_pc;
/* save current information from zintcmd_active */
mv_chain->mv_st_cont.mvs_zintcmd.restart_ctxt_prior
= TAREF1(zintcmd_active, ZINTCMD_LOCK).restart_ctxt_last;
mv_chain->mv_st_cont.mvs_zintcmd.restart_pc_prior
= TAREF1(zintcmd_active, ZINTCMD_LOCK).restart_pc_last;
TAREF1(zintcmd_active, ZINTCMD_LOCK).restart_pc_last = restart_pc;
TAREF1(zintcmd_active, ZINTCMD_LOCK).restart_ctxt_last = restart_ctxt;
TAREF1(zintcmd_active, ZINTCMD_LOCK).count++;
mv_chain->mv_st_cont.mvs_zintcmd.command = ZINTCMD_LOCK;
outofband_action(FALSE); /* no return */
}
}
break;
}
}
if (!mlk_lock(pvt_ptr1, 0, FALSE))
{ /* If we got the lock, break out of timer loop */
blocked = FALSE;
if (pvt_ptr1 != mlk_pvt_root)
{
rel_quant(); /* attempt to get a full timeslice for maximum chance to get all */
mlk_unlock(pvt_ptr1);
}
break;
}
if (pvt_ptr1->nodptr)
lk_check_own(pvt_ptr1); /* clear an abandoned owner */
hiber_start_wait_any(LOCK_SELF_WAKE);
}
if (blocked && out_of_time)
break;
}
if (remlkreq)
{
gvcmz_clrlkreq();
remlkreq = FALSE;
}
if (NO_M_TIMEOUT != timeout)
{ /* was timed or immediate */
if (timer_on && !out_of_time)
cancel_timer((TID)&timer_on);
if (blocked)
{
for (prior = &mlk_pvt_root; *prior;)
{
if (!(*prior)->granted)
{ /* if entry was never granted, delete list entry */
mlk_pvtblk_delete(prior);
} else
prior = &((*prior)->next);
}
mlk_stats.n_user_locks_fail++;
return (FALSE);
}
}
mlk_stats.n_user_locks_success++;
return (TRUE);
}
/* Note this module follows the basic pattern of op_newvar which handles the same
function except for local vars instead of intrinsic vars. */
void gtm_newintrinsic(mval *intrinsic)
{
mv_stent *mv_st_ent, *mvst_tmp, *mvst_prev;
stack_frame *fp, *fp_prev, *fp_fix;
tp_frame *tpp;
unsigned char *old_sp, *top;
int indx;
int4 shift_size;
error_def(ERR_STACKOFLOW);
error_def(ERR_STACKCRIT);
assert(intrinsic);
if (frame_pointer->type & SFT_COUNT)
{ /* Current (youngest) frame is NOT an indirect frame.
Create restore entry for intrinsic var.
*/
PUSH_MV_STENT(MVST_MSAV);
mv_chain->mv_st_cont.mvs_msav.v = *intrinsic;
mv_chain->mv_st_cont.mvs_msav.addr = intrinsic;
} else
{ /* Current (youngest) frame IS an indirect frame.
The situation is more complex because this is not a true stackframe.
It has full access to the base "counted" frame's vars and any new
done here must behave as if it were done in the base/counted frame.
To accomplish this, we actually find the base frame we are executing
in, then shift all frames younger than that up by the size of the mvstent
entry we need to save/restore the value being new'd and then go into
each frame modified and fixup all the addresses.
*/
fp = frame_pointer;
fp_prev = fp->old_frame_pointer;
assert(fp_prev);
/* Find relevant base (counted) frame */
while (!(fp_prev->type & SFT_COUNT))
{
fp = fp_prev;
fp_prev = fp->old_frame_pointer;
assert(fp_prev);
}
/* top is beginning of earliest indirect stackframe before counted base frame.
It is the point where we will shift to make room to insert an mv_stent into
the base frame.
*/
top = (unsigned char *)(fp + 1);
old_sp = msp;
shift_size = mvs_size[MVST_MSAV];
msp -= shift_size;
if (msp <= stackwarn)
{
if (msp <= stacktop)
{
msp = old_sp;
rts_error(VARLSTCNT(1) ERR_STACKOFLOW);
}
else
rts_error(VARLSTCNT(1) ERR_STACKCRIT);
}
/* Ready, set, shift the younger indirect frames to make room for mv_stent */
memmove(msp, old_sp, top - (unsigned char *)old_sp);
mv_st_ent = (mv_stent *)(top - shift_size);
mv_st_ent->mv_st_type = MVST_MSAV;
ADJUST_FRAME_POINTER(frame_pointer, shift_size);
/* adjust all the pointers in all the stackframes that were moved */
for (fp_fix = frame_pointer; fp_fix != fp_prev; fp_fix = fp_fix->old_frame_pointer)
{
if ((unsigned char *)fp_fix->l_symtab < top && (unsigned char *)fp_fix->l_symtab > stacktop)
fp_fix->l_symtab = (mval **)((char *)fp_fix->l_symtab - shift_size);
if (fp_fix->temps_ptr < top && fp_fix->temps_ptr > stacktop)
fp_fix->temps_ptr -= shift_size;
if (fp_fix->vartab_ptr < (char *)top && fp_fix->vartab_ptr > (char *)stacktop)
fp_fix->vartab_ptr -= shift_size;
if ((unsigned char *)fp_fix->old_frame_pointer < top && (char *)fp_fix->old_frame_pointer
> (char *)stacktop)
{
ADJUST_FRAME_POINTER(fp_fix->old_frame_pointer, shift_size);
}
}
/* Adjust stackframe and mvstent pointers in relevant tp_frame blocks */
assert((NULL == tp_pointer && 0 == dollar_tlevel) || (NULL != tp_pointer && 0 != dollar_tlevel));
for (tpp = tp_pointer; (tpp && ((unsigned char *)tpp->fp < top)); tpp = tpp->old_tp_frame)
{
if ((unsigned char *)tpp->fp > stacktop)
tpp->fp = (struct stack_frame_struct *)((char *)tpp->fp - shift_size);
/* Note low check for < top may be superfluous here but without a test case to verify, I
feel better leaving it in. SE 8/2001 */
if ((unsigned char *)tpp->mvc < top && (unsigned char *)tpp->mvc > stacktop)
tpp->mvc = (struct mv_stent_struct *)((char *)tpp->mvc - shift_size);
}
/* Put new mvstent entry on (into) the mvstent chain */
if ((unsigned char *)mv_chain >= top)
{ /* Just put new entry on end of chain which preceeds our base frame */
mv_st_ent->mv_st_next = (unsigned int)((char *)mv_chain - (char *)mv_st_ent);
mv_chain = mv_st_ent;
} else
{ /* One of the indirect frames has mv_stents associated with it so we have to find
the appropriate insertion point for this frame.
*/
fp = (stack_frame *)((char *)fp - shift_size);
mv_chain = (mv_stent *)((char *)mv_chain - shift_size);
mvst_tmp = mv_chain;
mvst_prev = (mv_stent *)((char *)mvst_tmp + mvst_tmp->mv_st_next);
while (mvst_prev < (mv_stent *)fp)
{
mvst_tmp = mvst_prev;
mvst_prev = (mv_stent *)((char *)mvst_tmp + mvst_tmp->mv_st_next);
}
mvst_tmp->mv_st_next = (unsigned int)((char *)mv_st_ent - (char *)mvst_tmp);
mv_st_ent->mv_st_next = (unsigned int)((char *)mvst_prev - (char *)mv_st_ent + shift_size);
}
/* Save current values of intrinsic var in the inserted mv_stent */
mv_st_ent->mv_st_cont.mvs_msav.v = *intrinsic;
mv_st_ent->mv_st_cont.mvs_msav.addr = intrinsic;
}
/* New the intrinsic var's current value */
intrinsic->mvtype = MV_STR;
intrinsic->str.len = 0;
return;
}
/*
* ------------------------------------------
* Hang the process for a specified time.
*
* Goes to sleep for a positive value.
* Any caught signal will terminate the sleep
* following the execution of that signal's catching routine.
*
* The actual hang duration should be NO LESS than the specified
* duration for specified durations greater than .001 seconds.
* Certain applications depend on this assumption.
*
* Arguments:
* num - time to sleep
*
* Return:
* none
* ------------------------------------------
*/
void op_hang(mval* num)
{
int ms;
double tmp;
mv_stent *mv_zintcmd;
ABS_TIME cur_time, end_time;
# ifdef VMS
uint4 time[2];
int4 efn_mask, status;
# endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
ms = 0;
MV_FORCE_NUM(num);
if (num->mvtype & MV_INT)
{
if (0 < num->m[1])
{
assert(MV_BIAS >= 1000); /* if formats change overflow may need attention */
ms = num->m[1] * (1000 / MV_BIAS);
}
} else if (0 == num->sgn) /* if sign is not 0 it means num is negative */
{
tmp = mval2double(num) * (double)1000;
ms = ((double)MAXPOSINT4 >= tmp) ? (int)tmp : (int)MAXPOSINT4;
}
if (ms)
{
if (TREF(tpnotacidtime) * 1000 < ms)
TPNOTACID_CHECK(HANGSTR);
# if defined(DEBUG) && defined(UNIX)
if (WBTEST_ENABLED(WBTEST_DEFERRED_TIMERS) && (3 > gtm_white_box_test_case_count) && (123000 == ms))
{
DEFER_INTERRUPTS(INTRPT_NO_TIMER_EVENTS);
DBGFPF((stderr, "OP_HANG: will sleep for 20 seconds\n"));
LONG_SLEEP(20);
DBGFPF((stderr, "OP_HANG: done sleeping\n"));
ENABLE_INTERRUPTS(INTRPT_NO_TIMER_EVENTS);
return;
}
if (WBTEST_ENABLED(WBTEST_BREAKMPC)&& (0 == gtm_white_box_test_case_count) && (999 == ms))
{
frame_pointer->old_frame_pointer->mpc = (unsigned char *)GTM64_ONLY(0xdeadbeef12345678)
NON_GTM64_ONLY(0xdead1234);
return;
}
if (WBTEST_ENABLED(WBTEST_UTIL_OUT_BUFFER_PROTECTION) && (0 == gtm_white_box_test_case_count) && (999 == ms))
{ /* Upon seeing a .999s hang this white-box test launches a timer that pops with a period of
* UTIL_OUT_SYSLOG_INTERVAL and prints a long message via util_out_ptr.
*/
start_timer((TID)&util_out_syslog_dump, UTIL_OUT_SYSLOG_INTERVAL, util_out_syslog_dump, 0, NULL);
return;
}
# endif
sys_get_curr_time(&cur_time);
mv_zintcmd = find_mvstent_cmd(ZINTCMD_HANG, restart_pc, restart_ctxt, FALSE);
if (!mv_zintcmd)
add_int_to_abs_time(&cur_time, ms, &end_time);
else
{
end_time = mv_zintcmd->mv_st_cont.mvs_zintcmd.end_or_remain;
cur_time = sub_abs_time(&end_time, &cur_time); /* get remaing time to sleep */
if (0 <= cur_time.at_sec)
ms = (int4)(cur_time.at_sec * 1000 + cur_time.at_usec / 1000);
else
ms = 0; /* all done */
/* restore/pop previous zintcmd_active[ZINTCMD_HANG] hints */
TAREF1(zintcmd_active, ZINTCMD_HANG).restart_pc_last = mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_pc_prior;
TAREF1(zintcmd_active, ZINTCMD_HANG).restart_ctxt_last
= mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_ctxt_prior;
TAREF1(zintcmd_active, ZINTCMD_HANG).count--;
assert(0 <= TAREF1(zintcmd_active, ZINTCMD_HANG).count);
if (mv_chain == mv_zintcmd)
POP_MV_STENT(); /* just pop if top of stack */
else
{ /* flag as not active */
mv_zintcmd->mv_st_cont.mvs_zintcmd.command = ZINTCMD_NOOP;
mv_zintcmd->mv_st_cont.mvs_zintcmd.restart_pc_check = NULL;
}
if (0 == ms)
return; /* done HANGing */
}
# ifdef UNIX
if (ms < 10)
SLEEP_USEC(ms * 1000, TRUE); /* Finish the sleep if it is less than 10ms. */
else
hiber_start(ms);
# elif defined(VMS)
time[0] = -time_low_ms(ms);
time[1] = -time_high_ms(ms) - 1;
efn_mask = (1 << efn_outofband | 1 << efn_timer);
if (SS$_NORMAL != (status = sys$setimr(efn_timer, &time, NULL, &time, 0)))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("$setimr"), CALLFROM, status);
if (SS$_NORMAL != (status = sys$wflor(efn_outofband, efn_mask)))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("$wflor"), CALLFROM, status);
if (outofband)
{
if (SS$_WASCLR == (status = sys$readef(efn_timer, &efn_mask)))
{
if (SS$_NORMAL != (status = sys$cantim(&time, 0)))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("$cantim"),
CALLFROM, status);
} else
assertpro(SS$_WASSET == status);
}
# endif
} else
rel_quant();
if (outofband)
{
PUSH_MV_STENT(MVST_ZINTCMD);
mv_chain->mv_st_cont.mvs_zintcmd.end_or_remain = end_time;
mv_chain->mv_st_cont.mvs_zintcmd.restart_ctxt_check = restart_ctxt;
mv_chain->mv_st_cont.mvs_zintcmd.restart_pc_check = restart_pc;
/* save current information from zintcmd_active */
mv_chain->mv_st_cont.mvs_zintcmd.restart_ctxt_prior = TAREF1(zintcmd_active, ZINTCMD_HANG).restart_ctxt_last;
mv_chain->mv_st_cont.mvs_zintcmd.restart_pc_prior = TAREF1(zintcmd_active, ZINTCMD_HANG).restart_pc_last;
TAREF1(zintcmd_active, ZINTCMD_HANG).restart_pc_last = restart_pc;
TAREF1(zintcmd_active, ZINTCMD_HANG).restart_ctxt_last = restart_ctxt;
TAREF1(zintcmd_active, ZINTCMD_HANG).count++;
mv_chain->mv_st_cont.mvs_zintcmd.command = ZINTCMD_HANG;
outofband_action(FALSE);
}
return;
}
int gtm_trigger(gv_trigger_t *trigdsc, gtm_trigger_parms *trigprm)
{
mval *lvvalue;
lnr_tabent *lbl_offset_p;
uchar_ptr_t transfer_addr;
lv_val *lvval;
mname_entry *mne_p;
uint4 *indx_p;
ht_ent_mname *tabent;
boolean_t added;
int clrlen, rc, i, unwinds;
mval **lvvalarray;
mv_stent *mv_st_ent;
symval *new_symval;
uint4 dollar_tlevel_start;
stack_frame *fp, *fpprev;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(!skip_dbtriggers); /* should not come here if triggers are not supposed to be invoked */
assert(trigdsc);
assert(trigprm);
assert((NULL != trigdsc->rtn_desc.rt_adr) || ((MV_STR & trigdsc->xecute_str.mvtype)
&& (0 != trigdsc->xecute_str.str.len)
&& (NULL != trigdsc->xecute_str.str.addr)));
assert(dollar_tlevel);
/* Determine if trigger needs to be compiled */
if (NULL == trigdsc->rtn_desc.rt_adr)
{ /* No routine hdr addr exists. Need to do compile */
if (0 != gtm_trigger_complink(trigdsc, TRUE))
{
PRN_ERROR; /* Leave record of what error caused the compilation failure if any */
rts_error(VARLSTCNT(4) ERR_TRIGCOMPFAIL, 2, trigdsc->rtn_desc.rt_name.len, trigdsc->rtn_desc.rt_name.addr);
}
}
assert(trigdsc->rtn_desc.rt_adr);
assert(trigdsc->rtn_desc.rt_adr == CURRENT_RHEAD_ADR(trigdsc->rtn_desc.rt_adr));
/* Setup trigger environment stack frame(s) for execution */
if (!(frame_pointer->type & SFT_TRIGR))
{ /* Create new trigger base frame first that back-stops stack unrolling and return to us */
if (GTM_TRIGGER_DEPTH_MAX < (gtm_trigger_depth + 1)) /* Verify we won't nest too deep */
rts_error(VARLSTCNT(3) ERR_MAXTRIGNEST, 1, GTM_TRIGGER_DEPTH_MAX);
DBGTRIGR((stderr, "gtm_trigger: PUSH: frame_pointer 0x%016lx ctxt value: 0x%016lx\n", frame_pointer, ctxt));
/* Protect against interrupts while we have only a trigger base frame on the stack */
DEFER_INTERRUPTS(INTRPT_IN_TRIGGER_NOMANS_LAND);
/* The current frame invoked a trigger. We cannot return to it for a TP restart or other reason unless
* either the total operation (including trigger) succeeds and we unwind normally or unless the mpc is reset
* (like what happens in various error or restart conditions) because right now it returns to where a database
* command (KILL, SET or ZTRIGGER) was entered. Set flag in the frame to prevent MUM_TSTART unless the frame gets
* reset.
*/
frame_pointer->flags |= SFF_TRIGR_CALLD; /* Do not return to this frame via MUM_TSTART */
DBGTRIGR((stderr, "gtm_trigger: Setting SFF_TRIGR_CALLD in frame 0x"lvaddr"\n", frame_pointer));
base_frame(trigdsc->rtn_desc.rt_adr);
/* Finish base frame initialization - reset mpc/context to return to us without unwinding base frame */
frame_pointer->type |= SFT_TRIGR;
# if defined(__hpux) && defined(__hppa)
/* For HPUX-HPPA (PA-RISC), we use longjmp() to return to gtm_trigger() to avoid some some space register
* corruption issues. Use call-ins already existing mechanism for doing this. Although we no longer support
* HPUX-HPPA for triggers due to some unlocated space register error, this code (effectively always ifdef'd
* out) left in in case it gets resurrected in the future (01/2010 SE).
*/
frame_pointer->mpc = CODE_ADDRESS(ci_ret_code);
frame_pointer->ctxt = GTM_CONTEXT(ci_ret_code);
# else
frame_pointer->mpc = CODE_ADDRESS(gtm_levl_ret_code);
frame_pointer->ctxt = GTM_CONTEXT(gtm_levl_ret_code);
# endif
/* This base stack frame is also where we save environmental info for all triggers invoked at this stack level.
* Subsequent triggers fired at this level in this trigger invocation need only reinitialize a few things but
* can avoid "the big save".
*/
if (NULL == trigr_symval_list)
{ /* No available symvals for use with this trigger, create one */
symbinit(); /* Initialize a symbol table the trigger will use */
curr_symval->trigr_symval = TRUE; /* Mark as trigger symval so will be saved not decommissioned */
} else
{ /* Trigger symval is available for reuse */
new_symval = trigr_symval_list;
assert(new_symval->trigr_symval);
trigr_symval_list = new_symval->last_tab; /* dequeue new curr_symval from list */
REINIT_SYMVAL_BLK(new_symval, curr_symval);
curr_symval = new_symval;
PUSH_MV_STENT(MVST_STAB);
mv_chain->mv_st_cont.mvs_stab = new_symval; /* So unw_mv_ent() can requeue it for later use */
}
/* Push our trigger environment save mv_stent onto the chain */
PUSH_MV_STENT(MVST_TRIGR);
mv_st_ent = mv_chain;
/* Initialize the mv_stent elements processed by stp_gcol which can be called by either op_gvsavtarg() or
* by the extnam saving code below. This initialization keeps stp_gcol - should it be called - from attempting
* to process unset fields filled with garbage in them as valid mstr address/length pairs.
*/
mv_st_ent->mv_st_cont.mvs_trigr.savtarg.str.len = 0;
mv_st_ent->mv_st_cont.mvs_trigr.savextref.len = 0;
mv_st_ent->mv_st_cont.mvs_trigr.dollar_etrap_save.str.len = 0;
mv_st_ent->mv_st_cont.mvs_trigr.dollar_ztrap_save.str.len = 0;
mv_st_ent->mv_st_cont.mvs_trigr.saved_dollar_truth = dollar_truth;
op_gvsavtarg(&mv_st_ent->mv_st_cont.mvs_trigr.savtarg);
if (extnam_str.len)
{
ENSURE_STP_FREE_SPACE(extnam_str.len);
mv_st_ent->mv_st_cont.mvs_trigr.savextref.addr = (char *)stringpool.free;
memcpy(mv_st_ent->mv_st_cont.mvs_trigr.savextref.addr, extnam_str.addr, extnam_str.len);
stringpool.free += extnam_str.len;
assert(stringpool.free <= stringpool.top);
}
mv_st_ent->mv_st_cont.mvs_trigr.savextref.len = extnam_str.len;
mv_st_ent->mv_st_cont.mvs_trigr.ztname_save = dollar_ztname;
mv_st_ent->mv_st_cont.mvs_trigr.ztdata_save = dollar_ztdata;
mv_st_ent->mv_st_cont.mvs_trigr.ztoldval_save = dollar_ztoldval;
mv_st_ent->mv_st_cont.mvs_trigr.ztriggerop_save = dollar_ztriggerop;
mv_st_ent->mv_st_cont.mvs_trigr.ztupdate_save = dollar_ztupdate;
mv_st_ent->mv_st_cont.mvs_trigr.ztvalue_save = dollar_ztvalue;
mv_st_ent->mv_st_cont.mvs_trigr.ztvalue_changed_ptr = ztvalue_changed_ptr;
# ifdef DEBUG
/* In a debug process, these fields give clues of what trigger we are working on */
mv_st_ent->mv_st_cont.mvs_trigr.gtm_trigdsc_last_save = trigdsc;
mv_st_ent->mv_st_cont.mvs_trigr.gtm_trigprm_last_save = trigprm;
# endif
assert(((0 == gtm_trigger_depth) && (ch_at_trigger_init == ctxt->ch))
|| ((0 < gtm_trigger_depth) && (&mdb_condition_handler == ctxt->ch)));
mv_st_ent->mv_st_cont.mvs_trigr.ctxt_save = ctxt;
mv_st_ent->mv_st_cont.mvs_trigr.gtm_trigger_depth_save = gtm_trigger_depth;
if (0 == gtm_trigger_depth)
{ /* Only back up $*trap settings when initiating the first trigger level */
mv_st_ent->mv_st_cont.mvs_trigr.dollar_etrap_save = dollar_etrap;
mv_st_ent->mv_st_cont.mvs_trigr.dollar_ztrap_save = dollar_ztrap;
mv_st_ent->mv_st_cont.mvs_trigr.ztrap_explicit_null_save = ztrap_explicit_null;
dollar_ztrap.str.len = 0;
ztrap_explicit_null = FALSE;
if (NULL != gtm_trigger_etrap.str.addr)
/* An etrap was defined for the trigger environment - Else existing $etrap persists */
dollar_etrap = gtm_trigger_etrap;
}
mv_st_ent->mv_st_cont.mvs_trigr.mumps_status_save = mumps_status;
mv_st_ent->mv_st_cont.mvs_trigr.run_time_save = run_time;
/* See if a MERGE launched the trigger. If yes, save some state so ZWRITE, ZSHOW and/or MERGE can be
* run in the trigger we dispatch. */
if ((0 != merge_args) || TREF(in_zwrite))
PUSH_MVST_MRGZWRSV;
mumps_status = 0;
run_time = TRUE; /* Previous value saved just above restored when frame pops */
} else
{ /* Trigger base frame exists so reinitialize the symbol table for new trigger invocation */
REINIT_SYMVAL_BLK(curr_symval, curr_symval->last_tab);
/* Locate the MVST_TRIGR mv_stent containing the backed up values. Some of those values need
* to be restored so the 2nd trigger has the same environment as the previous trigger at this level
*/
for (mv_st_ent = mv_chain;
(NULL != mv_st_ent) && (MVST_TRIGR != mv_st_ent->mv_st_type);
mv_st_ent = (mv_stent *)(mv_st_ent->mv_st_next + (char *)mv_st_ent))
;
assert(NULL != mv_st_ent);
assert((char *)mv_st_ent < (char *)frame_pointer); /* Ensure mv_stent associated this trigger frame */
/* Reinit backed up values from the trigger environment backup */
dollar_truth = mv_st_ent->mv_st_cont.mvs_trigr.saved_dollar_truth;
op_gvrectarg(&mv_st_ent->mv_st_cont.mvs_trigr.savtarg);
extnam_str.len = mv_st_ent->mv_st_cont.mvs_trigr.savextref.len;
if (extnam_str.len)
memcpy(extnam_str.addr, mv_st_ent->mv_st_cont.mvs_trigr.savextref.addr, extnam_str.len);
mumps_status = 0;
assert(run_time);
/* Note we do not reset the handlers for parallel triggers - set one time only when enter first level
* trigger. After that, whatever happens in trigger world, stays in trigger world.
*/
}
assert(frame_pointer->type & SFT_TRIGR);
# ifdef DEBUG
gtm_trigdsc_last = trigdsc;
gtm_trigprm_last = trigprm;
# endif
/* Set new value of trigger ISVs. Previous values already saved in trigger base frame */
dollar_ztname = &trigdsc->rtn_desc.rt_name;
dollar_ztdata = (mval *)trigprm->ztdata_new;
dollar_ztoldval = trigprm->ztoldval_new;
dollar_ztriggerop = (mval *)trigprm->ztriggerop_new;
dollar_ztupdate = trigprm->ztupdate_new;
dollar_ztvalue = trigprm->ztvalue_new;
ztvalue_changed_ptr = &trigprm->ztvalue_changed;
/* Set values associated with trigger into symbol table */
lvvalarray = trigprm->lvvalarray;
for (i = 0, mne_p = trigdsc->lvnamearray, indx_p = trigdsc->lvindexarray;
i < trigdsc->numlvsubs; ++i, ++mne_p, ++indx_p)
{ /* Once thru for each subscript we are to set */
lvvalue = lvvalarray[*indx_p]; /* Locate mval that contains value */
assert(NULL != lvvalue);
assert(MV_DEFINED(lvvalue)); /* No sense in defining the undefined */
lvval = lv_getslot(curr_symval); /* Allocate an lvval to put into symbol table */
LVVAL_INIT(lvval, curr_symval);
lvval->v = *lvvalue; /* Copy mval into lvval */
added = add_hashtab_mname_symval(&curr_symval->h_symtab, mne_p, lvval, &tabent);
assert(added);
assert(NULL != tabent);
}
/* While the routine header is available in trigdsc, we also need the <null> label address associated with
* the first (and only) line of code.
*/
lbl_offset_p = LNRTAB_ADR(trigdsc->rtn_desc.rt_adr);
transfer_addr = (uchar_ptr_t)LINE_NUMBER_ADDR(trigdsc->rtn_desc.rt_adr, lbl_offset_p);
/* Create new stack frame for invoked trigger in same fashion as gtm_init_env() creates its 2ndary frame */
# ifdef HAS_LITERAL_SECT
new_stack_frame(trigdsc->rtn_desc.rt_adr, (unsigned char *)LINKAGE_ADR(trigdsc->rtn_desc.rt_adr), transfer_addr);
# else
/* Any platform that does not follow pv-based linkage model either
* (1) uses the following calculation to determine the context pointer value, or
* (2) doesn't need a context pointer
*/
new_stack_frame(trigdsc->rtn_desc.rt_adr, PTEXT_ADR(trigdsc->rtn_desc.rt_adr), transfer_addr);
# endif
dollar_tlevel_start = dollar_tlevel;
assert(gv_target->gd_csa == cs_addrs);
gv_target->trig_local_tn = local_tn; /* Record trigger being driven for this global */
/* Invoke trigger generated code */
rc = gtm_trigger_invoke();
if (1 == rc)
{ /* Normal return code (from dm_start). Check if TP has been unwound or not */
assert(dollar_tlevel <= dollar_tlevel_start); /* Bigger would be quite the surprise */
if (dollar_tlevel < dollar_tlevel_start)
{ /* Our TP level was unwound during the trigger so throw an error */
DBGTRIGR((stderr, "gtm_trigger: $TLEVEL less than at start - throwing TRIGTLVLCHNG\n"));
gtm_trigger_fini(TRUE, FALSE); /* dump this trigger level */
rts_error(VARLSTCNT(4) ERR_TRIGTLVLCHNG, 2, trigdsc->rtn_desc.rt_name.len,
trigdsc->rtn_desc.rt_name.addr);
}
rc = 0; /* Be polite and return 0 for the (hopefully common) success case */
} else if (ERR_TPRETRY == rc)
{ /* We are restarting the entire transaction. There are two possibilities here:
* 1) This is a nested trigger level in which case we need to unwind further or
* the outer trigger level was created by M code. If either is true, just
* rethrow the TPRETRY error.
* 2) This is the outer trigger and the call to op_tstart() was done by our caller.
* In this case, we just return to our caller with a code signifying they need
* to restart the implied transaction.
*/
assert(dollar_tlevel && (tstart_trigger_depth <= gtm_trigger_depth));
if ((tstart_trigger_depth < gtm_trigger_depth) || !tp_pointer->implicit_tstart || !tp_pointer->implicit_trigger)
{ /* Unwind a trigger level to restart level or to next trigger boundary */
gtm_trigger_fini(FALSE, FALSE); /* Get rid of this trigger level - we won't be returning */
DBGTRIGR((stderr, "gtm_trigger: dm_start returned rethrow code - rethrowing ERR_TPRETRY\n"));
INVOKE_RESTART;
} else
{ /* It is possible we are restarting a transaction that never got around to creating a base
* frame yet the implicit TStart was done. So if there is no trigger base frame, do not
* run gtm_trigger_fini() but instead do the one piece of cleanup it does that we still need.
*/
assert(donot_INVOKE_MUMTSTART);
if (SFT_TRIGR & frame_pointer->type)
{ /* Normal case when TP restart unwinding back to implicit beginning */
gtm_trigger_fini(FALSE, FALSE);
DBGTRIGR((stderr, "gtm_trigger: dm_start returned rethrow code - returning to gvcst_<caller>\n"));
} else
{ /* Unusual case of trigger that died in no-mans-land before trigger base frame established.
* Remove the "do not return to me" flag only on non-error unwinds */
assert(tp_pointer->implicit_tstart);
assert(SFF_TRIGR_CALLD & frame_pointer->flags);
frame_pointer->flags &= SFF_TRIGR_CALLD_OFF;
DBGTRIGR((stderr, "gtm_trigger: turning off SFF_TRIGR_CALLD (1) in frame 0x"lvaddr"\n",
frame_pointer));
DBGTRIGR((stderr, "gtm_trigger: unwinding no-base-frame trigger for TP restart\n"));
}
}
/* Fall out and return ERR_TPRETRY to caller */
} else if (0 == rc)
/* We should never get a return code of 0. This would be out-of-design and a signal that something
* is quite broken. We cannot "rethrow" outside the trigger because it was not initially an error so
* mdb_condition_handler would have no record of it (rethrown errors must have originally occurred in
* or to be RE-thrown) and assert fail at best.
*/
GTMASSERT;
else
{ /* We have an unexpected return code due to some error during execution of the trigger that tripped
* gtm_trigger's safety handler (i.e. an error occurred in mdb_condition_handler() established by
* dm_start(). Since we are going to unwind the trigger frame and rethrow the error, we also have
* to unwind all the stack frames on top of the trigger frame. Figure out how many frames that is,
* unwind them all plus the trigger base frame before rethrowing the error.
*/
for (unwinds = 0, fp = frame_pointer; (NULL != fp) && !(SFT_TRIGR & fp->type); fp = fp->old_frame_pointer)
unwinds++;
assert((NULL != fp) && (SFT_TRIGR & fp->type));
GOFRAMES(unwinds, TRUE, FALSE);
assert((NULL != frame_pointer) && !(SFT_TRIGR & frame_pointer->type));
DBGTRIGR((stderr, "gtm_trigger: Unsupported return code (%d) - unwound %d frames and now rethrowing error\n",
rc, unwinds));
rts_error(VARLSTCNT(1) ERR_REPEATERROR);
}
return rc;
}
int gtm_trigger_complink(gv_trigger_t *trigdsc, boolean_t dolink)
{
char rtnname[GTM_PATH_MAX + 1], rtnname_template[GTM_PATH_MAX + 1];
char objname[GTM_PATH_MAX + 1];
char zcomp_parms[(GTM_PATH_MAX * 2) + SIZEOF(mident_fixed) + SIZEOF(OBJECT_PARM) + SIZEOF(NAMEOFRTN_PARM)];
mstr save_zsource;
int rtnfd, rc, lenrtnname, lenobjname, len, alphnum_len, retry, save_errno;
char *mident_suffix_p1, *mident_suffix_p2, *mident_suffix_top, *namesub1, *namesub2, *zcomp_parms_ptr;
mval zlfile, zcompprm;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
DBGTRIGR_ONLY(memcpy(rtnname, trigdsc->rtn_desc.rt_name.addr, trigdsc->rtn_desc.rt_name.len));
DBGTRIGR_ONLY(rtnname[trigdsc->rtn_desc.rt_name.len] = 0);
DBGTRIGR((stderr, "gtm_trigger_complink: (Re)compiling trigger %s\n", rtnname));
ESTABLISH_RET(gtm_trigger_complink_ch, ((0 == error_condition) ? TREF(dollar_zcstatus) : error_condition ));
/* Verify there are 2 available chars for uniqueness */
assert((MAX_MIDENT_LEN - TRIGGER_NAME_RESERVED_SPACE) >= (trigdsc->rtn_desc.rt_name.len));
assert(NULL == trigdsc->rtn_desc.rt_adr);
gtm_trigger_comp_prev_run_time = run_time;
run_time = TRUE; /* Required by compiler */
/* Verify the routine name set by MUPIP TRIGGER and read by gvtr_db_read_hasht() is not in use */
if (NULL != find_rtn_hdr(&trigdsc->rtn_desc.rt_name))
{ /* Ooops .. need name to be more unique.. */
/* Though variable definitions are conventionally done at the function entry, the reason alphanumeric_table
* definition is done here is to minimize the time taken to initialize the below table in the most common case
* (i.e. no trigger name collisions).
*/
char alphanumeric_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', '\0'};
alphnum_len = STR_LIT_LEN(alphanumeric_table);
namesub1 = trigdsc->rtn_desc.rt_name.addr + trigdsc->rtn_desc.rt_name.len++;
/* If WBTEST_HELPOUT_TRIGNAMEUNIQ is defined, set alphnum_len to 1. This way, we make the maximum
* possible combinations for the uniqe trigger names to be 3 which is significantly lesser than
* the actual number of combinations (62x62 = 3844). For eg., if ^a is a global having triggers defined
* in 4 global directories, then the possible unique trigger names are a#1# ; a#1#A ; a#1#AA.
*/
GTM_WHITE_BOX_TEST(WBTEST_HELPOUT_TRIGNAMEUNIQ, alphnum_len, 1);
mident_suffix_top = (char *)alphanumeric_table + alphnum_len;
/* Phase 1. See if any single character can add uniqueness */
for (mident_suffix_p1 = (char *)alphanumeric_table; mident_suffix_p1 < mident_suffix_top; mident_suffix_p1++)
{
*namesub1 = *mident_suffix_p1;
if (NULL == find_rtn_hdr(&trigdsc->rtn_desc.rt_name))
break;
}
if (mident_suffix_p1 == mident_suffix_top)
{ /* Phase 2. Phase 1 could not find uniqueness .. Find it with 2 char variations */
namesub2 = trigdsc->rtn_desc.rt_name.addr + trigdsc->rtn_desc.rt_name.len++;
for (mident_suffix_p1 = (char *)alphanumeric_table; mident_suffix_p1 < mident_suffix_top;
mident_suffix_p1++)
{ /* First char loop */
for (mident_suffix_p2 = (char *)alphanumeric_table; mident_suffix_p2 < mident_suffix_top;
mident_suffix_p2++)
{ /* 2nd char loop */
*namesub1 = *mident_suffix_p1;
*namesub2 = *mident_suffix_p2;
if (NULL == find_rtn_hdr(&trigdsc->rtn_desc.rt_name))
{
mident_suffix_p1 = mident_suffix_top + 1; /* Break out of both loops */
break;
}
}
}
if (mident_suffix_p1 == mident_suffix_top)
{ /* Phase 3: Punt */
assert(WBTEST_HELPOUT_TRIGNAMEUNIQ == gtm_white_box_test_case_number);
rts_error(VARLSTCNT(5) ERR_TRIGNAMEUNIQ, 3, trigdsc->rtn_desc.rt_name.len - 2,
trigdsc->rtn_desc.rt_name.addr, alphnum_len * alphnum_len);
}
}
}
/* Write trigger execute string out to temporary file and compile it */
assert(MAX_XECUTE_LEN >= trigdsc->xecute_str.str.len);
rc = SNPRINTF(rtnname_template, GTM_PATH_MAX, "%s/trgtmpXXXXXX", DEFAULT_GTM_TMP);
assert(0 < rc); /* Note rc is return code aka length - we expect a non-zero length */
assert(GTM_PATH_MAX >= rc);
/* The mkstemp() routine is known to bogus-fail for no apparent reason at all especially on AIX 6.1. In the event
* this shortcoming plagues other platforms as well, we add a low-cost retry wrapper.
*/
retry = MAX_MKSTEMP_RETRIES;
do
{
strcpy(rtnname, rtnname_template);
rtnfd = mkstemp(rtnname);
} while ((-1 == rtnfd) && (EEXIST == errno) && (0 < --retry));
if (-1 == rtnfd)
{
save_errno = errno;
assert(FALSE);
rts_error(VARLSTCNT(12) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("mkstemp()"), CALLFROM,
ERR_TEXT, 2, RTS_ERROR_TEXT(rtnname), save_errno);
}
assert(0 < rtnfd); /* Verify file descriptor */
rc = 0;
# ifdef GEN_TRIGCOMPFAIL_ERROR
{ /* Used ONLY to generate an error in a trigger compile by adding some junk in a previous line */
DOWRITERC(rtnfd, ERROR_CAUSING_JUNK, strlen(ERROR_CAUSING_JUNK), rc); /* BYPASSOK */
if (0 != rc)
{
UNLINK(rtnname);
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("write()"), CALLFROM, rc);
}
}
# endif
DOWRITERC(rtnfd, trigdsc->xecute_str.str.addr, trigdsc->xecute_str.str.len, rc);
if (0 != rc)
{
UNLINK(rtnname);
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("write()"), CALLFROM, rc);
}
if (NULL == memchr(trigdsc->xecute_str.str.addr, '\n', trigdsc->xecute_str.str.len))
{
DOWRITERC(rtnfd, NEWLINE, strlen(NEWLINE), rc); /* BYPASSOK */
if (0 != rc)
{
UNLINK(rtnname);
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("write()"), CALLFROM, rc);
}
}
CLOSEFILE(rtnfd, rc);
if (0 != rc)
{
UNLINK(rtnname);
rts_error(VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("close()"), CALLFROM, rc);
}
assert(MAX_MIDENT_LEN > trigdsc->rtn_desc.rt_name.len);
zcomp_parms_ptr = zcomp_parms;
lenrtnname = STRLEN(rtnname);
MEMCPY_LIT(zcomp_parms_ptr, NAMEOFRTN_PARM);
zcomp_parms_ptr += STRLEN(NAMEOFRTN_PARM);
memcpy(zcomp_parms_ptr, trigdsc->rtn_desc.rt_name.addr, trigdsc->rtn_desc.rt_name.len);
zcomp_parms_ptr += trigdsc->rtn_desc.rt_name.len;
MEMCPY_LIT(zcomp_parms_ptr, OBJECT_PARM);
zcomp_parms_ptr += STRLEN(OBJECT_PARM);
strcpy(objname, rtnname); /* Make copy of rtnname to become object name */
strcat(objname, OBJECT_FTYPE); /* Turn into object file reference */
lenobjname = lenrtnname + STRLEN(OBJECT_FTYPE);
memcpy(zcomp_parms_ptr, objname, lenobjname);
zcomp_parms_ptr += lenobjname;
*zcomp_parms_ptr++ = ' ';
memcpy(zcomp_parms_ptr, rtnname, lenrtnname);
zcomp_parms_ptr += lenrtnname;
*zcomp_parms_ptr = '\0'; /* Null tail */
len = INTCAST(zcomp_parms_ptr - zcomp_parms);
assert((SIZEOF(zcomp_parms) - 1) > len); /* Verify no overflow */
zcompprm.mvtype = MV_STR;
zcompprm.str.addr = zcomp_parms;
zcompprm.str.len = len;
/* Backup dollar_zsource so trigger doesn't show */
PUSH_MV_STENT(MVST_MSAV);
mv_chain->mv_st_cont.mvs_msav.v = dollar_zsource;
mv_chain->mv_st_cont.mvs_msav.addr = &dollar_zsource;
TREF(trigger_compile) = TRUE; /* Set flag so compiler knows this is a special trigger compile */
op_zcompile(&zcompprm, FALSE); /* Compile but don't require a .m file extension */
TREF(trigger_compile) = FALSE; /* compile_source_file() establishes handler so always returns */
if (0 != TREF(dollar_zcstatus))
{ /* Someone err'd.. */
run_time = gtm_trigger_comp_prev_run_time;
REVERT;
UNLINK(objname); /* Remove files before return error */
UNLINK(rtnname);
return ERR_TRIGCOMPFAIL;
}
if (dolink)
{ /* Link is optional as MUPIP TRIGGER doesn't need link */
zlfile.mvtype = MV_STR;
zlfile.str.addr = objname;
zlfile.str.len = lenobjname;
/* Specifying literal_null for a second arg (as opposed to NULL or 0) allows us to specify
* linking the object file (no compilation or looking for source). The 2nd arg is parms for
* recompilation and is non-null in an explicit zlink which we need to emulate.
*/
# ifdef GEN_TRIGLINKFAIL_ERROR
UNLINK(objname); /* delete object before it can be used */
# endif
op_zlink(&zlfile, (mval *)&literal_null); /* need cast due to "extern const" attributes */
/* No return here if link fails for some reason */
trigdsc->rtn_desc.rt_adr = find_rtn_hdr(&trigdsc->rtn_desc.rt_name);
if (NULL == trigdsc->rtn_desc.rt_adr)
GTMASSERT; /* Can't find routine we just put there? Catastrophic if happens */
/* Replace the randomly generated source name with the constant "GTM Trigger" */
trigdsc->rtn_desc.rt_adr->src_full_name.addr = GTM_TRIGGER_SOURCE_NAME;
trigdsc->rtn_desc.rt_adr->src_full_name.len = STRLEN(GTM_TRIGGER_SOURCE_NAME);
trigdsc->rtn_desc.rt_adr->trigr_handle = trigdsc; /* Back pointer to trig def */
}
if (MVST_MSAV == mv_chain->mv_st_type && &dollar_zsource == mv_chain->mv_st_cont.mvs_msav.addr)
{ /* Top mv_stent is one we pushed on there - restore dollar_zsource and get rid of it */
dollar_zsource = mv_chain->mv_st_cont.mvs_msav.v;
POP_MV_STENT();
} else
assert(FALSE); /* This mv_stent should be the one we just pushed */
/* Remove temporary files created */
UNLINK(objname); /* Delete the object file first since rtnname is the unique key */
UNLINK(rtnname); /* Delete the source file */
run_time = gtm_trigger_comp_prev_run_time;
REVERT;
return 0;
}
void op_merge(void)
{
boolean_t found, check_for_null_subs, is_base_var;
lv_val *dst_lv;
mval *mkey, *value, *subsc;
int org_glvn1_keysz, org_glvn2_keysz, delta2, dollardata_src, dollardata_dst, sbs_depth;
unsigned char *ptr, *ptr2;
unsigned char buff[MAX_ZWR_KEY_SZ];
unsigned char nullcoll_src, nullcoll_dst;
zshow_out output;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(MAX_STRLEN >= MAX_ZWR_KEY_SZ);
assert ((merge_args == (MARG1_LCL | MARG2_LCL)) ||
(merge_args == (MARG1_LCL | MARG2_GBL)) ||
(merge_args == (MARG1_GBL | MARG2_LCL)) ||
(merge_args == (MARG1_GBL | MARG2_GBL)));
assert(!lvzwrite_block || 0 == lvzwrite_block->curr_subsc);
/* Need to protect value from stpgcol */
PUSH_MV_STENT(MVST_MVAL);
value = &mv_chain->mv_st_cont.mvs_mval;
value->mvtype = 0; /* initialize mval in the M-stack in case stp_gcol gets called before value gets initialized below */
if (MARG2_IS_GBL(merge_args))
{ /* Need to protect mkey returned from gvcst_queryget from stpgcol */
PUSH_MV_STENT(MVST_MVAL);
mkey = &mv_chain->mv_st_cont.mvs_mval;
mkey->mvtype = 0; /* initialize mval in M-stack in case stp_gcol gets called before mkey gets initialized below */
gvname_env_restore(mglvnp->gblp[IND2]);
/* now $DATA will be done for gvn2. op_gvdata input parameters are set in the form of some GBLREF */
op_gvdata(value);
dollardata_src = MV_FORCE_INT(value);
if (0 == dollardata_src)
{ /* nothing in source global */
UNDO_ACTIVE_LV;
POP_MV_STENT(); /* value */
POP_MV_STENT(); /* mkey */
if (MARG1_IS_GBL(merge_args))
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
merge_args = 0; /* Must reset to zero to reuse the Global */
return;
}
if (NULL == TREF(gv_mergekey2))
{ /* We need to initialize gvn2 (right hand side). */
GVKEY_INIT(TREF(gv_mergekey2), DBKEYSIZE(MAX_KEY_SZ));
}
org_glvn1_keysz = mglvnp->gblp[IND1]->s_gv_currkey->end + 1;
org_glvn2_keysz = gv_currkey->end + 1;
(TREF(gv_mergekey2))->end = gv_currkey->end;
(TREF(gv_mergekey2))->prev = gv_currkey->prev;
memcpy((TREF(gv_mergekey2))->base, gv_currkey->base, gv_currkey->end + 1);
if (MARG1_IS_GBL(merge_args))
{ /*==================== MERGE ^gvn1=^gvn2 =====================*/
if (mglvnp->gblp[IND2]->s_gv_target->nct != mglvnp->gblp[IND1]->s_gv_target->nct)
rts_error(VARLSTCNT(1) ERR_NCTCOLLDIFF);
/* if self merge then NOOP*/
if (!merge_desc_check()) /* will not proceed if one is descendant of another */
{
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
POP_MV_STENT(); /* value */
merge_args = 0; /* Must reset to zero to reuse the Global */
return;
}
nullcoll_src = mglvnp->gblp[IND2]->s_gv_cur_region->std_null_coll;
nullcoll_dst = mglvnp->gblp[IND1]->s_gv_cur_region->std_null_coll;
if (1 == dollardata_src || 11 == dollardata_src)
{
found = op_gvget(value); /* value of ^glvn2 */
if (found)
{ /* SET ^gvn1=^gvn2 */
gvname_env_restore(mglvnp->gblp[IND1]);
op_gvput(value);
/* Note: If ^gvn1's null_sub=ALLOWEXISTING and say ^gvn1("")=^gvn,
* this will give NULL_SUBC error
*/
}
}
check_for_null_subs = (NEVER != mglvnp->gblp[IND2]->s_gv_cur_region->null_subs) &&
(ALWAYS != mglvnp->gblp[IND1]->s_gv_cur_region->null_subs);
/* Traverse descendant of ^gvn2 and copy into ^gvn1 */
for (; ;)
{
if (outofband)
{
gvname_env_restore(mglvnp->gblp[IND1]); /* naked indicator is restored into gv_currkey */
outofband_action(FALSE);
}
/* Restore last key under ^gvn2 we worked */
gvname_env_restore(mglvnp->gblp[IND2]);
assert(0 == gv_currkey->base[gv_currkey->end - 1] && 0 == gv_currkey->base[gv_currkey->end]);
/* following is an attempt to find immidiate right sibling */
gv_currkey->base[gv_currkey->end] = 1;
gv_currkey->base[gv_currkey->end + 1] = 0;
gv_currkey->base[gv_currkey->end + 2] = 0;
gv_currkey->end += 2;
/* Do atomic $QUERY and $GET of current glvn2:
* mkey is a mstr which contains $QUERY result in database format (So no conversion necessary)
* value is a mstr which contains $GET result
*/
if (!op_gvqueryget(mkey, value))
break;
assert(MV_IS_STRING(mkey));
if (mkey->str.len < org_glvn2_keysz)
break;
if (0 != *((unsigned char *)mkey->str.addr + (TREF(gv_mergekey2))->end - 1) ||
memcmp(mkey->str.addr, (TREF(gv_mergekey2))->base, (TREF(gv_mergekey2))->end - 1))
break; /* mkey is not under the sub-tree */
delta2 = mkey->str.len - org_glvn2_keysz; /* length increase of source key */
assert (0 < delta2);
/* Save the new source key for next iteration */
memcpy(mglvnp->gblp[IND2]->s_gv_currkey->base + org_glvn2_keysz - 2,
mkey->str.addr + org_glvn2_keysz - 2, delta2 + 2);
mglvnp->gblp[IND2]->s_gv_currkey->end = mkey->str.len - 1;
/* Create the destination key for this iteration (under ^glvn1) */
gvname_env_restore(mglvnp->gblp[IND1]);
if (gv_cur_region->max_key_size < org_glvn1_keysz + delta2)
ISSUE_GVSUBOFLOW_ERROR(gv_currkey);
assert(gv_currkey->end == org_glvn1_keysz - 1);
memcpy(gv_currkey->base + org_glvn1_keysz - 2,
mkey->str.addr + org_glvn2_keysz - 2, delta2 + 2);
gv_currkey->end = org_glvn1_keysz + delta2 - 1;
if (nullcoll_src != nullcoll_dst)
{
if (0 == nullcoll_dst)
{ /* Standard to GTM null subscript conversion*/
STD2GTMNULLCOLL((unsigned char *)gv_currkey->base + org_glvn1_keysz - 1,
delta2 - 1);
} else
{ /* GTM to standard null subscript conversion */
GTM2STDNULLCOLL((unsigned char *)gv_currkey->base + org_glvn1_keysz - 1,
delta2 - 1);
}
}
/* check null subscripts in destination key, note that we have already restored, destination global
* and curresponding region, key information
*/
if (check_for_null_subs)
{
ptr2 = gv_currkey->base + gv_currkey->end - 1;
for (ptr = gv_currkey->base + org_glvn1_keysz - 2; ptr < ptr2; )
{
if (KEY_DELIMITER == *ptr++ && KEY_DELIMITER == *(ptr + 1) &&
(0 == gv_cur_region->std_null_coll ? (STR_SUB_PREFIX == *ptr) :
(SUBSCRIPT_STDCOL_NULL == *ptr)))
/* Note: For sgnl_gvnulsubsc/rts_error
* we do not restore proper naked indicator.
* The standard states that the effect of a MERGE command
* on the naked indicator is that the naked indicator will be changed
* as if a specific SET command would have been executed.
* The standard also states that the effect on the naked indicator
* will only take be visible after the MERGE command has completed.
* So, if there is an error during the execution of a MERGE command,
* the standard allows the naked indicator to reflect any intermediate
* state. This provision was made intentionally, otherwise it would
* have become nearly impossible to create a fully standard
* implementation. : From Ed de Moel : 2/1/2
*/
sgnl_gvnulsubsc();
}
}
/* Now put value of ^glvn2 descendant into corresponding descendant under ^glvn1 */
op_gvput(value);
}
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
} else
{ /*==================== MERGE lvn1=^gvn2 =====================*/
assert(MARG1_IS_LCL(merge_args));
assert(mglvnp->lclp[IND1]);
/* Need to protect subsc created from global variable subscripts from stpgcol */
PUSH_MV_STENT(MVST_MVAL);
subsc = &mv_chain->mv_st_cont.mvs_mval;
/* Restore ^gvn2 we will work */
gvname_env_save(mglvnp->gblp[IND2]);
if (1 == dollardata_src || 11 == dollardata_src)
{ /* SET lvn1=^gvn2 */
found = op_gvget(value);
if (found)
mglvnp->lclp[IND1]->v = *value;
}
for (; ;)
{
if (outofband)
{
gvname_env_restore(mglvnp->gblp[IND2]); /* naked indicator is restored into gv_currkey */
outofband_action(FALSE);
}
assert(0 == gv_currkey->base[gv_currkey->end - 1] && 0 == gv_currkey->base[gv_currkey->end]);
/* following is an attempt to find immidiate right sibling */
gv_currkey->base[gv_currkey->end] = 1;
gv_currkey->base[gv_currkey->end + 1] = 0;
gv_currkey->base[gv_currkey->end + 2] = 0;
gv_currkey->end += 2;
/* Do $QUERY and $GET of current glvn2. Result will be in mkey and value respectively.
* mkey->str contains data as database format. So no conversion necessary
*/
if (!op_gvqueryget(mkey, value))
break;
if (mkey->str.len < (TREF(gv_mergekey2))->end + 1)
break;
ptr = (unsigned char *)mkey->str.addr + (TREF(gv_mergekey2))->end - 1;
if (0 != *ptr || memcmp(mkey->str.addr, (TREF(gv_mergekey2))->base, (TREF(gv_mergekey2))->end - 1))
break;
assert(MV_IS_STRING(mkey));
delta2 = mkey->str.len - org_glvn2_keysz; /* length increase of key */
assert (0 < delta2);
/* Create next key for ^glvn2 */
memcpy(gv_currkey->base + org_glvn2_keysz - 2, mkey->str.addr + org_glvn2_keysz - 2, delta2 + 2);
gv_currkey->end = mkey->str.len - 1;
/* Now add subscripts to create the entire key */
dst_lv = mglvnp->lclp[IND1];
is_base_var = LV_IS_BASE_VAR(dst_lv);
ptr = (unsigned char *)gv_currkey->base + org_glvn2_keysz - 1;
assert(*ptr);
do
{
LV_SBS_DEPTH(dst_lv, is_base_var, sbs_depth);
if (MAX_LVSUBSCRIPTS <= sbs_depth)
rts_error(VARLSTCNT(3) ERR_MERGEINCOMPL, 0, ERR_MAXNRSUBSCRIPTS);
ptr2 = gvsub2str(ptr, buff, FALSE);
subsc->mvtype = MV_STR;
subsc->str.addr = (char *)buff;
subsc->str.len = INTCAST(ptr2 - buff);
s2pool(&subsc->str);
dst_lv = op_putindx(VARLSTCNT(2) dst_lv, subsc);
while (*ptr++); /* skip to start of next subscript */
is_base_var = FALSE;
} while (*ptr);
/* We created the key. Pre-process the node in case a container is being replaced,
* then assign the value directly. Note there is no need to worry about MV_ALIASCONT
* propagation since the source in this case is a global var.
*/
DECR_AC_REF(dst_lv, TRUE);
dst_lv->v = *value;
}
gvname_env_restore(mglvnp->gblp[IND2]); /* naked indicator is restored into gv_currkey */
POP_MV_STENT(); /* subsc */
}
POP_MV_STENT(); /* mkey */
} else
{ /* source is local */
op_fndata(mglvnp->lclp[IND2], value);
dollardata_src = MV_FORCE_INT(value);
if (0 == dollardata_src)
{
UNDO_ACTIVE_LV;
POP_MV_STENT(); /* value */
if (MARG1_IS_GBL(merge_args))
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
merge_args = 0; /* Must reset to zero to reuse the Global */
return;
}
/* not memsetting output to 0 here can cause garbage value of output.out_var.lv.child which in turn can
* cause a premature return from lvzwr_var resulting in op_merge() returning without having done the merge.
*/
memset(&output, 0, SIZEOF(output));
if (MARG1_IS_LCL(merge_args))
{ /*==================== MERGE lvn1=lvn2 =====================*/
assert(mglvnp->lclp[IND1]);
/* if self merge then NOOP */
if (!merge_desc_check()) /* will not proceed if one is descendant of another */
{
POP_MV_STENT(); /* value */
merge_args = 0; /* Must reset to zero to reuse the Global */
return;
}
output.buff = (char *)buff;
output.ptr = output.buff;
output.out_var.lv.lvar = mglvnp->lclp[IND1];
zwr_output = &output;
lvzwr_init(zwr_patrn_mident, &mglvnp->lclp[IND2]->v);
lvzwr_arg(ZWRITE_ASTERISK, 0, 0);
lvzwr_var(mglvnp->lclp[IND2], 0);
/* assert that destination got all data of the source and its descendants */
DEBUG_ONLY(op_fndata(mglvnp->lclp[IND1], value));
DEBUG_ONLY(dollardata_dst = MV_FORCE_INT(value));
assert((dollardata_src & dollardata_dst) == dollardata_src);
} else
{ /*==================== MERGE ^gvn1=lvn2 =====================*/
assert(MARG1_IS_GBL(merge_args) && MARG2_IS_LCL(merge_args));
gvname_env_save(mglvnp->gblp[IND1]);
output.buff = (char *)buff;
output.ptr = output.buff;
output.out_var.gv.end = gv_currkey->end;
output.out_var.gv.prev = gv_currkey->prev;
zwr_output = &output;
lvzwr_init(zwr_patrn_mident, &mglvnp->lclp[IND2]->v);
lvzwr_arg(ZWRITE_ASTERISK, 0, 0);
lvzwr_var(mglvnp->lclp[IND2], 0);
gvname_env_restore(mglvnp->gblp[IND1]); /* store destination as naked indicator in gv_currkey */
}
}
POP_MV_STENT(); /* value */
merge_args = 0; /* Must reset to zero to reuse the Global */
}
