text: /*
   * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
   * Copyright 2011-2016, Rene Gollent, rene@gollent.com.
   * Distributed under the terms of the MIT License.
   */
  #ifndef JOBS_H
  #define JOBS_H
  
  #include <Entry.h>
  #include <kits/support/String.h>
  
  #include <ImageDebugInfoLoadingState.h>
  #include <ImageDebugInfoProvider.h>
  #include <Types.h>
  #include <Worker.h>
  
  
  class Architecture;
  class BVariant;
  class CpuState;
  class DebuggerInterface;
  class ExpressionInfo;
  class ExpressionResult;
  class Function;
  class FunctionInstance;
  class Image;
  class SourceLanguage;
  class StackFrame;
  class StackFrameValues;
  class Team;
  class TeamMemory;
  class TeamMemoryBlock;
  class TeamTypeInformation;
  class Thread;
  class Type;
  class TypeComponentPath;
  class Value;
  class ValueLocation;
  class ValueNode;
  class ValueNodeChild;
  class ValueNodeContainer;
  class ValueNodeManager;
  class Variable;
  
  
  // job types
  enum {
  	JOB_TYPE_GET_THREAD_STATE,
  	JOB_TYPE_GET_CPU_STATE,
  	JOB_TYPE_GET_STACK_TRACE,
  	JOB_TYPE_LOAD_IMAGE_DEBUG_INFO,
  	JOB_TYPE_LOAD_SOURCE_CODE,
  	JOB_TYPE_GET_STACK_FRAME_VALUE,
  	JOB_TYPE_RESOLVE_VALUE_NODE_VALUE,
  	JOB_TYPE_WRITE_VALUE_NODE_VALUE,
  	JOB_TYPE_GET_MEMORY_BLOCK,
  	JOB_TYPE_WRITE_MEMORY,
  	JOB_TYPE_EVALUATE_EXPRESSION,
  	JOB_TYPE_WRITE_CORE_FILE
  };
  
  
  class GetThreadStateJob : public Job {
  public:
  								GetThreadStateJob(
  									DebuggerInterface* debuggerInterface,
  									Thread* thread);
  	virtual						~GetThreadStateJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  private:
  			SimpleJobKey		fKey;
  			DebuggerInterface*	fDebuggerInterface;
  			Thread*				fThread;
  };
  
  
  class GetCpuStateJob : public Job {
  public:
  								GetCpuStateJob(
  									DebuggerInterface* debuggerInterface,
  									::Thread* thread);
  	virtual						~GetCpuStateJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  private:
  			SimpleJobKey		fKey;
  			DebuggerInterface*	fDebuggerInterface;
  			::Thread*			fThread;
  };
  
  
  class GetStackTraceJob : public Job, private ImageDebugInfoProvider {
  public:
  								GetStackTraceJob(
  									DebuggerInterface* debuggerInterface,
  									JobListener* jobListener,
  									Architecture* architecture,
  									::Thread* thread);
  	virtual						~GetStackTraceJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  private:
  	// ImageDebugInfoProvider
  	virtual	status_t			GetImageDebugInfo(Image* image,
  									ImageDebugInfo*& _info);
  
  private:
  			SimpleJobKey		fKey;
  			DebuggerInterface*	fDebuggerInterface;
  			JobListener*		fJobListener;
  			Architecture*		fArchitecture;
  			::Thread*			fThread;
  			CpuState*			fCpuState;
  };
  
  
  class LoadImageDebugInfoJob : public Job {
  public:
  								LoadImageDebugInfoJob(Image* image);
  	virtual						~LoadImageDebugInfoJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  	static	status_t			ScheduleIfNecessary(Worker* worker,
  									Image* image,
  									JobListener* jobListener,
  									ImageDebugInfo** _imageDebugInfo = NULL);
  										// If already loaded returns a
  										// reference, if desired. If not loaded
  										// schedules a job, but does not wait;
  										// returns B_OK and NULL. An error,
  										// if scheduling the job failed, or the
  										// debug info already failed to load
  										// earlier.
  
  			ImageDebugInfoLoadingState*
  									GetLoadingState()
  										{ return &fState; }
  
  private:
  			SimpleJobKey		fKey;
  			Image*				fImage;
  			ImageDebugInfoLoadingState
  								fState;
  };
  
  
  class LoadSourceCodeJob : public Job {
  public:
  								LoadSourceCodeJob(
  									DebuggerInterface* debuggerInterface,
  									Architecture* architecture, Team* team,
  									FunctionInstance* functionInstance,
  									bool loadForFunction);
  	virtual						~LoadSourceCodeJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  private:
  			SimpleJobKey		fKey;
  			DebuggerInterface*	fDebuggerInterface;
  			Architecture*		fArchitecture;
  			Team*				fTeam;
  			FunctionInstance*	fFunctionInstance;
  			bool				fLoadForFunction;
  };
  
  
  class ResolveValueNodeValueJob : public Job {
  public:
  								ResolveValueNodeValueJob(
  									DebuggerInterface* debuggerInterface,
  									Architecture* architecture,
  									CpuState* cpuState,
  									TeamTypeInformation* typeInformation,
  									ValueNodeContainer*	container,
  									ValueNode* valueNode);
  	virtual						~ResolveValueNodeValueJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  private:
  			status_t			_ResolveNodeValue();
  			status_t			_ResolveNodeChildLocation(
  									ValueNodeChild* nodeChild);
  			status_t			_ResolveParentNodeValue(ValueNode* parentNode);
  
  
  private:
  			SimpleJobKey		fKey;
  			DebuggerInterface*	fDebuggerInterface;
  			Architecture*		fArchitecture;
  			CpuState*			fCpuState;
  			TeamTypeInformation*
  								fTypeInformation;
  			ValueNodeContainer*	fContainer;
  			ValueNode*			fValueNode;
  };
  
  
  class WriteValueNodeValueJob : public Job {
  public:
  								WriteValueNodeValueJob(
  									DebuggerInterface* debuggerInterface,
  									Architecture* architecture,
  									CpuState* cpuState,
  									TeamTypeInformation* typeInformation,
  									ValueNode* valueNode,
  									Value* newValue);
  	virtual						~WriteValueNodeValueJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  private:
  			SimpleJobKey		fKey;
  			DebuggerInterface*	fDebuggerInterface;
  			Architecture*		fArchitecture;
  			CpuState*			fCpuState;
  			TeamTypeInformation*
  								fTypeInformation;
  			ValueNode*			fValueNode;
  			Value*				fNewValue;
  };
  
  
  class RetrieveMemoryBlockJob : public Job {
  public:
  								RetrieveMemoryBlockJob(Team* team,
  									TeamMemory* teamMemory,
  									TeamMemoryBlock* memoryBlock);
  	virtual						~RetrieveMemoryBlockJob();
  
  	virtual const JobKey&		Key() const;
  	virtual status_t			Do();
  
  private:
  			SimpleJobKey		fKey;
  			Team*				fTeam;
  			TeamMemory*			fTeamMemory;
  			TeamMemoryBlock*	fMemoryBlock;
  };
  
  
  class WriteMemoryJob : public Job {
  public:
  								WriteMemoryJob(Team* team,
  									TeamMemory* teamMemory,
  									target_addr_t address, void* data,
  									target_size_t size);
  	virtual						~WriteMemoryJob();
  
  	virtual const JobKey&		Key() const;
  	virtual status_t			Do();
  
  private:
  			SimpleJobKey		fKey;
  			Team*				fTeam;
  			TeamMemory*			fTeamMemory;
  			target_addr_t		fTargetAddress;
  			void*				fData;
  			target_size_t		fSize;
  };
  
  
  class ExpressionEvaluationJob : public Job {
  public:
  								ExpressionEvaluationJob(Team* team,
  									DebuggerInterface* debuggerInterface,
  									SourceLanguage* language,
  									ExpressionInfo* info,
  									StackFrame* frame,
  									Thread* thread);
  	virtual						~ExpressionEvaluationJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  			ExpressionResult*	GetResult() const { return fResultValue; }
  
  private:
  			status_t			ResolveNodeValue(ValueNode* node);
  
  private:
  			SimpleJobKey		fKey;
  			Team*				fTeam;
  			DebuggerInterface*	fDebuggerInterface;
  			Architecture*		fArchitecture;
  			TeamTypeInformation* fTypeInformation;
  			SourceLanguage*		fLanguage;
  			ExpressionInfo*		fExpressionInfo;
  			StackFrame*			fFrame;
  			Thread*				fThread;
  			ValueNodeManager*	fManager;
  			ExpressionResult*	fResultValue;
  };
  
  
  class WriteCoreFileJob : public Job {
  public:
  								WriteCoreFileJob(Team* team,
  									DebuggerInterface* debuggerInterface,
  									const entry_ref& targetPath);
  	virtual						~WriteCoreFileJob();
  
  	virtual	const JobKey&		Key() const;
  	virtual	status_t			Do();
  
  private:
  			SimpleJobKey		fKey;
  			Team*				fTeam;
  			DebuggerInterface*	fDebuggerInterface;
  			entry_ref			fTargetPath;
  };
  
  
  #endif	// JOBS_H
  