C++ Thread::State方法代码示例

bool
CommandLineUserInterface::_ReportTargetThreadStopNeeded() const
{
	if (fReportTargetThread < 0)
		return false;

	Team* team = fContext.GetTeam();
	AutoLocker<Team> teamLocker(team);
	Thread* thread = team->ThreadByID(fReportTargetThread);
	if (thread == NULL)
		return false;

	return thread->State() != THREAD_STATE_STOPPED;
}

	virtual bool GetToolTipForTableCell(int32 rowIndex, int32 columnIndex,
		BToolTip** _tip)
	{
		Thread* thread = fThreads.ItemAt(rowIndex);
		if (thread == NULL)
			return false;

		BString text;
		text << "Thread: \"" << thread->Name() << "\" (" << thread->ID()
			<< ")\n";

		switch (thread->State()) {
			case THREAD_STATE_RUNNING:
				text << "Running";
				break;
			case THREAD_STATE_STOPPED:
			{
				switch (thread->StoppedReason()) {
					case THREAD_STOPPED_DEBUGGER_CALL:
						text << "Called debugger(): "
							<< thread->StoppedReasonInfo();
						break;
					case THREAD_STOPPED_EXCEPTION:
						text << "Caused exception: "
							<< thread->StoppedReasonInfo();
						break;
					case THREAD_STOPPED_BREAKPOINT:
					case THREAD_STOPPED_WATCHPOINT:
					case THREAD_STOPPED_SINGLE_STEP:
					case THREAD_STOPPED_DEBUGGED:
					case THREAD_STOPPED_UNKNOWN:
					default:
						text << "Stopped for debugging";
						break;
				}
				break;
			}
			case THREAD_STATE_UNKNOWN:
			default:
				text << "Current State Unknown";
				break;
		}

		BTextToolTip* tip = new(std::nothrow) BTextToolTip(text);
		if (tip == NULL)
			return false;

		*_tip = tip;
		return true;
	}

	virtual bool GetValueAt(int32 rowIndex, int32 columnIndex, BVariant& value)
	{
		Thread* thread = fThreads.ItemAt(rowIndex);
		if (thread == NULL)
			return false;

		switch (columnIndex) {
			case 0:
				value.SetTo(thread->ID());
				return true;
			case 1:
			{
				switch (thread->State()) {
					case THREAD_STATE_RUNNING:
						value.SetTo("Running", B_VARIANT_DONT_COPY_DATA);
						return true;
					case THREAD_STATE_STOPPED:
						break;
					case THREAD_STATE_UNKNOWN:
					default:
						value.SetTo("?", B_VARIANT_DONT_COPY_DATA);
						return true;
				}

				// thread is stopped -- get the reason
				switch (thread->StoppedReason()) {
					case THREAD_STOPPED_DEBUGGER_CALL:
						value.SetTo("Call", B_VARIANT_DONT_COPY_DATA);
						return true;
					case THREAD_STOPPED_EXCEPTION:
						value.SetTo("Exception", B_VARIANT_DONT_COPY_DATA);
						return true;
					case THREAD_STOPPED_BREAKPOINT:
					case THREAD_STOPPED_WATCHPOINT:
					case THREAD_STOPPED_SINGLE_STEP:
					case THREAD_STOPPED_DEBUGGED:
					case THREAD_STOPPED_UNKNOWN:
					default:
						value.SetTo("Debugged", B_VARIANT_DONT_COPY_DATA);
						return true;
				}
			}
			case 2:
				value.SetTo(thread->Name(), B_VARIANT_DONT_COPY_DATA);
				return true;
			default:
				return false;
		}
	}

void
CommandLineUserInterface::ThreadStateChanged(const Team::ThreadEvent& event)
{
	if (fSaveReport) {
		Thread* thread = event.GetThread();
		// If we were asked to attach/report on a specific thread
		// rather than a team, and said thread was still
		// running, when we attached, we need to wait for its corresponding
		// stop state before generating a report, else we might not get its
		// stack trace.
		if (thread->ID() == fReportTargetThread
			&& thread->State() == THREAD_STATE_STOPPED) {
			_SubmitSaveReport();
		}
	}
}

void
CliStackTraceCommand::Execute(int argc, const char* const* argv,
	CliContext& context)
{
	// get the current thread
	Team* team = context.GetTeam();
	AutoLocker<Team> teamLocker(team);
	Thread* thread = context.CurrentThread();
	if (thread == NULL) {
		printf("no current thread\n");
		return;
	}

	if (thread->State() != THREAD_STATE_STOPPED) {
		printf("Current thread is not stopped. Can't get stack trace.\n");
		return;
	}

	// get its stack trace
	StackTrace* stackTrace = thread->GetStackTrace();
	while (stackTrace == NULL) {
		context.WaitForEvents(CliContext::EVENT_THREAD_STACK_TRACE_CHANGED);
		if (context.IsTerminating())
			return;
		stackTrace = thread->GetStackTrace();
	}
	BReference<StackTrace> stackTraceReference(stackTrace);
		// hold a reference until we're done

	teamLocker.Unlock();

	// print the stack trace
	int32 frameCount = stackTrace->CountFrames();
	for (int32 i = 0; i < frameCount; i++) {
		StackFrame* frame = stackTrace->FrameAt(i);
		printf("%3" B_PRId32 "  %#" B_PRIx64 "  %#" B_PRIx64, i,
			(uint64)frame->FrameAddress(), (uint64)frame->InstructionPointer());

		char functionName[512];
		UiUtils::FunctionNameForFrame(frame, functionName,
			sizeof(functionName));
		printf("  %s\n", functionName);
	}
}