bool gtcmtr_data(void)
{
cm_region_list *reg_ref;
unsigned char *ptr,regnum;
unsigned short top,len;
mval v;
int x;
ptr = curr_entry->clb_ptr->mbf;
assert(*ptr == CMMS_Q_DATA);
ptr++;
GET_USHORT(len, ptr);
ptr += sizeof(unsigned short);
regnum = *ptr++;
reg_ref = gtcm_find_region(curr_entry, regnum);
len--; /* subtract size of regnum */
CM_GET_GVCURRKEY(ptr, len);
gtcm_bind_name(reg_ref->reghead, TRUE);
x = 0;
if (gv_target->root)
x = gvcst_data();
v = *fndata_table[x / 10][x & 1];
ptr = curr_entry->clb_ptr->mbf;
*ptr++ = CMMS_R_DATA;
len = sizeof(unsigned char);
PUT_USHORT(ptr, len);
ptr += sizeof(unsigned short);
*ptr++ = MV_FORCE_INTD(&v);
curr_entry->clb_ptr->cbl = ptr - curr_entry->clb_ptr->mbf;
return TRUE;
}
void iosocket_iocontrol(mstr *mn, int4 argcnt, va_list args)
{
char action[MAX_DEVCTL_LENGTH];
unsigned short depth;
int length, n, timeout;
pid_t pid;
mval *arg, *handlesvar = NULL;
#ifdef GTM_TLS
mval *option, *tlsid, *password, *extraarg;
#endif
if (0 == mn->len)
return;
assert(MAX_DEVCTL_LENGTH > mn->len);
lower_to_upper((uchar_ptr_t)action, (uchar_ptr_t)mn->addr, mn->len);
length = mn->len;
if (0 == memcmp(action, "LISTEN", length))
{
if (1 > argcnt)
depth = DEFAULT_LISTEN_DEPTH;
else
{
arg = va_arg(args, mval *);
if ((NULL == arg) || M_ARG_SKIPPED(arg) || !MV_DEFINED(arg))
{
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_EXPR);
return;
}
depth = MV_FORCE_INTD(arg);
}
iosocket_listen(io_curr_device.in, depth);
} else if (0 == memcmp(action, "WAIT", length))
mint gvcmx_data(void)
{
mval v;
mint ret;
gvcmz_doop(CMMS_Q_DATA, CMMS_R_DATA, &v);
ret = MV_FORCE_INTD(&v);
return ret;
}
bool gvcmx_zprevious(void)
{
mval v;
gvcmz_doop(CMMS_Q_PREV, CMMS_R_PREV, &v);
if (MV_FORCE_INTD(&v))
return TRUE;
else
return FALSE;
}
int one_job_param (char **parptr)
{
boolean_t neg;
int x, num;
int len;
error_def (ERR_JOBPARUNK);
error_def (ERR_JOBPARNOVAL);
error_def (ERR_JOBPARVALREQ);
error_def (ERR_JOBPARNUM);
error_def (ERR_JOBPARSTR);
if ((window_token != TK_IDENT) ||
((x = namelook (job_param_index, job_param_names, window_ident.addr, window_ident.len)) < 0))
{
stx_error (ERR_JOBPARUNK);
return FALSE;
}
advancewindow ();
*(*parptr)++ = job_param_data[x];
if (job_param_datatypes[job_param_data[x]] != jpdt_nul)
{
if (window_token != TK_EQUAL)
{
stx_error (ERR_JOBPARVALREQ);
return FALSE;
}
advancewindow ();
switch (job_param_datatypes[job_param_data[x]])
{
case jpdt_num:
neg = FALSE;
if (window_token == TK_MINUS && director_token == TK_INTLIT)
{
advancewindow();
neg = TRUE;
}
if (window_token != TK_INTLIT)
{
stx_error (ERR_JOBPARNUM);
return FALSE;
}
num = MV_FORCE_INTD(&window_mval);
*((int4 *) (*parptr)) = (neg ? -num : num);
*parptr += SIZEOF(int4);
break;
case jpdt_str:
if (window_token != TK_STRLIT)
{
stx_error (ERR_JOBPARSTR);
return FALSE;
}
len = window_mval.str.len;
*(*parptr)++ = len;
memcpy (*parptr, window_mval.str.addr, len);
*parptr += len;
break;
default:
GTMASSERT;
}
advancewindow ();
} else if (window_token == TK_EQUAL)
{
stx_error (ERR_JOBPARNOVAL);
return FALSE;
}
return TRUE;
}
void gvzwr_fini(zshow_out *out, int pat)
{
char m[SIZEOF(mident_fixed)];
mval local, data;
gv_key *old;
gvnh_reg_t *gvnh_reg;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
if (!gv_currkey)
gvinit();
ESTABLISH(gvzwrite_ch);
zwr_output = out;
assert(INVALID_GV_TARGET == reset_gv_target);
reset_gv_target = gv_target;
DBG_CHECK_GVTARGET_GVCURRKEY_IN_SYNC(CHECK_CSA_TRUE);
gvzwrite_block->gd_reg = gv_cur_region;
gvzwrite_block->old_targ = (unsigned char *)gv_target;
old = (gv_key *)malloc(SIZEOF(gv_key) + gv_currkey->end);
gvzwrite_block->old_key = (unsigned char *)old;
memcpy(gvzwrite_block->old_key, gv_currkey, SIZEOF(gv_key) + gv_currkey->end);
gvzwrite_block->gv_last_subsc_null = TREF(gv_last_subsc_null);
gvzwrite_block->gv_some_subsc_null = TREF(gv_some_subsc_null);
if (!pat)
{
local = *gvzwrite_block->pat;
if (local.str.len) /* New reference. Will get new gv_target.. */
{
gv_target = NULL;
gv_currkey->base[0] = '\0';
op_gvname(VARLSTCNT(1) &local);
op_gvdata(&data);
if (!(MV_FORCE_INTD(&data)))
{
if (!undef_inhibit)
sgnl_gvundef();
} else
{
gvzwrite_block->fixed = (gvzwrite_block->fixed ? TRUE : FALSE);
gvzwr_var(MV_FORCE_INTD(&data), 0);
}
} else /* Old (naked) reference. Keep previous gv_target reference */
{
if (gv_currkey->prev == 0)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(1) ERR_GVNAKED);
gv_currkey->end = gv_currkey->prev;
gv_currkey->base[gv_currkey->end] = 0;
gv_currkey->prev = 0;
/* If gvnh_reg corresponds to a spanning global, then determine
* gv_cur_region/gv_target/gd_targ_* variables based on updated gv_currkey.
*/
gvnh_reg = TREF(gd_targ_gvnh_reg); /* set by op_gvname in previous call */
GV_BIND_SUBSNAME_FROM_GVNH_REG_IF_GVSPAN(gvnh_reg, gd_header, gv_currkey);
op_gvdata(&data);
if (!(MV_FORCE_INTD(&data)))
{
if (!undef_inhibit)
sgnl_gvundef();
} else
{
gvzwrite_block->fixed = (gvzwrite_block->fixed ? TRUE : FALSE);
gvzwr_var((int4)MV_FORCE_INTD(&data), 0);
}
}
} else
{
gv_target = NULL;
gv_currkey->base[0] = '\0';
local.mvtype = MV_STR;
local.str.addr = &m[0];
local.str.len = 1;
m[0] = '%';
gvzwrite_block->fixed = FALSE;
for (; ;)
{
op_gvname(VARLSTCNT(1) &local);
if (do_pattern(&local, gvzwrite_block->pat))
{
op_gvdata(&data);
if ((MV_FORCE_INTD(&data)))
{
gvzwr_var((int4)MV_FORCE_INTD(&data), 0);
}
}
op_gvorder(&local);
if (local.str.len)
{
assert(local.str.len <= MAX_MIDENT_LEN + 1);
local.str.addr++;
local.str.len--;
memcpy(&m[0], local.str.addr, local.str.len);
local.str.addr = &m[0];
} else
break;
}
}
gvzwrite_clnup(); /* this routine is called by gvzwrite_ch() too */
REVERT;
return;
}
void op_fnzdate(mval *src, mval *fmt, mval *mo_str, mval *day_str, mval *dst)
{
unsigned char ch, *fmtptr, *fmttop, *i, *outptr, *outtop, *outpt1;
int cent, day, dow, month, nlen, outlen, time, year;
unsigned int n;
mval temp_mval;
static readonly unsigned char montab[] = {31,28,31,30,31,30,31,31,30,31,30,31};
static readonly unsigned char default1[] = DEFAULT1;
static readonly unsigned char default2[] = DEFAULT2;
static readonly unsigned char default3[] = DEFAULT3;
static readonly unsigned char defmonlst[] = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
static readonly unsigned char defdaylst[] = "SUNMONTUEWEDTHUFRISAT";
#if defined(BIGENDIAN)
static readonly int comma = (((int)',') << 24);
#else
static readonly int comma = ',';
#endif
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
MV_FORCE_NUM(src);
MV_FORCE_STR(fmt);
MV_FORCE_STR(mo_str);
MV_FORCE_STR(day_str);
ENSURE_STP_FREE_SPACE(ZDATE_MAX_LEN);
time = 0;
outlen = src->str.len;
if ((src->mvtype & MV_STR) && (src->mvtype & MV_NUM_APPROX))
{
for (outptr = (unsigned char *)src->str.addr, outtop = outptr + outlen; outptr < outtop; )
{
if (',' == *outptr++)
{
outlen = outptr - (unsigned char *)src->str.addr - 1;
temp_mval.mvtype = MV_STR;
temp_mval.str.addr = (char *)outptr;
temp_mval.str.len = INTCAST(outtop - outptr);
s2n(&temp_mval);
time = MV_FORCE_INTD(&temp_mval);
if ((0 > time) || (MAX_TIME < time))
rts_error(VARLSTCNT(4) ERR_ZDATEBADTIME, 2, temp_mval.str.len, temp_mval.str.addr);
break;
}
}
}
day = (int)MV_FORCE_INTD(src);
if ((MAX_DATE < day) || (MIN_DATE > day))
{
MV_FORCE_STR(src);
rts_error(VARLSTCNT(4) ERR_ZDATEBADDATE, 2, outlen, src->str.addr);
}
day += DAYS_MOST_YEARS;
dow = ((day + ADJUST_TO_1900) % DAYS_IN_WEEK) + 1;
for (cent = DAYS_BASE_TO_1900, n = ADJUST_TO_1900; cent < day; cent += DAYS_IN_CENTURY, n++)
day += (0 < (n % COMMON_LEAP_CYCLE));
year = day / DAYS_IN_FOUR_YEARS;
day = day - (year * DAYS_IN_FOUR_YEARS);
year = (year * COMMON_LEAP_CYCLE) + BASE_YEAR;
if (DAYS_BEFORE_LEAP == day)
{
day = MIN_DAYS_IN_MONTH + 1;
month = 2;
} else
{
if (DAYS_BEFORE_LEAP < day)
day--;
month = day / DAYS_MOST_YEARS;
year += month;
day -= (month * DAYS_MOST_YEARS);
for (i = montab; day >= *i; day -= *i++)
;
month = (int)((i - montab)) + 1;
day++;
assert((0 < month) && (MONTHS_IN_YEAR >= month));
}
if ((0 == fmt->str.len) || ((1 == fmt->str.len) && ('1' == *fmt->str.addr)))
{
if (!TREF(zdate_form) || ((1 == TREF(zdate_form)) && (PIVOT_MILLENIUM > year)))
{
fmtptr = default1;
fmttop = fmtptr + STR_LIT_LEN(DEFAULT1);
} else
{
fmtptr = default3;
fmttop = fmtptr + STR_LIT_LEN(DEFAULT3);
}
} else if ((1 == fmt->str.len) && ('2' == *fmt->str.addr))
{
fmtptr = default2;
fmttop = fmtptr + STR_LIT_LEN(DEFAULT2);
} else
{
fmtptr = (unsigned char *)fmt->str.addr;
fmttop = fmtptr + fmt->str.len;
}
outlen = (int)(fmttop - fmtptr);
if (outlen >= ZDATE_MAX_LEN)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
outptr = stringpool.free;
outtop = outptr + ZDATE_MAX_LEN;
temp_mval.mvtype = MV_STR;
assert(0 <= time);
nlen = 0;
while (fmtptr < fmttop)
{
switch (ch = *fmtptr++) /* NOTE assignment */
{
case '/':
case ':':
case '.':
case ',':
case '-':
case ' ':
case '*':
case '+':
case ';':
*outptr++ = ch;
continue;
case 'M':
ch = *fmtptr++;
if ('M' == ch)
{
n = month;
nlen = 2;
break;
}
if (('O' != ch) || ('N' != *fmtptr++))
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
if (0 == mo_str->str.len)
{
temp_mval.str.addr = (char *)&defmonlst[(month - 1) * LEN_OF_3_CHAR_ABBREV];
temp_mval.str.len = LEN_OF_3_CHAR_ABBREV;
nlen = -LEN_OF_3_CHAR_ABBREV;
} else
{
UNICODE_ONLY(gtm_utf8_mode ? op_fnp1(mo_str, comma, month, &temp_mval) :
op_fnzp1(mo_str, comma, month, &temp_mval));
VMS_ONLY(op_fnzp1(mo_str, comma, month, &temp_mval, TRUE));
nlen = -temp_mval.str.len;
outlen += - LEN_OF_3_CHAR_ABBREV - nlen;
if (outlen >= ZDATE_MAX_LEN)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
}
break;
case 'D':
ch = *fmtptr++;
if ('D' == ch)
{
n = day;
nlen = 2;
break;
}
if (('A' != ch) || ('Y' != *fmtptr++))
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
if (0 == day_str->str.len)
{
temp_mval.str.addr = (char *)&defdaylst[(dow - 1) * LEN_OF_3_CHAR_ABBREV];
temp_mval.str.len = LEN_OF_3_CHAR_ABBREV;
nlen = -LEN_OF_3_CHAR_ABBREV;
} else
{
UNICODE_ONLY(gtm_utf8_mode ? op_fnp1(day_str, comma, dow, &temp_mval)
: op_fnzp1(day_str, comma, dow, &temp_mval));
VMS_ONLY(op_fnzp1(day_str, comma, dow, &temp_mval, TRUE));
nlen = -temp_mval.str.len;
outlen += - LEN_OF_3_CHAR_ABBREV - nlen;
if (outlen >= ZDATE_MAX_LEN)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
}
break;
case 'Y':
ch = *fmtptr++;
n = year;
if ('Y' == ch)
{
for (nlen = 2; (MAX_YEAR_DIGITS >=nlen) && fmtptr < fmttop; ++nlen, fmtptr++)
if ('Y' != *fmtptr)
break;
} else
{
if (('E' != ch) || ('A' != *fmtptr++) || ('R' != *fmtptr++))
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 4;
}
break;
case '1':
if ('2' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 2;
n = time / SECONDS_PER_HOUR;
n = ((n + HOURS_PER_AM_OR_PM - 1) % HOURS_PER_AM_OR_PM) + 1;
break;
case '2':
if ('4' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 2;
n = time / SECONDS_PER_HOUR;
break;
case '6':
if ('0' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 2;
n = time;
n /= MINUTES_PER_HOUR;
n %= MINUTES_PER_HOUR;
break;
case 'S':
if ('S' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
nlen = 2;
n = time % SECONDS_PER_MINUTE;
break;
case 'A':
if ('M' != *fmtptr++)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
*outptr++ = (time < (HOURS_PER_AM_OR_PM * SECONDS_PER_HOUR)) ? 'A' : 'P';
*outptr++ = 'M';
continue;
default:
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
}
if (nlen > 0)
{
outptr += nlen;
outpt1 = outptr;
while (nlen-- > 0)
{
*--outpt1 = '0' + (n % 10);
n /= 10;
}
} else
{
outpt1 = (unsigned char *)temp_mval.str.addr;
while (nlen++ < 0)
*outptr++ = *outpt1++;
}
}
if (fmtptr > fmttop)
rts_error(VARLSTCNT(1) ERR_ZDATEFMT);
dst->mvtype = MV_STR;
dst->str.addr = (char *)stringpool.free;
dst->str.len = INTCAST((char *)outptr - dst->str.addr);
stringpool.free = outptr;
return;
}
void gvzwr_fini(zshow_out *out, int pat)
{
char m[sizeof(mident_fixed)];
mval local, data;
gv_key *old;
error_def(ERR_GVNAKED);
if (!gv_currkey)
gvinit();
ESTABLISH(gvzwrite_ch);
zwr_output = out;
assert(INVALID_GV_TARGET == reset_gv_target);
reset_gv_target = gv_target;
DBG_CHECK_GVTARGET_CSADDRS_IN_SYNC;
gvzwrite_block.gd_reg = gv_cur_region;
gvzwrite_block.old_targ = (unsigned char *)gv_target;
old = (gv_key *)malloc(sizeof(gv_key) + gv_currkey->end);
gvzwrite_block.old_key = (unsigned char *)old;
memcpy(gvzwrite_block.old_key, gv_currkey, sizeof(gv_key) + gv_currkey->end);
gvzwrite_block.old_map = gd_map;
gvzwrite_block.old_map_top = gd_map_top;
if (!pat)
{
local = *gvzwrite_block.pat;
if (local.str.len) /* New reference. Will get new gv_target.. */
{
gv_target = NULL;
gv_currkey->base[0] = '\0';
op_gvname(VARLSTCNT(1) &local);
op_gvdata(&data);
if (!(MV_FORCE_INTD(&data)))
sgnl_gvundef();
else
{
gvzwrite_block.fixed = (gvzwrite_block.fixed ? TRUE : FALSE);
gvzwr_var(MV_FORCE_INTD(&data), 0);
}
} else /* Old (naked) reference. Keep previous gv_target reference */
{
if (gv_currkey->prev == 0)
rts_error(VARLSTCNT(1) ERR_GVNAKED);
gv_currkey->end = gv_currkey->prev;
gv_currkey->base[ gv_currkey->end ] = 0;
gv_currkey->prev = 0;
op_gvdata(&data);
if (!(MV_FORCE_INTD(&data)))
sgnl_gvundef();
else
{
gvzwrite_block.fixed = (gvzwrite_block.fixed ? TRUE : FALSE);
gvzwr_var((int4)MV_FORCE_INTD(&data), 0);
}
}
} else
{
gv_target = NULL;
gv_currkey->base[0] = '\0';
local.mvtype = MV_STR;
local.str.addr = &m[0];
local.str.len = 1;
m[0] = '%';
gvzwrite_block.fixed = FALSE;
for (; ;)
{
op_gvname(VARLSTCNT(1) &local);
if (do_pattern(&local, gvzwrite_block.pat))
{
op_gvdata(&data);
if ((MV_FORCE_INTD(&data)))
{
gvzwr_var((int4)MV_FORCE_INTD(&data), 0);
}
}
op_gvorder(&local);
if (local.str.len)
{
assert(local.str.len <= MAX_MIDENT_LEN + 1);
local.str.addr++;
local.str.len--;
memcpy(&m[0], local.str.addr, local.str.len);
local.str.addr = &m[0];
} else
break;
}
}
gvzwrite_clnup(); /* this routine is called by gvzwrite_ch() too */
REVERT;
return;
}
