// Warn about failure writing to the log file and then exit.
static void
warn_log_fail(void)
{
extern struct conf *conf;
// Note: Can't call fatal() since that would lead to recursion.
fprintf(stderr, "ccache: error: Failed to write to %s: %s\n",
conf->log_file, strerror(errno));
x_exit(EXIT_FAILURE);
}
// Something went badly wrong!
void
fatal(const char *format, ...)
{
va_list ap;
va_start(ap, format);
char msg[8192];
vsnprintf(msg, sizeof(msg), format, ap);
va_end(ap);
cc_log("FATAL: %s", msg);
fprintf(stderr, "ccache: error: %s\n", msg);
x_exit(1);
}
int main ()
{
union lofl_u x;
int i;
for (i = 0; i < (int) (sizeof(t) / sizeof(t[0])); i++) {
x.lo = pgm_read_dword (& t[i].x);
vn = 0;
vf.fl = modf (x.fl, & vn);
if (!isnan (vf.fl) || !isnan (vn)) {
x_exit (i+1);
}
}
return 0;
}
/* Execute a compiler backend, capturing all output to the given paths the full
* path to the compiler to run is in argv[0]. */
int
execute(char **argv, int fd_out, int fd_err, pid_t *pid)
{
int status;
cc_log_argv("Executing ", argv);
block_signals();
*pid = fork();
unblock_signals();
if (*pid == -1) {
fatal("Failed to fork: %s", strerror(errno));
}
if (*pid == 0) {
/* Child. */
dup2(fd_out, 1);
close(fd_out);
dup2(fd_err, 2);
close(fd_err);
x_exit(execv(argv[0], argv));
}
close(fd_out);
close(fd_err);
if (waitpid(*pid, &status, 0) != *pid) {
fatal("waitpid failed: %s", strerror(errno));
}
block_signals();
*pid = 0;
unblock_signals();
if (WEXITSTATUS(status) == 0 && WIFSIGNALED(status)) {
return -1;
}
return WEXITSTATUS(status);
}
int main ()
{
int i;
for (i = 0; i < (int) (sizeof(t) / sizeof(t[0])); i++) {
x.lo = pgm_read_dword (& t[i].x);
y.lo = pgm_read_dword (& t[i].y);
if ((x.fl != y.fl) != pgm_read_byte (& t[i].ne))
x_exit (i+1, 1);
if ((x.fl < y.fl) != pgm_read_byte (& t[i].lt))
x_exit (i+1, 2);
if ((x.fl <= y.fl) != pgm_read_byte (& t[i].le))
x_exit (i+1, 3);
if ((x.fl == y.fl) != pgm_read_byte (& t[i].eq))
x_exit (i+1, 4);
if ((x.fl >= y.fl) != pgm_read_byte (& t[i].ge))
x_exit (i+1, 5);
if ((x.fl > y.fl) != pgm_read_byte (& t[i].gt))
x_exit (i+1, 6);
}
return 0;
}
int
win32execute(char *path, char **argv, int doreturn,
int fd_stdout, int fd_stderr)
{
PROCESS_INFORMATION pi;
memset(&pi, 0x00, sizeof(pi));
STARTUPINFO si;
memset(&si, 0x00, sizeof(si));
char *sh = win32getshell(path);
if (sh) {
path = sh;
}
si.cb = sizeof(STARTUPINFO);
if (fd_stdout != -1) {
si.hStdOutput = (HANDLE)_get_osfhandle(fd_stdout);
si.hStdError = (HANDLE)_get_osfhandle(fd_stderr);
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
si.dwFlags = STARTF_USESTDHANDLES;
if (si.hStdOutput == INVALID_HANDLE_VALUE
|| si.hStdError == INVALID_HANDLE_VALUE) {
return -1;
}
} else {
// Redirect subprocess stdout, stderr into current process.
si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
si.dwFlags = STARTF_USESTDHANDLES;
if (si.hStdOutput == INVALID_HANDLE_VALUE
|| si.hStdError == INVALID_HANDLE_VALUE) {
return -1;
}
}
char *args = win32argvtos(sh, argv);
const char *ext = strrchr(path, '.');
char full_path_win_ext[MAX_PATH] = {0};
add_exe_ext_if_no_to_fullpath(full_path_win_ext, MAX_PATH, ext, path);
BOOL ret =
CreateProcess(full_path_win_ext, args, NULL, NULL, 1, 0, NULL, NULL,
&si, &pi);
if (fd_stdout != -1) {
close(fd_stdout);
close(fd_stderr);
}
free(args);
if (ret == 0) {
LPVOID lpMsgBuf;
DWORD dw = GetLastError();
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf,
0, NULL);
LPVOID lpDisplayBuf =
(LPVOID) LocalAlloc(LMEM_ZEROINIT,
(lstrlen((LPCTSTR) lpMsgBuf)
+ lstrlen((LPCTSTR) __FILE__) + 200)
* sizeof(TCHAR));
_snprintf((LPTSTR) lpDisplayBuf,
LocalSize(lpDisplayBuf) / sizeof(TCHAR),
TEXT("%s failed with error %lu: %s"), __FILE__, dw,
(const char *)lpMsgBuf);
cc_log("can't execute %s; OS returned error: %s",
full_path_win_ext, (char *)lpDisplayBuf);
LocalFree(lpMsgBuf);
LocalFree(lpDisplayBuf);
return -1;
}
WaitForSingleObject(pi.hProcess, INFINITE);
DWORD exitcode;
GetExitCodeProcess(pi.hProcess, &exitcode);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
if (!doreturn) {
x_exit(exitcode);
}
return exitcode;
}
void
do_c70d(word32 arg0)
{
int cmd;
int cmd_list_lo, cmd_list_mid, cmd_list_hi;
int rts_lo, rts_hi;
word32 rts_addr;
word32 cmd_list;
int unit;
int param_cnt;
int status_ptr_lo, status_ptr_mid, status_ptr_hi;
int buf_ptr_lo, buf_ptr_hi;
int buf_ptr;
int block_lo, block_mid, block_hi;
int block;
word32 status_ptr;
int status_code;
int ctl_ptr_lo, ctl_ptr_hi;
int ctl_ptr;
int ctl_code;
int mask;
int stat_val;
int size;
int ret;
int ext;
int i;
set_memory_c(0x7f8, 0xc7, 0);
if((g_sim65816.engine.psr & 0x100) == 0) {
disk_printf("c70d called in native mode!\n");
if((g_sim65816.engine.psr & 0x30) != 0x30) {
halt_printf("c70d called native, psr: %03x!\n",
g_sim65816.engine.psr);
}
}
g_sim65816.engine.stack = ((g_sim65816.engine.stack + 1) & 0xff) + 0x100;
rts_lo = get_memory_c(g_sim65816.engine.stack, 0);
g_sim65816.engine.stack = ((g_sim65816.engine.stack + 1) & 0xff) + 0x100;
rts_hi = get_memory_c(g_sim65816.engine.stack, 0);
rts_addr = (rts_lo + (256*rts_hi) + 1) & 0xffff;
disk_printf("rts_addr: %04x\n", rts_addr);
cmd = get_memory_c(rts_addr, 0);
cmd_list_lo = get_memory_c((rts_addr + 1) & 0xffff, 0);
cmd_list_mid = get_memory_c((rts_addr + 2) & 0xffff, 0);
cmd_list_hi = 0;
mask = 0xffff;
if(cmd & 0x40) {
/* extended */
mask = 0xffffff;
cmd_list_hi = get_memory_c((rts_addr + 3) & 0xffff, 0);
}
cmd_list = cmd_list_lo + (256*cmd_list_mid) + (65536*cmd_list_hi);
disk_printf("cmd: %02x, cmd_list: %06x\n", cmd, cmd_list);
param_cnt = get_memory_c(cmd_list, 0);
ext = 0;
if(cmd & 0x40) {
ext = 2;
}
smartport_log(0xc70d, cmd, rts_addr, cmd_list);
switch(cmd & 0x3f) {
case 0x00: /* Status == 0x00 and 0x40 */
if(param_cnt != 3) {
disk_printf("param_cnt %d is != 3!\n", param_cnt);
x_exit(8);
}
unit = get_memory_c((cmd_list+1) & mask, 0);
status_ptr_lo = get_memory_c((cmd_list+2) & mask, 0);
status_ptr_mid = get_memory_c((cmd_list+3) & mask, 0);
status_ptr_hi = 0;
if(cmd & 0x40) {
status_ptr_hi = get_memory_c((cmd_list+4) & mask, 0);
}
status_ptr = status_ptr_lo + (256*status_ptr_mid) +
(65536*status_ptr_hi);
if(cmd & 0x40) {
status_code = get_memory_c((cmd_list+6) & mask, 0);
} else {
status_code = get_memory_c((cmd_list+4) & mask, 0);
}
smartport_log(0, unit, status_ptr, status_code);
disk_printf("unit: %02x, status_ptr: %06x, code: %02x\n",
unit, status_ptr, status_code);
if(unit == 0 && status_code == 0) {
/* Smartport driver status */
/* see technotes/smpt/tn-smpt-002 */
set_memory_c(status_ptr, g_iwm.g_highest_smartport_unit+1, 0);
set_memory_c(status_ptr+1, 0xff, 0); /* interrupt stat*/
set_memory16_c(status_ptr+2, 0x0002, 0); /* vendor id */
set_memory16_c(status_ptr+4, 0x1000, 0); /* version */
set_memory16_c(status_ptr+6, 0x0000, 0);
g_sim65816.engine.xreg = 8;
g_sim65816.engine.yreg = 0;
g_sim65816.engine.acc &= 0xff00;
g_sim65816.engine.psr &= ~1;
g_sim65816.engine.kpc = (rts_addr + 3 + ext) & mask;
return;
} else if(unit > 0 && status_code == 0) {
/* status for unit x */
if(unit > MAX_C7_DISKS || g_iwm.iwm.smartport[unit-1].fd < 0){
stat_val = 0x80;
size = 0;
} else {
stat_val = 0xf8;
size = g_iwm.iwm.smartport[unit-1].image_size;
size = (size+511) / 512;
}
set_memory_c(status_ptr, stat_val, 0);
set_memory24_c(status_ptr +1, size, 0);
g_sim65816.engine.xreg = 4;
if(cmd & 0x40) {
set_memory_c(status_ptr + 4,
(size >> 16) & 0xff, 0);
g_sim65816.engine.xreg = 5;
}
g_sim65816.engine.yreg = 0;
g_sim65816.engine.acc &= 0xff00;
g_sim65816.engine.psr &= ~1;
g_sim65816.engine.kpc = (rts_addr + 3 + ext) & mask;
disk_printf("just finished unit %d, stat 0\n", unit);
return;
} else if(status_code == 3) {
