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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
//===-- UserInput.cpp - Interpreter Input Loop support --------------------===//
//
// This file implements the interpreter Input I/O loop.
//
//===----------------------------------------------------------------------===//
#include "Interpreter.h"
#include "llvm/Assembly/Writer.h"
#include <algorithm>
enum CommandID {
Quit, Help, // Basics
Print, Info, List, StackTrace, Up, Down, // Inspection
Next, Step, Run, Finish, Call, // Control flow changes
Break, Watch, // Debugging
Load, Flush
};
// CommandTable - Build a lookup table for the commands available to the user...
static struct CommandTableElement {
const char *Name;
enum CommandID CID;
inline bool operator<(const CommandTableElement &E) const {
return string(Name) < string(E.Name);
}
inline bool operator==(const string &S) const {
return string(Name) == S;
}
} CommandTable[] = {
{ "quit" , Quit }, { "q", Quit }, { "", Quit }, // Empty str = eof
{ "help" , Help }, { "h", Help },
{ "print" , Print }, { "p", Print },
{ "list" , List },
{ "info" , Info },
{ "backtrace", StackTrace }, { "bt", StackTrace }, { "where", StackTrace },
{ "up" , Up },
{ "down" , Down },
{ "next" , Next }, { "n", Next },
{ "step" , Step }, { "s", Step },
{ "run" , Run },
{ "finish" , Finish },
{ "call" , Call },
{ "break" , Break }, { "b", Break },
{ "watch" , Watch },
{ "load" , Load },
{ "flush" , Flush },
};
static CommandTableElement *CommandTableEnd =
CommandTable+sizeof(CommandTable)/sizeof(CommandTable[0]);
//===----------------------------------------------------------------------===//
// handleUserInput - Enter the input loop for the interpreter. This function
// returns when the user quits the interpreter.
//
void Interpreter::handleUserInput() {
bool UserQuit = false;
// Sort the table...
sort(CommandTable, CommandTableEnd);
// Print the instruction that we are stopped at...
printCurrentInstruction();
do {
string Command;
cout << "lli> " << flush;
cin >> Command;
CommandTableElement *E = find(CommandTable, CommandTableEnd, Command);
if (E == CommandTableEnd) {
cout << "Error: '" << Command << "' not recognized!\n";
continue;
}
switch (E->CID) {
case Quit: UserQuit = true; break;
case Print:
cin >> Command;
printValue(Command);
break;
case Info:
cin >> Command;
infoValue(Command);
break;
case List: list(); break;
case StackTrace: printStackTrace(); break;
case Up:
if (CurFrame > 0) --CurFrame;
else cout << "Error: Already at root of stack!\n";
break;
case Down:
if ((unsigned)CurFrame < ECStack.size()-1) ++CurFrame;
else cout << "Error: Already at bottom of stack!\n";
break;
case Next: nextInstruction(); break;
case Step: stepInstruction(); break;
case Run: run(); break;
case Finish: finish(); break;
case Call:
cin >> Command;
callMethod(Command); // Enter the specified method
finish(); // Run until it's complete
break;
default:
cout << "Command '" << Command << "' unimplemented!\n";
break;
}
} while (!UserQuit);
}
//===----------------------------------------------------------------------===//
// setBreakpoint - Enable a breakpoint at the specified location
//
void Interpreter::setBreakpoint(const string &Name) {
Value *PickedVal = ChooseOneOption(Name, LookupMatchingNames(Name));
// TODO: Set a breakpoint on PickedVal
}
//===----------------------------------------------------------------------===//
// callMethod - Enter the specified method...
//
bool Interpreter::callMethod(const string &Name) {
vector<Value*> Options = LookupMatchingNames(Name);
for (unsigned i = 0; i < Options.size(); ++i) { // Remove nonmethod matches...
if (!Options[i]->isMethod()) {
Options.erase(Options.begin()+i);
--i;
}
}
Value *PickedMeth = ChooseOneOption(Name, Options);
if (PickedMeth == 0)
return true;
callMethod(PickedMeth->castMethodAsserting()); // Start executing it...
// Reset the current frame location to the top of stack
CurFrame = ECStack.size()-1;
return false;
}
|
