3 * Parser for command lines in the Wine debugger
5 * Copyright 1993 Eric Youngdale
6 * Copyright 1995 Morten Welinder
7 * Copyright 2000 Eric Pouech
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
29 #include "wine/exception.h"
33 static int dbg_error
(const char*);
34 static void parser
(const char*);
38 %define api.prefix
{dbg_
}
42 struct dbg_lvalue lvalue
;
45 IMAGEHLP_LINE64 listing
;
46 struct expr
* expression
;
48 struct list_string
* strings
;
51 %token tCONT tPASS tSTEP tLIST tNEXT tQUIT tHELP tBACKTRACE tALL tINFO tUP tDOWN
52 %token tENABLE tDISABLE tBREAK tHBREAK tWATCH tRWATCH tDELETE tSET tPRINT tEXAM
54 %token tCLASS tMAPS tSTACK tSEGMENTS tSYMBOL tREGS tALLREGS tWND tLOCAL tEXCEPTION
55 %token tPROCESS tTHREAD tEOL tEOF
56 %token tFRAME tSHARE tMODULE tCOND tDISPLAY tUNDISPLAY tDISASSEMBLE tSYSTEM
57 %token tSTEPI tNEXTI tFINISH tSHOW tDIR tWHATIS tSOURCE
58 %token
<string> tPATH tIDENTIFIER tSTRING tINTVAR
59 %token
<integer
> tNUM tFORMAT
60 %token
<type
> tTYPEDEF
61 %token tSYMBOLFILE tEXECFILE tRUN tATTACH tDETACH tKILL tMAINTENANCE tTYPE tMINIDUMP
62 %token tNOPROCESS tWOW
64 /* can be prefixed by module name */
65 %token
<string> tVOID tCHAR tWCHAR tSHORT tINT tLONG tFLOAT tDOUBLE tUNSIGNED tSIGNED
66 %token tSTRUCT tUNION tENUM
69 /* %left '=' OP_OR_EQUAL OP_XOR_EQUAL OP_AND_EQUAL OP_SHL_EQUAL \
70 OP_SHR_EQUAL OP_PLUS_EQUAL OP_MINUS_EQUAL \
71 OP_TIMES_EQUAL OP_DIVIDE_EQUAL OP_MODULO_EQUAL */
72 /* %left OP_COND */ /* ... ? ... : ... */
79 %left
'<' '>' OP_LE OP_GE
83 %left OP_SIGN
'!' '~' OP_DEREF
/* OP_INC OP_DEC OP_ADDR */
87 %type
<expression
> expr lvalue
88 %type
<lvalue
> expr_lvalue lvalue_addr
89 %type
<integer
> expr_rvalue
90 %type
<string> pathname identifier
91 %type
<listing
> list_arg
92 %type
<type
> type_expr
93 %type
<strings
> list_of_words
103 command tEOL
{ expr_free_all
(); }
106 |
error tEOL
{ yyerrok; expr_free_all
(); }
111 | tHELP
{ print_help
(); }
112 | tHELP tINFO
{ info_help
(); }
113 | tPASS
{ dbg_wait_next_exception
(DBG_EXCEPTION_NOT_HANDLED
, 0, 0); }
114 | tCONT
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_cont
); }
115 | tCONT tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_cont
); }
116 | tSTEP
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_step_into_line
); }
117 | tSTEP tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_step_into_line
); }
118 | tNEXT
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_step_over_line
); }
119 | tNEXT tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_step_over_line
); }
120 | tSTEPI
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_step_into_insn
); }
121 | tSTEPI tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_step_into_insn
); }
122 | tNEXTI
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_step_over_insn
); }
123 | tNEXTI tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_step_over_insn
); }
124 | tFINISH
{ dbg_wait_next_exception
(DBG_CONTINUE
, 0, dbg_exec_finish
); }
125 | tABORT
{ abort
(); }
126 | tBACKTRACE
{ stack_backtrace
(dbg_curr_tid
); }
127 | tBACKTRACE tNUM
{ stack_backtrace
($2); }
128 | tBACKTRACE tALL
{ stack_backtrace
(-1); }
129 | tUP
{ stack_set_frame
(dbg_curr_thread
->curr_frame
+ 1); }
130 | tUP tNUM
{ stack_set_frame
(dbg_curr_thread
->curr_frame
+ $2); }
131 | tDOWN
{ stack_set_frame
(dbg_curr_thread
->curr_frame
- 1); }
132 | tDOWN tNUM
{ stack_set_frame
(dbg_curr_thread
->curr_frame
- $2); }
133 | tFRAME tNUM
{ stack_set_frame
($2); }
134 | tSHOW tDIR
{ source_show_path
(); }
135 | tDIR pathname
{ source_add_path
($2); }
136 | tDIR
{ source_nuke_path
(dbg_curr_process
); }
137 | tCOND tNUM
{ break_add_condition
($2, NULL
); }
138 | tCOND tNUM expr
{ break_add_condition
($2, $3); }
139 | tSOURCE pathname
{ parser
($2); }
140 | tSYMBOLFILE pathname
{ symbol_read_symtable
($2, 0); }
141 | tSYMBOLFILE pathname expr_rvalue
{ symbol_read_symtable
($2, $3); }
142 | tWHATIS expr_lvalue
{ dbg_printf
("type = "); types_print_type
(&$2.type
, FALSE
, NULL
); dbg_printf
("\n"); }
143 | tATTACH tNUM
{ dbg_attach_debuggee
($2); dbg_active_wait_for_first_exception
(); }
144 | tATTACH pathname
{ minidump_reload
($2); }
145 | tDETACH
{ dbg_curr_process
->process_io
->close_process
(dbg_curr_process
, FALSE
); }
146 | tTHREAD tNUM
{ dbg_set_curr_thread
($2); }
147 | tKILL
{ dbg_curr_process
->process_io
->close_process
(dbg_curr_process
, TRUE
); }
148 | tMINIDUMP pathname
{ minidump_write
($2, (dbg_curr_thread
&& dbg_curr_thread
->in_exception
) ?
&dbg_curr_thread
->excpt_record
: NULL
); }
149 | tECHO tSTRING
{ dbg_printf
("%s\n", $2); }
150 | tEXECFILE pathname
{ dbg_set_exec_file
($2); }
153 | disassemble_command
161 | maintenance_command
166 identifier
{ $$
= $1; }
167 | tSTRING
{ $$
= $1; }
172 tIDENTIFIER
{ $$
= $1; }
176 tNUM
{ $$.FileName
= NULL
; $$.LineNumber
= $1; }
177 | pathname
':' tNUM
{ $$.FileName
= $1; $$.LineNumber
= $3; }
178 | identifier
{ symbol_get_line
(NULL
, $1, &$$
); }
179 | pathname
':' identifier
{ symbol_get_line
($1, $3, &$$
); }
180 |
'*' expr_lvalue
{ DWORD disp
; ADDRESS64 addr
; $$.SizeOfStruct
= sizeof
($$
);
181 types_extract_as_address
(&$2, &addr
);
182 SymGetLineFromAddr64
(dbg_curr_process
->handle
, (ULONG_PTR
)memory_to_linear_addr
(& addr
), &disp
, & $$
); }
186 tRUN list_of_words
{ dbg_run_debuggee
($2); }
190 %empty
{ $$
= NULL
; }
191 | tSTRING list_of_words
{ $$
= (struct list_string
*)lexeme_alloc_size
(sizeof
(*$$
)); $$
->next
= $2; $$
->string = $1; }
195 tLIST
{ source_list
(NULL
, NULL
, 10); }
196 | tLIST
'-' { source_list
(NULL
, NULL
, -10); }
197 | tLIST list_arg
{ source_list
(& $2, NULL
, 10); }
198 | tLIST
',' list_arg
{ source_list
(NULL
, & $3, -10); }
199 | tLIST list_arg
',' list_arg
{ source_list
(& $2, & $4, 0); }
203 tDISASSEMBLE
{ memory_disassemble
(NULL
, NULL
, 10); }
204 | tDISASSEMBLE expr_lvalue
{ memory_disassemble
(&$2, NULL
, 10); }
205 | tDISASSEMBLE expr_lvalue
',' expr_lvalue
{ memory_disassemble
(&$2, &$4, 0); }
209 tSET lvalue_addr
'=' expr_lvalue
{ types_store_value
(&$2, &$4); }
210 | tSET
'+' tIDENTIFIER
{ info_wine_dbg_channel
(TRUE
, NULL
, $3); }
211 | tSET
'+' tALL
{ info_wine_dbg_channel
(TRUE
, NULL
, "all"); }
212 | tSET
'-' tIDENTIFIER
{ info_wine_dbg_channel
(FALSE
, NULL
, $3); }
213 | tSET
'-' tALL
{ info_wine_dbg_channel
(FALSE
, NULL
, "all"); }
214 | tSET tIDENTIFIER
'+' tIDENTIFIER
{ info_wine_dbg_channel
(TRUE
, $2, $4); }
215 | tSET tIDENTIFIER
'+' tALL
{ info_wine_dbg_channel
(TRUE
, $2, "all"); }
216 | tSET tIDENTIFIER
'-' tIDENTIFIER
{ info_wine_dbg_channel
(FALSE
, $2, $4); }
217 | tSET tIDENTIFIER
'-' tALL
{ info_wine_dbg_channel
(FALSE
, $2, "all"); }
218 | tSET
'!' tIDENTIFIER tIDENTIFIER
{ dbg_set_option
($3, $4); }
219 | tSET
'!' tIDENTIFIER
{ dbg_set_option
($3, NULL
); }
223 tEXAM expr_lvalue
{ memory_examine
(&$2, 1, 'x'); }
224 | tEXAM tFORMAT expr_lvalue
{ memory_examine
(&$3, $2 >> 8, $2 & 0xff); }
228 tPRINT expr_lvalue
{ print_value
(&$2, 0, 0); }
229 | tPRINT tFORMAT expr_lvalue
{ if
(($2 >> 8) == 1) print_value
(&$3, $2 & 0xff, 0); else dbg_printf
("Count is meaningless in print command\n"); }
230 | tPRINT type_expr
{ types_print_type
(&$2, TRUE
, NULL
); dbg_printf
("\n"); }
234 tBREAK
'*' expr_lvalue
{ break_add_break_from_lvalue
(&$3, TRUE
); }
235 | tBREAK identifier
{ break_add_break_from_id
($2, -1, TRUE
); }
236 | tBREAK pathname
':' tNUM
{ break_add_break_from_lineno
($2, $4, TRUE
); }
237 | tBREAK tNUM
{ break_add_break_from_lineno
(NULL
, $2, TRUE
); }
238 | tBREAK
{ break_add_break_from_lineno
(NULL
, -1, TRUE
); }
239 | tHBREAK
'*' expr_lvalue
{ break_add_break_from_lvalue
(&$3, FALSE
); }
240 | tHBREAK identifier
{ break_add_break_from_id
($2, -1, FALSE
); }
241 | tHBREAK pathname
':' tNUM
{ break_add_break_from_lineno
($2, $4, FALSE
); }
242 | tHBREAK tNUM
{ break_add_break_from_lineno
(NULL
, $2, FALSE
); }
243 | tHBREAK
{ break_add_break_from_lineno
(NULL
, -1, FALSE
); }
244 | tENABLE tNUM
{ break_enable_xpoint
($2, TRUE
); }
245 | tENABLE tBREAK tNUM
{ break_enable_xpoint
($3, TRUE
); }
246 | tDISABLE tNUM
{ break_enable_xpoint
($2, FALSE
); }
247 | tDISABLE tBREAK tNUM
{ break_enable_xpoint
($3, FALSE
); }
248 | tDELETE tNUM
{ break_delete_xpoint
($2); }
249 | tDELETE tBREAK tNUM
{ break_delete_xpoint
($3); }
253 tWATCH expr_lvalue
{ break_add_watch
(&$2, TRUE
); }
254 | tRWATCH expr_lvalue
{ break_add_watch
(&$2, FALSE
); }
259 tDISPLAY
{ display_print
(); }
260 | tDISPLAY expr
{ display_add
($2, 1, 0); }
261 | tDISPLAY tFORMAT expr
{ display_add
($3, $2 >> 8, $2 & 0xff); }
262 | tENABLE tDISPLAY tNUM
{ display_enable
($3, TRUE
); }
263 | tDISABLE tDISPLAY tNUM
{ display_enable
($3, FALSE
); }
264 | tDELETE tDISPLAY tNUM
{ display_delete
($3); }
265 | tDELETE tDISPLAY
{ display_delete
(-1); }
266 | tUNDISPLAY tNUM
{ display_delete
($2); }
267 | tUNDISPLAY
{ display_delete
(-1); }
271 tINFO tBREAK
{ break_info
(); }
272 | tINFO tSHARE
{ info_win32_module
(0, FALSE
); }
273 | tINFO tWOW tSHARE
{ info_win32_module
(0, TRUE
); }
274 | tINFO tSHARE expr_rvalue
{ info_win32_module
($3, FALSE
); }
275 | tINFO tREGS
{ dbg_curr_process
->be_cpu
->print_context
(dbg_curr_thread
->handle
, &dbg_context
, 0); }
276 | tINFO tALLREGS
{ dbg_curr_process
->be_cpu
->print_context
(dbg_curr_thread
->handle
, &dbg_context
, 1); }
277 | tINFO tSEGMENTS expr_rvalue
{ info_win32_segments
($3 >> 3, 1); }
278 | tINFO tSEGMENTS
{ info_win32_segments
(0, -1); }
279 | tINFO tSTACK tNUM
{ stack_info
($3); }
280 | tINFO tSTACK
{ stack_info
(-1); }
281 | tINFO tSYMBOL tSTRING
{ symbol_info
($3); }
282 | tINFO tLOCAL
{ symbol_info_locals
(); }
283 | tINFO tDISPLAY
{ display_info
(); }
284 | tINFO tCLASS
{ info_win32_class
(NULL
, NULL
); }
285 | tINFO tCLASS tSTRING
{ info_win32_class
(NULL
, $3); }
286 | tINFO tWND
{ info_win32_window
(NULL
, FALSE
); }
287 | tINFO tWND expr_rvalue
{ info_win32_window
((HWND
)(DWORD_PTR
)$3, FALSE
); }
288 | tINFO
'*' tWND
{ info_win32_window
(NULL
, TRUE
); }
289 | tINFO
'*' tWND expr_rvalue
{ info_win32_window
((HWND
)(DWORD_PTR
)$4, TRUE
); }
290 | tINFO tPROCESS
{ info_win32_processes
(); }
291 | tINFO tTHREAD
{ info_win32_threads
(); }
292 | tINFO tFRAME
{ info_win32_frame_exceptions
(dbg_curr_tid
); }
293 | tINFO tFRAME expr_rvalue
{ info_win32_frame_exceptions
($3); }
294 | tINFO tMAPS
{ info_win32_virtual
(dbg_curr_pid
); }
295 | tINFO tMAPS expr_rvalue
{ info_win32_virtual
($3); }
296 | tINFO tEXCEPTION
{ info_win32_exception
(); }
297 | tINFO tSYSTEM
{ info_win32_system
(); }
301 tMAINTENANCE tTYPE
{ print_types
(); }
302 | tMAINTENANCE tMODULE tSTRING
{ tgt_module_load
($3, FALSE
); }
303 | tMAINTENANCE
'*' tMODULE tSTRING
{ tgt_module_load
($4, TRUE
); }
307 tNOPROCESS
{} /* <CR> shall not barf anything */
308 | tNOPROCESS tBACKTRACE tALL
{ stack_backtrace
(-1); } /* can backtrace all threads with no attached process */
309 | tNOPROCESS tSTRING
{ dbg_printf
("No process loaded, cannot execute '%s'\n", $2); }
313 tVOID
{ if
(!types_find_basic
(L
"void", $1, &$$
)) YYERROR; }
314 | tCHAR
{ if
(!types_find_basic
(L
"char", $1, &$$
)) YYERROR; }
315 | tWCHAR
{ if
(!types_find_basic
(L
"WCHAR", $1, &$$
)) YYERROR; }
316 | tSIGNED tCHAR
{ if
(!types_find_basic
(L
"signed char", $1, &$$
)) YYERROR; }
317 | tUNSIGNED tCHAR
{ if
(!types_find_basic
(L
"unsigned char", $1, &$$
)) YYERROR; }
318 | tSHORT tINT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
319 | tSHORT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
320 | tSIGNED tSHORT tINT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
321 | tSIGNED tSHORT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
322 | tSHORT tSIGNED tINT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
323 | tSHORT tSIGNED
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
324 | tSHORT tUNSIGNED
{ if
(!types_find_basic
(L
"unsigned short int", $1, &$$
)) YYERROR; }
325 | tSHORT tUNSIGNED tINT
{ if
(!types_find_basic
(L
"unsigned short int", $1, &$$
)) YYERROR; }
326 | tUNSIGNED tSHORT
{ if
(!types_find_basic
(L
"unsigned short int", $1, &$$
)) YYERROR; }
327 | tUNSIGNED tSHORT tINT
{ if
(!types_find_basic
(L
"unsigned short int", $1, &$$
)) YYERROR; }
328 | tINT
{ if
(!types_find_basic
(L
"int", $1, &$$
)) YYERROR; }
329 | tSIGNED tINT
{ if
(!types_find_basic
(L
"int", $1, &$$
)) YYERROR; }
330 | tUNSIGNED
{ if
(!types_find_basic
(L
"unsigned int", $1, &$$
)) YYERROR; }
331 | tUNSIGNED tINT
{ if
(!types_find_basic
(L
"unsigned int", $1, &$$
)) YYERROR; }
332 | tLONG
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
333 | tLONG tINT
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
334 | tSIGNED tLONG
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
335 | tSIGNED tLONG tINT
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
336 | tLONG tSIGNED
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
337 | tLONG tSIGNED tINT
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
338 | tLONG tUNSIGNED
{ if
(!types_find_basic
(L
"unsigned long int", $1, &$$
)) YYERROR; }
339 | tLONG tUNSIGNED tINT
{ if
(!types_find_basic
(L
"unsigned long int", $1, &$$
)) YYERROR; }
340 | tUNSIGNED tLONG
{ if
(!types_find_basic
(L
"unsigned long int", $1, &$$
)) YYERROR; }
341 | tUNSIGNED tLONG tINT
{ if
(!types_find_basic
(L
"unsigned long int", $1, &$$
)) YYERROR; }
342 | tLONG tLONG
{ if
(!types_find_basic
(L
"long long int", $1, &$$
)) YYERROR; }
343 | tLONG tLONG tINT
{ if
(!types_find_basic
(L
"long long int", $1, &$$
)) YYERROR; }
344 | tSIGNED tLONG tLONG
{ if
(!types_find_basic
(L
"long long int", $1, &$$
)) YYERROR; }
345 | tSIGNED tLONG tLONG tINT
{ if
(!types_find_basic
(L
"long long int", $1, &$$
)) YYERROR; }
346 | tUNSIGNED tLONG tLONG
{ if
(!types_find_basic
(L
"unsigned long long int", $1, &$$
)) YYERROR; }
347 | tUNSIGNED tLONG tLONG tINT
{ if
(!types_find_basic
(L
"unsigned long long int", $1, &$$
)) YYERROR; }
348 | tLONG tLONG tUNSIGNED
{ if
(!types_find_basic
(L
"unsigned long long int", $1, &$$
)) YYERROR; }
349 | tLONG tLONG tUNSIGNED tINT
{ if
(!types_find_basic
(L
"unsigned long long int", $1, &$$
)) YYERROR; }
350 | tFLOAT
{ if
(!types_find_basic
(L
"float", $1, &$$
)) YYERROR; }
351 | tDOUBLE
{ if
(!types_find_basic
(L
"double", $1, &$$
)) YYERROR; }
352 | tLONG tDOUBLE
{ if
(!types_find_basic
(L
"long double", $1, &$$
)) YYERROR; }
353 | tTYPEDEF
{ $$
= $1; }
354 | type_expr
'*' { if
(!types_find_pointer
(&$1, &$$
)) {yyerror("Cannot find pointer type\n"); YYERROR; } }
355 | tCLASS identifier
{ if
(!types_find_type
($2, SymTagUDT
, &$$
)) {yyerror("Unknown type\n"); YYERROR; } }
356 | tSTRUCT identifier
{ if
(!types_find_type
($2, SymTagUDT
, &$$
)) {yyerror("Unknown type\n"); YYERROR; } }
357 | tUNION identifier
{ if
(!types_find_type
($2, SymTagUDT
, &$$
)) {yyerror("Unknown type\n"); YYERROR; } }
358 | tENUM identifier
{ if
(!types_find_type
($2, SymTagEnum
, &$$
)) {yyerror("Unknown type\n"); YYERROR; } }
362 expr
{ $$
= expr_eval
($1); }
366 expr_lvalue
{ $$
= types_extract_as_integer
(&$1); }
370 * The expr rule builds an expression tree. When we are done, we call
371 * EvalExpr to evaluate the value of the expression. The advantage of
372 * the two-step approach is that it is possible to save expressions for
373 * use in 'display' commands, and in conditional watchpoints.
376 tNUM
{ $$
= expr_alloc_sconstant
($1); }
377 | tSTRING
{ $$
= expr_alloc_string
($1); }
378 | tINTVAR
{ $$
= expr_alloc_internal_var
($1); }
379 | identifier
{ $$
= expr_alloc_symbol
($1); }
380 | expr OP_DRF tIDENTIFIER
{ $$
= expr_alloc_pstruct
($1, $3); }
381 | expr
'.' tIDENTIFIER
{ $$
= expr_alloc_struct
($1, $3); }
382 | identifier
'(' ')' { $$
= expr_alloc_func_call
($1, 0); }
383 | identifier
'(' expr
')' { $$
= expr_alloc_func_call
($1, 1, $3); }
384 | identifier
'(' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 2, $3, $5); }
385 | identifier
'(' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 3, $3, $5, $7); }
386 | identifier
'(' expr
',' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 4, $3, $5, $7, $9); }
387 | identifier
'(' expr
',' expr
',' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 5, $3, $5, $7, $9, $11); }
388 | expr
'[' expr
']' { $$
= expr_alloc_binary_op
(EXP_OP_ARR
, $1, $3); }
389 | expr
':' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SEG
, $1, $3); }
390 | expr OP_LOR expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LOR
, $1, $3); }
391 | expr OP_LAND expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LAND
, $1, $3); }
392 | expr
'|' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_OR
, $1, $3); }
393 | expr
'&' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_AND
, $1, $3); }
394 | expr
'^' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_XOR
, $1, $3); }
395 | expr OP_EQ expr
{ $$
= expr_alloc_binary_op
(EXP_OP_EQ
, $1, $3); }
396 | expr
'>' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_GT
, $1, $3); }
397 | expr
'<' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LT
, $1, $3); }
398 | expr OP_GE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_GE
, $1, $3); }
399 | expr OP_LE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LE
, $1, $3); }
400 | expr OP_NE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_NE
, $1, $3); }
401 | expr OP_SHL expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SHL
, $1, $3); }
402 | expr OP_SHR expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SHR
, $1, $3); }
403 | expr
'+' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_ADD
, $1, $3); }
404 | expr
'-' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SUB
, $1, $3); }
405 | expr
'*' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_MUL
, $1, $3); }
406 | expr
'/' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_DIV
, $1, $3); }
407 | expr
'%' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_REM
, $1, $3); }
408 |
'-' expr %prec OP_SIGN
{ $$
= expr_alloc_unary_op
(EXP_OP_NEG
, $2); }
409 |
'+' expr %prec OP_SIGN
{ $$
= $2; }
410 |
'!' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_NOT
, $2); }
411 |
'~' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_LNOT
, $2); }
412 |
'(' expr
')' { $$
= $2; }
413 |
'*' expr %prec OP_DEREF
{ $$
= expr_alloc_unary_op
(EXP_OP_DEREF
, $2); }
414 |
'&' expr %prec OP_DEREF
{ $$
= expr_alloc_unary_op
(EXP_OP_ADDR
, $2); }
415 |
'(' type_expr
')' expr %prec OP_DEREF
{ $$
= expr_alloc_typecast
(&$2, $4); }
419 * The lvalue rule builds an expression tree. This is a limited form
420 * of expression that is suitable to be used as an lvalue.
423 lvalue
{ $$
= expr_eval
($1); }
427 tNUM
{ $$
= expr_alloc_sconstant
($1); }
428 | tINTVAR
{ $$
= expr_alloc_internal_var
($1); }
429 | identifier
{ $$
= expr_alloc_symbol
($1); }
430 | lvalue OP_DRF tIDENTIFIER
{ $$
= expr_alloc_pstruct
($1, $3); }
431 | lvalue
'.' tIDENTIFIER
{ $$
= expr_alloc_struct
($1, $3); }
432 | lvalue
'[' expr
']' { $$
= expr_alloc_binary_op
(EXP_OP_ARR
, $1, $3); }
433 |
'*' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_DEREF
, $2); }
438 static LONG WINAPI wine_dbg_cmd
(EXCEPTION_POINTERS
*eptr
)
440 switch
(eptr
->ExceptionRecord
->ExceptionCode
)
442 case DEBUG_STATUS_INTERNAL_ERROR
:
443 dbg_printf
("\nWineDbg internal error\n");
445 case DEBUG_STATUS_NO_SYMBOL
:
446 dbg_printf
("\nUndefined symbol\n");
448 case DEBUG_STATUS_DIV_BY_ZERO
:
449 dbg_printf
("\nDivision by zero\n");
451 case DEBUG_STATUS_BAD_TYPE
:
452 dbg_printf
("\nNo type or type mismatch\n");
454 case DEBUG_STATUS_NO_FIELD
:
455 dbg_printf
("\nNo such field in structure or union\n");
457 case DEBUG_STATUS_CANT_DEREF
:
458 dbg_printf
("\nDereference failed (not a pointer, or out of array bounds)\n");
460 case DEBUG_STATUS_ABORT
:
462 case DEBUG_STATUS_NOT_AN_INTEGER
:
463 dbg_printf
("\nNeeding an integral value\n");
466 /* this is generally sent by a ctrl-c when we run winedbg outside of wineconsole */
467 /* stop the debuggee, and continue debugger execution, we will be reentered by the
468 * debug events generated by stopping
470 dbg_interrupt_debuggee
();
471 return EXCEPTION_CONTINUE_EXECUTION
;
473 dbg_printf
("\nException %lx\n", eptr
->ExceptionRecord
->ExceptionCode
);
477 return EXCEPTION_EXECUTE_HANDLER
;
480 struct parser_context
482 const char* filename
;
487 size_t last_line_idx
;
490 static struct parser_context dbg_parser
= {NULL
, INVALID_HANDLE_VALUE
, INVALID_HANDLE_VALUE
, 0, NULL
, 0};
492 static int input_fetch_entire_line
(const char* pfx
, char** line
)
499 /* as of today, console handles can be file handles... so better use file APIs rather than
502 WriteFile
(dbg_parser.output
, pfx
, strlen
(pfx
), &nread
, NULL
);
504 buffer
= malloc
(alloc
= 16);
505 assert
(buffer
!= NULL
);
507 dbg_parser.line_no
++;
511 if
(!ReadFile
(dbg_parser.input
, &ch
, 1, &nread
, NULL
) || nread
== 0)
520 while
(len
+ 2 > alloc
) alloc
*= 2;
521 if
(!(new
= realloc
(buffer
, alloc
)))
537 size_t input_lex_read_buffer
(char* buf
, int size
)
541 /* try first to fetch the remaining of an existing line */
542 if
(dbg_parser.last_line_idx
== 0)
545 /* no remaining chars to be read from last line, grab a brand new line up to '\n' */
547 len
= input_fetch_entire_line
("Wine-dbg>", &tmp
);
548 if
(len
< 0) return
0; /* eof */
550 /* remove carriage return in newline */
551 if
(len
>= 2 && tmp
[len
- 2] == '\r')
558 /* recall last command when empty input buffer and not parsing a file */
559 if
(dbg_parser.last_line
&& (len
== 0 ||
(len
== 1 && tmp
[0] == '\n')) &&
560 dbg_parser.output
!= INVALID_HANDLE_VALUE
)
566 free
(dbg_parser.last_line
);
567 dbg_parser.last_line
= tmp
;
571 len
= min
(strlen
(dbg_parser.last_line
+ dbg_parser.last_line_idx
), size
- 1);
572 memcpy
(buf
, dbg_parser.last_line
+ dbg_parser.last_line_idx
, len
);
574 if
((dbg_parser.last_line_idx
+= len
) >= strlen
(dbg_parser.last_line
))
575 dbg_parser.last_line_idx
= 0;
579 int input_read_line
(const char* pfx
, char* buf
, int size
)
583 int len
= input_fetch_entire_line
(pfx
, &line
);
584 if
(len
< 0) return
0;
585 /* remove trailing \n and \r */
586 while
(len
> 0 && (line
[len
- 1] == '\n' || line
[len
- 1] == '\r')) len
--;
587 len
= min
(size
- 1, len
);
588 memcpy
(buf
, line
, len
);
594 /***********************************************************************
597 * Debugger command line parser
599 void parser_handle
(const char* filename
, HANDLE input
)
602 struct parser_context prev
= dbg_parser
;
606 if
(input
!= INVALID_HANDLE_VALUE
)
608 dbg_parser.output
= INVALID_HANDLE_VALUE
;
609 dbg_parser.input
= input
;
613 dbg_parser.output
= GetStdHandle
(STD_OUTPUT_HANDLE
);
614 dbg_parser.input
= GetStdHandle
(STD_INPUT_HANDLE
);
616 dbg_parser.line_no
= 0;
617 dbg_parser.filename
= filename
;
618 dbg_parser.last_line
= NULL
;
619 dbg_parser.last_line_idx
= 0;
627 __EXCEPT
(wine_dbg_cmd
)
639 static void parser
(const char* filename
)
641 HANDLE h
= CreateFileA
(filename
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0L, 0);
642 if
(h
!= INVALID_HANDLE_VALUE
)
644 parser_handle
(filename
, h
);
649 static int dbg_error
(const char* s
)
651 if
(dbg_parser.filename
)
652 dbg_printf
("%s:%d:", dbg_parser.filename
, dbg_parser.line_no
);
653 dbg_printf
("%s\n", s
);
657 HANDLE WINAPIV parser_generate_command_file
(const char* pmt
, ...
)
660 char path
[MAX_PATH
], file
[MAX_PATH
];
664 GetTempPathA
(sizeof
(path
), path
);
665 GetTempFileNameA
(path
, "WD", 0, file
);
666 hFile
= CreateFileA
(file
, GENERIC_READ|GENERIC_WRITE|DELETE
, FILE_SHARE_DELETE
,
667 NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE
, 0);
668 if
(hFile
!= INVALID_HANDLE_VALUE
)
672 WriteFile
(hFile
, pmt
, strlen
(pmt
), &w
, 0);
674 while
((p
= va_arg
(ap
, const char*)) != NULL
)
676 WriteFile
(hFile
, "\n", 1, &w
, 0);
677 WriteFile
(hFile
, p
, strlen
(p
), &w
, 0);
680 WriteFile
(hFile
, "\nquit\n", 6, &w
, 0);
681 SetFilePointer
(hFile
, 0, NULL
, FILE_BEGIN
);