C++ Continue函数代码示例

void GetScienceAndSensorReading(int idx)
{
  char str[1024];
  printf("=== SCIENCE READING ===\n");
  FillKeyboardBufferString("SCI-OV 32 .READINGS\n");
  Continue();

  sprintf(str, "%i %i SENSE-ADDR 1.5!\n",
    planets[idx].instanceoffset&0xFFFF, planets[idx].instanceoffset>>16
  );
  FillKeyboardBufferString(str);
  Continue();

  FillKeyboardBufferString("AN-OV\n");
  Continue();

  // Patch science level
  Write16(0xedc9, 0x0f30-2); // 1
  Write16(0xedc9+2, 0x1692-2); // EXIT

  printf("=== SENSOR READING ===\n");
  FillKeyboardBufferString("32 (/ANALYSIS)\n");
  Continue();
  fflush(stdout);
}

void GetAtmosphere(int idx)
{
  char str[1024];

  FillKeyboardBufferString("ATMO @ .\n");
  Continue();

  //FillKeyboardBufferString("PLSET-OV ATMO.ACTIVITY @ ATMO.DENSITY [email protected]\n");
  FillKeyboardBufferString("PLSET-OV SURFTYPE [email protected] ATMO @ ATMO.DENSITY [email protected] ATMO.ACTIVITY @\n");
  Continue();
  printf("planet %i x=%3i y=%3i orbit=%i surftype=%i atmo=%2i atmospheric_density=%2i atmospheric_activity=%2i\n",
    idx,
    planets[idx].x,
    planets[idx].y,
    planets[idx].orbit,
    Read16(regsp+8),
    Read16(regsp+6),
    Read16(regsp+4),
    Read16(regsp+2)
  );
  Pop();
  Pop();
  Pop();
  Pop();
}

void introTest(WINDOW *win)
{
    werase(win);
    wmove(win, height / 2 - 5, width / 2);
    wvline(win, ACS_VLINE, 10);
    wmove(win, height / 2, width / 2 - 10);
    whline(win, ACS_HLINE, 20);
    Continue(win);

    beep();
    werase(win);

    box(win, ACS_VLINE, ACS_HLINE);
    wrefresh(win);

    cbreak();
    mvwaddstr(win, 1, 1,
        "You should have a rectangle in the middle of the screen");
    mvwaddstr(win, 2, 1, "You should have heard a beep");
    Continue(win);

    flash();
    mvwaddstr(win, 3, 1, "You should have seen a flash");
    Continue(win);
}

void GetRegions()
{
  FillKeyboardBufferString("BIO\n");
  Continue();

  printf("=== MAPS READING ===\n");
  FillKeyboardBufferString("MAPS- WF4F4\n");
  Continue();

  FillKeyboardBufferString("DPART-OV WF166 OTHER-DELETE\n");
  Continue();
  fflush(stdout);
}

void resizeTest(WINDOW *dummy)
{
    WINDOW *win1;
    int nwidth = 135, nheight = 52;
    int owidth = COLS, oheight = LINES;

    savetty();

    resize_term(nheight, nwidth);

    clear();
    refresh();

    win1 = newwin(10, 50, 14, 25);

    if (win1 == NULL)
    {
        endwin();
        return;
    }

#ifdef A_COLOR
    if (has_colors())
    {
        init_pair(3, COLOR_BLUE, COLOR_WHITE);
        wattrset(win1, COLOR_PAIR(3));
    }

    wclear(win1);
#endif
    mvwaddstr(win1, 0, 0, "The screen may now be resized");
    mvwprintw(win1, 1, 4, "Given size: %d by %d", nwidth, nheight);
    mvwprintw(win1, 2, 4, "Actual size: %d by %d", COLS, LINES);
    Continue(win1);

    wclear(win1);
    resetty();

    mvwaddstr(win1, 0, 0, "The screen should now be reset");
    mvwprintw(win1, 1, 6, "Old size: %d by %d", owidth, oheight);
    mvwprintw(win1, 2, 6, "Size now: %d by %d", COLS, LINES);
    Continue(win1);

    delwin(win1);

    clear();
    refresh();
}

void NodeJSDebugger::OnDebugStart(clDebugEvent& event)
{
    event.Skip();
    CHECK_COND_RET(NodeJSWorkspace::Get()->IsOpen());

    // Our to handle
    event.Skip(false);
    if(m_socket && m_socket->IsConnected()) {
        Continue();
        return;
    };

    NodeJSDebuggerDlg dlg(EventNotifier::Get()->TopFrame(), NodeJSDebuggerDlg::kDebug);
    if(dlg.ShowModal() != wxID_OK) {
        return;
    }

    wxString command = dlg.GetCommand();

    if(!m_node.ExecuteConsole(command, "", false, command)) {
        ::wxMessageBox(_("Failed to start NodeJS application"), "CodeLite", wxOK | wxICON_ERROR | wxCENTER);
        m_socket.Reset(NULL);
    }

    // already connected?
    m_socket.Reset(new NodeJSSocket(this));
    NodeJSWorkspaceUser userConf(NodeJSWorkspace::Get()->GetFilename().GetFullPath());
    userConf.Load();
    m_socket->Connect("127.0.0.1", userConf.GetDebuggerPort());
}

void NodeJSDebugger::OnDebugContinue(clDebugEvent& event)
{
    event.Skip();
    CHECK_RUNNING();
    event.Skip(false);
    Continue();
}

void UnitMng::issueCommands()
{
	if(conUnit)
	{
		//double *inputs,*outputs;
		//inputs=generateInputs();
		generateInputs();
		//outputs=generateOutputs(inputs);
		generateOutputs();
		//Keep Last Command incase of CONTINUE
		lastCommand=act;
		if(outputs[0]>outputs[1]&&outputs[0]>outputs[2])//&&outputs[0]>=outputs[3])
		{
			act=ATTACK;
			attack();
		}
		else if(outputs[1]>outputs[0]&&outputs[1]>outputs[2])//&&outputs[1]>=outputs[3])
		{
			act=MOVE;
			move();
		}
		else if(outputs[2]>outputs[0]&&outputs[2]>outputs[1])//&&outputs[2]>=outputs[3])
		{
			act=HOLD;
			hold();
		}
		else
		{ 
			Continue();
		}
	}

}

void Model::ContinuePauseButton()
{
  if (m_printing)
    Pause();
  else
    Continue();
}

TEST_F(BasicThreadTest, ValidateThreadTimes) {
  AutoCurrentContext ctxt;
  ctxt->Initiate();

  static const size_t spinCount = 10000000;
  auto spinsThenQuits = ctxt->Construct<SpinsAndThenQuits>(spinCount);

  // Instantaneous benchmark on the time it takes to decrement the counter value:
  std::chrono::nanoseconds benchmark;
  {
    auto startTime = std::chrono::high_resolution_clock::now();
    for(volatile size_t i = spinCount; i--;);
    benchmark = std::chrono::high_resolution_clock::now() - startTime;
  }

  // By this point, not much should have happened:
  std::chrono::milliseconds kernelTime;
  std::chrono::milliseconds userTime;
  spinsThenQuits->GetThreadTimes(kernelTime, userTime);

  // Kick off the thread and wait for it to exit:
  spinsThenQuits->Continue();
  ASSERT_TRUE(spinsThenQuits->WaitFor(std::chrono::seconds(10))) << "Spin-then-quit test took too long to execute";

  // Thread should not have been able to complete in less time than we completed, by a factor of ten or so at least
  ASSERT_LE(benchmark, spinsThenQuits->m_userTime * 10) <<
    "Reported execution time could not possibly be correct, spin operation took less time to execute than should have been possible with the CPU";
}

bool Player::SlowMotion(int repeats)
{
	if (input.videoTrack && !isHttp && isPlaying)
	{
		if (isPaused)
		{
			Continue();
		}
		switch (repeats)
		{
			case 2:
			case 4:
			case 8:
			{
				isSlowMotion = true;
				break;
			}
			default:
			{
				repeats = 0;
			}
		}
		output.SlowMotion(repeats);
		return true;
	}
	fprintf(stderr, "[player.cpp] slowmotion not possible\n");
	return false;
}

NS_IMETHODIMP
DOMCursor::Continue()
{
    ErrorResult rv;
    Continue(rv);
    return rv.ErrorCode();
}

NS_IMETHODIMP
DOMCursor::Continue()
{
    ErrorResult rv;
    Continue(rv);
    return rv.StealNSResult();
}

void WindowsService::HandleControlCode(DWORD opcode)
{
  // Handle the requested control code.
  switch(opcode) {
  case SERVICE_CONTROL_STOP:
    // Stop the service.
    status.dwCurrentState= SERVICE_STOP_PENDING;
    Stop();
    break;

  case SERVICE_CONTROL_PAUSE:
    status.dwCurrentState= SERVICE_PAUSE_PENDING;
    Pause();
    break;

  case SERVICE_CONTROL_CONTINUE:
    status.dwCurrentState= SERVICE_CONTINUE_PENDING;
    Continue();
    break;

  case SERVICE_CONTROL_SHUTDOWN:
    Shutdown();
    break;

  case SERVICE_CONTROL_INTERROGATE:
    ReportStatus(status.dwCurrentState);
    break;

  default:
    // invalid control code
    break;
  }
}

void CPDF_ProgressiveRenderer::Start(IFX_Pause* pPause) {
  if (!m_pContext || !m_pDevice || m_Status != Ready) {
    m_Status = Failed;
    return;
  }
  m_Status = ToBeContinued;
  Continue(pPause);
}