/*
========================================================================
This routine checks if there are any active debug monitors and calls
each attached monitor so it can perform it's debug tasks.
========================================================================
*/
void do_debug_stuff(void)
{
int i;
/* Call all debug monitor callback routines */
unlock_remote();
for (i = 0; i < 3; i++)
{
if (gpDebugMonitors[i] != NULL)
gpDebugMonitors[i](DEBUG_PC_CHANGED);
}
if (gStopped)
{
if (gLastWasSingleStep)
{
for (i = 0; i < 3; i++)
{
if (gpDebugMonitors[i] != NULL)
gpDebugMonitors[i](DEBUG_CPU_STEP);
}
}
gOsDelay = 1;
/* Loop until not stopped or single step */
while (gStopped && !gSingleStep && !gExitApp)
{
process_windows_event();
}
gOsDelay = 0;
gLastWasSingleStep = gSingleStep;
gSingleStep = 0;
}
lock_remote();
}
void model_8201_bug_workaround(int reason)
{
// Remove debugging after we get the to main menu
if (PC == 0x6d91)
{
lock_remote();
debug_clear_monitor_callback(model_8201_bug_workaround);
gDebugActive--;
unlock_remote();
}
}
/*
========================================================================
This routine peforms a CPU reset and reinitializes memory.
========================================================================
*/
void resetcpu(void)
{
int i;
/* Clear all CPU registers */
for (i = 0; i < sizeof(cpu); i++)
cpu[i] = 0;
/* Set interrupt mask */
IM=0x08;
cpuMISC=0;
/* Re-initialize memory */
reinit_mem();
/* Check if debug monitor active and updae if there are */
if (gDebugActive)
{
/* Call all debug monitor callback routines */
for (i = 0; i < 3; i++)
{
if (gpDebugMonitors[i] != NULL)
gpDebugMonitors[i](DEBUG_PC_CHANGED);
}
}
/*
Work around a stupid PC-8201 bug that couldn't be found. For some reason,
in the Windows Release build, the ROM gets stuck looking for RS232 data and
waiting for SHIFT-BREAK to be pressed in the boot routine. If I try to trace
the ROM, the problem goes away, so it has to be timing related somewhere. I
found that simply adding delay by "debug tracing" each PC location fixes the
issue. The code below adds a 1-time debug hook during boot do add delay that
is later removed. This allows delay to be added at boot without adding any
additional delay (if statements) during the main portion of the code. This is a
horrible kludge, but it fixes the problem.
*/
#ifdef WIN32
if (gModel == MODEL_PC8201 || gModel == MODEL_PC8300)
{
lock_remote();
debug_set_monitor_callback(model_8201_bug_workaround);
gDebugActive++;
unlock_remote();
}
#endif
}
/*
======================================================================
initcpu: This function initializes the CPU and the system memories
including loading the ROM and RAM files.
======================================================================
*/
void init_cpu(void)
{
int i;
/* Initialize CPU registers */
A = F = B = C = D = E = H = L = 0;
SPH = SPL = 0;
PCH = PCL = 0;
IM=0x08;
cpuMISC=0;
load_sys_rom();
/* Clear the system memory RAM area */
for (i = 0; i < RAMSIZE; i++)
gBaseMemory[RAMSTART + i] = 0;
/* Read RAM from file in emulation directory */
load_ram();
/* Load option ROM if any */
load_opt_rom();
/*
Work around a stupid PC-8201 bug that couldn't be found. For some reason,
in the Windows Release build, the ROM gets stuck looking for RS232 data and
waiting for SHIFT-BREAK to be pressed in the boot routine. If I try to trace
the ROM, the problem goes away, so it has to be timing related somewhere. I
found that simply adding delay by "debug tracing" each PC location fixes the
issue. The code below adds a 1-time debug hook during boot do add delay that
is later removed. This allows delay to be added at boot without adding any
additional delay (if statements) during the main portion of the code. This is a
horrible kludge, but it fixes the problem.
*/
#ifdef WIN32
if (gModel == MODEL_PC8201 || gModel == MODEL_PC8300)
{
lock_remote();
debug_set_monitor_callback(model_8201_bug_workaround);
gDebugActive++;
unlock_remote();
}
#endif
gExitLoop = 1;
}
/*
========================================================================
emulate: This routine contains the main loop that handles active
emulation and maintenance tasks.
========================================================================
*/
void emulate(void)
{
unsigned int i,j;
unsigned int v;
int nxtmaint=1;
int ins;
starttime=msclock();
lock_remote();
while(!gExitApp)
{
/* Run appropriate emulation loop base on ReMem support */
if (gReMem)
while (!gExitLoop)
{
/* Check for active debug monitor windows */
if (gDebugActive)
{
do_debug_stuff();
if (gExitLoop)
break;
}
/* Instruction emulation contained in header file */
#undef NO_REMEM
#include "cpu.h"
#include "do_instruct.h"
// Check if next inst is SIM
if ((get_memory8(PC) == 0xF3) || ((IM & 0x2A) == 0x20) ||
((IM & 0x4C) == 0x40))
{
check_interrupts();
}
// Check for return from interrupt
if (gIntActive)
{
if (SP == gIntSP)
gIntActive = FALSE;
}
if (gSingleStep)
{
if (!gIntActive)
{
gSingleStep = 0;
}
}
/* Do maintenance tasks (Windows events, interrupts, etc.) */
#ifdef __APPLE__
if(!(--nxtmaint))
#else
if(!(--nxtmaint & 0x3FF))
#endif
{
unlock_remote();
gOsDelay = nxtmaint == 0;
throttle(cycle_delta);
maint();
ser_poll();
check_interrupts();
if (gOsDelay)
nxtmaint=gMaintCount;
lock_remote();
}
#if 0
exec_remem_instruction();
if (gExitLoop)
break;
#endif
}
if (!gReMem)
{
while (!gExitLoop)
{
/* Check for active debug monitor windows */
if (gDebugActive)
{
do_debug_stuff();
if (gExitLoop)
break;
}
/* Instruction emulation contained in header file */
#define NO_REMEM
#include "cpu.h"
#include "do_instruct.h"
// Check if next inst is SIM or RS-232 waiting
if ((get_memory8(PC) == 0xF3) || ((IM & 0x2A) == 0x20) ||
((IM & 0x4C) == 0x40))
{
check_interrupts();
}
// Check for return from interrupt
if (gIntActive)
{
if (SP == gIntSP)
gIntActive = FALSE;
}
if (gSingleStep)
{
if (!gIntActive)
{
gSingleStep = 0;
}
}
/* Do maintenance tasks (Windows events, interrupts, etc.) */
#ifdef __APPLE__
if(!(--nxtmaint))
#else
if(!(--nxtmaint & 0x3FF))
#endif
{
unlock_remote();
gOsDelay = nxtmaint == 0;
throttle(cycle_delta);
maint();
ser_poll();
check_interrupts();
if (gOsDelay)
nxtmaint=gMaintCount;
lock_remote();
}
}
}
gExitLoop = 0;
}
unlock_remote();
}
int cmd_main(int argc, const char **argv)
{
struct transfer_request *request;
struct transfer_request *next_request;
int nr_refspec = 0;
const char **refspec = NULL;
struct remote_lock *ref_lock = NULL;
struct remote_lock *info_ref_lock = NULL;
struct rev_info revs;
int delete_branch = 0;
int force_delete = 0;
int objects_to_send;
int rc = 0;
int i;
int new_refs;
struct ref *ref, *local_refs;
repo = xcalloc(1, sizeof(*repo));
argv++;
for (i = 1; i < argc; i++, argv++) {
const char *arg = *argv;
if (*arg == '-') {
if (!strcmp(arg, "--all")) {
push_all = MATCH_REFS_ALL;
continue;
}
if (!strcmp(arg, "--force")) {
force_all = 1;
continue;
}
if (!strcmp(arg, "--dry-run")) {
dry_run = 1;
continue;
}
if (!strcmp(arg, "--helper-status")) {
helper_status = 1;
continue;
}
if (!strcmp(arg, "--verbose")) {
push_verbosely = 1;
http_is_verbose = 1;
continue;
}
if (!strcmp(arg, "-d")) {
delete_branch = 1;
continue;
}
if (!strcmp(arg, "-D")) {
delete_branch = 1;
force_delete = 1;
continue;
}
if (!strcmp(arg, "-h"))
usage(http_push_usage);
}
if (!repo->url) {
char *path = strstr(arg, "//");
str_end_url_with_slash(arg, &repo->url);
repo->path_len = strlen(repo->url);
if (path) {
repo->path = strchr(path+2, '/');
if (repo->path)
repo->path_len = strlen(repo->path);
}
continue;
}
refspec = argv;
nr_refspec = argc - i;
break;
}
#ifndef USE_CURL_MULTI
die("git-push is not available for http/https repository when not compiled with USE_CURL_MULTI");
#endif
if (!repo->url)
usage(http_push_usage);
if (delete_branch && nr_refspec != 1)
die("You must specify only one branch name when deleting a remote branch");
setup_git_directory();
memset(remote_dir_exists, -1, 256);
http_init(NULL, repo->url, 1);
#ifdef USE_CURL_MULTI
is_running_queue = 0;
#endif
/* Verify DAV compliance/lock support */
if (!locking_available()) {
rc = 1;
goto cleanup;
}
sigchain_push_common(remove_locks_on_signal);
/* Check whether the remote has server info files */
repo->can_update_info_refs = 0;
repo->has_info_refs = remote_exists("info/refs");
repo->has_info_packs = remote_exists("objects/info/packs");
if (repo->has_info_refs) {
info_ref_lock = lock_remote("info/refs", LOCK_TIME);
if (info_ref_lock)
repo->can_update_info_refs = 1;
else {
error("cannot lock existing info/refs");
rc = 1;
goto cleanup;
}
}
if (repo->has_info_packs)
fetch_indices();
/* Get a list of all local and remote heads to validate refspecs */
local_refs = get_local_heads();
fprintf(stderr, "Fetching remote heads...\n");
get_dav_remote_heads();
run_request_queue();
/* Remove a remote branch if -d or -D was specified */
if (delete_branch) {
if (delete_remote_branch(refspec[0], force_delete) == -1) {
fprintf(stderr, "Unable to delete remote branch %s\n",
refspec[0]);
if (helper_status)
printf("error %s cannot remove\n", refspec[0]);
}
goto cleanup;
}
/* match them up */
if (match_push_refs(local_refs, &remote_refs,
nr_refspec, (const char **) refspec, push_all)) {
rc = -1;
goto cleanup;
}
if (!remote_refs) {
fprintf(stderr, "No refs in common and none specified; doing nothing.\n");
if (helper_status)
printf("error null no match\n");
rc = 0;
goto cleanup;
}
new_refs = 0;
for (ref = remote_refs; ref; ref = ref->next) {
struct argv_array commit_argv = ARGV_ARRAY_INIT;
if (!ref->peer_ref)
continue;
if (is_null_oid(&ref->peer_ref->new_oid)) {
if (delete_remote_branch(ref->name, 1) == -1) {
error("Could not remove %s", ref->name);
if (helper_status)
printf("error %s cannot remove\n", ref->name);
rc = -4;
}
else if (helper_status)
printf("ok %s\n", ref->name);
new_refs++;
continue;
}
if (!oidcmp(&ref->old_oid, &ref->peer_ref->new_oid)) {
if (push_verbosely)
fprintf(stderr, "'%s': up-to-date\n", ref->name);
if (helper_status)
printf("ok %s up to date\n", ref->name);
continue;
}
if (!force_all &&
!is_null_oid(&ref->old_oid) &&
!ref->force) {
if (!has_object_file(&ref->old_oid) ||
!ref_newer(&ref->peer_ref->new_oid,
&ref->old_oid)) {
/*
* We do not have the remote ref, or
* we know that the remote ref is not
* an ancestor of what we are trying to
* push. Either way this can be losing
* commits at the remote end and likely
* we were not up to date to begin with.
*/
error("remote '%s' is not an ancestor of\n"
"local '%s'.\n"
"Maybe you are not up-to-date and "
"need to pull first?",
ref->name,
ref->peer_ref->name);
if (helper_status)
printf("error %s non-fast forward\n", ref->name);
rc = -2;
continue;
}
}
oidcpy(&ref->new_oid, &ref->peer_ref->new_oid);
new_refs++;
fprintf(stderr, "updating '%s'", ref->name);
if (strcmp(ref->name, ref->peer_ref->name))
fprintf(stderr, " using '%s'", ref->peer_ref->name);
fprintf(stderr, "\n from %s\n to %s\n",
oid_to_hex(&ref->old_oid), oid_to_hex(&ref->new_oid));
if (dry_run) {
if (helper_status)
printf("ok %s\n", ref->name);
continue;
}
/* Lock remote branch ref */
ref_lock = lock_remote(ref->name, LOCK_TIME);
if (ref_lock == NULL) {
fprintf(stderr, "Unable to lock remote branch %s\n",
ref->name);
if (helper_status)
printf("error %s lock error\n", ref->name);
rc = 1;
continue;
}
/* Set up revision info for this refspec */
argv_array_push(&commit_argv, ""); /* ignored */
argv_array_push(&commit_argv, "--objects");
argv_array_push(&commit_argv, oid_to_hex(&ref->new_oid));
if (!push_all && !is_null_oid(&ref->old_oid))
argv_array_pushf(&commit_argv, "^%s",
oid_to_hex(&ref->old_oid));
init_revisions(&revs, setup_git_directory());
setup_revisions(commit_argv.argc, commit_argv.argv, &revs, NULL);
revs.edge_hint = 0; /* just in case */
/* Generate a list of objects that need to be pushed */
pushing = 0;
if (prepare_revision_walk(&revs))
die("revision walk setup failed");
mark_edges_uninteresting(&revs, NULL);
objects_to_send = get_delta(&revs, ref_lock);
finish_all_active_slots();
/* Push missing objects to remote, this would be a
convenient time to pack them first if appropriate. */
pushing = 1;
if (objects_to_send)
fprintf(stderr, " sending %d objects\n",
objects_to_send);
run_request_queue();
/* Update the remote branch if all went well */
if (aborted || !update_remote(ref->new_oid.hash, ref_lock))
rc = 1;
if (!rc)
fprintf(stderr, " done\n");
if (helper_status)
printf("%s %s\n", !rc ? "ok" : "error", ref->name);
unlock_remote(ref_lock);
check_locks();
argv_array_clear(&commit_argv);
}
/* Update remote server info if appropriate */
if (repo->has_info_refs && new_refs) {
if (info_ref_lock && repo->can_update_info_refs) {
fprintf(stderr, "Updating remote server info\n");
if (!dry_run)
update_remote_info_refs(info_ref_lock);
} else {
fprintf(stderr, "Unable to update server info\n");
}
}
cleanup:
if (info_ref_lock)
unlock_remote(info_ref_lock);
free(repo);
http_cleanup();
request = request_queue_head;
while (request != NULL) {
next_request = request->next;
release_request(request);
request = next_request;
}
return rc;
}
