void file_input_init(char *fn, short fn_len)
{
int status;
mval pars, val;
unsigned char no_param = (unsigned char)iop_eol;
ESTABLISH(mupip_load_ch);
pars.mvtype = MV_STR;
pars.str.len = SIZEOF(open_params_list);
pars.str.addr = (char *)open_params_list;
val.mvtype = MV_STR;
val.str.len = fn_len;
val.str.addr = (char *)fn;
/* The mode will be set to M for reads */
status = (*op_open_ptr)(&val, &pars, 0, 0);
pars.str.len = SIZEOF(iop_eol);
pars.str.addr = (char *)&no_param;
op_use(&val, &pars);
load_fn_ptr = fn;
load_fn_len = fn_len;
buff1_ptr = buff1;
buff1_end = buff1;
REVERT;
return;
}
/* Due to historic reasons, *buffer must be terminated with '\\' character (or something else). (length-1) of the buffer will be
* written to the file or STDOUT which means '\\' will be ignored here.
*
* Passing NULL to *file_info prints to STDOUT.
*/
void jnlext_write(fi_type *file_info, char *buffer, int length)
{
int status;
mval op_val, op_pars;
io_pair dev_in_use;
assert(buffer[length - 1] == '\\');
dev_in_use = io_curr_device;
op_val.mvtype = MV_STR;
if (file_info) /* FILE */
{
op_val.str.addr = (char *)file_info->fn;
op_val.str.len = file_info->fn_len;
}
else /* STDOUT */
{
assert(sys_output.len > 0);
assert(sys_output.addr);
op_val.str = sys_output;
}
op_pars.str.len = SIZEOF(open_params_list);
op_pars.str.addr = (char *)open_params_list;
op_pars.mvtype = MV_STR;
op_use(&op_val, &op_pars);
op_val.mvtype = MV_STR;
op_val.str.addr = (char *)buffer;
op_val.str.len = length - 1;
op_write(&op_val);
op_wteol(1);
io_curr_device = dev_in_use;
}
void open_list_file(void)
{
char charspace;
uint4 status;
char *p, list_name[MAX_MIDENT_LEN + STR_LIT_LEN(LISTEXT)], fname[MAX_FBUFF + 1];
mval parms;
mval file;
mstr fstr;
parse_blk pblk;
time_t clock;
lst_param.list_line = 1;
lst_param.page = 0;
memset(&pblk, 0, sizeof(pblk));
assert(module_name.len <= MAX_MIDENT_LEN);
pblk.def1_size = module_name.len;
memcpy(&list_name[0], module_name.addr, pblk.def1_size);
MEMCPY_LIT(&list_name[pblk.def1_size], LISTEXT);
pblk.def1_size += STR_LIT_LEN(LISTEXT);
pblk.def1_buf = list_name;
pblk.buffer = &fname[0];
pblk.buff_size = MAX_FBUFF;
pblk.fop = F_SYNTAXO;
fstr.len = (MV_DEFINED(&cmd_qlf.list_file) ? cmd_qlf.list_file.str.len : 0);
fstr.addr = cmd_qlf.list_file.str.addr;
if (!(status = parse_file(&fstr, &pblk)) & 1)
rts_error(VARLSTCNT(1) status);
file.mvtype = parms.mvtype = MV_STR;
file.str.len = pblk.b_esl;
file.str.addr = &fname[0];
parms.str.len = sizeof(open_params_list);
parms.str.addr = (char *)&open_params_list;
(*op_open_ptr)(&file, &parms, 30, 0);
parms.str.len = 1;
charspace = (char)iop_eol;
parms.str.addr = &charspace;
dev_in_use = io_curr_device;
op_use(&file,&parms);
clock = time(0);
p = GTM_CTIME(&clock);
memcpy (print_time_buf, p + 4, sizeof(print_time_buf));
list_head(0);
return;
}
bool open_source_file (void)
{
static readonly unsigned char open_params_list[] =
{
(unsigned char)iop_readonly,
(unsigned char)iop_eol
};
mstr fstr;
int status, n,index;
parse_blk pblk;
char *p, buff[MAX_FBUFF + 1];
time_t clock;
struct stat statbuf;
mval val;
mval pars;
error_def (ERR_FILEPARSE);
memset(&pblk, 0, sizeof(pblk));
pblk.buffer = buff;
pblk.buff_size = MAX_FBUFF;
pblk.fop = F_SYNTAXO;
fstr.addr = (char *)source_file_name;
fstr.len = source_name_len;
status = parse_file(&fstr, &pblk);
if (!(status & 1))
rts_error(VARLSTCNT(5) ERR_FILEPARSE, 2, fstr.len, fstr.addr, status);
pars.mvtype = MV_STR;
pars.str.len = sizeof(open_params_list);
pars.str.addr = (char *)open_params_list;
val.mvtype = MV_STR;
val.str.len = source_name_len;
val.str.addr = (char *)source_file_name;
op_open(&val, &pars, 0, 0);
dev_in_use = io_curr_device; /* save list file info in use if it is opened */
op_use(&val, &pars);
compile_src_dev = io_curr_device;
if (tt_so_do_once)
{
clock = time(0);
memcpy(&routine_name[0], "MDEFAULT", sizeof("MDEFAULT") - 1);
memcpy(&module_name[0], "MDEFAULT", sizeof("MDEFAULT") - 1);
} else
{
STAT_FILE((char *)&source_file_name[0], &statbuf, status);
assert(status == 0);
clock = statbuf.st_mtime;
p = pblk.l_name;
n = pblk.b_name;
if (n > sizeof(mident))
n = sizeof(mident);
index = 0;
if ('_' == *p)
{
routine_name[index] = '%';
module_name[index] = '_';
p++; index++;
}
for (; index < n; index++)
routine_name[index] = module_name[index] = *p++;
for (; index < (sizeof(mident)); index++ )
routine_name[index] = module_name[index] = 0;
}
p = (char *)GTM_CTIME(&clock);
memcpy (rev_time_buf, p + 4, sizeof(rev_time_buf));
io_curr_device = dev_in_use; /* set it back to make open_list_file save the device */
return TRUE;
}
void open_ceprep_file(void)
{
#ifdef VMS
/* stub except for VMS */
#ifdef __ALPHA
# pragma member_alignment save
# pragma nomember_alignment
#endif
static readonly struct
{
unsigned char newversion;
unsigned char wrap;
unsigned char width;
int4 v_width;
unsigned char eol;
} open_params_list =
{
(unsigned char) iop_newversion,
(unsigned char) iop_wrap,
(unsigned char) iop_recordsize,
(int4) MAX_SRCLINE,
(unsigned char) iop_eol
};
#ifdef __ALPHA
# pragma member_alignment restore
#endif
int mname_len;
uint4 status;
char charspace, ceprep_name_buff[sizeof(mident) + sizeof(".MCI") - 1], fname[255];
mval file, params;
struct NAM ceprep_nam; /* name block for file access block for compiler escape preprocessor output */
/* Create cepreprocessor output file. */
ceprep_fab = cc$rms_fab;
ceprep_fab.fab$l_dna = ceprep_name_buff;
mname_len = mid_len(module_name);
assert(mname_len <= sizeof(mident));
if (0 == mname_len)
{
memcpy(ceprep_name_buff, "MDEFAULT.MCI", sizeof("MDEFAULT.MCI") - 1);
ceprep_fab.fab$b_dns = sizeof("MDEFAULT.MCI") - 1;
} else
{
memcpy(ceprep_name_buff, module_name, mname_len);
memcpy(&ceprep_name_buff[mname_len], ".MCI", sizeof(".MCI") - 1);
ceprep_fab.fab$b_dns = mname_len + sizeof(".MCI") - 1;
}
if (MV_DEFINED(&cmd_qlf.ceprep_file))
{
ceprep_fab.fab$b_fns = cmd_qlf.ceprep_file.str.len;
ceprep_fab.fab$l_fna = cmd_qlf.ceprep_file.str.addr;
}
ceprep_nam = cc$rms_nam;
ceprep_nam.nam$l_esa = fname;
ceprep_nam.nam$b_ess = sizeof(fname);
ceprep_nam.nam$b_nop = (NAM$M_SYNCHK);
ceprep_fab.fab$l_nam = &ceprep_nam;
ceprep_fab.fab$l_fop = FAB$M_NAM;
if (RMS$_NORMAL != (status = sys$parse(&ceprep_fab, 0, 0)))
rts_error(VARLSTCNT(1) status);
file.mvtype = params.mvtype = MV_STR;
file.str.len = ceprep_nam.nam$b_esl;
file.str.addr = fname;
params.str.len = sizeof(open_params_list);
params.str.addr = &open_params_list;
op_open(&file, ¶ms, CEPREP_OPEN_TIMEOUT, 0);
params.str.len = 1;
charspace = (char)iop_eol;
params.str.addr = &charspace;
dev_in_use = io_curr_device;
op_use(&file, ¶ms);
#endif
return;
}
void open_list_file(void)
{
char charspace;
uint4 status;
unsigned char list_name[MAX_MIDENT_LEN + STR_LIT_LEN(LISTEXT)], fname[255];
struct FAB fab;
struct NAM nam;
#ifdef __ALPHA
# pragma member_alignment save
# pragma nomember_alignment
#endif
static readonly struct{
unsigned char newversion;
unsigned char wrap;
unsigned char width;
int4 v_width;
unsigned char eol;
}open_params_list = {
(unsigned char)iop_newversion, (unsigned char)iop_wrap,
(unsigned char)iop_recordsize, (int4)132,
(unsigned char)iop_eol
};
#ifdef __ALPHA
# pragma member_alignment restore
#endif
mval params;
mval file;
struct dsc$descriptor_s print_time_d
= { SIZEOF(print_time_buf), DSC$K_DTYPE_T, DSC$K_CLASS_S, print_time_buf };
lst_param.list_line = 1;
lst_param.page = 0;
fab = cc$rms_fab;
nam = cc$rms_nam;
fab.fab$l_dna = &list_name[0];
assert(module_name.len <= MAX_MIDENT_LEN);
fab.fab$b_dns = module_name.len;
memcpy(&list_name[0], module_name.addr, fab.fab$b_dns);
MEMCPY_LIT(&list_name[fab.fab$b_dns], LISTEXT);
fab.fab$b_dns += STR_LIT_LEN(LISTEXT);
if (MV_DEFINED(&cmd_qlf.list_file))
{
fab.fab$b_fns = cmd_qlf.list_file.str.len;
fab.fab$l_fna = cmd_qlf.list_file.str.addr;
}
nam.nam$l_esa = &fname[0];
nam.nam$b_ess = SIZEOF(fname);
nam.nam$b_nop = (NAM$M_SYNCHK);
fab.fab$l_nam = &nam;
fab.fab$l_fop = FAB$M_NAM;
if ((status = sys$parse(&fab,0,0)) != RMS$_NORMAL)
{ rts_error(VARLSTCNT(1) status);
}
file.mvtype = params.mvtype = MV_STR;
file.str.len = nam.nam$b_esl;
file.str.addr = &fname[0];
params.str.len = SIZEOF(open_params_list);
params.str.addr = &open_params_list;
(*op_open_ptr)(&file, ¶ms, 30, 0);
params.str.len = 1;
charspace = (char) iop_eol;
params.str.addr = &charspace;
dev_in_use = io_curr_device;
op_use(&file,¶ms);
lib$date_time(&print_time_d);
list_head(0);
return;
}
void dse_open (void)
{
unsigned short cli_len;
int4 save_errno;
mval val;
mval pars;
int cnt;
static readonly unsigned char open_params_list[2] =
{
(unsigned char)iop_newversion,
(unsigned char)iop_eol
};
if (cli_present("FILE") == CLI_PRESENT)
{
if (CLOSED_FMT != dse_dmp_format)
{
util_out_print("Error: output file already open.",TRUE);
util_out_print("Current output file: !AD", TRUE, strlen(patch_ofile), &patch_ofile[0]);
return;
}
cli_len = sizeof(patch_ofile);
if (!cli_get_str("FILE", patch_ofile, &cli_len))
return;
if (0 == cli_len)
{
util_out_print("Error: must specify a file name.",TRUE);
return;
}
patch_ofile[cli_len] = 0;
patch_len = cli_len;
pars.mvtype = MV_STR;
pars.str.len = sizeof(open_params_list);
pars.str.addr = (char *)open_params_list;
val.mvtype = MV_STR;
val.str.len = patch_len;
val.str.addr = (char *)patch_ofile;
(*op_open_ptr)(&val, &pars, 0, NULL);
op_use(&val, &pars);
if (CLI_PRESENT == cli_present("OCHSET"))
{
if (cli_get_str("OCHSET", ch_set_name, &cli_len))
{
if (0 == cli_len)
{
util_out_print("Error: must specify a charactor set name.",TRUE);
return;
}
ch_set_name[cli_len] = 0;
ch_set_len = cli_len;
if ( (iconv_t)0 != dse_over_cvtcd )
{
ICONV_CLOSE_CD(dse_over_cvtcd);
}
ICONV_OPEN_CD(dse_over_cvtcd, INSIDE_CH_SET, ch_set_name);
}
} else if ( (iconv_t) 0 == dse_over_cvtcd )
ICONV_OPEN_CD(dse_over_cvtcd, INSIDE_CH_SET, OUTSIDE_CH_SET);
dse_dmp_format = OPEN_FMT;
} else
{
if (CLOSED_FMT != dse_dmp_format)
util_out_print("Current output file: !AD", TRUE, strlen(patch_ofile), &patch_ofile[0]);
else
util_out_print("No current output file.",TRUE);
}
return;
}
bool open_source_file (void)
{
mstr fstr;
int status, n;
parse_blk pblk;
char *p, buff[MAX_FBUFF + 1];
time_t clock;
struct stat statbuf;
mval val;
mval pars;
unsigned short clen;
memset(&pblk, 0, SIZEOF(pblk));
pblk.buffer = buff;
pblk.buff_size = MAX_FBUFF;
pblk.fop = F_SYNTAXO;
fstr.addr = (char *)source_file_name;
fstr.len = source_name_len;
status = parse_file(&fstr, &pblk);
if (!(status & 1))
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(5) ERR_FILEPARSE, 2, fstr.len, fstr.addr, status);
pars.mvtype = MV_STR;
pars.str.len = SIZEOF(open_params_list);
pars.str.addr = (char *)open_params_list;
val.mvtype = MV_STR;
val.str.len = source_name_len;
val.str.addr = (char *)source_file_name;
op_open(&val, &pars, 0, 0);
dev_in_use = io_curr_device; /* save list file info in use if it is opened */
op_use(&val, &pars);
compile_src_dev = io_curr_device;
if (tt_so_do_once)
{
clock = time(0);
p = "MDEFAULT";
n = STR_LIT_LEN("MDEFAULT");
} else
{
STAT_FILE((char *)source_file_name, &statbuf, status);
assert(status == 0);
clock = statbuf.st_mtime;
p = pblk.l_name;
n = pblk.b_name;
if (n > MAX_MIDENT_LEN)
n = MAX_MIDENT_LEN;
}
/* routine_name is the internal name of the routine (with '%' translated to '_') which can be
* different from module_name if the NAMEOFRTN parm is used (by trigger compilation code).
* module_name is the external file name of the module (file.m, file.o).
* int_module_name is the external symbol that gets exposed (in the GTM context) and is normally
* the same as module_name except when NAMEOFRTN is specified in which case it takes on the
* untranslated value of routine_name.
*/
memcpy(module_name.addr, p, n);
module_name.len = n;
if (!(cmd_qlf.qlf & CQ_NAMEOFRTN))
{
memcpy(routine_name.addr, p, n);
routine_name.len = n;
} else
{ /* Routine name specified */
clen = MAX_MIDENT_LEN;
cli_get_str("NAMEOFRTN", routine_name.addr, &clen);
routine_name.len = MIN(clen, MAX_MIDENT_LEN);
cmd_qlf.qlf &= ~CQ_NAMEOFRTN; /* Can only be used for first module in list */
}
memcpy(int_module_name.addr, routine_name.addr, routine_name.len);
int_module_name.len = routine_name.len;
if ('_' == *routine_name.addr)
routine_name.addr[0] = '%';
GTM_CTIME(p, &clock);
memcpy(rev_time_buf, p + 4, REV_TIME_BUFF_LEN);
io_curr_device = dev_in_use; /* set it back to make open_list_file save the device */
return TRUE;
}
void mu_extract(void)
{
int stat_res, truncate_res;
int reg_max_rec, reg_max_key, reg_max_blk, reg_std_null_coll;
int iter, format, local_errno, int_nlen;
boolean_t freeze = FALSE, logqualifier, success;
char format_buffer[FORMAT_STR_MAX_SIZE], ch_set_name[MAX_CHSET_NAME], cli_buff[MAX_LINE],
label_buff[LABEL_STR_MAX_SIZE], gbl_name_buff[MAX_MIDENT_LEN + 2]; /* 2 for null and '^' */
glist gl_head, *gl_ptr;
gd_region *reg, *region_top;
mu_extr_stats global_total, grand_total;
uint4 item_code, devbufsiz, maxfield;
unsigned short label_len, n_len, ch_set_len, buflen;
unsigned char *outbuf, *outptr, *chptr, *leadptr;
struct stat statbuf;
mval val, curr_gbl_name, op_val, op_pars;
mstr chset_mstr;
gtm_chset_t saved_out_set;
static unsigned char ochset_set = FALSE;
static readonly unsigned char open_params_list[] =
{
(unsigned char)iop_noreadonly,
(unsigned char)iop_nowrap,
(unsigned char)iop_stream,
(unsigned char)iop_eol
};
static readonly unsigned char no_param = (unsigned char)iop_eol;
coll_hdr extr_collhdr;
error_def(ERR_NOSELECT);
error_def(ERR_GTMASSERT);
error_def(ERR_EXTRACTCTRLY);
error_def(ERR_EXTRACTFILERR);
error_def(ERR_MUPCLIERR);
error_def(ERR_MUNOACTION);
error_def(ERR_MUNOFINISH);
error_def(ERR_RECORDSTAT);
error_def(ERR_NULLCOLLDIFF);
/* Initialize all local character arrays to zero before using */
memset(cli_buff, 0, sizeof(cli_buff));
memset(outfilename, 0, sizeof(outfilename));
memset(label_buff, 0, sizeof(label_buff));
memset(format_buffer, 0, sizeof(format_buffer));
active_device = io_curr_device.out;
mu_outofband_setup();
if (CLI_PRESENT == cli_present("OCHSET"))
{
ch_set_len = sizeof(ch_set_name);
if (cli_get_str("OCHSET", ch_set_name, &ch_set_len))
{
if (0 == ch_set_len)
mupip_exit(ERR_MUNOACTION); /* need to change to OPCHSET error when added */
ch_set_name[ch_set_len] = '\0';
#ifdef KEEP_zOS_EBCDIC
if ( (iconv_t)0 != active_device->output_conv_cd)
ICONV_CLOSE_CD(active_device->output_conv_cd);
if (DEFAULT_CODE_SET != active_device->out_code_set)
ICONV_OPEN_CD(active_device->output_conv_cd, INSIDE_CH_SET, ch_set_name);
#else
chset_mstr.addr = ch_set_name;
chset_mstr.len = ch_set_len;
SET_ENCODING(active_device->ochset, &chset_mstr);
get_chset_desc(&chset_names[active_device->ochset]);
#endif
ochset_set = TRUE;
}
}
logqualifier = (CLI_NEGATED != cli_present("LOG"));
if (CLI_PRESENT == cli_present("FREEZE"))
freeze = TRUE;
n_len = sizeof(format_buffer);
if (FALSE == cli_get_str("FORMAT", format_buffer, &n_len))
{
n_len = sizeof("ZWR") - 1;
memcpy(format_buffer, "ZWR", n_len);
}
int_nlen = n_len;
lower_to_upper((uchar_ptr_t)format_buffer, (uchar_ptr_t)format_buffer, int_nlen);
if (0 == memcmp(format_buffer, "ZWR", n_len))
format = MU_FMT_ZWR;
else if (0 == memcmp(format_buffer, "GO", n_len))
{
if (gtm_utf8_mode)
{
util_out_print("Extract error: GO format is not supported in UTF-8 mode. Use ZWR format.", TRUE);
mupip_exit(ERR_MUPCLIERR);
}
format = MU_FMT_GO;
} else if (0 == memcmp(format_buffer, "BINARY", n_len))
format = MU_FMT_BINARY;
else
{
util_out_print("Extract error: bad format type", TRUE);
mupip_exit(ERR_MUPCLIERR);
}
n_len = sizeof(cli_buff);
if (FALSE == cli_get_str((char *)select_text, cli_buff, &n_len))
{
n_len = 1;
cli_buff[0] = '*';
}
/* gv_select will select globals */
gv_select(cli_buff, n_len, freeze, (char *)select_text, &gl_head, ®_max_rec, ®_max_key, ®_max_blk);
if (!gl_head.next)
{
rts_error(VARLSTCNT(1) ERR_NOSELECT);
mupip_exit(ERR_NOSELECT);
}
/* For binary format, check whether all regions have same null collation order */
if (MU_FMT_BINARY == format)
{
for (reg = gd_header->regions, region_top = gd_header->regions + gd_header->n_regions, reg_std_null_coll = -1;
reg < region_top ; reg++)
{
if (reg->open)
{
if (reg_std_null_coll != reg->std_null_coll)
{
if (reg_std_null_coll == -1)
reg_std_null_coll = reg->std_null_coll;
else
{
rts_error(VARLSTCNT(1) ERR_NULLCOLLDIFF);
mupip_exit(ERR_NULLCOLLDIFF);
}
}
}
}
assert(-1 != reg_std_null_coll);
}
grand_total.recknt = grand_total.reclen = grand_total.keylen = grand_total.datalen = 0;
global_total.recknt = global_total.reclen = global_total.keylen = global_total.datalen = 0;
n_len = sizeof(outfilename);
if (FALSE == cli_get_str("FILE", outfilename, &n_len))
{
rts_error(VARLSTCNT(1) ERR_MUPCLIERR);
mupip_exit(ERR_MUPCLIERR);
}
if (-1 == Stat((char *)outfilename, &statbuf))
{
if (ENOENT != errno)
{
local_errno = errno;
perror("Error opening output file");
mupip_exit(local_errno);
}
}
else
{
util_out_print("Error opening output file: !AD -- File exists", TRUE, n_len, outfilename);
mupip_exit(ERR_MUNOACTION);
}
op_pars.mvtype = MV_STR;
op_pars.str.len = sizeof(open_params_list);
op_pars.str.addr = (char *)open_params_list;
op_val.mvtype = MV_STR;
op_val.str.len = filename_len = n_len;
op_val.str.addr = (char *)outfilename;
(*op_open_ptr)(&op_val, &op_pars, 0, 0);
ESTABLISH(mu_extract_handler);
op_use(&op_val, &op_pars);
if (MU_FMT_BINARY == format)
{
/* binary header label format:
* fixed length text, fixed length date & time,
* fixed length max blk size, fixed length max rec size, fixed length max key size, fixed length std_null_coll
* 32-byte padded user-supplied string
*/
outbuf = (unsigned char *)malloc(sizeof(BIN_HEADER_LABEL) + sizeof(BIN_HEADER_DATEFMT) - 1 +
4 * BIN_HEADER_NUMSZ + BIN_HEADER_LABELSZ);
outptr = outbuf;
MEMCPY_LIT(outptr, BIN_HEADER_LABEL);
outptr += STR_LIT_LEN(BIN_HEADER_LABEL);
stringpool.free = stringpool.base;
op_horolog(&val);
stringpool.free = stringpool.base;
op_fnzdate(&val, (mval *)&mu_bin_datefmt, &null_str, &null_str, &val);
memcpy(outptr, val.str.addr, val.str.len);
outptr += val.str.len;
WRITE_NUMERIC(reg_max_blk);
WRITE_NUMERIC(reg_max_rec);
WRITE_NUMERIC(reg_max_key);
WRITE_NUMERIC(reg_std_null_coll);
if (gtm_utf8_mode)
{
MEMCPY_LIT(outptr, UTF8_NAME);
label_len = STR_LIT_LEN(UTF8_NAME);
outptr[label_len++] = ' ';
} else
label_len = 0;
buflen = sizeof(label_buff);
if (FALSE == cli_get_str("LABEL", label_buff, &buflen))
{
MEMCPY_LIT(&outptr[label_len], EXTR_DEFAULT_LABEL);
buflen = STR_LIT_LEN(EXTR_DEFAULT_LABEL);
} else
memcpy(&outptr[label_len], label_buff, buflen);
label_len += buflen;
if (label_len > BIN_HEADER_LABELSZ)
{ /* Label size exceeds the space, so truncate the label and back off to
the valid beginning (i.e. to the leading byte) of the last character
that can entirely fit in the space */
label_len = BIN_HEADER_LABELSZ;
chptr = &outptr[BIN_HEADER_LABELSZ];
UTF8_LEADING_BYTE(chptr, outptr, leadptr);
assert(chptr - leadptr < 4);
if (leadptr < chptr)
label_len -= (chptr - leadptr);
}
outptr += label_len;
for (iter = label_len; iter < BIN_HEADER_LABELSZ; iter++)
*outptr++ = ' ';
label_len = outptr - outbuf;
if (!ochset_set)
{
#ifdef KEEP_zOS_EBCDIC
/* extract ascii header for binary by default */
/* Do we need to restore it somewhere? */
saved_out_set = (io_curr_device.out)->out_code_set;
(io_curr_device.out)->out_code_set = DEFAULT_CODE_SET;
#else
saved_out_set = (io_curr_device.out)->ochset;
(io_curr_device.out)->ochset = CHSET_M;
#endif
}
op_val.str.addr = (char *)(&label_len);
op_val.str.len = sizeof(label_len);
op_write(&op_val);
op_val.str.addr = (char *)outbuf;
op_val.str.len = label_len;
op_write(&op_val);
} else
{
assert((MU_FMT_GO == format) || (MU_FMT_ZWR == format));
label_len = sizeof(label_buff);
if (FALSE == cli_get_str("LABEL", label_buff, &label_len))
{
MEMCPY_LIT(label_buff, EXTR_DEFAULT_LABEL);
label_len = STR_LIT_LEN(EXTR_DEFAULT_LABEL);
}
if (gtm_utf8_mode)
{
label_buff[label_len++] = ' ';
MEMCPY_LIT(&label_buff[label_len], UTF8_NAME);
label_len += STR_LIT_LEN(UTF8_NAME);
}
label_buff[label_len++] = '\n';
op_val.mvtype = MV_STR;
op_val.str.len = label_len;
op_val.str.addr = label_buff;
op_write(&op_val);
stringpool.free = stringpool.base;
op_horolog(&val);
stringpool.free = stringpool.base;
op_fnzdate(&val, &datefmt, &null_str, &null_str, &val);
op_val = val;
op_val.mvtype = MV_STR;
op_write(&op_val);
if (MU_FMT_ZWR == format)
{
op_val.str.addr = " ZWR";
op_val.str.len = sizeof(" ZWR") - 1;
op_write(&op_val);
}
op_wteol(1);
}
REVERT;
ESTABLISH(mu_extract_handler1);
success = TRUE;
for (gl_ptr = gl_head.next; gl_ptr; gl_ptr = gl_ptr->next)
{
if (mu_ctrly_occurred)
break;
if (mu_ctrlc_occurred)
{
gbl_name_buff[0]='^';
memcpy(&gbl_name_buff[1], gl_ptr->name.str.addr, gl_ptr->name.str.len);
gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, gl_ptr->name.str.len + 1, gbl_name_buff,
global_total.recknt, global_total.keylen, global_total.datalen, global_total.reclen);
mu_ctrlc_occurred = FALSE;
}
gv_bind_name(gd_header, &gl_ptr->name.str);
if (MU_FMT_BINARY == format)
{
label_len = sizeof(extr_collhdr);
op_val.mvtype = MV_STR;
op_val.str.addr = (char *)(&label_len);
op_val.str.len = sizeof(label_len);
op_write(&op_val);
extr_collhdr.act = gv_target->act;
extr_collhdr.nct = gv_target->nct;
extr_collhdr.ver = gv_target->ver;
op_val.str.addr = (char *)(&extr_collhdr);
op_val.str.len = sizeof(extr_collhdr);
op_write(&op_val);
}
/* Note: Do not change the order of the expression below.
* Otherwise if success is FALSE, mu_extr_gblout() will not be called at all.
* We want mu_extr_gblout() to be called irrespective of the value of success */
success = mu_extr_gblout(&gl_ptr->name, &global_total, format) && success;
if (logqualifier)
{
gbl_name_buff[0]='^';
memcpy(&gbl_name_buff[1], gl_ptr->name.str.addr, gl_ptr->name.str.len);
gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, gl_ptr->name.str.len + 1, gbl_name_buff,
global_total.recknt, global_total.keylen, global_total.datalen, global_total.reclen);
mu_ctrlc_occurred = FALSE;
}
grand_total.recknt += global_total.recknt;
if (grand_total.reclen < global_total.reclen)
grand_total.reclen = global_total.reclen;
if (grand_total.keylen < global_total.keylen)
grand_total.keylen = global_total.keylen;
if (grand_total.datalen < global_total.datalen)
grand_total.datalen = global_total.datalen;
}
op_val.mvtype = op_pars.mvtype = MV_STR;
op_val.str.addr = (char *)outfilename;;
op_val.str.len = filename_len;
op_pars.str.len = sizeof(no_param);
op_pars.str.addr = (char *)&no_param;
op_close(&op_val, &op_pars);
REVERT;
if (mu_ctrly_occurred)
{
gtm_putmsg(VARLSTCNT(1) ERR_EXTRACTCTRLY);
mupip_exit(ERR_MUNOFINISH);
}
gtm_putmsg(VARLSTCNT(8) ERR_RECORDSTAT, 6, LEN_AND_LIT(gt_lit),
grand_total.recknt, grand_total.keylen, grand_total.datalen, grand_total.reclen);
if (MU_FMT_BINARY == format)
{
/* truncate the last newline charactor flushed by op_close */
STAT_FILE((char *)outfilename, &statbuf, stat_res);
if (-1 == stat_res)
rts_error(VARLSTCNT(1) errno);
TRUNCATE_FILE((const char *)outfilename, statbuf.st_size - 1, truncate_res);
if (-1 == truncate_res)
rts_error(VARLSTCNT(1) errno);
}
mupip_exit(success ? SS_NORMAL : ERR_MUNOFINISH);
}
void io_init(bool term_ctrl)
{
static readonly unsigned char open_params_list[2] =
{
(unsigned char)iop_newversion,
(unsigned char)iop_eol
};
static readonly unsigned char null_params_list[2] =
{
(unsigned char)iop_nl,
(unsigned char)iop_eol
};
static readonly unsigned char no_params = (unsigned char)iop_eol;
static readonly unsigned char shr_params[3] =
{
(unsigned char)iop_shared,
(unsigned char)iop_readonly,
(unsigned char)iop_eol
};
int4 status;
mval val;
mstr tn;
MSTR_CONST (gtm_netout, "GTM_NETOUT");
MSTR_CONST (sys_net, "SYS$NET");
char buf1[MAX_TRANS_NAME_LEN]; /* buffer to hold translated name */
mval pars;
io_log_name *inp, *outp;
io_log_name *ln;
error_def(ERR_LOGTOOLONG);
io_init_name();
/* default logical names */
io_root_log_name = (io_log_name *)malloc(SIZEOF(*io_root_log_name));
memset(io_root_log_name, 0, SIZEOF(*io_root_log_name));
val.mvtype = MV_STR;
val.str.addr = "0";
val.str.len = 1;
ln = get_log_name(&val.str, INSERT);
assert(ln != 0);
val.str = gtm_principal;
status = TRANS_LOG_NAME(&val.str, &tn, buf1, SIZEOF(buf1), dont_sendmsg_on_log2long);
if (SS_NOLOGNAM == status)
dollar_principal = 0;
else if (SS_NORMAL == status)
dollar_principal = get_log_name(&tn, INSERT);
# ifdef UNIX
else if (SS_LOG2LONG == status)
rts_error(VARLSTCNT(5) ERR_LOGTOOLONG, 3, val.str.len, val.str.addr, SIZEOF(buf1) - 1);
# endif
else
rts_error(VARLSTCNT(1) status);
/* open devices */
val.str = sys_input;
inp = get_log_name(&val.str, INSERT);
pars.mvtype = MV_STR;
status = TRANS_LOG_NAME(&val.str, &tn, buf1, SIZEOF(buf1), dont_sendmsg_on_log2long);
if (SS_NOLOGNAM == status)
{
pars.str.len = SIZEOF(null_params_list);
pars.str.addr = (char *)null_params_list;
} else if (SS_NORMAL == status)
{
if (!io_is_rm(&val.str))
{
pars.str.len = SIZEOF(no_params);
pars.str.addr = (char *)&no_params;
} else if (io_is_sn(&val.str))
{
pars.str.len = SIZEOF(open_params_list);
pars.str.addr = (char *)open_params_list;
} else
{
pars.str.len = SIZEOF(shr_params);
pars.str.addr = (char *)shr_params;
}
}
# ifdef UNIX
else if (SS_LOG2LONG == status)
rts_error(VARLSTCNT(5) ERR_LOGTOOLONG, 3, val.str.len, val.str.addr, SIZEOF(buf1) - 1);
# endif
else
rts_error(VARLSTCNT(1) status);
ESTABLISH(io_init_ch);
(*op_open_ptr)(&val, &pars, 0, 0);
io_curr_device.in = io_std_device.in = inp->iod;
val.str = sys_output;
if ((SS_NORMAL == TRANS_LOG_NAME(>m_netout, &tn, buf1, SIZEOF(buf1), do_sendmsg_on_log2long))
&& (SS_NORMAL == TRANS_LOG_NAME(&sys_net, &tn, buf1, SIZEOF(buf1), do_sendmsg_on_log2long))
&& io_is_sn(&sys_net))
val.str = sys_net;
outp = get_log_name(&val.str, INSERT);
status = TRANS_LOG_NAME(&val.str, &tn, buf1, SIZEOF(buf1), dont_sendmsg_on_log2long);
if ((SS_NORMAL != status) && (SS_NOLOGNAM != status))
{
# ifdef UNIX
if (SS_LOG2LONG == status)
rts_error(VARLSTCNT(5) ERR_LOGTOOLONG, 3, val.str.len, val.str.addr, SIZEOF(buf1) - 1);
else
# endif
rts_error(VARLSTCNT(1) status);
}
if ((val.str.addr == sys_net.addr) && (pars.str.addr == (char *)open_params_list))
/* sys$net is the only input thing that uses open_params_list */
outp->iod = io_curr_device.in;
/* For terminals and mailboxes and sockets, SYS$INPUT and SYS$OUTPUT may point to
the same device. If input is one of those, then check translated
name for output against translated name for input;
in that case they should be joined by their logical names */
if (((tt == io_curr_device.in->type) || (mb == io_curr_device.in->type) ||
(gtmsocket == io_curr_device.in->type))
&& same_device_check(tn, buf1))
outp->iod = io_curr_device.in;
if (!outp->iod)
{
if (status == SS_NOLOGNAM)
{
pars.str.len = SIZEOF(null_params_list);
pars.str.addr = (char *)null_params_list;
} else if (status == SS_NORMAL)
{
pars.str.len = SIZEOF(open_params_list);
pars.str.addr = (char *)open_params_list;
}
(*op_open_ptr)(&val, &pars, 0, 0);
}
io_curr_device.out = io_std_device.out = outp->iod;
term_setup(term_ctrl);
io_std_device.out->pair = io_std_device;
io_std_device.in->pair = io_std_device;
io_std_device.out->perm = io_std_device.in->perm = TRUE;
for (ln = io_root_log_name; ln; ln = ln->next)
ln->iod = io_std_device.in;
if (dollar_principal)
dollar_principal->iod = io_std_device.in;
pars.str.len = SIZEOF(no_params);
pars.str.addr = (char *)&no_params;
val.str.len = io_curr_device.in->trans_name->len;
val.str.addr = io_std_device.in->trans_name->dollar_io;
op_use(&val, &pars);
REVERT;
return;
}
