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
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 tRUN tATTACH tDETACH tKILL tMAINTENANCE tTYPE tMINIDUMP
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
); dbg_printf
("\n"); }
143 | tATTACH tNUM
{ dbg_attach_debuggee
($2); dbg_active_wait_for_first_exception
(); }
144 | tDETACH
{ dbg_curr_process
->process_io
->close_process
(dbg_curr_process
, FALSE
); }
145 | tTHREAD tNUM
{ dbg_set_curr_thread
($2); }
146 | tKILL
{ dbg_curr_process
->process_io
->close_process
(dbg_curr_process
, TRUE
); }
147 | tMINIDUMP pathname
{ minidump_write
($2, (dbg_curr_thread
&& dbg_curr_thread
->in_exception
) ?
&dbg_curr_thread
->excpt_record
: NULL
);}
148 | tECHO tSTRING
{ dbg_printf
("%s\n", $2); }
151 | disassemble_command
159 | maintenance_command
164 identifier
{ $$
= $1; }
165 | tSTRING
{ $$
= $1; }
170 tIDENTIFIER
{ $$
= $1; }
174 tNUM
{ $$.FileName
= NULL
; $$.LineNumber
= $1; }
175 | pathname
':' tNUM
{ $$.FileName
= $1; $$.LineNumber
= $3; }
176 | identifier
{ symbol_get_line
(NULL
, $1, &$$
); }
177 | pathname
':' identifier
{ symbol_get_line
($1, $3, &$$
); }
178 |
'*' expr_lvalue
{ DWORD disp
; ADDRESS64 addr
; $$.SizeOfStruct
= sizeof
($$
);
179 types_extract_as_address
(&$2, &addr
);
180 SymGetLineFromAddr64
(dbg_curr_process
->handle
, (ULONG_PTR
)memory_to_linear_addr
(& addr
), &disp
, & $$
); }
184 tRUN list_of_words
{ dbg_run_debuggee
($2); }
188 %empty
{ $$
= NULL
; }
189 | tSTRING list_of_words
{ $$
= (struct list_string
*)lexeme_alloc_size
(sizeof
(*$$
)); $$
->next
= $2; $$
->string = $1; }
193 tLIST
{ source_list
(NULL
, NULL
, 10); }
194 | tLIST
'-' { source_list
(NULL
, NULL
, -10); }
195 | tLIST list_arg
{ source_list
(& $2, NULL
, 10); }
196 | tLIST
',' list_arg
{ source_list
(NULL
, & $3, -10); }
197 | tLIST list_arg
',' list_arg
{ source_list
(& $2, & $4, 0); }
201 tDISASSEMBLE
{ memory_disassemble
(NULL
, NULL
, 10); }
202 | tDISASSEMBLE expr_lvalue
{ memory_disassemble
(&$2, NULL
, 10); }
203 | tDISASSEMBLE expr_lvalue
',' expr_lvalue
{ memory_disassemble
(&$2, &$4, 0); }
207 tSET lvalue_addr
'=' expr_lvalue
{ types_store_value
(&$2, &$4); }
208 | tSET
'+' tIDENTIFIER
{ info_wine_dbg_channel
(TRUE
, NULL
, $3); }
209 | tSET
'+' tALL
{ info_wine_dbg_channel
(TRUE
, NULL
, "all"); }
210 | tSET
'-' tIDENTIFIER
{ info_wine_dbg_channel
(FALSE
, NULL
, $3); }
211 | tSET
'-' tALL
{ info_wine_dbg_channel
(FALSE
, NULL
, "all"); }
212 | tSET tIDENTIFIER
'+' tIDENTIFIER
{ info_wine_dbg_channel
(TRUE
, $2, $4); }
213 | tSET tIDENTIFIER
'+' tALL
{ info_wine_dbg_channel
(TRUE
, $2, "all"); }
214 | tSET tIDENTIFIER
'-' tIDENTIFIER
{ info_wine_dbg_channel
(FALSE
, $2, $4); }
215 | tSET tIDENTIFIER
'-' tALL
{ info_wine_dbg_channel
(FALSE
, $2, "all"); }
216 | tSET
'!' tIDENTIFIER tIDENTIFIER
{ dbg_set_option
($3, $4); }
217 | tSET
'!' tIDENTIFIER
{ dbg_set_option
($3, NULL
); }
221 tEXAM expr_lvalue
{ memory_examine
(&$2, 1, 'x'); }
222 | tEXAM tFORMAT expr_lvalue
{ memory_examine
(&$3, $2 >> 8, $2 & 0xff); }
226 tPRINT expr_lvalue
{ print_value
(&$2, 0, 0); }
227 | tPRINT tFORMAT expr_lvalue
{ if
(($2 >> 8) == 1) print_value
(&$3, $2 & 0xff, 0); else dbg_printf
("Count is meaningless in print command\n"); }
228 | tPRINT type_expr
{ types_print_type
(&$2, TRUE
); dbg_printf
("\n"); }
232 tBREAK
'*' expr_lvalue
{ break_add_break_from_lvalue
(&$3, TRUE
); }
233 | tBREAK identifier
{ break_add_break_from_id
($2, -1, TRUE
); }
234 | tBREAK pathname
':' tNUM
{ break_add_break_from_lineno
($2, $4, TRUE
); }
235 | tBREAK tNUM
{ break_add_break_from_lineno
(NULL
, $2, TRUE
); }
236 | tBREAK
{ break_add_break_from_lineno
(NULL
, -1, TRUE
); }
237 | tHBREAK
'*' expr_lvalue
{ break_add_break_from_lvalue
(&$3, FALSE
); }
238 | tHBREAK identifier
{ break_add_break_from_id
($2, -1, FALSE
); }
239 | tHBREAK pathname
':' tNUM
{ break_add_break_from_lineno
($2, $4, FALSE
); }
240 | tHBREAK tNUM
{ break_add_break_from_lineno
(NULL
, $2, FALSE
); }
241 | tHBREAK
{ break_add_break_from_lineno
(NULL
, -1, FALSE
); }
242 | tENABLE tNUM
{ break_enable_xpoint
($2, TRUE
); }
243 | tENABLE tBREAK tNUM
{ break_enable_xpoint
($3, TRUE
); }
244 | tDISABLE tNUM
{ break_enable_xpoint
($2, FALSE
); }
245 | tDISABLE tBREAK tNUM
{ break_enable_xpoint
($3, FALSE
); }
246 | tDELETE tNUM
{ break_delete_xpoint
($2); }
247 | tDELETE tBREAK tNUM
{ break_delete_xpoint
($3); }
251 tWATCH
'*' expr_lvalue
{ break_add_watch_from_lvalue
(&$3, TRUE
); }
252 | tWATCH identifier
{ break_add_watch_from_id
($2, TRUE
); }
253 | tRWATCH
'*' expr_lvalue
{ break_add_watch_from_lvalue
(&$3, FALSE
); }
254 | tRWATCH identifier
{ break_add_watch_from_id
($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); }
273 | tINFO tSHARE expr_rvalue
{ info_win32_module
($3); }
274 | tINFO tREGS
{ dbg_curr_process
->be_cpu
->print_context
(dbg_curr_thread
->handle
, &dbg_context
, 0); }
275 | tINFO tALLREGS
{ dbg_curr_process
->be_cpu
->print_context
(dbg_curr_thread
->handle
, &dbg_context
, 1); }
276 | tINFO tSEGMENTS expr_rvalue
{ info_win32_segments
($3 >> 3, 1); }
277 | tINFO tSEGMENTS
{ info_win32_segments
(0, -1); }
278 | tINFO tSTACK tNUM
{ stack_info
($3); }
279 | tINFO tSTACK
{ stack_info
(-1); }
280 | tINFO tSYMBOL tSTRING
{ symbol_info
($3); }
281 | tINFO tLOCAL
{ symbol_info_locals
(); }
282 | tINFO tDISPLAY
{ display_info
(); }
283 | tINFO tCLASS
{ info_win32_class
(NULL
, NULL
); }
284 | tINFO tCLASS tSTRING
{ info_win32_class
(NULL
, $3); }
285 | tINFO tWND
{ info_win32_window
(NULL
, FALSE
); }
286 | tINFO tWND expr_rvalue
{ info_win32_window
((HWND
)(DWORD_PTR
)$3, FALSE
); }
287 | tINFO
'*' tWND
{ info_win32_window
(NULL
, TRUE
); }
288 | tINFO
'*' tWND expr_rvalue
{ info_win32_window
((HWND
)(DWORD_PTR
)$4, TRUE
); }
289 | tINFO tPROCESS
{ info_win32_processes
(); }
290 | tINFO tTHREAD
{ info_win32_threads
(); }
291 | tINFO tFRAME
{ info_win32_frame_exceptions
(dbg_curr_tid
); }
292 | tINFO tFRAME expr_rvalue
{ info_win32_frame_exceptions
($3); }
293 | tINFO tMAPS
{ info_win32_virtual
(dbg_curr_pid
); }
294 | tINFO tMAPS expr_rvalue
{ info_win32_virtual
($3); }
295 | tINFO tEXCEPTION
{ info_win32_exception
(); }
299 tMAINTENANCE tTYPE
{ print_types
(); }
300 | tMAINTENANCE tMODULE tSTRING
{ tgt_module_load
($3, FALSE
); }
301 | tMAINTENANCE
'*' tMODULE tSTRING
{ tgt_module_load
($4, TRUE
); }
305 tNOPROCESS
{} /* <CR> shall not barf anything */
306 | tNOPROCESS tBACKTRACE tALL
{ stack_backtrace
(-1); } /* can backtrace all threads with no attached process */
307 | tNOPROCESS tSTRING
{ dbg_printf
("No process loaded, cannot execute '%s'\n", $2); }
311 tVOID
{ if
(!types_find_basic
(L
"void", $1, &$$
)) YYERROR; }
312 | tCHAR
{ if
(!types_find_basic
(L
"char", $1, &$$
)) YYERROR; }
313 | tWCHAR
{ if
(!types_find_basic
(L
"WCHAR", $1, &$$
)) YYERROR; }
314 | tSIGNED tCHAR
{ if
(!types_find_basic
(L
"signed char", $1, &$$
)) YYERROR; }
315 | tUNSIGNED tCHAR
{ if
(!types_find_basic
(L
"unsigned char", $1, &$$
)) YYERROR; }
316 | tSHORT tINT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
317 | tSHORT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
318 | tSIGNED tSHORT tINT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
319 | tSIGNED tSHORT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
320 | tSHORT tSIGNED tINT
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
321 | tSHORT tSIGNED
{ if
(!types_find_basic
(L
"short int", $1, &$$
)) YYERROR; }
322 | tSHORT tUNSIGNED
{ if
(!types_find_basic
(L
"unsigned short int", $1, &$$
)) YYERROR; }
323 | tSHORT tUNSIGNED tINT
{ if
(!types_find_basic
(L
"unsigned short int", $1, &$$
)) YYERROR; }
324 | tUNSIGNED tSHORT
{ if
(!types_find_basic
(L
"unsigned short int", $1, &$$
)) YYERROR; }
325 | tUNSIGNED tSHORT tINT
{ if
(!types_find_basic
(L
"unsigned short int", $1, &$$
)) YYERROR; }
326 | tINT
{ if
(!types_find_basic
(L
"int", $1, &$$
)) YYERROR; }
327 | tSIGNED tINT
{ if
(!types_find_basic
(L
"int", $1, &$$
)) YYERROR; }
328 | tUNSIGNED
{ if
(!types_find_basic
(L
"unsigned int", $1, &$$
)) YYERROR; }
329 | tUNSIGNED tINT
{ if
(!types_find_basic
(L
"unsigned int", $1, &$$
)) YYERROR; }
330 | tLONG
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
331 | tLONG tINT
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
332 | tSIGNED tLONG
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
333 | tSIGNED tLONG tINT
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
334 | tLONG tSIGNED
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
335 | tLONG tSIGNED tINT
{ if
(!types_find_basic
(L
"long int", $1, &$$
)) YYERROR; }
336 | tLONG tUNSIGNED
{ if
(!types_find_basic
(L
"unsigned long int", $1, &$$
)) YYERROR; }
337 | tLONG tUNSIGNED tINT
{ if
(!types_find_basic
(L
"unsigned long int", $1, &$$
)) YYERROR; }
338 | tUNSIGNED tLONG
{ if
(!types_find_basic
(L
"unsigned long int", $1, &$$
)) YYERROR; }
339 | tUNSIGNED tLONG tINT
{ if
(!types_find_basic
(L
"unsigned long int", $1, &$$
)) YYERROR; }
340 | tLONG tLONG
{ if
(!types_find_basic
(L
"long long int", $1, &$$
)) YYERROR; }
341 | tLONG tLONG tINT
{ if
(!types_find_basic
(L
"long long int", $1, &$$
)) YYERROR; }
342 | tSIGNED tLONG tLONG
{ if
(!types_find_basic
(L
"long long int", $1, &$$
)) YYERROR; }
343 | tSIGNED tLONG tLONG tINT
{ if
(!types_find_basic
(L
"long long int", $1, &$$
)) YYERROR; }
344 | tUNSIGNED tLONG tLONG
{ if
(!types_find_basic
(L
"unsigned long long int", $1, &$$
)) YYERROR; }
345 | tUNSIGNED tLONG tLONG tINT
{ if
(!types_find_basic
(L
"unsigned long long int", $1, &$$
)) YYERROR; }
346 | tLONG tLONG tUNSIGNED
{ if
(!types_find_basic
(L
"unsigned long long int", $1, &$$
)) YYERROR; }
347 | tLONG tLONG tUNSIGNED tINT
{ if
(!types_find_basic
(L
"unsigned long long int", $1, &$$
)) YYERROR; }
348 | tFLOAT
{ if
(!types_find_basic
(L
"float", $1, &$$
)) YYERROR; }
349 | tDOUBLE
{ if
(!types_find_basic
(L
"double", $1, &$$
)) YYERROR; }
350 | tLONG tDOUBLE
{ if
(!types_find_basic
(L
"long double", $1, &$$
)) YYERROR; }
351 | tTYPEDEF
{ $$
= $1; }
352 | type_expr
'*' { if
(!types_find_pointer
(&$1, &$$
)) {yyerror("Cannot find pointer type\n"); YYERROR; } }
353 | tCLASS identifier
{ if
(!types_find_type
($2, SymTagUDT
, &$$
)) {yyerror("Unknown type\n"); YYERROR; } }
354 | tSTRUCT identifier
{ if
(!types_find_type
($2, SymTagUDT
, &$$
)) {yyerror("Unknown type\n"); YYERROR; } }
355 | tUNION identifier
{ if
(!types_find_type
($2, SymTagUDT
, &$$
)) {yyerror("Unknown type\n"); YYERROR; } }
356 | tENUM identifier
{ if
(!types_find_type
($2, SymTagEnum
, &$$
)) {yyerror("Unknown type\n"); YYERROR; } }
360 expr
{ $$
= expr_eval
($1); }
364 expr_lvalue
{ $$
= types_extract_as_integer
(&$1); }
368 * The expr rule builds an expression tree. When we are done, we call
369 * EvalExpr to evaluate the value of the expression. The advantage of
370 * the two-step approach is that it is possible to save expressions for
371 * use in 'display' commands, and in conditional watchpoints.
374 tNUM
{ $$
= expr_alloc_sconstant
($1); }
375 | tSTRING
{ $$
= expr_alloc_string
($1); }
376 | tINTVAR
{ $$
= expr_alloc_internal_var
($1); }
377 | identifier
{ $$
= expr_alloc_symbol
($1); }
378 | expr OP_DRF tIDENTIFIER
{ $$
= expr_alloc_pstruct
($1, $3); }
379 | expr
'.' tIDENTIFIER
{ $$
= expr_alloc_struct
($1, $3); }
380 | identifier
'(' ')' { $$
= expr_alloc_func_call
($1, 0); }
381 | identifier
'(' expr
')' { $$
= expr_alloc_func_call
($1, 1, $3); }
382 | identifier
'(' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 2, $3, $5); }
383 | identifier
'(' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 3, $3, $5, $7); }
384 | identifier
'(' expr
',' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 4, $3, $5, $7, $9); }
385 | identifier
'(' expr
',' expr
',' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 5, $3, $5, $7, $9, $11); }
386 | expr
'[' expr
']' { $$
= expr_alloc_binary_op
(EXP_OP_ARR
, $1, $3); }
387 | expr
':' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SEG
, $1, $3); }
388 | expr OP_LOR expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LOR
, $1, $3); }
389 | expr OP_LAND expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LAND
, $1, $3); }
390 | expr
'|' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_OR
, $1, $3); }
391 | expr
'&' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_AND
, $1, $3); }
392 | expr
'^' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_XOR
, $1, $3); }
393 | expr OP_EQ expr
{ $$
= expr_alloc_binary_op
(EXP_OP_EQ
, $1, $3); }
394 | expr
'>' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_GT
, $1, $3); }
395 | expr
'<' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LT
, $1, $3); }
396 | expr OP_GE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_GE
, $1, $3); }
397 | expr OP_LE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LE
, $1, $3); }
398 | expr OP_NE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_NE
, $1, $3); }
399 | expr OP_SHL expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SHL
, $1, $3); }
400 | expr OP_SHR expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SHR
, $1, $3); }
401 | expr
'+' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_ADD
, $1, $3); }
402 | expr
'-' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SUB
, $1, $3); }
403 | expr
'*' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_MUL
, $1, $3); }
404 | expr
'/' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_DIV
, $1, $3); }
405 | expr
'%' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_REM
, $1, $3); }
406 |
'-' expr %prec OP_SIGN
{ $$
= expr_alloc_unary_op
(EXP_OP_NEG
, $2); }
407 |
'+' expr %prec OP_SIGN
{ $$
= $2; }
408 |
'!' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_NOT
, $2); }
409 |
'~' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_LNOT
, $2); }
410 |
'(' expr
')' { $$
= $2; }
411 |
'*' expr %prec OP_DEREF
{ $$
= expr_alloc_unary_op
(EXP_OP_DEREF
, $2); }
412 |
'&' expr %prec OP_DEREF
{ $$
= expr_alloc_unary_op
(EXP_OP_ADDR
, $2); }
413 |
'(' type_expr
')' expr %prec OP_DEREF
{ $$
= expr_alloc_typecast
(&$2, $4); }
417 * The lvalue rule builds an expression tree. This is a limited form
418 * of expression that is suitable to be used as an lvalue.
421 lvalue
{ $$
= expr_eval
($1); }
425 tNUM
{ $$
= expr_alloc_sconstant
($1); }
426 | tINTVAR
{ $$
= expr_alloc_internal_var
($1); }
427 | identifier
{ $$
= expr_alloc_symbol
($1); }
428 | lvalue OP_DRF tIDENTIFIER
{ $$
= expr_alloc_pstruct
($1, $3); }
429 | lvalue
'.' tIDENTIFIER
{ $$
= expr_alloc_struct
($1, $3); }
430 | lvalue
'[' expr
']' { $$
= expr_alloc_binary_op
(EXP_OP_ARR
, $1, $3); }
431 |
'*' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_DEREF
, $2); }
436 static LONG WINAPI wine_dbg_cmd
(EXCEPTION_POINTERS
*eptr
)
438 switch
(eptr
->ExceptionRecord
->ExceptionCode
)
440 case DEBUG_STATUS_INTERNAL_ERROR
:
441 dbg_printf
("\nWineDbg internal error\n");
443 case DEBUG_STATUS_NO_SYMBOL
:
444 dbg_printf
("\nUndefined symbol\n");
446 case DEBUG_STATUS_DIV_BY_ZERO
:
447 dbg_printf
("\nDivision by zero\n");
449 case DEBUG_STATUS_BAD_TYPE
:
450 dbg_printf
("\nNo type or type mismatch\n");
452 case DEBUG_STATUS_NO_FIELD
:
453 dbg_printf
("\nNo such field in structure or union\n");
455 case DEBUG_STATUS_CANT_DEREF
:
456 dbg_printf
("\nDereference failed (not a pointer, or out of array bounds)\n");
458 case DEBUG_STATUS_ABORT
:
460 case DEBUG_STATUS_NOT_AN_INTEGER
:
461 dbg_printf
("\nNeeding an integral value\n");
464 /* this is generally sent by a ctrl-c when we run winedbg outside of wineconsole */
465 /* stop the debuggee, and continue debugger execution, we will be reentered by the
466 * debug events generated by stopping
468 dbg_interrupt_debuggee
();
469 return EXCEPTION_CONTINUE_EXECUTION
;
471 dbg_printf
("\nException %lx\n", eptr
->ExceptionRecord
->ExceptionCode
);
475 return EXCEPTION_EXECUTE_HANDLER
;
478 struct parser_context
480 const char* filename
;
485 size_t last_line_idx
;
488 static struct parser_context dbg_parser
= {NULL
, INVALID_HANDLE_VALUE
, INVALID_HANDLE_VALUE
, 0, NULL
, 0};
490 static int input_fetch_entire_line
(const char* pfx
, char** line
)
497 /* as of today, console handles can be file handles... so better use file APIs rather than
500 WriteFile
(dbg_parser.output
, pfx
, strlen
(pfx
), &nread
, NULL
);
502 buffer
= HeapAlloc
(GetProcessHeap
(), 0, alloc
= 16);
503 assert
(buffer
!= NULL
);
505 dbg_parser.line_no
++;
509 if
(!ReadFile
(dbg_parser.input
, &ch
, 1, &nread
, NULL
) || nread
== 0)
511 HeapFree
(GetProcessHeap
(), 0, buffer
);
517 while
(len
+ 2 > alloc
) alloc
*= 2;
518 buffer
= dbg_heap_realloc
(buffer
, alloc
);
529 size_t input_lex_read_buffer
(char* buf
, int size
)
533 /* try first to fetch the remaining of an existing line */
534 if
(dbg_parser.last_line_idx
== 0)
537 /* no remaining chars to be read from last line, grab a brand new line up to '\n' */
539 len
= input_fetch_entire_line
("Wine-dbg>", &tmp
);
540 if
(len
< 0) return
0; /* eof */
542 /* remove carriage return in newline */
543 if
(len
>= 2 && tmp
[len
- 2] == '\r')
550 /* recall last command when empty input buffer and not parsing a file */
551 if
(dbg_parser.last_line
&& (len
== 0 ||
(len
== 1 && tmp
[0] == '\n')) &&
552 dbg_parser.output
!= INVALID_HANDLE_VALUE
)
554 HeapFree
(GetProcessHeap
(), 0, tmp
);
558 HeapFree
(GetProcessHeap
(), 0, dbg_parser.last_line
);
559 dbg_parser.last_line
= tmp
;
563 len
= min
(strlen
(dbg_parser.last_line
+ dbg_parser.last_line_idx
), size
- 1);
564 memcpy
(buf
, dbg_parser.last_line
+ dbg_parser.last_line_idx
, len
);
566 if
((dbg_parser.last_line_idx
+= len
) >= strlen
(dbg_parser.last_line
))
567 dbg_parser.last_line_idx
= 0;
571 int input_read_line
(const char* pfx
, char* buf
, int size
)
575 int len
= input_fetch_entire_line
(pfx
, &line
);
576 if
(len
< 0) return
0;
577 /* remove trailing \n and \r */
578 while
(len
> 0 && (line
[len
- 1] == '\n' || line
[len
- 1] == '\r')) len
--;
579 len
= min
(size
- 1, len
);
580 memcpy
(buf
, line
, len
);
582 HeapFree
(GetProcessHeap
(), 0, line
);
586 /***********************************************************************
589 * Debugger command line parser
591 void parser_handle
(const char* filename
, HANDLE input
)
594 struct parser_context prev
= dbg_parser
;
598 if
(input
!= INVALID_HANDLE_VALUE
)
600 dbg_parser.output
= INVALID_HANDLE_VALUE
;
601 dbg_parser.input
= input
;
605 dbg_parser.output
= GetStdHandle
(STD_OUTPUT_HANDLE
);
606 dbg_parser.input
= GetStdHandle
(STD_INPUT_HANDLE
);
608 dbg_parser.line_no
= 0;
609 dbg_parser.filename
= filename
;
610 dbg_parser.last_line
= NULL
;
611 dbg_parser.last_line_idx
= 0;
619 __EXCEPT
(wine_dbg_cmd
)
630 static void parser
(const char* filename
)
632 HANDLE h
= CreateFileA
(filename
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0L, 0);
633 if
(h
!= INVALID_HANDLE_VALUE
)
635 parser_handle
(filename
, h
);
640 static int dbg_error
(const char* s
)
642 if
(dbg_parser.filename
)
643 dbg_printf
("%s:%d:", dbg_parser.filename
, dbg_parser.line_no
);
644 dbg_printf
("%s\n", s
);
648 HANDLE WINAPIV parser_generate_command_file
(const char* pmt
, ...
)
651 char path
[MAX_PATH
], file
[MAX_PATH
];
655 GetTempPathA
(sizeof
(path
), path
);
656 GetTempFileNameA
(path
, "WD", 0, file
);
657 hFile
= CreateFileA
(file
, GENERIC_READ|GENERIC_WRITE|DELETE
, FILE_SHARE_DELETE
,
658 NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE
, 0);
659 if
(hFile
!= INVALID_HANDLE_VALUE
)
663 WriteFile
(hFile
, pmt
, strlen
(pmt
), &w
, 0);
665 while
((p
= va_arg
(ap
, const char*)) != NULL
)
667 WriteFile
(hFile
, "\n", 1, &w
, 0);
668 WriteFile
(hFile
, p
, strlen
(p
), &w
, 0);
671 WriteFile
(hFile
, "\nquit\n", 6, &w
, 0);
672 SetFilePointer
(hFile
, 0, NULL
, FILE_BEGIN
);