Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/types.c | 37 +++++++++++++++++++++---------------- 1 file changed, 21 insertions(+), 16 deletions(-)
diff --git a/programs/winedbg/types.c b/programs/winedbg/types.c index 5e9188ccc6e..0ee6ab05f0f 100644 --- a/programs/winedbg/types.c +++ b/programs/winedbg/types.c @@ -519,24 +519,29 @@ void print_value(const struct dbg_lvalue* lvalue, char format, int level) count = 1; size = 1; types_get_info(&type, TI_GET_COUNT, &count); types_get_info(&type, TI_GET_LENGTH, &size); + lvalue_field = *lvalue; + types_get_info(&lvalue_field.type, TI_GET_TYPE, &lvalue_field.type.id); + types_get_real_type(&lvalue_field.type, &tag);
- if (size == count) - { - unsigned len; - char buffer[256]; - /* - * Special handling for character arrays. - */ - /* FIXME should check basic type here (should be a char!!!!)... */ - len = min(count, sizeof(buffer)); - memory_get_string(dbg_curr_process, - memory_to_linear_addr(&lvalue->addr), - lvalue->cookie == DLV_TARGET, TRUE, buffer, len); - dbg_printf(""%s%s"", buffer, (len < count) ? "..." : ""); - break; + if (size == count && tag == SymTagBaseType) + { + DWORD basetype; + + types_get_info(&lvalue_field.type, TI_GET_BASETYPE, &basetype); + if (basetype == btChar) + { + char buffer[256]; + /* + * Special handling for character arrays. + */ + unsigned len = min(count, sizeof(buffer)); + memory_get_string(dbg_curr_process, + memory_to_linear_addr(&lvalue->addr), + lvalue->cookie == DLV_TARGET, TRUE, buffer, len); + dbg_printf(""%s%s"", buffer, (len < count) ? "..." : ""); + break; + } } - lvalue_field = *lvalue; - types_get_info(&type, TI_GET_TYPE, &lvalue_field.type.id); dbg_printf("{"); for (i = 0; i < count; i++) {
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/debug.l | 1 + 1 file changed, 1 insertion(+)
diff --git a/programs/winedbg/debug.l b/programs/winedbg/debug.l index 875688f774f..3c9acc5fe60 100644 --- a/programs/winedbg/debug.l +++ b/programs/winedbg/debug.l @@ -138,6 +138,7 @@ STRING "[^\n"]+" if (!dbg_num_processes() && YYSTATE == INITIAL) {BEGIN(NOPROCESS);}
<<EOF>> { return tEOF; } +<*>"#"[^\n]* /* Skip comments */ <*>\n { BEGIN(INITIAL); syntax_error = 0; return tEOL; } /* Indicates end of command. Reset state. */
introduce struct parser_context to store parsing related information
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/dbg.y | 41 +++++++++++++++++++++++++---------------- programs/winedbg/debugger.h | 4 ++-- programs/winedbg/tgt_active.c | 6 +++--- programs/winedbg/winedbg.c | 8 +++++--- 4 files changed, 35 insertions(+), 24 deletions(-)
diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index 3b206342946..2106b8414e8 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -452,8 +452,15 @@ static LONG WINAPI wine_dbg_cmd(EXCEPTION_POINTERS *eptr) return EXCEPTION_EXECUTE_HANDLER; }
-static HANDLE dbg_parser_input; -static HANDLE dbg_parser_output; +struct parser_context +{ + const char* filename; + HANDLE input; + HANDLE output; + unsigned line_no; +}; + +static struct parser_context dbg_parser = {NULL, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, 0};
int input_fetch_entire_line(const char* pfx, char** line) { @@ -465,15 +472,16 @@ int input_fetch_entire_line(const char* pfx, char** line) /* as of today, console handles can be file handles... so better use file APIs rather than * console's */ - WriteFile(dbg_parser_output, pfx, strlen(pfx), &nread, NULL); + WriteFile(dbg_parser.output, pfx, strlen(pfx), &nread, NULL);
buffer = HeapAlloc(GetProcessHeap(), 0, alloc = 16); assert(buffer != NULL);
+ dbg_parser.line_no++; len = 0; do { - if (!ReadFile(dbg_parser_input, &ch, 1, &nread, NULL) || nread == 0) + if (!ReadFile(dbg_parser.input, &ch, 1, &nread, NULL) || nread == 0) { HeapFree(GetProcessHeap(), 0, buffer); return -1; @@ -513,25 +521,25 @@ int input_read_line(const char* pfx, char* buf, int size) * * Debugger command line parser */ -void parser_handle(HANDLE input) +void parser_handle(const char* filename, HANDLE input) { - BOOL ret_ok; - HANDLE in_copy = dbg_parser_input; - HANDLE out_copy = dbg_parser_output; + BOOL ret_ok; + struct parser_context prev = dbg_parser;
ret_ok = FALSE;
if (input != INVALID_HANDLE_VALUE) { - dbg_parser_output = INVALID_HANDLE_VALUE; - dbg_parser_input = input; + dbg_parser.output = INVALID_HANDLE_VALUE; + dbg_parser.input = input; } else { - dbg_parser_output = GetStdHandle(STD_OUTPUT_HANDLE); - dbg_parser_input = GetStdHandle(STD_INPUT_HANDLE); + dbg_parser.output = GetStdHandle(STD_OUTPUT_HANDLE); + dbg_parser.input = GetStdHandle(STD_INPUT_HANDLE); } - + dbg_parser.line_no = 0; + dbg_parser.filename = filename; do { __TRY @@ -547,8 +555,7 @@ void parser_handle(HANDLE input) lexeme_flush(); } while (!ret_ok);
- dbg_parser_input = in_copy; - dbg_parser_output = out_copy; + dbg_parser = prev; }
static void parser(const char* filename) @@ -556,13 +563,15 @@ static void parser(const char* filename) HANDLE h = CreateFileA(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0L, 0); if (h != INVALID_HANDLE_VALUE) { - parser_handle(h); + parser_handle(filename, h); CloseHandle(h); } }
static int dbg_error(const char* s) { + if (dbg_parser.filename) + dbg_printf("%s:%d:", dbg_parser.filename, dbg_parser.line_no); dbg_printf("%s\n", s); return 0; } diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index 28126c28930..8180488d1e5 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -309,7 +309,7 @@ extern HANDLE display_crash_details(HANDLE event); extern int msgbox_res_id(HWND hwnd, UINT textId, UINT captionId, UINT uType);
/* dbg.y */ -extern void parser_handle(HANDLE); +extern void parser_handle(const char*, HANDLE); extern int input_read_line(const char* pfx, char* buffer, int size); extern int input_fetch_entire_line(const char* pfx, char** line); extern HANDLE WINAPIV parser_generate_command_file(const char*, ...); @@ -476,7 +476,7 @@ extern void dbg_del_thread(struct dbg_thread* t); extern BOOL dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade); extern BOOL dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD_PTR base, DWORD size); extern void dbg_set_option(const char*, const char*); -extern void dbg_start_interactive(HANDLE hFile); +extern void dbg_start_interactive(const char*, HANDLE hFile); extern void dbg_init_console(void);
/* gdbproxy.c */ diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 2fd05df39d9..2a2af67debe 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -865,7 +865,7 @@ enum dbg_start dbg_active_auto(int argc, char* argv[]) case ID_DEBUG: AllocConsole(); dbg_init_console(); - dbg_start_interactive(INVALID_HANDLE_VALUE); + dbg_start_interactive(NULL, INVALID_HANDLE_VALUE); return start_ok; case ID_DETAILS: event = CreateEventW( NULL, TRUE, FALSE, NULL ); @@ -882,7 +882,7 @@ enum dbg_start dbg_active_auto(int argc, char* argv[]) dbg_active_wait_for_first_exception();
dbg_interactiveP = TRUE; - parser_handle(input); + parser_handle(NULL, input); output_system_info();
if (output != INVALID_HANDLE_VALUE) @@ -963,7 +963,7 @@ enum dbg_start dbg_active_minidump(int argc, char* argv[]) dbg_active_wait_for_first_exception();
dbg_interactiveP = TRUE; - parser_handle(hFile); + parser_handle(NULL, hFile);
return start_ok; } diff --git a/programs/winedbg/winedbg.c b/programs/winedbg/winedbg.c index 55801536a79..659ca364544 100644 --- a/programs/winedbg/winedbg.c +++ b/programs/winedbg/winedbg.c @@ -562,7 +562,7 @@ static int dbg_winedbg_usage(BOOL advanced) return 0; }
-void dbg_start_interactive(HANDLE hFile) +void dbg_start_interactive(const char* filename, HANDLE hFile) { struct dbg_process* p; struct dbg_process* p2; @@ -574,7 +574,7 @@ void dbg_start_interactive(HANDLE hFile) }
dbg_interactiveP = TRUE; - parser_handle(hFile); + parser_handle(filename, hFile);
LIST_FOR_EACH_ENTRY_SAFE(p, p2, &dbg_process_list, struct dbg_process, entry) p->process_io->close_process(p, FALSE); @@ -624,6 +624,7 @@ int main(int argc, char** argv) int retv = 0; HANDLE hFile = INVALID_HANDLE_VALUE; enum dbg_start ds; + const char* filename = NULL;
/* Initialize the output */ dbg_houtput = GetStdHandle(STD_OUTPUT_HANDLE); @@ -688,6 +689,7 @@ int main(int argc, char** argv) if (!strcmp(argv[0], "--file") && argc > 1) { argc--; argv++; + filename = argv[0]; hFile = CreateFileA(argv[0], GENERIC_READ|DELETE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if (hFile == INVALID_HANDLE_VALUE) @@ -718,7 +720,7 @@ int main(int argc, char** argv)
restart_if_wow64();
- dbg_start_interactive(hFile); + dbg_start_interactive(filename, hFile);
return 0; }
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/dbg.y | 47 ++++++++++++++++++++++++++++++++++++++++++- programs/winedbg/debug.l | 47 +------------------------------------------ programs/winedbg/debugger.h | 2 +- 3 files changed, 48 insertions(+), 48 deletions(-)
diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index 2106b8414e8..ace29039753 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -462,7 +462,7 @@ struct parser_context
static struct parser_context dbg_parser = {NULL, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, 0};
-int input_fetch_entire_line(const char* pfx, char** line) +static int input_fetch_entire_line(const char* pfx, char** line) { char* buffer; char ch; @@ -501,6 +501,51 @@ int input_fetch_entire_line(const char* pfx, char** line) return len; }
+size_t input_lex_read_buffer(char* buf, int size) +{ + int len; + static char* last_line = NULL; + static size_t last_line_idx = 0; + + /* try first to fetch the remaining of an existing line */ + if (last_line_idx == 0) + { + char* tmp = NULL; + /* no remaining chars to be read from last line, grab a brand new line up to '\n' */ + lexeme_flush(); + len = input_fetch_entire_line("Wine-dbg>", &tmp); + if (len < 0) return 0; /* eof */ + + /* remove carriage return in newline */ + if (len >= 2 && tmp[len - 2] == '\r') + { + tmp[len - 2] = '\n'; + tmp[len - 1] = '\0'; + len--; + } + + /* FIXME: should have a pair of buffers, and switch between the two, instead of + * reallocating a new one for each line + */ + if (last_line && (len == 0 || (len == 1 && tmp[0] == '\n'))) + { + HeapFree(GetProcessHeap(), 0, tmp); + } + else + { + HeapFree(GetProcessHeap(), 0, last_line); + last_line = tmp; + } + } + + len = min(strlen(last_line + last_line_idx), size - 1); + memcpy(buf, last_line + last_line_idx, len); + buf[len] = '\0'; + if ((last_line_idx += len) >= strlen(last_line)) + last_line_idx = 0; + return len; +} + int input_read_line(const char* pfx, char* buf, int size) { char* line = NULL; diff --git a/programs/winedbg/debug.l b/programs/winedbg/debug.l index 3c9acc5fe60..a497f34e6b0 100644 --- a/programs/winedbg/debug.l +++ b/programs/winedbg/debug.l @@ -60,53 +60,8 @@ void lexeme_flush(void) next_lexeme = 0; }
-static size_t read_input(const char* pfx, char* buf, int size) -{ - int len; - static char* last_line = NULL; - static size_t last_line_idx = 0; - - /* try first to fetch the remaining of an existing line */ - if (last_line_idx == 0) - { - char* tmp = NULL; - /* no remaining chars to be read from last line, grab a brand new line up to '\n' */ - lexeme_flush(); - len = input_fetch_entire_line(pfx, &tmp); - if (len < 0) return 0; /* eof */ - - /* remove carriage return in newline */ - if (len >= 2 && tmp[len - 2] == '\r') - { - tmp[len - 2] = '\n'; - tmp[len - 1] = '\0'; - len--; - } - - /* FIXME: should have a pair of buffers, and switch between the two, instead of - * reallocating a new one for each line - */ - if (last_line && (len == 0 || (len == 1 && tmp[0] == '\n'))) - { - HeapFree(GetProcessHeap(), 0, tmp); - } - else - { - HeapFree(GetProcessHeap(), 0, last_line); - last_line = tmp; - } - } - - len = min(strlen(last_line + last_line_idx), size - 1); - memcpy(buf, last_line + last_line_idx, len); - buf[len] = '\0'; - if ((last_line_idx += len) >= strlen(last_line)) - last_line_idx = 0; - return len; -} - #define YY_INPUT(buf,result,max_size) \ - (result = read_input("Wine-dbg>", buf, max_size)) + (result = input_lex_read_buffer(buf, max_size))
static int syntax_error; %} diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index 8180488d1e5..c511f3f76bc 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -311,7 +311,7 @@ extern int msgbox_res_id(HWND hwnd, UINT textId, UINT captionId, UI /* dbg.y */ extern void parser_handle(const char*, HANDLE); extern int input_read_line(const char* pfx, char* buffer, int size); -extern int input_fetch_entire_line(const char* pfx, char** line); +extern size_t input_lex_read_buffer(char* pfx, int size); extern HANDLE WINAPIV parser_generate_command_file(const char*, ...);
/* debug.l */
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/dbg.y | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-)
diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index ace29039753..b58875b6c31 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -458,9 +458,11 @@ struct parser_context HANDLE input; HANDLE output; unsigned line_no; + char* last_line; + size_t last_line_idx; };
-static struct parser_context dbg_parser = {NULL, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, 0}; +static struct parser_context dbg_parser = {NULL, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, 0, NULL, 0};
static int input_fetch_entire_line(const char* pfx, char** line) { @@ -504,11 +506,9 @@ static int input_fetch_entire_line(const char* pfx, char** line) size_t input_lex_read_buffer(char* buf, int size) { int len; - static char* last_line = NULL; - static size_t last_line_idx = 0;
/* try first to fetch the remaining of an existing line */ - if (last_line_idx == 0) + if (dbg_parser.last_line_idx == 0) { char* tmp = NULL; /* no remaining chars to be read from last line, grab a brand new line up to '\n' */ @@ -527,22 +527,22 @@ size_t input_lex_read_buffer(char* buf, int size) /* FIXME: should have a pair of buffers, and switch between the two, instead of * reallocating a new one for each line */ - if (last_line && (len == 0 || (len == 1 && tmp[0] == '\n'))) + if (dbg_parser.last_line && (len == 0 || (len == 1 && tmp[0] == '\n'))) { HeapFree(GetProcessHeap(), 0, tmp); } else { - HeapFree(GetProcessHeap(), 0, last_line); - last_line = tmp; + HeapFree(GetProcessHeap(), 0, dbg_parser.last_line); + dbg_parser.last_line = tmp; } }
- len = min(strlen(last_line + last_line_idx), size - 1); - memcpy(buf, last_line + last_line_idx, len); + len = min(strlen(dbg_parser.last_line + dbg_parser.last_line_idx), size - 1); + memcpy(buf, dbg_parser.last_line + dbg_parser.last_line_idx, len); buf[len] = '\0'; - if ((last_line_idx += len) >= strlen(last_line)) - last_line_idx = 0; + if ((dbg_parser.last_line_idx += len) >= strlen(dbg_parser.last_line)) + dbg_parser.last_line_idx = 0; return len; }
@@ -585,6 +585,8 @@ void parser_handle(const char* filename, HANDLE input) } dbg_parser.line_no = 0; dbg_parser.filename = filename; + dbg_parser.last_line = NULL; + dbg_parser.last_line_idx = 0; do { __TRY
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/dbg.y | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index b58875b6c31..612e6a4106d 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -524,10 +524,9 @@ size_t input_lex_read_buffer(char* buf, int size) len--; }
- /* FIXME: should have a pair of buffers, and switch between the two, instead of - * reallocating a new one for each line - */ - if (dbg_parser.last_line && (len == 0 || (len == 1 && tmp[0] == '\n'))) + /* recall last command when empty input buffer and not parsing a file */ + if (dbg_parser.last_line && (len == 0 || (len == 1 && tmp[0] == '\n')) && + dbg_parser.output != INVALID_HANDLE_VALUE) { HeapFree(GetProcessHeap(), 0, tmp); }
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/tgt_active.c | 106 +++++++++++++++++++++++++++++++++-------- 1 file changed, 85 insertions(+), 21 deletions(-)
diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 2a2af67debe..4bcd5ba659e 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -636,6 +636,88 @@ static BOOL dbg_start_debuggee(LPSTR cmdLine) return TRUE; }
+/*********************************************************************** + * dbg_build_command_line + * + * (converted from dlls/ntdll/unix/env.c) + * + * Build the command line of a process from the argv array. + * + * We must quote and escape characters so that the argv array can be rebuilt + * from the command line: + * - spaces and tabs must be quoted + * 'a b' -> '"a b"' + * - quotes must be escaped + * '"' -> '"' + * - if ''s are followed by a '"', they must be doubled and followed by '"', + * resulting in an odd number of '' followed by a '"' + * '"' -> '\"' + * '\"' -> '\\"' + * - ''s are followed by the closing '"' must be doubled, + * resulting in an even number of '' followed by a '"' + * ' ' -> '" \"' + * ' \' -> '" \\"' + * - ''s that are not followed by a '"' can be left as is + * 'a\b' == 'a\b' + * 'a\b' == 'a\b' + */ +static char *dbg_build_command_line( char **argv ) +{ + int len; + char **arg, *ret; + LPSTR p; + + len = 1; + for (arg = argv; *arg; arg++) len += 3 + 2 * strlen( *arg ); + if (!(ret = malloc( len ))) return NULL; + + p = ret; + for (arg = argv; *arg; arg++) + { + BOOL has_space, has_quote; + int i, bcount; + char *a; + + /* check for quotes and spaces in this argument (first arg is always quoted) */ + has_space = (arg == argv) || !**arg || strchr( *arg, ' ' ) || strchr( *arg, '\t' ); + has_quote = strchr( *arg, '"' ) != NULL; + + /* now transfer it to the command line */ + if (has_space) *p++ = '"'; + if (has_quote || has_space) + { + bcount = 0; + for (a = *arg; *a; a++) + { + if (*a == '\') bcount++; + else + { + if (*a == '"') /* double all the '\' preceding this '"', plus one */ + for (i = 0; i <= bcount; i++) *p++ = '\'; + bcount = 0; + } + *p++ = *a; + } + } + else + { + strcpy( p, *arg ); + p += strlen( p ); + } + if (has_space) + { + /* Double all the '' preceding the closing quote */ + for (i = 0; i < bcount; i++) *p++ = '\'; + *p++ = '"'; + } + *p++ = ' '; + } + if (p > ret) p--; /* remove last space */ + *p = 0; + return ret; +} + + void dbg_run_debuggee(const char* args) { if (args) @@ -807,35 +889,17 @@ enum dbg_start dbg_active_attach(int argc, char* argv[]) */ enum dbg_start dbg_active_launch(int argc, char* argv[]) { - int i, len; LPSTR cmd_line;
if (argc == 0) return start_error_parse;
- if (!(cmd_line = HeapAlloc(GetProcessHeap(), 0, len = 1))) - { - oom_leave: - dbg_printf("Out of memory\n"); - return start_error_init; - } - cmd_line[0] = '\0'; - - for (i = 0; i < argc; i++) - { - len += strlen(argv[i]) + 1; - if (!(cmd_line = HeapReAlloc(GetProcessHeap(), 0, cmd_line, len))) - goto oom_leave; - strcat(cmd_line, argv[i]); - cmd_line[len - 2] = ' '; - cmd_line[len - 1] = '\0'; - } - + cmd_line = dbg_build_command_line(argv); if (!dbg_start_debuggee(cmd_line)) { - HeapFree(GetProcessHeap(), 0, cmd_line); + free(cmd_line); return start_error_init; } - HeapFree(GetProcessHeap(), 0, dbg_last_cmd_line); + free(dbg_last_cmd_line); dbg_last_cmd_line = cmd_line; return start_ok; }
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/debug.l | 32 ++++++++++++++++++++++++++++++-- 1 file changed, 30 insertions(+), 2 deletions(-)
diff --git a/programs/winedbg/debug.l b/programs/winedbg/debug.l index a497f34e6b0..280dcbfbc6b 100644 --- a/programs/winedbg/debug.l +++ b/programs/winedbg/debug.l @@ -60,6 +60,34 @@ void lexeme_flush(void) next_lexeme = 0; }
+/* called with quoted string, unescape all elements inside the quotes */ +static char* unescape_string(const char* str) +{ + size_t len = strlen(str) - 2; + char* ret = lexeme_alloc_size(len + 1); + char* dst = ret; + const char* ptr; + for (ptr = str + 1; ptr < str + 1 + len; ptr++) + { + if (*ptr == '\') + { + switch (*++ptr) + { + case 't': *dst++ = '\t'; break; + case 'r': *dst++ = '\r'; break; + case 'n': *dst++ = '\n'; break; + case '\': *dst++ = '\'; break; + case '"': *dst++ = '"'; break; + default: *dst++ = '\'; *dst++ = *ptr; /* not handled, don't change */ + } + } + else + *dst++ = *ptr; + } + *dst = '\0'; + return ret; +} + #define YY_INPUT(buf,result,max_size) \ (result = input_lex_read_buffer(buf, max_size))
@@ -72,7 +100,7 @@ HEXDIGIT [0-9a-fA-F] FORMAT [ubcdgiswxa] IDENTIFIER [_a-zA-Z~?][_a-zA-Z0-9~?@]* PATHNAME [\/_a-zA-Z0-9.~@][\/-_a-zA-Z0-9.~@]* -STRING "[^\n"]+" +STRING "(\[^\n]|[^\"\n])*"
%s FORMAT_EXPECTED %s INFO_CMD @@ -125,7 +153,7 @@ STRING "[^\n"]+"
<FORMAT_EXPECTED>"/"{FORMAT} { dbg_lval.integer = (1 << 8) | yytext[1]; return tFORMAT; }
-{STRING} { dbg_lval.string = lexeme_alloc(yytext + 1); dbg_lval.string[strlen(dbg_lval.string) - 1] = '\0'; return tSTRING; } +{STRING} { dbg_lval.string = unescape_string(yytext); return tSTRING;} <ASTRING_EXPECTED>[^\n]+ { char* p = yytext; while (*p == ' ' || *p == '\t') p++; dbg_lval.string = lexeme_alloc(p); return tSTRING; }
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/dbg.y | 10 ++++++- programs/winedbg/debug.l | 8 ++++-- programs/winedbg/debugger.h | 7 ++++- programs/winedbg/tgt_active.c | 55 ++++++++++++++++++++++++++++++--------- programs/winedbg/winedbg.man.in | 8 ++++++ 5 files changed, 69 insertions(+), 19 deletions(-)
diff --git a/programs/winedbg/dbg.y b/programs/winedbg/dbg.y index 612e6a4106d..c5e7b2b43ca 100644 --- a/programs/winedbg/dbg.y +++ b/programs/winedbg/dbg.y @@ -43,6 +43,7 @@ static void parser(const char*); IMAGEHLP_LINE64 listing; struct expr* expression; struct type_expr_t type; + struct list_string* strings; }
%token tCONT tPASS tSTEP tLIST tNEXT tQUIT tHELP tBACKTRACE tALL tINFO tUP tDOWN @@ -85,6 +86,7 @@ static void parser(const char*); %type <string> pathname identifier cpp_identifier %type <listing> list_arg %type <type> type_expr +%type <strings> list_of_words
%%
@@ -183,8 +185,12 @@ list_arg: ;
run_command: - tRUN { dbg_run_debuggee(NULL); } - | tRUN tSTRING { dbg_run_debuggee($2); } + tRUN list_of_words { dbg_run_debuggee($2); } + ; + +list_of_words: + %empty { $$ = NULL; } + | tSTRING list_of_words { $$ = (struct list_string*)lexeme_alloc_size(sizeof(*$$)); $$->next = $2; $$->string = $1; } ;
list_command: diff --git a/programs/winedbg/debug.l b/programs/winedbg/debug.l index 280dcbfbc6b..dc93901a71c 100644 --- a/programs/winedbg/debug.l +++ b/programs/winedbg/debug.l @@ -115,6 +115,7 @@ STRING "(\[^\n]|[^\"\n])*"
%x PATH_EXPECTED %x ASTRING_EXPECTED +%x AWORD_EXPECTED %x NOPROCESS %% /* set to special state when no process is loaded. */ @@ -153,10 +154,11 @@ STRING "(\[^\n]|[^\"\n])*"
<FORMAT_EXPECTED>"/"{FORMAT} { dbg_lval.integer = (1 << 8) | yytext[1]; return tFORMAT; }
-{STRING} { dbg_lval.string = unescape_string(yytext); return tSTRING;} +<*>{STRING} { dbg_lval.string = unescape_string(yytext); return tSTRING;} <ASTRING_EXPECTED>[^\n]+ { char* p = yytext; while (*p == ' ' || *p == '\t') p++; dbg_lval.string = lexeme_alloc(p); return tSTRING; } - +<AWORD_EXPECTED>[^ \t\n]+ { char* p = yytext; while (*p == ' ' || *p == '\t') p++; + dbg_lval.string = lexeme_alloc(p); return tSTRING; } <INITIAL,NOPROCESS>info|inf|in { BEGIN(INFO_CMD); return tINFO; } <INITIAL>up { BEGIN(NOCMD); return tUP; } <INITIAL>down|dow|do { BEGIN(NOCMD); return tDOWN; } @@ -200,7 +202,7 @@ STRING "(\[^\n]|[^\"\n])*" <INITIAL>watch|watc|wat { BEGIN(NOCMD); return tWATCH; } <INITIAL>rwatch|rwatc|rwat { BEGIN(NOCMD); return tRWATCH; } <INITIAL>whatis|whati|what { BEGIN(NOCMD); return tWHATIS; } -<INITIAL,NOPROCESS>run|ru|r { BEGIN(ASTRING_EXPECTED); return tRUN;} +<INITIAL,NOPROCESS>run|ru|r { BEGIN(AWORD_EXPECTED); return tRUN;} <INITIAL>detach|detac|deta|det { BEGIN(NOCMD); return tDETACH; } <INITIAL>kill|kil|ki|k { BEGIN(NOCMD); return tKILL; } <INITIAL,NOPROCESS>maintenance|maint { BEGIN(MAINT_CMD); return tMAINTENANCE; } diff --git a/programs/winedbg/debugger.h b/programs/winedbg/debugger.h index c511f3f76bc..0e6d715a2d1 100644 --- a/programs/winedbg/debugger.h +++ b/programs/winedbg/debugger.h @@ -421,7 +421,12 @@ extern enum sym_get_lval symbol_picker_scoped(const char* name, const struct sgv struct dbg_lvalue* rtn);
/* tgt_active.c */ -extern void dbg_run_debuggee(const char* args); +struct list_string +{ + char* string; + struct list_string* next; +}; +extern void dbg_run_debuggee(struct list_string* ls); extern void dbg_wait_next_exception(DWORD cont, int count, int mode); extern enum dbg_start dbg_active_attach(int argc, char* argv[]); extern BOOL dbg_set_curr_thread(DWORD tid); diff --git a/programs/winedbg/tgt_active.c b/programs/winedbg/tgt_active.c index 4bcd5ba659e..0993bddc985 100644 --- a/programs/winedbg/tgt_active.c +++ b/programs/winedbg/tgt_active.c @@ -31,6 +31,7 @@
WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
+static char* dbg_executable; static char* dbg_last_cmd_line; static struct be_process_io be_process_active_io;
@@ -632,6 +633,11 @@ static BOOL dbg_start_debuggee(LPSTR cmdLine) dbg_curr_pid = info.dwProcessId; if (!(dbg_curr_process = dbg_add_process(&be_process_active_io, dbg_curr_pid, 0))) return FALSE; dbg_curr_process->active_debuggee = TRUE; + if (cmdLine != dbg_last_cmd_line) + { + free(dbg_last_cmd_line); + dbg_last_cmd_line = cmdLine; + }
return TRUE; } @@ -718,24 +724,46 @@ static char *dbg_build_command_line( char **argv ) }
-void dbg_run_debuggee(const char* args) +void dbg_run_debuggee(struct list_string* ls) { - if (args) + if (dbg_curr_process) { - WINE_FIXME("Re-running current program with %s as args is broken\n", wine_dbgstr_a(args)); + dbg_printf("Already attached to a process. Use 'detach' or 'kill' before using 'run'\n"); return; } - else + if (!dbg_executable) { - if (!dbg_last_cmd_line) + dbg_printf("No active target to be restarted\n"); + return; + } + if (ls) + { + char* cl; + char** argv; + unsigned argc = 2, i; + struct list_string* cls; + + for (cls = ls; cls; cls = cls->next) argc++; + if (!(argv = malloc(argc * sizeof(argv[0])))) return; + argv[0] = dbg_executable; + for (i = 1, cls = ls; cls; cls = cls->next, i++) argv[i] = cls->string; + argv[i] = NULL; + cl = dbg_build_command_line(argv); + free(argv); + + if (!cl || !dbg_start_debuggee(cl)) { - dbg_printf("Cannot find previously used command line.\n"); - return; - } - dbg_start_debuggee(dbg_last_cmd_line); - dbg_active_wait_for_first_exception(); - source_list_from_addr(NULL, 0); + free(cl); + return; + } + } + else + { + if (!dbg_last_cmd_line) dbg_last_cmd_line = strdup(dbg_executable); + dbg_start_debuggee(dbg_last_cmd_line); } + dbg_active_wait_for_first_exception(); + source_list_from_addr(NULL, 0); }
static BOOL str2int(const char* str, DWORD_PTR* val) @@ -893,14 +921,15 @@ enum dbg_start dbg_active_launch(int argc, char* argv[])
if (argc == 0) return start_error_parse;
+ dbg_executable = strdup(argv[0]); cmd_line = dbg_build_command_line(argv); + if (!dbg_start_debuggee(cmd_line)) { free(cmd_line); return start_error_init; } - free(dbg_last_cmd_line); - dbg_last_cmd_line = cmd_line; + return start_ok; }
diff --git a/programs/winedbg/winedbg.man.in b/programs/winedbg/winedbg.man.in index 6ed8d4474c4..871b7ad6764 100644 --- a/programs/winedbg/winedbg.man.in +++ b/programs/winedbg/winedbg.man.in @@ -109,6 +109,8 @@ of variations from \fBgdb\fR commands. Aborts the debugger. .IP \fBquit\fR Exits the debugger. +.PP +\fIProcess handling\fR .IP \fBattach\ \fIN\fR Attach to a Wine process (\fIN\fR is its Windows ID, numeric or hexadecimal). IDs can be obtained using the \fBinfo\ process\fR command. Note the @@ -119,6 +121,12 @@ Detach from a Wine-process. .IP \fBthread\ \fIN\fR Change the current thread to \fIN\fR (its Windows TID, numeric or hexadecimal). .IP +.IP \fBrun\fR +Re-run the same process with the same arguments. +Note: all breakpoints of precedent process are no longer available. +.IP \fBrun\ \fIarg1\ arg2...\fR +Re-run the same process with arguments \fIarg1\ arg2...\fR. +Note: all breakpoints of precedent process are no longer available. .PP \fIHelp commands\fR .IP \fBhelp\fR
(fix listing twice the same symbol in some commands like 'break foo!bar')
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/symbol.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/programs/winedbg/symbol.c b/programs/winedbg/symbol.c index a3b9cb38995..13a61774c4b 100644 --- a/programs/winedbg/symbol.c +++ b/programs/winedbg/symbol.c @@ -421,7 +421,7 @@ enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno, SymSetExtendedOption(SYMOPT_EX_WINE_NATIVE_MODULES, opt);
/* now grab local symbols */ - if ((frm = stack_get_curr_frame()) && sgv.num < NUMDBGV) + if ((frm = stack_get_curr_frame()) && sgv.num < NUMDBGV && !strchr(name, '!')) { sgv.frame_offset = frm->linear_frame; SymEnumSymbols(dbg_curr_process->handle, 0, name, sgv_cb, (void*)&sgv);
(likely falled into the cracks from my rebasing)
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/types.c | 1 + 1 file changed, 1 insertion(+)
diff --git a/programs/winedbg/types.c b/programs/winedbg/types.c index 0ee6ab05f0f..ebee3449a37 100644 --- a/programs/winedbg/types.c +++ b/programs/winedbg/types.c @@ -757,6 +757,7 @@ BOOL types_get_info(const struct dbg_type* type, IMAGEHLP_SYMBOL_TYPE_INFO ti, v DWORD ret, tag, bt; ret = SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, ti, pInfo); if (!ret && + ti == TI_GET_SYMNAME && SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, TI_GET_SYMTAG, &tag) && tag == SymTagBaseType && SymGetTypeInfo(dbg_curr_process->handle, type->module, type->id, TI_GET_BASETYPE, &bt))
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/memory.c | 9 +----- programs/winedbg/symbol.c | 3 +- programs/winedbg/types.c | 67 +++++++++++++++++---------------------------- 3 files changed, 29 insertions(+), 50 deletions(-)
diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c index b736d06a67e..f7baf3e6381 100644 --- a/programs/winedbg/memory.c +++ b/programs/winedbg/memory.c @@ -447,7 +447,6 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)]; TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer; WCHAR* ptr; - char tmp[256]; VARIANT variant; int i;
@@ -471,14 +470,10 @@ static void print_typed_basic(const struct dbg_lvalue* lvalue) case VT_I8: ok = (val_int == V_I8(&variant)); break; default: WINE_FIXME("Unsupported variant type (%u)\n", V_VT(&variant)); } - if (ok) + if (ok && types_get_info(&sub_type, TI_GET_SYMNAME, &ptr) && ptr) { - ptr = NULL; - types_get_info(&sub_type, TI_GET_SYMNAME, &ptr); - if (!ptr) continue; - WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL); + dbg_printf("%ls", ptr); HeapFree(GetProcessHeap(), 0, ptr); - dbg_printf("%s", tmp); count = 0; /* so that we'll get away from outer loop */ break; } diff --git a/programs/winedbg/symbol.c b/programs/winedbg/symbol.c index 13a61774c4b..896690c9eaf 100644 --- a/programs/winedbg/symbol.c +++ b/programs/winedbg/symbol.c @@ -756,11 +756,10 @@ BOOL symbol_info_locals(void) addr.Mode = AddrModeFlat; addr.Offset = frm->linear_pc; print_address(&addr, FALSE); - dbg_printf(": (%0*lx)\n", ADDRWIDTH, (DWORD_PTR)frm->linear_frame); + dbg_printf(": (%0*Ix)\n", ADDRWIDTH, frm->linear_frame); SymEnumSymbols(dbg_curr_process->handle, 0, NULL, info_locals_cb, (void*)frm->linear_frame);
return TRUE; - }
static BOOL CALLBACK symbols_info_cb(PSYMBOL_INFO sym, ULONG size, PVOID ctx) diff --git a/programs/winedbg/types.c b/programs/winedbg/types.c index ebee3449a37..9d82171c2c1 100644 --- a/programs/winedbg/types.c +++ b/programs/winedbg/types.c @@ -261,15 +261,14 @@ BOOL types_udt_find_element(struct dbg_lvalue* lvalue, const char* name, ULONG * type.module = lvalue->type.module; for (i = 0; i < min(fcp->Count, count); i++) { - ptr = NULL; type.id = fcp->ChildId[i]; - types_get_info(&type, TI_GET_SYMNAME, &ptr); - if (!ptr) continue; - WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL); - HeapFree(GetProcessHeap(), 0, ptr); - if (strcmp(tmp, name)) continue; - - return types_get_udt_element_lvalue(lvalue, &type, tmpbuf); + if (types_get_info(&type, TI_GET_SYMNAME, &ptr) && ptr) + { + WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL); + HeapFree(GetProcessHeap(), 0, ptr); + if (!strcmp(tmp, name)) + return types_get_udt_element_lvalue(lvalue, &type, tmpbuf); + } } } count -= min(count, 256); @@ -477,7 +476,6 @@ void print_value(const struct dbg_lvalue* lvalue, char format, int level) char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)]; TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer; WCHAR* ptr; - char tmp[256]; ULONG tmpbuf; struct dbg_type sub_type;
@@ -490,13 +488,10 @@ void print_value(const struct dbg_lvalue* lvalue, char format, int level) { for (i = 0; i < min(fcp->Count, count); i++) { - ptr = NULL; sub_type.module = type.module; sub_type.id = fcp->ChildId[i]; - types_get_info(&sub_type, TI_GET_SYMNAME, &ptr); - if (!ptr) continue; - WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL); - dbg_printf("%s=", tmp); + if (!types_get_info(&sub_type, TI_GET_SYMNAME, &ptr) || !ptr) continue; + dbg_printf("%ls=", ptr); HeapFree(GetProcessHeap(), 0, ptr); lvalue_field = *lvalue; if (types_get_udt_element_lvalue(&lvalue_field, &sub_type, &tmpbuf)) @@ -602,8 +597,7 @@ BOOL print_types(void) BOOL types_print_type(const struct dbg_type* type, BOOL details) { WCHAR* ptr; - char tmp[256]; - const char* name; + const WCHAR* name; DWORD tag, udt, count; struct dbg_type subtype;
@@ -613,18 +607,12 @@ BOOL types_print_type(const struct dbg_type* type, BOOL details) return FALSE; }
- if (types_get_info(type, TI_GET_SYMNAME, &ptr) && ptr) - { - WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL); - name = tmp; - HeapFree(GetProcessHeap(), 0, ptr); - } - else name = "--none--"; + name = (types_get_info(type, TI_GET_SYMNAME, &ptr) && ptr) ? ptr : L"--none--";
switch (tag) { case SymTagBaseType: - if (details) dbg_printf("Basic<%s>", name); else dbg_printf("%s", name); + if (details) dbg_printf("Basic<%ls>", name); else dbg_printf("%ls", name); break; case SymTagPointerType: types_get_info(type, TI_GET_TYPE, &subtype.id); @@ -636,10 +624,10 @@ BOOL types_print_type(const struct dbg_type* type, BOOL details) types_get_info(type, TI_GET_UDTKIND, &udt); switch (udt) { - case UdtStruct: dbg_printf("struct %s", name); break; - case UdtUnion: dbg_printf("union %s", name); break; - case UdtClass: dbg_printf("class %s", name); break; - default: WINE_ERR("Unsupported UDT type (%d) for %s\n", udt, name); break; + case UdtStruct: dbg_printf("struct %ls", name); break; + case UdtUnion: dbg_printf("union %ls", name); break; + case UdtClass: dbg_printf("class %ls", name); break; + default: WINE_ERR("Unsupported UDT type (%d) for %ls\n", udt, name); break; } if (details && types_get_info(type, TI_GET_CHILDRENCOUNT, &count)) @@ -647,7 +635,6 @@ BOOL types_print_type(const struct dbg_type* type, BOOL details) char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)]; TI_FINDCHILDREN_PARAMS* fcp = (TI_FINDCHILDREN_PARAMS*)buffer; WCHAR* ptr; - char tmp[256]; int i; struct dbg_type type_elt; dbg_printf(" {"); @@ -660,14 +647,11 @@ BOOL types_print_type(const struct dbg_type* type, BOOL details) { for (i = 0; i < min(fcp->Count, count); i++) { - ptr = NULL; type_elt.module = type->module; type_elt.id = fcp->ChildId[i]; - types_get_info(&type_elt, TI_GET_SYMNAME, &ptr); - if (!ptr) continue; - WideCharToMultiByte(CP_ACP, 0, ptr, -1, tmp, sizeof(tmp), NULL, NULL); + if (!types_get_info(&type_elt, TI_GET_SYMNAME, &ptr) || !ptr) continue; + dbg_printf("%ls", ptr); HeapFree(GetProcessHeap(), 0, ptr); - dbg_printf("%s", tmp); if (types_get_info(&type_elt, TI_GET_TYPE, &type_elt.id)) { dbg_printf(":"); @@ -687,12 +671,12 @@ BOOL types_print_type(const struct dbg_type* type, BOOL details) subtype.module = type->module; types_print_type(&subtype, details); if (types_get_info(type, TI_GET_COUNT, &count)) - dbg_printf(" %s[%d]", name, count); + dbg_printf(" %ls[%d]", name, count); else - dbg_printf(" %s[]", name); + dbg_printf(" %ls[]", name); break; case SymTagEnum: - dbg_printf("enum %s", name); + dbg_printf("enum %ls", name); break; case SymTagFunctionType: types_get_info(type, TI_GET_TYPE, &subtype.id); @@ -707,7 +691,7 @@ BOOL types_print_type(const struct dbg_type* type, BOOL details) subtype.module = 0; dbg_printf("<ret_type=self>"); } - dbg_printf(" (*%s)(", name); + dbg_printf(" (*%ls)(", name); if (types_get_info(type, TI_GET_CHILDRENCOUNT, &count)) { char buffer[sizeof(TI_FINDCHILDREN_PARAMS) + 256 * sizeof(DWORD)]; @@ -736,13 +720,14 @@ BOOL types_print_type(const struct dbg_type* type, BOOL details) dbg_printf(")"); break; case SymTagTypedef: - dbg_printf("%s", name); + dbg_printf("%ls", name); break; default: - WINE_ERR("Unknown type %u for %s\n", tag, name); + WINE_ERR("Unknown type %u for %ls\n", tag, name); break; } - + + HeapFree(GetProcessHeap(), 0, ptr); return TRUE; }
Signed-off-by: Eric Pouech eric.pouech@gmail.com
--- programs/winedbg/memory.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/programs/winedbg/memory.c b/programs/winedbg/memory.c index f7baf3e6381..1653736e919 100644 --- a/programs/winedbg/memory.c +++ b/programs/winedbg/memory.c @@ -337,7 +337,8 @@ static void dbg_print_hex(DWORD size, ULONGLONG sv) if (!sv) dbg_printf("0"); else - dbg_printf("%#I64x", sv); + /* clear unneeded high bits, esp. sign extension */ + dbg_printf("%#I64x", sv & (~0LLU >> (64 - 8 * size))); }
static void print_typed_basic(const struct dbg_lvalue* lvalue)
-
Eric Pouech