boolean_t dse_fdmp_output (void *addr, int4 len)
{
mval val;
static char *buffer = NULL;
static int bufsiz = 0;
assert(len >= 0);
if (len + 1 > bufsiz)
{
if (buffer)
free(buffer);
bufsiz = len + 1;
buffer = (char *)malloc(bufsiz);
}
if (len)
{
memcpy(buffer, addr, len);
buffer[len] = 0;
val.mvtype = MV_STR;
val.str.addr = (char *)buffer;
val.str.len = len;
op_write(&val);
}
op_wteol(1);
return TRUE;
}
/* 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 list_line_number(void)
{
void op_write();
unsigned char buf[8];
int n,m, i, q;
unsigned char *pt;
mval out;
assert(cmd_qlf.qlf & CQ_LIST);
if (io_curr_device.out->dollar.y >= lst_param.lines_per_page -
((lst_param.lines_per_page < BIG_PG) ? SMALL_PG_BOT_SP : BIG_PG_BOT_SP))
list_head(1);
n = lst_param.list_line++;
pt = &buf[5];
memset(&buf[0],SP,SIZEOF(buf));
do
{
i = n / 10;
q = n - (i * 10);
*--pt = q + '0';
n = i;
} while(i > 0);
out.mvtype = MV_STR;
out.str.addr = buf;
out.str.len = SIZEOF(buf);
op_write(&out);
}
void SMPcore::op_not1_bit() {
dp = op_readpc() << 0;
dp |= op_readpc() << 8;
bit = dp >> 13;
dp &= 0x1fff;
rd = op_read(dp);
rd ^= 1 << bit;
op_write(dp, rd);
}
error_code sys_fs_fcntl(u32 fd, u32 op, vm::ptr<void> _arg, u32 _size)
{
sys_fs.trace("sys_fs_fcntl(fd=%d, op=0x%x, arg=*0x%x, size=0x%x)", fd, op, _arg, _size);
switch (op)
{
case 0x8000000A: // Read with offset
case 0x8000000B: // Write with offset
{
const auto arg = vm::static_ptr_cast<lv2_file_op_rw>(_arg);
if (_size < arg.size())
{
return CELL_EINVAL;
}
const auto file = idm::get<lv2_file>(fd);
if (!file)
{
return CELL_EBADF;
}
if (op == 0x8000000A && file->flags & CELL_FS_O_WRONLY)
{
return CELL_EBADF;
}
if (op == 0x8000000B && !(file->flags & CELL_FS_O_ACCMODE))
{
return CELL_EBADF;
}
std::lock_guard<std::mutex> lock(file->mp->mutex);
const u64 old_pos = file->file.pos();
const u64 new_pos = file->file.seek(arg->offset);
arg->out_size = op == 0x8000000A
? file->op_read(arg->buf, arg->size)
: file->op_write(arg->buf, arg->size);
verify(HERE), old_pos == file->file.seek(old_pos);
arg->out_code = CELL_OK;
break;
}
default:
{
sys_fs.todo("sys_fs_fcntl(): Unknown operation 0x%08x (fd=%d, arg=*0x%x, size=0x%x)", op, fd, _arg, _size);
}
}
return CELL_OK;
}
void put_ceprep_line(void)
{
#ifdef VMS
/* stub except for VMS */
mval out;
out.mvtype = MV_STR;
out.str.len = strlen((char *)source_buffer);
out.str.addr = source_buffer;
op_write(&out);
op_wteol(1);
#endif
return;
}
int op_tfs_file(const FileType type)
{
int extra_flag = 0;
if (type == TFS_LARGE_FILE)
{
extra_flag = T_LARGE;
}
else if (type != TFS_SMALL_FILE)
{
printf("unknown type: %d\n", type);
return TFS_ERROR;
}
printf("========== op demo type: tfs %s file ===========\n", type == TFS_LARGE_FILE ? "large" : "small");
// write
int ret = op_write(extra_flag);
print_info("write", ret);
if (ret != TFS_SUCCESS)
{
return ret;
}
printf("write tfs file name: %s\n", tfs_name);
// read
ret = op_read(extra_flag);
print_info("read", ret);
// stat
ret = op_stat(extra_flag);
print_info("stat", ret);
// unlink
ret = op_unlink(extra_flag);
print_info("unlink", ret);
ret = op_unique(extra_flag);
print_info("unique", ret);
return ret;
}
int main(int argc, char *argv[]) {
assert(argc == 2);
op_time = strtol(argv[1], NULL, 10);
assert(op_time >= 0);
debug("Hello client! Got %ld.\n", op_time);
control_queue = get_queue(CONTROL_KEY);
clients_server_queue = get_queue(CLIENTS_SERVER_KEY);
server_clients_queue = get_queue(SERVER_CLIENTS_KEY);
pid = getpid();
debug("My pid is %ld.\n", pid);
Mesg msg;
msg.mesg_type = pid;
queue_send(control_queue, (char *) &msg);
char buffer[500];
while (fgets(buffer, sizeof buffer, stdin) != NULL) {
char op;
int n;
const char *p = buffer;
sscanf(p, "%c%n", &op, &n);
p += n;
switch (op) {
case 'r': op_read(p); break;
case 'w': op_write(p); break;
case 's': op_sum(p); break;
case 'x': op_swap(p); break;
}
}
msg.op = QUIT;
queue_send(clients_server_queue, (char *) &msg);
return 0;
}
void list_head(bool newpage)
{
short col_2 = 70;
static readonly unsigned char page_lit[] = "page ";
unsigned char page_no_buf[10];
mval head;
if (newpage)
op_wtff();
head.mvtype = MV_STR;
head.str.addr = (char *)>m_release_name[0];
head.str.len = gtm_release_name_len;
op_write (&head);
head.str.addr = (char *)>m_copy_right[0];
head.str.len = sizeof(gtm_copy_right) - 1;
op_write (&head);
op_wttab(col_2);
head.str.addr = print_time_buf;
head.str.len = 20;
op_write(&head);
op_wttab(100);
lst_param.page++;
head.str.addr = (char *)page_lit;
head.str.len = sizeof(page_lit) - 1;
op_write(&head);
head.str.addr = (char *)page_no_buf;
head.str.len = INTCAST(i2asc(page_no_buf, lst_param.page) - page_no_buf);
op_write(&head);
op_wteol(1);
head.str.addr = source_file_name;
head.str.len = source_name_len;
op_write(&head);
if (source_name_len >= col_2)
op_wteol(1);
op_wttab(col_2);
head.str.addr = rev_time_buf;
head.str.len = 20;
op_write(&head);
op_wteol(3);
}
int
main(int argc, const char *argv[])
{
const char *file = argv[1];
int fd;
struct athregrec a;
int r;
if (argc < 2) {
printf("usage: %s <ahq log>\n", argv[0]);
exit(127);
}
fd = open(file, O_RDONLY);
if (fd < 0) {
perror("open");
exit(127);
}
while (1) {
r = read(fd, &a, sizeof(a));
if (r != sizeof(a))
break;
switch (a.op) {
case OP_READ:
op_read(&a);
break;
case OP_WRITE:
op_write(&a);
break;
case OP_DEVICE:
op_device(&a);
break;
case OP_MARK:
op_mark(&a);
break;
default:
printf("op: %d; reg: 0x%x; val: 0x%x\n",
a.op, a.reg, a.val);
}
}
close(fd);
}
error_code sys_fs_write(u32 fd, vm::cptr<void> buf, u64 nbytes, vm::ptr<u64> nwrite)
{
sys_fs.trace("sys_fs_write(fd=%d, buf=*0x%x, nbytes=0x%llx, nwrite=*0x%x)", fd, buf, nbytes, nwrite);
const auto file = idm::get<lv2_file>(fd);
if (!file || !(file->flags & CELL_FS_O_ACCMODE))
{
return CELL_EBADF;
}
// TODO: return CELL_EBUSY if locked by stream
std::lock_guard<std::mutex> lock(file->mp->mutex);
*nwrite = file->op_write(buf, nbytes);
return CELL_OK;
}
void kmain(int argc, char **argv) {
assert(argc > 2 && "Usage: fstest <fstype> <op> <params>");
const char *fstype = argv[1];
const char *op = argv[2];
const char **params = (const char**) &argv[3];
int nparams = argc - 2;
/* Mount /dev/hda on / */
int st = vfs_mount(makedev(DEV_MAJ_HDA, 0), vfs_get_root(), fstype);
assert(st == 0 && "mount failed!");
if (!strcmp(op, "cat"))
op_cat(params, nparams);
else if (!strcmp(op, "ls"))
op_ls(params, nparams);
else if (!strcmp(op, "write"))
op_write(params, nparams);
else if (!strcmp(op, "mkdir"))
op_mkdir(params, nparams);
else
kprintf("Unknown command: %s!\n", op);
}
void list_line(char *c)
{
short n, c_len, space_avail;
mval out;
if (io_curr_device.out->dollar.y >= lst_param.lines_per_page -
((lst_param.lines_per_page < BIG_PG) ? SMALL_PG_BOT_SP : BIG_PG_BOT_SP))
list_head(1);
out.mvtype = MV_STR;
c_len = (short)strlen(c);
while(c_len > 0)
{
if (c_len < (space_avail = PG_WID - io_curr_device.out->dollar.x))
space_avail = c_len;
out.str.len = space_avail;
out.str.addr = c;
op_write(&out);
c_len -= space_avail;
c += space_avail;
if (c_len > 0)
{
assert(io_curr_device.out->dollar.x != 0);
op_wteol(1);
}
}
if ((n = lst_param.lines_per_page - io_curr_device.out->dollar.y) <
lst_param.space)
{
assert(n > 0);
op_wteol(n);
}
else
op_wteol(lst_param.space);
}
void CPU::op_ldd_hl_a() {
op_write(r[HL], r[A]);
r[HL]--;
}
void CPU::op_ld_ffc_a() {
op_write(0xff00 + r[C], r[A]);
}
void CPU::op_ldi_hl_a() {
op_write(r[HL], r[A]);
r[HL]++;
}
void CPU::op_ld_nn_a() {
uint8 lo = op_read(r[PC]++);
uint8 hi = op_read(r[PC]++);
op_write((hi << 8) | (lo << 0), r[A]);
}
void CPU::op_ld_ffn_a() {
op_write(0xff00 + op_read(r[PC]++), r[A]);
}
void CPU::op_ld_hl_n() {
op_write(r[HL], op_read(r[PC]++));
}
template<unsigned x> void CPU::op_ld_rr_a() {
op_write(r[x], r[A]);
}
void op_zprint(mval *rtn, mval *start_label, int start_int_exp, mval *end_label, int end_int_exp)
/* contains label to be located or null string */
/* contains label offset or line number to reference */
/* contains routine to look in or null string */
/* NOTE: If only the first label is specified, the */
/* parser makes the second label the duplicate */
/* of the first. (not so vice versa) */
{
mval print_line, null_str;
mstr *src1, *src2;
uint4 stat1, stat2;
rhdtyp *rtn_vector;
error_def(ERR_FILENOTFND);
error_def(ERR_TXTSRCMAT);
error_def(ERR_ZPRTLABNOTFND);
error_def(ERR_ZLINKFILE);
error_def(ERR_ZLMODULE);
MV_FORCE_STR(start_label);
MV_FORCE_STR(end_label);
MV_FORCE_STR(rtn);
if (NULL == (rtn_vector = find_rtn_hdr(&rtn->str)))
{
op_zlink(rtn, NULL);
rtn_vector = find_rtn_hdr(&rtn->str);
if (NULL == rtn_vector)
rts_error(VARLSTCNT(8) ERR_ZLINKFILE, 2, rtn->str.len, rtn->str.addr,
ERR_ZLMODULE, 2, mid_len(&zlink_mname), &zlink_mname.c[0]);
}
stat1 = get_src_line(rtn, start_label, start_int_exp, &src1);
if (stat1 & LABELNOTFOUND)
rts_error(VARLSTCNT(1) ERR_ZPRTLABNOTFND);
if (stat1 & SRCNOTFND)
rts_error(VARLSTCNT(4) ERR_FILENOTFND, 2, rtn_vector->src_full_name.len, rtn_vector->src_full_name.addr);
if (stat1 & (SRCNOTAVAIL | AFTERLASTLINE))
return;
if (stat1 & (ZEROLINE | NEGATIVELINE))
{
null_str.mvtype = MV_STR;
null_str.str.len = 0;
stat1 = get_src_line(rtn, &null_str, 1, &src1);
if (stat1 & AFTERLASTLINE) /* the "null" file */
return;
}
if (end_int_exp == 0 && (end_label->str.len == 0 || *end_label->str.addr == 0))
stat2 = AFTERLASTLINE;
else if ((stat2 = get_src_line(rtn, end_label, end_int_exp, &src2)) & LABELNOTFOUND)
rts_error(VARLSTCNT(1) ERR_ZPRTLABNOTFND);
if (stat2 & (ZEROLINE | NEGATIVELINE))
return;
if (stat2 & AFTERLASTLINE)
{
null_str.mvtype = MV_STR;
null_str.str.len = 0;
stat2 = get_src_line(rtn, &null_str, 1, &src2);
/* number of lines less one for duplicated zero'th line and one due
to termination condition being <=
*/
assert((INTPTR_T)src2 > 0);
src2 += rtn_vector->lnrtab_len - 2;
}
if (stat1 & CHECKSUMFAIL)
{
rts_error(VARLSTCNT(1) INFO_MSK(ERR_TXTSRCMAT));
op_wteol(1);
}
print_line.mvtype = MV_STR;
for ( ; src1 <= src2 ; src1++)
{
if (outofband)
outofband_action(FALSE);
print_line.str.addr = src1->addr;
print_line.str.len = src1->len;
op_write(&print_line);
op_wteol(1);
}
return;
}
template<unsigned x> void CPU::op_ld_hl_r() {
op_write(r[HL], r[x]);
}
void CPU::oam_dma() {
for(unsigned n = 0; n < 256; n++) {
uint8 data = op_read((status.oam_dma_page << 8) + n);
op_write(0x2004, data);
}
}
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 CPU::op_writesp(uint8 data) {
op_write(0x0100 | regs.s--, data);
}
void CPU::op_writezp(uint8 addr, uint8 data) {
op_write(addr, data);
}
static void *consumer_loop(void *arg)
{
while (1) {
int rc, space;
int size;
char *rpos;
consumer_lock();
if (!consumer_running)
break;
if (consumer_status == CS_PAUSED || consumer_status == CS_STOPPED) {
pthread_cond_wait(&consumer_playing, &consumer_mutex);
consumer_unlock();
continue;
}
space = op_buffer_space();
if (space < 0) {
d_print("op_buffer_space returned %d %s\n", space,
space == -1 ? strerror(errno) : "");
/* try to reopen */
op_close();
__consumer_status_update(CS_STOPPED);
__consumer_play();
consumer_unlock();
continue;
}
/* d_print("BS: %6d %3d\n", space, space * 1000 / (44100 * 2 * 2)); */
while (1) {
if (space == 0) {
__consumer_position_update();
consumer_unlock();
ms_sleep(25);
break;
}
size = buffer_get_rpos(&rpos);
if (size == 0) {
producer_lock();
if (producer_status != PS_PLAYING) {
producer_unlock();
consumer_unlock();
break;
}
/* must recheck rpos */
size = buffer_get_rpos(&rpos);
if (size == 0) {
/* OK. now it's safe to check if we are at EOF */
if (ip_eof(ip)) {
/* EOF */
__consumer_handle_eof();
producer_unlock();
consumer_unlock();
break;
} else {
/* possible underrun */
producer_unlock();
__consumer_position_update();
consumer_unlock();
/* d_print("possible underrun\n"); */
ms_sleep(10);
break;
}
}
/* player_buffer and ip.eof were inconsistent */
producer_unlock();
}
if (size > space)
size = space;
if (soft_vol || replaygain)
scale_samples(rpos, (unsigned int *)&size);
rc = op_write(rpos, size);
if (rc < 0) {
d_print("op_write returned %d %s\n", rc,
rc == -1 ? strerror(errno) : "");
/* try to reopen */
op_close();
__consumer_status_update(CS_STOPPED);
__consumer_play();
consumer_unlock();
break;
}
buffer_consume(rc);
consumer_pos += rc;
space -= rc;
}
}
__consumer_stop();
consumer_unlock();
return NULL;
}
