void lvzwr_out_targkey(mstr *one)
{
int n, nsubs;
zshow_output(zwr_output, lvzwrite_block->curr_name);
nsubs = lvzwrite_block->curr_subsc;
if (nsubs)
{
*one->addr = '(';
zshow_output(zwr_output, one);
for (n = 0 ; ; )
{
mval_write(zwr_output, ((zwr_sub_lst *)lvzwrite_block->sub)->subsc_list[n].actual, FALSE);
if (++n < nsubs)
{
*one->addr = ',';
zshow_output(zwr_output, one);
} else
{
*one->addr = ')';
zshow_output(zwr_output, one);
break;
}
}
}
}
void zshow_format_lock(zshow_out *output, mlk_pvtblk *temp)
{
static readonly char lp[] = "(";
static readonly char rp[] = ")";
static readonly char cm[] = ",";
mval v;
unsigned short subs;
unsigned char *ptr,len;
ptr = temp->value;
len = v.str.len = *ptr++;
v.str.addr = (char *)ptr;
zshow_output(output, &v.str);
if (temp->subscript_cnt > 1)
{
v.mvtype = MV_STR;
v.str.len = 1;
v.str.addr = lp;
zshow_output(output, &v.str);
for (subs = 1 ; subs < temp->subscript_cnt; subs++)
{
if (subs > 1)
{
v.str.len = 1;
v.str.addr = cm;
zshow_output(output, &v.str);
}
ptr += len;
len = v.str.len = *ptr++;
v.str.addr = (char *)ptr;
mval_write(output, &v, FALSE);
}
v.str.len = 1;
v.str.addr = rp;
zshow_output(output,&v.str);
}
}
void zshow_locks(zshow_out *output)
{
static readonly char zal[] = "ZAL ";
static readonly char lck[] = "LOCK ";
static readonly char lvl[] = " LEVEL=";
mval v;
mlk_pvtblk *temp;
for (temp = mlk_pvt_root; temp; temp = temp->next)
{
if (!temp->granted)
continue;
if (temp->nodptr && (temp->nodptr->owner != process_id
|| temp->sequence != temp->nodptr->sequence))
continue;
output->flush = FALSE;
if (temp->level && temp->zalloc)
{
v.str.addr = &zal[0];
v.str.len = sizeof(zal) - 1;
zshow_output(output,&v.str);
zshow_format_lock(output,temp);
output->flush = TRUE;
v.str.len = 0;
zshow_output(output,&v.str);
output->flush = FALSE;
v.str.addr = &lck[0];
v.str.len = sizeof(lck) - 1;
zshow_output(output,&v.str);
zshow_format_lock(output,temp);
v.str.addr = &lvl[0];
v.str.len = sizeof(lvl) - 1;
zshow_output(output,&v.str);
MV_FORCE_MVAL(&v,temp->level) ;
mval_write(output,&v,TRUE);
}
else if (temp->level)
{
v.str.addr = &lck[0];
v.str.len = sizeof(lck) - 1;
zshow_output(output,&v.str);
zshow_format_lock(output,temp);
v.str.addr = &lvl[0];
v.str.len = sizeof(lvl) - 1;
zshow_output(output,&v.str);
MV_FORCE_MVAL(&v,temp->level) ;
mval_write(output,&v,TRUE);
}else if (temp->zalloc)
{
v.str.addr = &zal[0];
v.str.len = sizeof(zal) - 1;
zshow_output(output,&v.str);
zshow_format_lock(output,temp);
output->flush = TRUE;
v.str.len = 0;
zshow_output(output,&v.str);
}
}
}
void zshow_devices(zshow_out *output)
{
static readonly char filchar_text[] = "CHARACTERS";
static readonly char filesc_text[] = "ESCAPES";
static readonly char terminal_text[] = "TERMINAL ";
static readonly char magtape_text[] = "MAGTAPE ";
static readonly char rmsfile_text[] = "RMS ";
static readonly char mailbox_text[] = "MAILBOX ";
static readonly char dollarc_text[] = "$C(";
static readonly char equal_text[] = {'='};
static readonly char comma_text[] = {','};
static readonly char quote_text[] = {'"'};
static readonly char lparen_text[] = {'('};
static readonly char rparen_text[] = {')'};
static readonly char devop[] = "OPEN ";
static readonly char devcl[] = "CLOSED ";
static readonly char largerecord[] = "BIGRECORD ";
static readonly char rfm_tab[][7] = {"UDF ", "FIXED ", "VAR ", "VFC ", "STM ", "STMLF ", "STMCR "};
bool first;
int4 i, j, ii, jj;
io_log_name *l; /* logical name pointer */
mval v;
mval m;
struct FAB *f;
struct RAB *r;
d_mb_struct *mb_ptr;
d_mt_struct *mt_ptr;
d_rm_struct *rm_ptr;
d_tt_struct *tt_ptr;
d_socket_struct *dsocketptr;
socket_struct *socketptr;
io_termmask *mask_out;
unsigned char delim_buff_sm[MAX_DELIM_LEN];
unsigned short delim_len_sm;
char delim_mstr_buff[(MAX_DELIM_LEN * MAX_ZWR_EXP_RATIO) + 11];
mstr delim;
int delim_len;
static readonly char space8_text[] = " "; /* starting from here, for gtmsocket only */
static readonly char lb_text[] = {'['};
static readonly char rb_text[] = {']'};
static readonly char at_text[] = {'@'};
static readonly char delimiter_text[] = "DELIMITER ";
static readonly char nodelimiter_text[] = "NODELIMITER ";
static readonly char local_text[] = "LOCAL=";
static readonly char remote_text[] = "REMOTE=";
static readonly char total_text[] = "TOTAL=";
static readonly char current_text[] = "CURRENT=";
static readonly char passive_text[] = "PASSIVE ";
static readonly char active_text[] = "ACTIVE ";
static readonly char socket_text[] = "SOCKET";
static readonly char descriptor_text[] = "DESC=";
static readonly char trap_text[] = "TRAP ";
static readonly char notrap_text[] = "NOTRAP ";
static readonly char zdelay_text[] = "ZDELAY ";
static readonly char znodelay_text[] = "ZNODELAY ";
static readonly char zbfsize_text[] = "ZBFSIZE=";
static readonly char zibfsize_text[] = "ZIBFSIZE=";
static readonly char port_text[] = "PORT=";
static readonly char zsh_socket_state[][10] =
{ "CONNECTED"
,"LISTENING"
,"BOUND"
,"CREATED"
};
static readonly char morereadtime_text[] = "MOREREADTIME=";
v.mvtype = MV_STR;
for (l = io_root_log_name; l != 0; l = l->next)
{
if (l->dollar_io[0] != IO_ESC && l->iod->trans_name == l)
{
v.str.addr = &l->dollar_io[0];
v.str.len = l->len;
zshow_output(output, &v.str);
ZS_ONE_OUT(&v, space_text);
if (l->iod->state == dev_open)
{
ZS_STR_OUT(&v, devop);
switch(l->iod->type)
{
case tt:
ZS_STR_OUT(&v, terminal_text);
tt_ptr = (d_tt_struct *)l->iod->dev_sp;
if (!ctrlc_on && io_std_device->out == l->iod) /* and standard input */
ZS_PARM_SP(&v, zshow_nocene);
if ((int4)(tt_ptr->item_list[0].addr) & TRM$M_TM_CVTLOW)
ZS_PARM_SP(&v, zshow_conv);
if (tt_ptr->enbld_outofbands.mask)
{
ZS_PARM_EQU(&v, zshow_ctra);
ZS_STR_OUT(&v, dollarc_text);
first = TRUE;
for (i = 1, j = 0; j < 32; j++, i = i * 2)
{
if (i & tt_ptr->enbld_outofbands.mask)
{
if (!first)
ZS_ONE_OUT(&v, comma_text);
else
first = FALSE;
MV_FORCE_MVAL(&m, j);
mval_write(output, &m, FALSE);
}
}
ZS_ONE_OUT(&v, rparen_text);
ZS_ONE_OUT(&v, space_text);
}
if ((int4)(tt_ptr->term_char) & TT$M_NOECHO)
ZS_PARM_SP(&v, zshow_noecho);
if ((int4)(tt_ptr->ext_cap) & TT2$M_EDITING)
ZS_PARM_SP(&v, zshow_edit);
else
ZS_PARM_SP(&v, zshow_noedit);
if (!((int4)(tt_ptr->term_char) & TT$M_ESCAPE))
ZS_PARM_SP(&v, zshow_noesca);
if (tt_ptr->in_buf_sz != TTDEF_BUF_SZ)
{
ZS_PARM_EQU(&v, zshow_field);
MV_FORCE_MVAL(&m, tt_ptr->in_buf_sz);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
if (tt_ptr->term_char & TT$M_HOSTSYNC)
ZS_PARM_SP(&v, zshow_host);
else
ZS_PARM_SP(&v, zshow_nohost);
if (tt_ptr->ext_cap & TT2$M_INSERT)
ZS_PARM_SP(&v, zshow_inse);
else
ZS_PARM_SP(&v, zshow_noinse);
if (tt_ptr->ext_cap & TT2$M_PASTHRU)
ZS_PARM_SP(&v, zshow_past);
else
ZS_PARM_SP(&v, zshow_nopast);
if (tt_ptr->term_char & TT$M_READSYNC)
ZS_PARM_SP(&v, zshow_reads);
else
ZS_PARM_SP(&v, zshow_noreads);
if (tt_ptr->term_char & TT$M_TTSYNC)
ZS_PARM_SP(&v, zshow_ttsy);
else
ZS_PARM_SP(&v, zshow_nottsy);
if (tt_ptr->term_char & TT$M_NOTYPEAHD)
ZS_PARM_SP(&v, zshow_notype);
else
ZS_PARM_SP(&v, zshow_type);
if (!l->iod->wrap)
ZS_PARM_SP(&v, zshow_nowrap);
mask_out = tt_ptr->item_list[2].addr;
if (mask_out->mask[0] != TERM_MSK)
{
ZS_PARM_EQU(&v, zshow_term);
ZS_STR_OUT(&v, dollarc_text);
first = TRUE;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 32; j++)
if (mask_out->mask[i] & (1 << j))
{
if (!first)
ZS_ONE_OUT(&v, comma_text);
else
first = FALSE;
MV_FORCE_MVAL(&m, i * 32 + j);
mval_write(output, &m, FALSE);
}
}
ZS_ONE_OUT(&v, rparen_text);
ZS_ONE_OUT(&v, space_text);
}
ZS_PARM_EQU(&v, zshow_width);
MV_FORCE_MVAL(&m, l->iod->width);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
ZS_PARM_EQU(&v, zshow_leng);
MV_FORCE_MVAL(&m, l->iod->pair.out->length);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
if (l->iod->write_filter)
{
bool twoparms = FALSE;
ZS_PARM_EQU(&v, zshow_fil);
if (l->iod->write_filter & CHAR_FILTER)
{
if (l->iod->write_filter & ESC1)
{
twoparms = TRUE;
ZS_ONE_OUT(&v, lparen_text);
}
ZS_STR_OUT(&v, filchar_text);
if (twoparms)
{
ZS_ONE_OUT(&v, comma_text);
ZS_ONE_OUT(&v, space_text);
}
}
if (l->iod->write_filter & ESC1)
ZS_STR_OUT(&v, filesc_text);
if (twoparms)
ZS_ONE_OUT(&v, rparen_text);
ZS_ONE_OUT(&v, space_text);
}
break;
case mt:
ZS_STR_OUT(&v, magtape_text);
mt_ptr = (d_tt_struct *)l->iod->dev_sp;
if (mt_ptr->block_sz != MTDEF_BUF_SZ)
{
ZS_PARM_EQU(&v, zshow_bloc);
MV_FORCE_MVAL(&m, mt_ptr->block_sz);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
if (mt_ptr->record_sz != MTDEF_REC_SZ)
{
ZS_PARM_EQU(&v, zshow_rec);
MV_FORCE_MVAL(&m, mt_ptr->record_sz);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
if (mt_ptr->read_only)
ZS_PARM_SP(&v, zshow_read);
if (mt_ptr->ebcdic)
ZS_PARM_SP(&v, zshow_ebcd);
if (mt_ptr->fixed)
ZS_PARM_SP(&v, zshow_fixed);
if (mt_ptr->read_mask & IO$M_DATACHECK)
ZS_PARM_SP(&v, zshow_rchk);
if (mt_ptr->write_mask & IO$M_DATACHECK)
ZS_PARM_SP(&v, zshow_wchk);
if (!l->iod->wrap)
ZS_PARM_SP(&v, zshow_nowrap);
break;
case rm:
ZS_STR_OUT(&v, rmsfile_text);
rm_ptr = (d_rm_struct *)l->iod->dev_sp;
f = &rm_ptr->f;
r = &rm_ptr->r;
if (r->rab$l_rop & RAB$M_CVT)
ZS_PARM_SP(&v, zshow_conv);
if (f->fab$l_alq != 0)
{
ZS_PARM_EQU(&v, zshow_allo);
MV_FORCE_MVAL(&m, f->fab$l_alq);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
if (f->fab$l_fop & FAB$M_DLT)
ZS_PARM_SP(&v, zshow_dele);
if (f->fab$w_deq != 0)
{
ZS_PARM_EQU(&v, zshow_exte);
MV_FORCE_MVAL(&m, f->fab$w_deq);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
assert(FAB$C_MAXRFM == (SIZEOF(rfm_tab)/SIZEOF(rfm_tab[0]) - 1));
if (FAB$C_MAXRFM >= rm_ptr->b_rfm && FAB$C_RFM_DFLT != rm_ptr->b_rfm)
ZS_STR_OUT(&v, rfm_tab[rm_ptr->b_rfm]);
if (rm_ptr->largerecord)
ZS_STR_OUT(&v, largerecord);
if (f->fab$b_fac == FAB$M_GET)
ZS_PARM_SP(&v, zshow_read);
if (rm_ptr->l_mrs != DEF_RM_WIDTH)
{
ZS_PARM_EQU(&v, zshow_rec);
MV_FORCE_MVAL(&m, rm_ptr->l_mrs);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
/* smw should we add width aka usz */
if (f->fab$b_shr & FAB$M_SHRGET)
ZS_PARM_SP(&v, zshow_shar);
/*
if (f->fab$l_fop & FAB$M_SPL)
ZS_PARM_SP(&v, zshow_spo);
if (f->fab$l_fop & FAB$M_SCF)
ZS_PARM_SP(&v, zshow_sub);
*/
if (!l->iod->wrap)
ZS_PARM_SP(&v, zshow_nowrap);
if (f->fab$l_xab)
{
/* smw need to handle other XABs and uic as octal */
struct XABPRO *xabpro;
uic_struct uic;
ZS_PARM_EQU(&v, zshow_uic);
ZS_ONE_OUT(&v, quote_text);
xabpro = f->fab$l_xab;
memcpy(&uic, &xabpro->xab$l_uic, SIZEOF(int4));
MV_FORCE_MVAL(&m, uic.grp);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, comma_text);
MV_FORCE_MVAL(&m, uic.mem);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, quote_text);
ZS_ONE_OUT(&v, space_text);
}
break;
case mb:
ZS_STR_OUT(&v, mailbox_text);
mb_ptr = (d_mb_struct *)l->iod->dev_sp;
if (!(mb_ptr->write_mask & IO$M_NOW))
ZS_PARM_SP(&v, zshow_wait);
if (mb_ptr->prmflg)
ZS_PARM_SP(&v, zshow_prmmbx);
if (mb_ptr->maxmsg != DEF_MB_MAXMSG)
{
ZS_PARM_EQU(&v, zshow_bloc);
MV_FORCE_MVAL(&m, mb_ptr->maxmsg);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
if (mb_ptr->promsk & IO_RD_ONLY)
ZS_PARM_SP(&v, zshow_read);
if (mb_ptr->del_on_close)
ZS_PARM_SP(&v, zshow_dele);
if (mb_ptr->promsk & IO_SEQ_WRT)
ZS_PARM_SP(&v, zshow_write);
if (l->iod->width != DEF_MB_MAXMSG)
{
ZS_PARM_EQU(&v, zshow_width);
MV_FORCE_MVAL(&m, l->iod->width);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
if (!l->iod->wrap)
ZS_PARM_SP(&v, zshow_nowrap);
if (l->iod->length != DEF_MB_LENGTH)
{
ZS_PARM_EQU(&v, zshow_leng);
MV_FORCE_MVAL(&m, l->iod->length);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
break;
case gtmsocket:
delim.addr = delim_mstr_buff;
delim_len = 0;
ZS_STR_OUT(&v, socket_text);
dsocketptr = (d_socket_struct *)l->iod->dev_sp;
ZS_ONE_OUT(&v, space_text);
ZS_STR_OUT(&v, total_text);
MV_FORCE_MVAL(&m, (int)dsocketptr->n_socket);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
ZS_STR_OUT(&v, current_text);
MV_FORCE_MVAL(&m, (int)dsocketptr->current_socket);
mval_write(output, &m, FALSE);
output->flush = TRUE;
zshow_output(output, 0);
for(ii = 0; ii < dsocketptr->n_socket; ii++)
{
/* output each socket */
socketptr = dsocketptr->socket[ii];
ZS_STR_OUT(&v, space8_text);
/* socket handle */ ZS_STR_OUT(&v, socket_text);
ZS_ONE_OUT(&v, lb_text);
MV_FORCE_MVAL(&m, ii);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, rb_text);
ZS_ONE_OUT(&v, equal_text);
v.str.addr = socketptr->handle;
v.str.len = socketptr->handle_len;
zshow_output(output, &v.str);
ZS_ONE_OUT(&v, space_text);
/* socket descriptor */ ZS_STR_OUT(&v, descriptor_text);
MV_FORCE_MVAL(&m, socketptr->sd);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
/* socket state */ ZS_STR_OUT(&v, zsh_socket_state[socketptr->state]);
ZS_ONE_OUT(&v, space_text);
/* socket type */ if (socketptr->passive)
{
ZS_STR_OUT(&v, passive_text);
} else
{
ZS_STR_OUT(&v, active_text);
}
ZS_ONE_OUT(&v, space_text);
/* error trapping */ if (socketptr->ioerror)
{
ZS_STR_OUT(&v, trap_text);
} else
{
ZS_STR_OUT(&v, notrap_text);
}
ZS_ONE_OUT(&v, space_text);
/* address + port */ if (socketptr->passive)
{
ZS_STR_OUT(&v, port_text);
MV_FORCE_MVAL(&m, (int)socketptr->local.port);
mval_write(output, &m, FALSE);
} else
{
ZS_STR_OUT(&v, remote_text);
if (NULL != socketptr->remote.saddr_ip)
{
v.str.addr = socketptr->remote.saddr_ip;
v.str.len = strlen(socketptr->remote.saddr_ip);
} else
{
v.str.addr = "";
v.str.len = 0;
}
zshow_output(output, &v.str);
ZS_ONE_OUT(&v, at_text);
MV_FORCE_MVAL(&m, (int)socketptr->remote.port);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
/* to be added later ...
ZS_STR_OUT(&v, local_text);
v.str.addr = socketptr->local.saddr_ip;
v.str.len = strlen(socketptr->local.saddr_ip);
zshow_output(output, &v.str);
ZS_ONE_OUT(&v, at_text);
MV_FORCE_MVAL(&m, (int)socketptr->local.port);
mval_write(output, &m, FALSE);
*/
}
ZS_ONE_OUT(&v, space_text);
output->flush = TRUE;
zshow_output(output, 0);
ZS_STR_OUT(&v, space8_text);
ZS_STR_OUT(&v, space8_text);
/* zdelay */ if (socketptr->nodelay)
{
ZS_STR_OUT(&v, znodelay_text);
} else
{
ZS_STR_OUT(&v, zdelay_text);
}
ZS_ONE_OUT(&v, space_text);
/* zbfsize */ ZS_STR_OUT(&v, zbfsize_text);
MV_FORCE_MVAL(&m, socketptr->buffer_size);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
/* izbfsize */ ZS_STR_OUT(&v, zibfsize_text);
MV_FORCE_MVAL(&m, socketptr->bufsiz);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
/* delimiters */ if (socketptr->n_delimiter > 0)
{
output->flush = TRUE;
zshow_output(output, 0);
ZS_STR_OUT(&v, space8_text);
ZS_STR_OUT(&v, space8_text);
ZS_STR_OUT(&v, delimiter_text);
for (jj = 0; jj < socketptr->n_delimiter; jj++)
{
delim_len_sm = socketptr->delimiter[jj].len;
memcpy(delim_buff_sm, socketptr->delimiter[jj].addr, delim_len_sm);
format2zwr(delim_buff_sm, delim_len_sm, (uchar_ptr_t)delim.addr,
&delim_len);
delim.len = (unsigned short) delim_len;
assert(SIZEOF(delim_mstr_buff) >= delim_len);
zshow_output(output, &delim);
ZS_ONE_OUT(&v, space_text);
}
} else
{
ZS_STR_OUT(&v, nodelimiter_text);
}
/* readmoretime */ if (DEFAULT_MOREREAD_TIMEOUT != socketptr->moreread_timeout)
{
ZS_STR_OUT(&v, morereadtime_text);
MV_FORCE_MVAL(&m, socketptr->moreread_timeout);
mval_write(output, &m, FALSE);
}
output->flush = TRUE;
zshow_output(output, 0);
}
default:
v.str.len = 0;
break;
}
if (l->iod->error_handler.len)
{
ZS_PARM_EQU(&v, zshow_exce);
ZS_ONE_OUT(&v, quote_text);
v.str = l->iod->error_handler;
zshow_output(output, &v.str);
output->flush = TRUE;
ZS_ONE_OUT(&v, quote_text);
} else
{
output->flush = TRUE;
zshow_output(output, 0);
}
}
else
{
output->flush = TRUE;
ZS_STR_OUT(&v, devcl);
}
}
}
}
void lvzwr_out(lv_val *lvp)
{
char buff;
uchar_ptr_t lastc;
int n, nsubs, sbs_depth;
lv_val *dst_lv, *res_lv, *lvpc;
mstr one;
mval *subscp, *val, outindx;
ht_ent_addr *tabent_addr;
ht_ent_mname *tabent_mname;
boolean_t htent_added, dump_container;
zwr_alias_var *newzav, *zav;
mident_fixed zwrt_varname;
lvzwrite_datablk *newzwrb;
gparam_list param_list; /* for op_putindx call through callg */
gvnh_reg_t *gvnh_reg;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
val = &lvp->v;
assert(lvzwrite_block);
if (!merge_args)
{ /* The cases that exist here are:
* 1) This is a container variable. If the lv_val it refers to has been printed, show that association.
* Else, "create" a $ZWRTACxxx var/index that will define the value. Then before returning, cause
* that container var to be dumped with the appropriate $ZWRTACxxx index as the var name.
* 2) This is an alias base variable. If first time seen, we print normally but record it and put a
* ";#" tag on the end to signify it is an alias var (doesn't affect value). If we look it up and it
* is not the first time this lv_val has been printed, then we instead print the statement needed to
* alias it to the first seen var.
* 3) This is just a normal var needing to be printed normally.
*/
htent_added = FALSE;
one.addr = &buff;
one.len = 1;
lvzwrite_block->zav_added = FALSE;
if (lvp->v.mvtype & MV_ALIASCONT)
{ /* Case 1 -- have an alias container */
assert(curr_symval->alias_activity);
assert(!LV_IS_BASE_VAR(lvp)); /* verify is subscripted var */
lvpc = (lv_val *)lvp->v.str.addr;
assert(lvpc);
assert(LV_IS_BASE_VAR(lvpc)); /* Verify base var lv_val */
if (tabent_addr = (ht_ent_addr *)lookup_hashtab_addr(&zwrhtab->h_zwrtab, (char **)&lvpc))
{ /* The value was found, we have a reference we can print now */
assert(HTENT_VALID_ADDR(tabent_addr, zwr_alias_var, zav));
*one.addr = '*';
zshow_output(zwr_output, &one);
lvzwr_out_targkey(&one);
*one.addr = '=';
zshow_output(zwr_output, &one);
zav = (zwr_alias_var *)tabent_addr->value;
assert(0 < zav->zwr_var.len);
zwr_output->flush = TRUE;
zshow_output(zwr_output, (const mstr *)&zav->zwr_var);
return;
}
/* This lv_val isn't known to us yet. Scan the hash curr_symval hash table to see if it is known as a
* base variable as we could have a "forward reference" here.
*/
tabent_mname = als_lookup_base_lvval(lvpc);
/* note even though both paths below add a zav, not bothering to set zav_added because that flag is
* really only (currently) cared about in reference to processing a basevar so we wouldn't
* be in this code path anyway. Comment here to record potential usage if that changes.
*/
if (tabent_mname)
{ /* Found a base var it can reference -- create a zwrhtab entry for it */
assert(tabent_mname->key.var_name.len);
newzav = als_getzavslot();
newzav->zwr_var = tabent_mname->key.var_name;
htent_added = add_hashtab_addr(&zwrhtab->h_zwrtab, (char **)&lvpc, newzav, &tabent_addr);
assert(htent_added);
dump_container = FALSE;
} else
{ /* Unable to find lv_val .. must be "orphaned" so we generate a new $ZWRTAC var for it. The first
* check however is if this is the first $ZWRTAC var being generated for this $ZWR. If yes, generate
* a $ZWRTAC="" line to preceed it. This will be a flag to load to clear out all existing $ZWRTAC
* temp vars so there is no pollution between loads of ZWRitten data.
*/
if (0 == zwrtacindx++)
{ /* Put out "dummy" statement that will clear all the $ZWRTAC vars for a clean slate */
zwr_output->flush = TRUE;
zshow_output(zwr_output, &dzwrtac_clean);
}
MEMCPY_LIT(zwrt_varname.c, DOLLAR_ZWRTAC);
lastc = i2asc((uchar_ptr_t)zwrt_varname.c + STR_LIT_LEN(DOLLAR_ZWRTAC), zwrtacindx);
newzav = als_getzavslot();
newzav->zwr_var.addr = zwrt_varname.c;
newzav->zwr_var.len = INTCAST(((char *)lastc - &zwrt_varname.c[0]));
s2pool(&newzav->zwr_var);
htent_added = add_hashtab_addr(&zwrhtab->h_zwrtab, (char **)&lvpc, newzav, &tabent_addr);
assert(htent_added);
dump_container = TRUE;
}
/* Note value_printed flag in newzav not set since we are NOT dumping the value at this point
* but only the association. Since the flag is not set, we *will* dump it when we get to that
* actual variable.
*/
*one.addr = '*';
zshow_output(zwr_output, &one);
lvzwr_out_targkey(&one);
*one.addr = '=';
zshow_output(zwr_output, &one);
zwr_output->flush = TRUE;
zshow_output(zwr_output, (const mstr *)&newzav->zwr_var);
if (dump_container)
{ /* We want to dump the entire container variable but the name doesn't match the var we are
* currently dumping so push a new lvzwrite_block onto the stack, fill it in for the current var
* and call lvzwr_var() to handle it. When done, dismantle the temp lvzwrite_block.
*/
newzwrb = (lvzwrite_datablk *)malloc(SIZEOF(lvzwrite_datablk));
memset(newzwrb, 0, SIZEOF(lvzwrite_datablk));
newzwrb->sub = (zwr_sub_lst *)malloc(SIZEOF(zwr_sub_lst) * MAX_LVSUBSCRIPTS);
newzwrb->curr_name = &newzav->zwr_var;
newzwrb->prev = lvzwrite_block;
lvzwrite_block = newzwrb;
lvzwr_var(lvpc, 0);
assert(newzav->value_printed);
assert(newzwrb == lvzwrite_block);
free(newzwrb->sub);
lvzwrite_block = newzwrb->prev;
free(newzwrb);
}
return;
} else if (LV_IS_BASE_VAR(lvp) && IS_ALIASLV(lvp))
{ /* Case 2 -- alias base variable (only base vars have reference counts). Note this can occur with
* TP save/restore vars since we increment both trefcnt and crefcnt for these hidden copied references.
* Because of that, we can't assert alias_activity but otherwise it shouldn't affect processing.
*/
if (!(htent_added = add_hashtab_addr(&zwrhtab->h_zwrtab, (char **)&lvp, NULL, &tabent_addr)))
{ /* Entry already existed -- need to output association rather than values */
assert(tabent_addr);
zav = (zwr_alias_var *)tabent_addr->value;
assert(zav);
if (zav->value_printed)
{ /* Value has already been output -- print association this time */
*one.addr = '*'; /* Flag as creating an alias */
zshow_output(zwr_output, &one);
/* Now for (new) variable name */
zshow_output(zwr_output, lvzwrite_block->curr_name);
*one.addr = '=';
zshow_output(zwr_output, &one);
/* .. and the var name aliasing to (the first seen with this lv_val) */
assert(zav->zwr_var.len);
zwr_output->flush = TRUE;
zshow_output(zwr_output, &zav->zwr_var);
return;
}
/* Else the value for this entry has not yet been printed so let us fall into case 3
* and get that done. Also set the flag so we mark it as an alias. Note this can happen if
* a container value for a name is encountered before the base var it points to. We will
* properly resolve the entry but its value won't have been printed until we actually encounter
* it in the tree.
*/
htent_added = TRUE; /* to force the ;# tag at end of value printing */
zav->value_printed = TRUE; /* value will be output shortly below */
} else
{ /* Entry was added so is first appearance -- give it a value to hold onto and print it */
newzav = als_getzavslot();
newzav->zwr_var = *lvzwrite_block->curr_name;
newzav->value_printed = TRUE; /* or rather it will be shortly.. */
tabent_addr->value = (void *)newzav;
lvzwrite_block->zav_added = TRUE;
/* Note fall into case 3 to print var and value if exists */
}
}
/* Case 3 - everything else */
if (!MV_DEFINED(val))
return;
MV_FORCE_STR(val);
lvzwr_out_targkey(&one);
*one.addr = '=';
zshow_output(zwr_output, &one);
mval_write(zwr_output, val, !htent_added);
if (htent_added)
{ /* output the ";#" tag to indicate this is an alias output */
zwr_output->flush = TRUE;
zshow_output(zwr_output, &semi_star);
}
} else
{ /* MERGE assignment from local variable */
nsubs = lvzwrite_block->curr_subsc;
if (MARG1_IS_GBL(merge_args))
{ /* Target is a global var : i.e. MERGE ^gvn1=lcl1.
* In this case, mglvnp->gblp[IND1]->gvkey_nsubs would have been initialized in op_merge.c already.
* Use that to check if the target node in ^gvn1 exceeds max # of subscripts.
*/
if (MAX_GVSUBSCRIPTS <= (mglvnp->gblp[IND1]->gvkey_nsubs + nsubs))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_MERGEINCOMPL, 0, ERR_MAXNRSUBSCRIPTS);
memcpy(gv_currkey->base, mglvnp->gblp[IND1]->s_gv_currkey->base, mglvnp->gblp[IND1]->s_gv_currkey->end + 1);
gv_currkey->end = mglvnp->gblp[IND1]->s_gv_currkey->end;
for (n = 0; n < nsubs; n++)
{
subscp = ((zwr_sub_lst *)lvzwrite_block->sub)->subsc_list[n].actual;
MV_FORCE_STR(subscp);
mval2subsc(subscp, gv_currkey, gv_cur_region->std_null_coll);
if (!subscp->str.len && (ALWAYS != gv_cur_region->null_subs))
sgnl_gvnulsubsc();
}
MV_FORCE_STR(val);
gvnh_reg = TREF(gd_targ_gvnh_reg); /* set by op_gvname/op_gvextnam/op_gvnaked done before op_merge */
/* If gvnh_reg corresponds to a spanning global, then determine
* gv_cur_region/gv_target/gd_targ_* variables based on updated gv_currkey.
*/
GV_BIND_SUBSNAME_FROM_GVNH_REG_IF_GVSPAN(gvnh_reg, (TREF(gd_targ_addr)), gv_currkey);
/* For spanning globals, "gv_cur_region" points to the target region for ^gvn1 only now.
* So do the GVSUBOFLOW check (both for spanning and non-spanning globals) now.
*/
if (gv_currkey->end >= gv_cur_region->max_key_size)
ISSUE_GVSUBOFLOW_ERROR(gv_currkey, KEY_COMPLETE_TRUE);
op_gvput(val);
} else
{ /* Target is a local var : pre-process target in case it is a container */
assert(MARG1_IS_LCL(merge_args));
dst_lv = mglvnp->lclp[IND1];
if (!LV_IS_BASE_VAR(dst_lv))
{
LV_SBS_DEPTH(dst_lv, FALSE, sbs_depth);
if (MAX_LVSUBSCRIPTS < (sbs_depth + nsubs))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(3) ERR_MERGEINCOMPL, 0, ERR_MAXNRSUBSCRIPTS);
}
param_list.arg[0] = dst_lv; /* this is already protected from stp_gcol by op_merge so no need to
* push this into the stack for stp_gcol protection. */
for (n = 0 ; n < nsubs; n++)
{ /* Note: no need to do push these mvals on the stack before calling op_putindx
* as lvzwrite_block->sub is already protected by stp_gcol_src.h.
*/
param_list.arg[n+1] = ((zwr_sub_lst *)lvzwrite_block->sub)->subsc_list[n].actual;
}
param_list.n = n + 1;
dst_lv = (lv_val *)callg((callgfnptr)op_putindx, ¶m_list);
MV_FORCE_STR(val);
assert(!(MV_ALIASCONT & dst_lv->v.mvtype)); /* op_putindx would have already done DECR_AC_REF for us */
dst_lv->v = *val;
dst_lv->v.mvtype &= ~MV_ALIASCONT; /* Make sure alias container property does not pass */
}
}
}
void zshow_svn(zshow_out *output)
{
mstr x;
mval var, zdir;
io_log_name *tl;
stack_frame *fp;
int count, save_dollar_zlevel;
char *c1, *c2;
char zdir_error[3 * GTM_MAX_DIR_LEN + 128]; /* PATH_MAX + "->" + GTM-W-ZDIROUTOFSYNC, <text of ZDIROUTOFSYNC> */
error_def(ERR_ZDIROUTOFSYNC);
/* SV_DEVICE */
get_dlr_device(&var);
ZS_VAR_EQU(&x, device_text);
mval_write(output, &var, TRUE);
/* SV_ECODE */
ecode_get(-1, &var);
ZS_VAR_EQU(&x, ecode_text);
mval_write(output, &var, TRUE);
/* SV_ESTACK */
save_dollar_zlevel = dollar_zlevel();
count = (save_dollar_zlevel - 1) - dollar_estack_delta.m[0];
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, estack_text);
mval_write(output, &var, TRUE);
/* SV_ETRAP */
var.mvtype = MV_STR;
var.str = dollar_etrap.str;
ZS_VAR_EQU(&x, etrap_text);
mval_write(output, &var, TRUE);
/* SV_HOROLOG */
op_horolog(&var);
ZS_VAR_EQU(&x, horolog_text);
mval_write(output, &var, TRUE);
/* SV_IO */
var.str.addr = io_curr_device.in->name->dollar_io;
var.str.len = io_curr_device.in->name->len;
/*** The following should be in the I/O code ***/
if (ESC == *var.str.addr)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
var.mvtype = MV_STR;
ZS_VAR_EQU(&x, io_text);
mval_write(output, &var, TRUE);
/* SV_JOB */
ZS_VAR_EQU(&x, job_text);
mval_write(output, &dollar_job, TRUE);
/* SV_KEY */
get_dlr_key(&var);
ZS_VAR_EQU(&x, key_text);
mval_write(output, &var, TRUE);
/* SV_PRINCIPAL */
if (dollar_principal)
tl = dollar_principal;
else
tl = io_root_log_name->iod->trans_name;
var.str.addr = tl->dollar_io;
var.str.len = tl->len;
/*** The following should be in the I/O code ***/
if (ESC == *var.str.addr)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
var.mvtype = MV_STR;
ZS_VAR_EQU(&x, principal_text);
mval_write(output, &var, TRUE);
/* SV_QUIT */
count = ((NULL == get_ret_targ()) ? 0 : 1);
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, quit_text);
mval_write(output, &var, TRUE);
/* SV_REFERENCE */
get_reference(&var);
ZS_VAR_EQU(&x, reference_text);
mval_write(output, &var, TRUE);
/* SV_STACK */
count = (save_dollar_zlevel - 1);
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, stack_text);
mval_write(output, &var, TRUE);
/* SV_STORAGE */
i2mval(&var, getstorage());
ZS_VAR_EQU(&x, storage_text);
mval_write(output, &var, TRUE);
/* SV_SYSTEM */
var.mvtype = MV_STR;
var.str = dollar_system.str;
ZS_VAR_EQU(&x, system_text);
mval_write(output, &var, TRUE);
/* SV_TEST */
i2mval(&var, (int)op_dt_get());
ZS_VAR_EQU(&x, test_text);
mval_write(output, &var, TRUE);
/* SV_TLEVEL */
count = (int)dollar_tlevel;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, tlevel_text);
mval_write(output, &var, TRUE);
/* SV_TRESTART */
MV_FORCE_MVAL(&var, (int)((MAX_VISIBLE_TRESTART < dollar_trestart) ? MAX_VISIBLE_TRESTART : dollar_trestart));
ZS_VAR_EQU(&x, trestart_text);
mval_write(output, &var, TRUE);
/* SV_X */
count = (int)io_curr_device.out->dollar.x;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, x_text);
mval_write(output, &var, TRUE);
/* SV_Y */
count = (int)io_curr_device.out->dollar.y;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, y_text);
mval_write(output, &var, TRUE);
/* SV_ZA */
count = (int)io_curr_device.in->dollar.za;
MV_FORCE_MVAL(&var, count);
ZS_VAR_EQU(&x, za_text);
mval_write(output, &var, TRUE);
/* SV_ZB */
c1 = (char *)io_curr_device.in->dollar.zb;
c2 = c1 + sizeof(io_curr_device.in->dollar.zb);
var.mvtype = MV_STR;
var.str.addr = (char *)io_curr_device.in->dollar.zb;
while (c1 < c2 && *c1)
c1++;
var.str.len = (char *)c1 - var.str.addr;
ZS_VAR_EQU(&x, zb_text);
mval_write(output, &var, TRUE);
/* SV_ZCMDLINE */
get_command_line(&var, TRUE); /* TRUE to indicate we want $ZCMDLINE (i.e. processed not actual command line) */
ZS_VAR_EQU(&x, zcmdline_text);
mval_write(output, &var, TRUE);
/* SV_ZCOMPILE */
var.mvtype = MV_STR;
var.str = dollar_zcompile;
ZS_VAR_EQU(&x, zcompile_text);
mval_write(output, &var, TRUE);
/* SV_ZCSTATUS */
MV_FORCE_MVAL(&var, dollar_zcstatus);
ZS_VAR_EQU(&x, zcstatus_text);
mval_write(output, &var, TRUE);
/* SV_ZDATEFORM */
MV_FORCE_MVAL(&var, zdate_form);
ZS_VAR_EQU(&x, zdate_form_text);
mval_write(output, &var, TRUE);
/* SV_ZDIR */
ZS_VAR_EQU(&x, zdirectory_text);
setzdir(NULL, &zdir);
if (zdir.str.len != dollar_zdir.str.len || 0 != memcmp(zdir.str.addr, dollar_zdir.str.addr, zdir.str.len))
{
memcpy(zdir_error, zdir.str.addr, zdir.str.len);
memcpy(&zdir_error[zdir.str.len], arrow_text, STR_LIT_LEN(arrow_text));
sgtm_putmsg(&zdir_error[zdir.str.len + STR_LIT_LEN(arrow_text)], VARLSTCNT(6) ERR_ZDIROUTOFSYNC, 4,
zdir.str.len, zdir.str.addr, dollar_zdir.str.len, dollar_zdir.str.addr);
zdir.str.addr = zdir_error;
zdir.str.len = strlen(zdir_error) - 1; /* eliminate trailing '\n' */
}
SKIP_DEVICE_IF_NOT_NEEDED(&zdir);
mval_write(output, &zdir, TRUE);
/* SV_ZEDITOR */
MV_FORCE_MVAL(&var, dollar_zeditor);
ZS_VAR_EQU(&x, zeditor_text);
mval_write(output, &var, TRUE);
/* SV_ZEOF */
ZS_VAR_EQU(&x, zeof_text);
mval_write(output, io_curr_device.in->dollar.zeof ? (mval *)&literal_one : (mval *)&literal_zero, TRUE);
/* SV_ZERROR */
var.mvtype = MV_STR;
var.str = dollar_zerror.str;
ZS_VAR_EQU(&x, zerror_text);
mval_write(output, &var, TRUE);
/* SV_ZGBLDIR */
ZS_VAR_EQU(&x, zgbldir_text);
mval_write(output, &dollar_zgbldir, TRUE);
/* SV_ZININTERRUPT */
MV_FORCE_MVAL(&var, dollar_zininterrupt);
ZS_VAR_EQU(&x, zininterrupt_text);
mval_write(output, &var, TRUE);
/* SV_ZINTERRUPT */
var.mvtype = MV_STR;
var.str = dollar_zinterrupt.str;
ZS_VAR_EQU(&x, zinterrupt_text);
mval_write(output, &var, TRUE);
/* SV_ZIO */
var.mvtype = MV_STR;
/* NOTE: This is **NOT** equivalent to :
* io_curr_log_name->dollar_io
*/
var.str.addr = io_curr_device.in->trans_name->dollar_io;
var.str.len = io_curr_device.in->trans_name->len;
if (*var.str.addr == ESC)
{
if (5 > var.str.len)
var.str.len = 0;
else
{
var.str.addr += ESC_OFFSET;
var.str.len -= ESC_OFFSET;
}
}
ZS_VAR_EQU(&x, zio_text);
mval_write(output, &var, TRUE);
/* SV_ZJOB */
MV_FORCE_ULONG_MVAL(&var, dollar_zjob);
ZS_VAR_EQU(&x, zjob_text);
mval_write(output, &var, TRUE);
/* SV_ZLEVEL */
MV_FORCE_MVAL(&var, save_dollar_zlevel);
ZS_VAR_EQU(&x, zlevel_text);
mval_write(output, &var, TRUE);
/* SV_ZMAXTPTIME */
MV_FORCE_MVAL(&var, dollar_zmaxtptime);
ZS_VAR_EQU(&x, zmaxtptime_text);
mval_write(output, &var, TRUE);
/* SV_ZMODE */
ZS_VAR_EQU(&x, zmode_text);
mval_write(output, &dollar_zmode, TRUE);
/* SV_ZPOS */
getzposition(&var);
ZS_VAR_EQU(&x, zpos_text);
mval_write(output, &var, TRUE);
/* SV_ZPROC */
ZS_VAR_EQU(&x, zproc_text);
mval_write(output, &dollar_zproc, TRUE);
/* SV_PROMPT */
var.mvtype = MV_STR;
var.str.addr = gtmprompt.addr;
var.str.len = gtmprompt.len;
ZS_VAR_EQU(&x, zprompt_text);
mval_write(output, &var, TRUE);
/* SV_ZROUTINES */
if (!zro_root)
zro_init();
var.mvtype = MV_STR;
var.str = dollar_zroutines;
ZS_VAR_EQU(&x, zroutines_text);
mval_write(output, &var, TRUE);
/* SV_ZSOURCE */
var.mvtype = MV_STR;
var.str = dollar_zsource;
ZS_VAR_EQU(&x, zsource_text);
mval_write(output, &var, TRUE);
/* SV_ZSTATUS */
ZS_VAR_EQU(&x, zstatus_text);
mval_write(output, &dollar_zstatus, TRUE);
/* SV_ZSTEP */
ZS_VAR_EQU(&x, zstep_text);
mval_write(output, &dollar_zstep, TRUE);
/* SV_ZSYSTEM */
MV_FORCE_MVAL(&var, dollar_zsystem);
ZS_VAR_EQU(&x, zsystem_text);
mval_write(output, &var, TRUE);
/* SV_ZTEXIT */
var.mvtype = MV_STR;
var.str = dollar_ztexit.str;
ZS_VAR_EQU(&x, ztexit_text);
mval_write(output, &var, TRUE);
/* SV_ZTRAP */
var.mvtype = MV_STR;
var.str = dollar_ztrap.str;
ZS_VAR_EQU(&x, ztrap_text);
mval_write(output, &var, TRUE);
/* SV_ZVERSION */
var.mvtype = MV_STR;
var.str.addr = (char *)>m_release_name[0];
var.str.len = gtm_release_name_len;
ZS_VAR_EQU(&x, zversion_text);
mval_write(output, &var, TRUE);
/* SV_ZYERROR */
var.mvtype = MV_STR;
var.str = dollar_zyerror.str;
ZS_VAR_EQU(&x, zyerror_text);
mval_write(output, &var, TRUE);
}
void zshow_devices(zshow_out *output)
{
io_log_name *l; /* logical name pointer */
mval v;
mval m;
d_rm_struct *rm_ptr;
d_tt_struct *tt_ptr;
d_socket_struct *dsocketptr;
socket_struct *socketptr;
io_termmask *mask_out;
int4 i, j, ii, jj;
boolean_t first;
unsigned char delim_buff_sm[MAX_DELIM_LEN];
unsigned short delim_len_sm;
char delim_mstr_buff[(MAX_DELIM_LEN * MAX_ZWR_EXP_RATIO) + 11];
mstr delim;
int delim_len, tmpport;
static readonly char space8_text[] = " ";
static readonly char filchar_text[] = "CHARACTERS";
static readonly char filesc_text[] = "ESCAPES";
static readonly char terminal_text[] = "TERMINAL ";
static readonly char magtape_text[] = "MAGTAPE ";
static readonly char rmsfile_text[] = "RMS ";
static readonly char fifo_text[] = "FIFO ";
static readonly char pipe_text[] = "PIPE ";
static readonly char mailbox_text[] = "MAILBOX ";
static readonly char dollarc_text[] = "$C(";
static readonly char equal_text[] = {'='};
static readonly char comma_text[] = {','};
static readonly char quote_text[] = {'"'};
static readonly char lparen_text[] = {'('};
static readonly char rparen_text[] = {')'};
static readonly char lb_text[] = {'['};
static readonly char rb_text[] = {']'};
static readonly char devop[] = "OPEN ";
static readonly char devcl[] = "CLOSED ";
static readonly char interrupt_text[] = "ZINTERRUPT ";
/* gtmsocket specific */
static readonly char at_text[] = {'@'};
static readonly char delimiter_text[] = "DELIMITER ";
static readonly char nodelimiter_text[] = "NODELIMITER ";
static readonly char local_text[] = "LOCAL=";
static readonly char remote_text[] = "REMOTE=";
static readonly char total_text[] = "TOTAL=";
static readonly char current_text[] = "CURRENT=";
static readonly char passive_text[] = "PASSIVE ";
static readonly char active_text[] = "ACTIVE ";
static readonly char socket_text[] = "SOCKET";
static readonly char descriptor_text[] = "DESC=";
static readonly char trap_text[] = "TRAP ";
static readonly char notrap_text[] = "NOTRAP ";
static readonly char zdelay_text[] = "ZDELAY ";
static readonly char znodelay_text[] = "ZNODELAY ";
static readonly char zbfsize_text[] = "ZBFSIZE=";
static readonly char zibfsize_text[] = "ZIBFSIZE=";
static readonly char port_text[] = "PORT=";
static readonly char ichset_text[] = "ICHSET=";
static readonly char ochset_text[] = "OCHSET=";
#ifdef __MVS__
static readonly char filetag_text[] = "FILETAG=";
static readonly char untagged_text[] = "UNTAGGED";
static readonly char ebcdic_text[] = "EBCDIC";
static readonly char binary_text[] = "BINARY";
static readonly char processchset_text[] = "CHSET=";
static readonly char text_text[] = " TEXT";
char csname[_CSNAME_LEN_MAX + 1], *csptr;
#endif
static readonly char zsh_socket_state[][10] =
{ "CONNECTED"
,"LISTENING"
,"BOUND"
,"CREATED"
};
static readonly char morereadtime_text[] = "MOREREADTIME=";
v.mvtype = MV_STR;
for (l = io_root_log_name; l != 0; l = l->next)
{
if (l->iod->trans_name == l)
{
/* if it is an rm type we don't want to output the device if it is the stderr
device for a pipe device */
if ((rm_ptr = (d_rm_struct*)l->iod->dev_sp) && rm == l->iod->type && rm_ptr->pipe && rm_ptr->stderr_parent)
continue;
v.str.addr = &l->dollar_io[0];
v.str.len = l->len;
zshow_output(output,&v.str);
ZS_ONE_OUT(&v, space_text);
if (l->iod->state == dev_open)
{
ZS_STR_OUT(&v, devop);
switch(l->iod->type)
{
case tt:
ZS_STR_OUT(&v, terminal_text);
tt_ptr = (d_tt_struct*)l->iod->dev_sp;
if (!ctrlc_on && io_std_device->out == l->iod) /* and standard input */
{ ZS_PARM_SP(&v, zshow_nocene);
}
if (tt_ptr->enbld_outofbands.mask)
{ ZS_PARM_EQU(&v, zshow_ctra);
ZS_STR_OUT(&v,dollarc_text);
first = TRUE;
for ( i = 1, j = 0; j < 32 ; j++,i = i * 2)
{ if (i & tt_ptr->enbld_outofbands.mask)
{ if (!first)
{ ZS_ONE_OUT(&v, comma_text);
}else
{ first = FALSE;
}
MV_FORCE_MVAL(&m,j);
mval_write(output,&m,FALSE);
}
}
ZS_ONE_OUT(&v, rparen_text);
ZS_ONE_OUT(&v, space_text);
}
if ((int4)(tt_ptr->term_ctrl) & TRM_NOECHO)
{
ZS_PARM_SP(&v, zshow_noecho);
}
if (tt_ptr->term_ctrl & TRM_PASTHRU)
{
ZS_PARM_SP(&v, zshow_past);
} else
{
ZS_PARM_SP(&v, zshow_nopast);
}
if (!(tt_ptr->term_ctrl & TRM_ESCAPE))
{
ZS_PARM_SP(&v, zshow_noesca);
}
if (tt_ptr->term_ctrl & TRM_READSYNC)
{
ZS_PARM_SP(&v, zshow_reads);
} else
{
ZS_PARM_SP(&v, zshow_noreads);
}
if (tt_ptr->term_ctrl & TRM_NOTYPEAHD)
{
ZS_PARM_SP(&v, zshow_notype);
} else
{
ZS_PARM_SP(&v, zshow_type);
}
if (!l->iod->wrap)
{
ZS_PARM_SP(&v, zshow_nowrap);
}
mask_out = &tt_ptr->mask_term;
if (!tt_ptr->default_mask_term)
{
ZS_PARM_EQU(&v, zshow_term);
ZS_STR_OUT(&v,dollarc_text);
first = TRUE;
for ( i = 0; i < 8 ;i++)
{
for ( j = 0; j < 32; j++)
if (mask_out->mask[i] & (1 << j))
{
if (!first)
{
ZS_ONE_OUT(&v, comma_text);
} else
first = FALSE;
MV_FORCE_MVAL(&m,i * 32 + j);
mval_write(output,&m,FALSE);
}
}
ZS_ONE_OUT(&v, rparen_text);
ZS_ONE_OUT(&v, space_text);
}
ZS_PARM_EQU(&v, zshow_width);
MV_FORCE_MVAL(&m,(int)l->iod->width);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
ZS_PARM_EQU(&v, zshow_leng);
MV_FORCE_MVAL(&m,(int)l->iod->pair.out->length);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
if (l->iod->write_filter)
{
bool twoparms = FALSE;
ZS_PARM_EQU(&v, zshow_fil);
if (l->iod->write_filter & CHAR_FILTER)
{
if (l->iod->write_filter & ESC1)
{
twoparms = TRUE;
ZS_ONE_OUT(&v,lparen_text);
}
ZS_STR_OUT(&v,filchar_text);
if (twoparms)
{
ZS_ONE_OUT(&v, comma_text);
ZS_ONE_OUT(&v, space_text);
}
}
if (l->iod->write_filter & ESC1)
ZS_STR_OUT(&v,filesc_text);
if (twoparms)
ZS_ONE_OUT(&v,rparen_text);
ZS_ONE_OUT(&v, space_text);
}
if (TT_EDITING & tt_ptr->ext_cap)
ZS_PARM_SP(&v, zshow_edit);
if (TT_NOINSERT & tt_ptr->ext_cap)
ZS_PARM_SP(&v, zshow_noinse);
if (TT_EMPTERM & tt_ptr->ext_cap)
ZS_PARM_SP(&v, zshow_empterm);
if (tt_ptr->canonical)
ZS_STR_OUT(&v, "CANONICAL ");
switch(l->iod->ichset)
{
case CHSET_M:
if (gtm_utf8_mode)
{
ZS_STR_OUT(&v, ichset_text);
zshow_output(output, &chset_names[l->iod->ichset]);
ZS_ONE_OUT(&v, space_text);
}
break;
case CHSET_UTF8:
assert(gtm_utf8_mode);
break;
default:
GTMASSERT;
}
switch(l->iod->ochset)
{
case CHSET_M:
if (gtm_utf8_mode)
{
ZS_STR_OUT(&v, ochset_text);
zshow_output(output, &chset_names[l->iod->ochset]);
ZS_ONE_OUT(&v, space_text);
}
break;
case CHSET_UTF8:
assert(gtm_utf8_mode);
break;
default:
GTMASSERT;
}
if (tt_ptr->mupintr)
ZS_STR_OUT(&v, interrupt_text);
break;
case rm:
/* we go to rm_ptr above for the rm type */
if (rm_ptr->fifo)
ZS_STR_OUT(&v,fifo_text);
else if (!rm_ptr->pipe)
{
ZS_STR_OUT(&v,rmsfile_text);
if (rm_ptr->follow)
{
ZS_PARM_SP(&v, zshow_follow);
}
}
else
{
ZS_STR_OUT(&v,pipe_text);
if (rm_ptr->dev_param_pairs.num_pairs)
{
int ignore_stderr = FALSE;
/* if one of the dev_param_pairs[i]->name is the
STDERR then we don't want to output it if the
device is closed. We'll check them all even though
it is currently the last one - just to be safe. */
if (rm_ptr->stderr_child && (dev_open !=
rm_ptr->stderr_child->state))
ignore_stderr = TRUE;
for ( i = 0; i < rm_ptr->dev_param_pairs.num_pairs; i++ )
{
if (TRUE == ignore_stderr &&
0 == STRCMP(rm_ptr->dev_param_pairs.pairs[i].name,
"STDERR="))
continue;
ZS_VAR_STR_OUT(
&v,rm_ptr->dev_param_pairs.pairs[i].name);
ZS_VAR_STR_OUT(
&v,rm_ptr->dev_param_pairs.pairs[i].definition);
ZS_ONE_OUT(&v, space_text);
}
}
if (rm_ptr->independent)
{
ZS_PARM_SP(&v, zshow_independent);
}
if (rm_ptr->parse)
{
ZS_PARM_SP(&v, zshow_parse);
}
}
if (rm_ptr->fixed)
{
ZS_PARM_SP(&v, zshow_fixed);
}
if (rm_ptr->noread)
{
ZS_PARM_SP(&v, zshow_read);
}
if (gtm_utf8_mode && (IS_UTF_CHSET(l->iod->ichset) || IS_UTF_CHSET(l->iod->ochset)))
{
if (!rm_ptr->def_recsize)
{
ZS_PARM_EQU(&v, zshow_rec);
MV_FORCE_MVAL(&m, (int)rm_ptr->recordsize);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
if (!rm_ptr->def_width)
{
ZS_PARM_EQU(&v, zshow_width);
MV_FORCE_MVAL(&m, (int)l->iod->width);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
}
else if (l->iod->width != DEF_RM_WIDTH)
{
ZS_PARM_EQU(&v, zshow_rec);
MV_FORCE_MVAL(&m,(int)l->iod->width);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
}
if (!l->iod->wrap)
{
ZS_PARM_SP(&v, zshow_nowrap);
}
switch(l->iod->ichset)
{
case CHSET_M:
if (gtm_utf8_mode)
{
ZS_STR_OUT(&v, ichset_text);
zshow_output(output, &chset_names[l->iod->ichset]);
ZS_ONE_OUT(&v, space_text);
}
break;
case CHSET_UTF8:
assert(gtm_utf8_mode);
break;
case CHSET_UTF16:
case CHSET_UTF16BE:
case CHSET_UTF16LE:
assert(gtm_utf8_mode);
ZS_STR_OUT(&v, ichset_text);
zshow_output(output, &chset_names[l->iod->ichset]);
ZS_ONE_OUT(&v, space_text);
break;
default:
GTMASSERT;
}
switch(l->iod->ochset)
{
case CHSET_M:
if (gtm_utf8_mode)
{
ZS_STR_OUT(&v, ochset_text);
zshow_output(output, &chset_names[l->iod->ochset]);
ZS_ONE_OUT(&v, space_text);
}
break;
case CHSET_UTF8:
assert(gtm_utf8_mode);
break;
case CHSET_UTF16:
case CHSET_UTF16BE:
case CHSET_UTF16LE:
assert(gtm_utf8_mode);
ZS_STR_OUT(&v, ochset_text);
zshow_output(output, &chset_names[l->iod->ochset]);
ZS_ONE_OUT(&v, space_text);
break;
default:
GTMASSERT;
}
#ifdef __MVS__
if (TAG_ASCII != l->iod->file_tag)
{
ZS_STR_OUT(&v, filetag_text);
switch ((unsigned int)l->iod->file_tag)
{
case TAG_UNTAGGED:
ZS_STR_OUT(&v, untagged_text);
break;
case TAG_EBCDIC:
ZS_STR_OUT(&v, ebcdic_text);
break;
case TAG_BINARY:
ZS_STR_OUT(&v, binary_text);
break;
default:
if (-1 == __toCSName((__ccsid_t)l->iod->file_tag, csname))
{ /* no name so output number */
csptr = (char *)i2asc((uchar_ptr_t)csname,
(unsigned int)l->iod->file_tag);
*csptr = '\0'; /* terminate */
}
ZS_VAR_STR_OUT(&v, csname);
}
if (l->iod->text_flag)
ZS_STR_OUT(&v, text_text);
ZS_ONE_OUT(&v, space_text);
}
if (l->iod->file_chset != l->iod->process_chset &&
(!(0 == l->iod->file_chset && CHSET_ASCII == l->iod->process_chset) &&
!(CHSET_ASCII == l->iod->file_chset && CHSET_M == l->iod->process_chset)))
{ /* suppress default cases */
ZS_STR_OUT(&v, processchset_text);
zshow_output(output, &chset_names[l->iod->process_chset]);
ZS_ONE_OUT(&v, space_text);
}
#endif
break;
case gtmsocket:
delim.addr = delim_mstr_buff;
delim_len = 0;
ZS_STR_OUT(&v, socket_text);
dsocketptr = (d_socket_struct *)l->iod->dev_sp;
ZS_ONE_OUT(&v, space_text);
ZS_STR_OUT(&v, total_text);
MV_FORCE_MVAL(&m, (int)dsocketptr->n_socket);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
ZS_STR_OUT(&v, current_text);
MV_FORCE_MVAL(&m, (int)dsocketptr->current_socket);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
if (dsocketptr->mupintr)
ZS_STR_OUT(&v, interrupt_text);
output->flush = TRUE;
zshow_output(output, 0);
for(ii = 0; ii < dsocketptr->n_socket; ii++)
{
/* output each socket */
socketptr = dsocketptr->socket[ii];
ZS_STR_OUT(&v, space8_text);
/* socket handle */
ZS_STR_OUT(&v, socket_text);
ZS_ONE_OUT(&v, lb_text);
MV_FORCE_MVAL(&m, ii);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, rb_text);
ZS_ONE_OUT(&v, equal_text);
v.str.addr = socketptr->handle;
v.str.len = socketptr->handle_len;
zshow_output(output, &v.str);
ZS_ONE_OUT(&v, space_text);
/* socket descriptor */
ZS_STR_OUT(&v, descriptor_text);
MV_FORCE_MVAL(&m, socketptr->sd);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
/* socket state */
ZS_STR_OUT(&v, zsh_socket_state[socketptr->state]);
ZS_ONE_OUT(&v, space_text);
/* socket IO mode */ switch(l->iod->ichset)
{
case CHSET_M:
if (gtm_utf8_mode)
{
ZS_STR_OUT(&v, ichset_text);
zshow_output(output, &chset_names[l->iod->ichset]);
ZS_ONE_OUT(&v, space_text);
}
break;
case CHSET_UTF8:
assert(gtm_utf8_mode);
break;
case CHSET_UTF16:
case CHSET_UTF16BE:
case CHSET_UTF16LE:
assert(gtm_utf8_mode);
ZS_STR_OUT(&v, ichset_text);
zshow_output(output, &chset_names[l->iod->ichset]);
ZS_ONE_OUT(&v, space_text);
break;
default:
GTMASSERT;
}
switch(l->iod->ochset)
{
case CHSET_M:
if (gtm_utf8_mode)
{
ZS_STR_OUT(&v, ochset_text);
zshow_output(output, &chset_names[l->iod->ochset]);
ZS_ONE_OUT(&v, space_text);
}
break;
case CHSET_UTF8:
assert(gtm_utf8_mode);
break;
case CHSET_UTF16:
case CHSET_UTF16BE:
case CHSET_UTF16LE:
assert(gtm_utf8_mode);
ZS_STR_OUT(&v, ochset_text);
zshow_output(output, &chset_names[l->iod->ochset]);
ZS_ONE_OUT(&v, space_text);
break;
default:
GTMASSERT;
}
/* socket type */
if (socketptr->passive)
{
ZS_STR_OUT(&v, passive_text);
} else
{
ZS_STR_OUT(&v, active_text);
}
ZS_ONE_OUT(&v, space_text);
/* error trapping */
if (socketptr->ioerror)
{
ZS_STR_OUT(&v, trap_text);
} else
{
ZS_STR_OUT(&v, notrap_text);
}
ZS_ONE_OUT(&v, space_text);
/* address + port */
if (socketptr->passive)
{
ZS_STR_OUT(&v, port_text);
tmpport = (int)socketptr->local.port;
MV_FORCE_MVAL(&m, tmpport);
mval_write(output, &m, FALSE);
} else
{
ZS_STR_OUT(&v, remote_text);
if (NULL != socketptr->remote.saddr_ip)
{
v.str.addr = socketptr->remote.saddr_ip;
v.str.len = STRLEN(socketptr->remote.saddr_ip);
} else
{
v.str.addr = "";
v.str.len = 0;
}
zshow_output(output, &v.str);
ZS_ONE_OUT(&v, at_text);
tmpport = (int)socketptr->remote.port;
MV_FORCE_MVAL(&m, tmpport);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
if (NULL != socketptr->local.saddr_ip)
{
ZS_STR_OUT(&v, local_text);
v.str.addr = socketptr->local.saddr_ip;
v.str.len = STRLEN(socketptr->local.saddr_ip);
zshow_output(output, &v.str);
ZS_ONE_OUT(&v, at_text);
tmpport = (int)socketptr->local.port;
MV_FORCE_MVAL(&m, tmpport);
mval_write(output, &m, FALSE);
}
}
ZS_ONE_OUT(&v, space_text);
output->flush = TRUE;
zshow_output(output, 0);
ZS_STR_OUT(&v, space8_text);
ZS_STR_OUT(&v, space8_text);
/* zdelay */
if (socketptr->nodelay)
{
ZS_STR_OUT(&v, znodelay_text);
} else
{
ZS_STR_OUT(&v, zdelay_text);
}
ZS_ONE_OUT(&v, space_text);
/* zbfsize */
ZS_STR_OUT(&v, zbfsize_text);
MV_FORCE_MVAL(&m, (int4)(socketptr->buffer_size));
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
/* izbfsize */
ZS_STR_OUT(&v, zibfsize_text);
MV_FORCE_MVAL(&m, socketptr->bufsiz);
mval_write(output, &m, FALSE);
ZS_ONE_OUT(&v, space_text);
/* delimiters */
if (socketptr->n_delimiter > 0)
{
output->flush = TRUE;
zshow_output(output, 0);
ZS_STR_OUT(&v, space8_text);
ZS_STR_OUT(&v, space8_text);
ZS_STR_OUT(&v, delimiter_text);
for (jj = 0; jj < socketptr->n_delimiter; jj++)
{
delim_len_sm = socketptr->delimiter[jj].len;
memcpy(delim_buff_sm,
socketptr->delimiter[jj].addr, delim_len_sm);
format2zwr(delim_buff_sm, delim_len_sm,
(uchar_ptr_t)delim.addr, &delim_len);
delim.len = (unsigned short)delim_len;
assert(SIZEOF(delim_mstr_buff) >= delim_len);
zshow_output(output, &delim);
ZS_ONE_OUT(&v, space_text);
}
} else
{
ZS_STR_OUT(&v, nodelimiter_text);
}
/* readmoretime */
if (DEFAULT_MOREREAD_TIMEOUT != socketptr->moreread_timeout)
{
ZS_STR_OUT(&v, morereadtime_text);
MV_FORCE_MVAL(&m, (int)socketptr->moreread_timeout);
mval_write(output, &m, FALSE);
}
output->flush = TRUE;
zshow_output(output, 0);
}
default:
v.str.len = 0;
break;
}
if (l->iod->error_handler.len)
{
ZS_PARM_EQU(&v, zshow_exce);
ZS_ONE_OUT(&v, quote_text);
v.str = l->iod->error_handler;
zshow_output(output, &v.str);
output->flush = TRUE;
ZS_ONE_OUT(&v, quote_text);
} else
{ output->flush = TRUE;
zshow_output(output, 0);
}
} else
{ output->flush = TRUE;
ZS_STR_OUT(&v, devcl);
}
}
}
}
