void Runtime::Debugger::ProcessSrc(Load* load) {
if(interpreter) {
wcout << L"unable to modify source path while program is running." << endl;
return;
}
if(FileExists(program_file, true) && DirectoryExists(load->GetFileName())) {
ClearProgram();
base_path = load->GetFileName();
#ifdef _WIN32
if(base_path.size() > 0 && base_path[base_path.size() - 1] != '\\') {
base_path += '\\';
}
#else
if(base_path.size() > 0 && base_path[base_path.size() - 1] != '/') {
base_path += '/';
}
#endif
wcout << L"source files: path='" << base_path << L"'" << endl << endl;
}
else {
wcout << L"unable to locate base path." << endl;
is_error = true;
}
}
void Runtime::Debugger::Debug() {
wcout << L"-------------------------------------" << endl;
wcout << L"Objeck " << VERSION_STRING << L" - Interactive Debugger" << endl;
wcout << L"-------------------------------------" << endl << endl;
if(FileExists(program_file, true) && DirectoryExists(base_path)) {
wcout << L"loaded executable: file='" << program_file << L"'" << endl;
wcout << L"source files: path='" << base_path << L"'" << endl << endl;
// clear arguments
arguments.clear();
arguments.push_back(L"obr");
arguments.push_back(program_file);
}
else {
wcerr << L"unable to load executable or locate base path." << endl;
exit(1);
}
// enter feedback loop
ClearProgram();
wcout << L"> ";
while(true) {
wstring line;
getline(wcin, line);
if(line.size() > 0) {
ProcessCommand(line);
wcout << L"> ";
}
}
}
void Runtime::Debugger::ProcessRun() {
if(program_file.size() > 0) {
// process program parameters
const int argc = arguments.size();
wchar_t** argv = new wchar_t*[argc];
for(int i = 0; i < argc; i++) {
#ifdef _WIN32
argv[i] = _wcsdup(arguments[i].c_str());
#else
argv[i] = wcsdup(arguments[i].c_str());
#endif
}
// envoke loader
Loader loader(argc, argv);
loader.Load();
cur_program = loader.GetProgram();
// execute
op_stack = new long[CALC_STACK_SIZE];
stack_pos = new long;
(*stack_pos) = 0;
#ifdef _TIMING
long start = clock();
#endif
interpreter = new Runtime::StackInterpreter(cur_program, this);
interpreter->Execute(op_stack, stack_pos, 0, cur_program->GetInitializationMethod(), NULL, false);
#ifdef _TIMING
wcout << L"# final stack: pos=" << (*stack_pos) << L" #" << endl;
wcout << L"---------------------------" << endl;
wcout << L"Time: " << (float)(clock() - start) / CLOCKS_PER_SEC
<< L" second(s)." << endl;
#endif
#ifdef _DEBUG
wcout << L"# final stack: pos=" << (*stack_pos) << L" #" << endl;
#endif
// clear old program
for(int i = 0; i < argc; i++) {
wchar_t* param = argv[i];
free(param);
param = NULL;
}
delete[] argv;
argv = NULL;
ClearProgram();
}
else {
wcout << L"program file not specified." << endl;
}
}
GLvoid CGLES3Context::CreateProgramObject(GLuint progId)
{
CProgramObj *pProgram = FindProgram(progId);
if (pProgram)
{
ClearProgram(pProgram);
return;
}
pProgram = new CProgramObj(progId);
if (pProgram)
{
programMap.insert(std::make_pair(progId, pProgram));
}
else
{
Abort("Cannot allocate program object.\n");
}
}
void Runtime::Debugger::ProcessExe(Load* load) {
if(interpreter) {
wcout << L"unable to load executable while program is running." << endl;
return;
}
if(FileExists(load->GetFileName(), true) && DirectoryExists(base_path)) {
// clear program
ClearProgram();
ClearBreaks();
program_file = load->GetFileName();
// reset arguments
arguments.clear();
arguments.push_back(L"obr");
arguments.push_back(program_file);
wcout << L"loaded executable: file='" << program_file << L"'" << endl;
}
else {
wcout << L"program file doesn't exist." << endl;
is_error = true;
}
}
Command* Runtime::Debugger::ProcessCommand(const wstring &line) {
#ifdef _DEBUG
wcout << L"input: |" << line << L"|" << endl;
#endif
// parser input
is_next = is_next_line = false;
Parser parser;
Command* command = parser.Parse(L"?" + line);
if(command) {
switch(command->GetCommandType()) {
case EXE_COMMAND:
ProcessExe(static_cast<Load*>(command));
break;
case SRC_COMMAND:
ProcessSrc(static_cast<Load*>(command));
break;
case ARGS_COMMAND:
ProcessArgs(static_cast<Load*>(command));
break;
case QUIT_COMMAND:
ClearBreaks();
ClearProgram();
wcout << L"goodbye." << endl;
exit(0);
break;
case LIST_COMMAND: {
FilePostion* file_pos = static_cast<FilePostion*>(command);
wstring file_name;
if(file_pos->GetFileName().size() > 0) {
file_name = file_pos->GetFileName();
}
else {
file_name = cur_file_name;
}
int line_num;
if(file_pos->GetLineNumber() > 0) {
line_num = file_pos->GetLineNumber();
}
else {
line_num = cur_line_num;
}
const wstring &path = base_path + file_name;
if(FileExists(path) && line_num > 0) {
SourceFile src_file(path, cur_line_num);
if(!src_file.Print(line_num)) {
wcout << L"invalid line number." << endl;
is_error = true;
}
}
else {
wcout << L"source file or line number doesn't exist, ensure the program is running." << endl;
is_error = true;
}
}
break;
case BREAK_COMMAND:
ProcessBreak(static_cast<FilePostion*>(command));
break;
case BREAKS_COMMAND:
ProcessBreaks();
break;
case PRINT_COMMAND:
ProcessPrint(static_cast<Print*>(command));
break;
case RUN_COMMAND:
if(!cur_program) {
ProcessRun();
}
else {
wcout << L"instance already running." << endl;
is_error = true;
}
break;
case CLEAR_COMMAND: {
wcout << L" are sure you want to clear all breakpoints? [y/n] ";
wstring line;
getline(wcin, line);
if(line == L"y" || line == L"yes") {
ClearBreaks();
}
}
break;
case DELETE_COMMAND:
ProcessDelete(static_cast<FilePostion*>(command));
break;
case NEXT_COMMAND:
if(interpreter) {
is_next = true;
}
else {
wcout << L"program is not running." << endl;
}
break;
case NEXT_LINE_COMMAND:
if(interpreter) {
is_next_line = true;
}
else {
wcout << L"program is not running." << endl;
}
break;
case JUMP_OUT_COMMAND:
if(interpreter) {
is_jmp_out = true;
}
else {
wcout << L"program is not running." << endl;
}
break;
case CONT_COMMAND:
if(!interpreter) {
wcout << L"program is not running." << endl;
}
cur_line_num = -2;
break;
case INFO_COMMAND:
ProcessInfo(static_cast<Info*>(command));
break;
case STACK_COMMAND:
if(interpreter) {
wcout << L"stack:" << endl;
StackMethod* method = cur_frame->method;
wcerr << L" frame: pos=" << cur_call_stack_pos << L", class=" << method->GetClass()->GetName()
<< L", method=" << PrintMethod(method);
const long ip = cur_frame->ip;
if(ip > -1) {
StackInstr* instr = cur_frame->method->GetInstruction(ip);
wcerr << L", file=" << method->GetClass()->GetFileName() << L":" << instr->GetLineNumber() << endl;
}
else {
wcerr << endl;
}
long pos = cur_call_stack_pos - 1;
do {
StackMethod* method = cur_call_stack[pos]->method;
wcerr << L" frame: pos=" << pos << L", class=" << method->GetClass()->GetName()
<< L", method=" << PrintMethod(method);
const long ip = cur_call_stack[pos]->ip;
if(ip > -1) {
StackInstr* instr = cur_call_stack[pos]->method->GetInstruction(ip);
wcerr << L", file=" << method->GetClass()->GetFileName() << L":" << instr->GetLineNumber() << endl;
}
else {
wcerr << endl;
}
}
while(--pos);
}
else {
wcout << L"program is not running." << endl;
}
break;
default:
break;
}
is_error = false;
ref_mem = NULL;
return command;
}
else {
wcout << L"-- Unable to process command --" << endl;
}
is_error = false;
ref_mem = NULL;
return NULL;
}
