1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
//===-- RNBContext.h --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Created by Greg Clayton on 12/12/07.
//
//===----------------------------------------------------------------------===//
#ifndef __RNBContext_h__
#define __RNBContext_h__
#include "RNBDefs.h"
#include "DNBError.h"
#include "PThreadEvent.h"
#include <vector>
#include <string>
class RNBContext
{
public:
enum
{
event_proc_state_changed = 0x01,
event_proc_thread_running = 0x02, // Sticky
event_proc_thread_exiting = 0x04,
event_proc_stdio_available = 0x08,
event_read_packet_available = 0x10,
event_read_thread_running = 0x20, // Sticky
event_read_thread_exiting = 0x40,
normal_event_bits = event_proc_state_changed |
event_proc_thread_exiting |
event_proc_stdio_available |
event_read_packet_available |
event_read_thread_exiting,
sticky_event_bits = event_proc_thread_running |
event_read_thread_running,
all_event_bits = sticky_event_bits | normal_event_bits
} event_t;
//------------------------------------------------------------------
// Constructors and Destructors
//------------------------------------------------------------------
RNBContext () :
m_pid(INVALID_NUB_PROCESS),
m_pid_stop_count(0),
m_events(0, all_event_bits),
m_pid_pthread(),
m_launch_status(),
m_arg_vec (),
m_env_vec ()
{
}
virtual ~RNBContext();
nub_process_t ProcessID() const { return m_pid; }
bool HasValidProcessID() const { return m_pid != INVALID_NUB_PROCESS; }
void SetProcessID (nub_process_t pid);
nub_size_t GetProcessStopCount () const { return m_pid_stop_count; }
bool SetProcessStopCount (nub_size_t count)
{
// Returns true if this class' notion of the PID state changed
if (m_pid_stop_count == count)
return false; // Didn't change
m_pid_stop_count = count;
return true; // The stop count has changed.
}
bool ProcessStateRunning() const;
PThreadEvent& Events( ) { return m_events; }
nub_event_t AllEventBits() const { return all_event_bits; }
nub_event_t NormalEventBits() const { return normal_event_bits; }
nub_event_t StickyEventBits() const { return sticky_event_bits; }
const char* EventsAsString (nub_event_t events, std::string& s);
int ArgumentCount () const { return m_arg_vec.size(); }
const char * ArgumentAtIndex (int index);
void PushArgument (const char *arg) { if (arg) m_arg_vec.push_back (arg); }
void ClearArgv () { m_arg_vec.erase (m_arg_vec.begin(), m_arg_vec.end()); }
int EnvironmentCount () const { return m_env_vec.size(); }
const char * EnvironmentAtIndex (int index);
void PushEnvironment (const char *arg) { if (arg) m_env_vec.push_back (arg); }
void ClearEnvironment () { m_env_vec.erase (m_env_vec.begin(), m_env_vec.end()); }
DNBError& LaunchStatus () { return m_launch_status; }
const char * LaunchStatusAsString (std::string& s);
nub_launch_flavor_t LaunchFlavor () const { return m_launch_flavor; }
void SetLaunchFlavor (nub_launch_flavor_t flavor) { m_launch_flavor = flavor; }
protected:
//------------------------------------------------------------------
// Classes that inherit from RNBContext can see and modify these
//------------------------------------------------------------------
nub_process_t m_pid;
nub_size_t m_pid_stop_count;
PThreadEvent m_events; // Threaded events that we can wait for
pthread_t m_pid_pthread;
nub_launch_flavor_t m_launch_flavor; // How to launch our inferior process
DNBError m_launch_status; // This holds the status from the last launch attempt.
std::vector<std::string> m_arg_vec;
std::vector<std::string> m_env_vec; // This will be unparsed - entries FOO=value
void StartProcessStatusThread();
void StopProcessStatusThread();
static void* ThreadFunctionProcessStatus(void *arg);
private:
//------------------------------------------------------------------
// Outlaw copy and assignment operators
//------------------------------------------------------------------
RNBContext(const RNBContext& rhs);
RNBContext& operator=(const RNBContext& rhs);
};
#endif // #ifndef __RNBContext_h__
|
