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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include "wine/port.h"
31 #include "wine/exception.h"
36 int yyerror(const char*);
42 struct dbg_lvalue lvalue
;
45 IMAGEHLP_LINE listing
;
46 struct expr
* expression
;
47 struct type_expr_t type
;
50 %token tCONT tPASS tSTEP tLIST tNEXT tQUIT tHELP tBACKTRACE tALL tINFO tUP tDOWN
51 %token tENABLE tDISABLE tBREAK tWATCH tDELETE tSET tMODE tPRINT tEXAM tABORT tVM86
52 %token tCLASS tMAPS tSTACK tSEGMENTS tSYMBOL tREGS tWND tQUEUE tLOCAL tEXCEPTION
53 %token tPROCESS tTHREAD tMODREF tEOL tEOF
54 %token tFRAME tSHARE tCOND tDISPLAY tUNDISPLAY tDISASSEMBLE
55 %token tSTEPI tNEXTI tFINISH tSHOW tDIR tWHATIS tSOURCE
56 %token
<string> tPATH tIDENTIFIER tSTRING tDEBUGSTR tINTVAR
57 %token
<integer
> tNUM tFORMAT
58 %token tSYMBOLFILE tRUN tATTACH tDETACH tNOPROCESS tMAINTENANCE tTYPE
60 %token tCHAR tSHORT tINT tLONG tFLOAT tDOUBLE tUNSIGNED tSIGNED
61 %token tSTRUCT tUNION tENUM
64 /* %left '=' OP_OR_EQUAL OP_XOR_EQUAL OP_AND_EQUAL OP_SHL_EQUAL \
65 OP_SHR_EQUAL OP_PLUS_EQUAL OP_MINUS_EQUAL \
66 OP_TIMES_EQUAL OP_DIVIDE_EQUAL OP_MODULO_EQUAL */
67 /* %left OP_COND */ /* ... ? ... : ... */
74 %left
'<' '>' OP_LE OP_GE
78 %left OP_SIGN
'!' '~' OP_DEREF
/* OP_INC OP_DEC OP_ADDR */
82 %type
<expression
> expr lvalue
83 %type
<lvalue
> expr_lvalue lvalue_addr
84 %type
<integer
> expr_rvalue
85 %type
<string> pathname identifier
86 %type
<listing
> list_arg
87 %type
<type
> type_expr
97 command tEOL
{ expr_free_all
(); }
100 |
error tEOL
{ yyerrok; expr_free_all
(); }
105 | tHELP
{ print_help
(); }
106 | tHELP tINFO
{ info_help
(); }
107 | tPASS
{ dbg_wait_next_exception
(DBG_EXCEPTION_NOT_HANDLED
, 0, 0); }
108 | tCONT
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_cont
); }
109 | tCONT tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_cont
); }
110 | tSTEP
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_step_into_line
); }
111 | tSTEP tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_step_into_line
); }
112 | tNEXT
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_step_over_line
); }
113 | tNEXT tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_step_over_line
); }
114 | tSTEPI
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_step_into_insn
); }
115 | tSTEPI tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_step_into_insn
); }
116 | tNEXTI
{ dbg_wait_next_exception
(DBG_CONTINUE
, 1, dbg_exec_step_over_insn
); }
117 | tNEXTI tNUM
{ dbg_wait_next_exception
(DBG_CONTINUE
, $2, dbg_exec_step_over_insn
); }
118 | tFINISH
{ dbg_wait_next_exception
(DBG_CONTINUE
, 0, dbg_exec_finish
); }
119 | tABORT
{ abort
(); }
120 | tBACKTRACE
{ stack_backtrace
(dbg_curr_tid
, TRUE
); }
121 | tBACKTRACE tNUM
{ stack_backtrace
($2, TRUE
); }
122 | tBACKTRACE tALL
{ stack_backtrace
(-1, TRUE
); }
123 | tUP
{ stack_set_frame
(dbg_curr_frame
+ 1); }
124 | tUP tNUM
{ stack_set_frame
(dbg_curr_frame
+ $2); }
125 | tDOWN
{ stack_set_frame
(dbg_curr_frame
- 1); }
126 | tDOWN tNUM
{ stack_set_frame
(dbg_curr_frame
- $2); }
127 | tFRAME tNUM
{ stack_set_frame
($2); }
128 | tSHOW tDIR
{ source_show_path
(); }
129 | tDIR pathname
{ source_add_path
($2); }
130 | tDIR
{ source_nuke_path
(); }
131 | tCOND tNUM
{ break_add_condition
($2, NULL
); }
132 | tCOND tNUM expr
{ break_add_condition
($2, $3); }
133 | tSOURCE pathname
{ parser
($2); }
134 | tSYMBOLFILE pathname
{ symbol_read_symtable
($2, 0); }
135 | tSYMBOLFILE pathname expr_rvalue
{ symbol_read_symtable
($2, $3); }
136 | tWHATIS expr_lvalue
{ types_print_type
(&$2.type
, FALSE
); dbg_printf
("\n"); }
137 | tATTACH tNUM
{ dbg_attach_debuggee
($2, FALSE
, TRUE
); }
138 | tDETACH
{ dbg_detach_debuggee
(); }
141 | disassemble_command
149 | maintenance_command
154 identifier
{ $$
= $1; }
159 tIDENTIFIER
{ $$
= $1; }
160 | tIDENTIFIER
'!' tIDENTIFIER
{ char* ptr
= HeapAlloc
(GetProcessHeap
(), 0, strlen
($1) + 1 + strlen
($3) + 1);
161 sprintf
(ptr
, "%s!%s", $1, $3); $$
= lexeme_alloc
(ptr
);
162 HeapFree
(GetProcessHeap
(), 0, ptr
); }
163 | identifier
':' ':' tIDENTIFIER
{ char* ptr
= HeapAlloc
(GetProcessHeap
(), 0, strlen
($1) + 2 + strlen
($4) + 1);
164 sprintf
(ptr
, "%s::%s", $1, $4); $$
= lexeme_alloc
(ptr
);
165 HeapFree
(GetProcessHeap
(), 0, ptr
); }
169 tNUM
{ $$.FileName
= NULL
; $$.LineNumber
= $1; }
170 | pathname
':' tNUM
{ $$.FileName
= $1; $$.LineNumber
= $3; }
171 | identifier
{ symbol_get_line
(NULL
, $1, &$$
); }
172 | pathname
':' identifier
{ symbol_get_line
($3, $1, &$$
); }
173 |
'*' expr_lvalue
{ $$.SizeOfStruct
= sizeof
($$
);
174 SymGetLineFromAddr
(dbg_curr_process
->handle
, (unsigned long)memory_to_linear_addr
(& $2.addr
), NULL
, & $$
); }
178 tRUN
{ dbg_run_debuggee
(NULL
); }
179 | tRUN tSTRING
{ dbg_run_debuggee
($2); }
183 tLIST
{ source_list
(NULL
, NULL
, 10); }
184 | tLIST
'-' { source_list
(NULL
, NULL
, -10); }
185 | tLIST list_arg
{ source_list
(& $2, NULL
, 10); }
186 | tLIST
',' list_arg
{ source_list
(NULL
, & $3, -10); }
187 | tLIST list_arg
',' list_arg
{ source_list
(& $2, & $4, 0); }
191 tDISASSEMBLE
{ memory_disassemble
(NULL
, NULL
, 10); }
192 | tDISASSEMBLE expr_lvalue
{ memory_disassemble
(&$2, NULL
, 10); }
193 | tDISASSEMBLE expr_lvalue
',' expr_lvalue
{ memory_disassemble
(&$2, &$4, 0); }
197 tSET lvalue_addr
'=' expr_rvalue
{ memory_write_value
(&$2, sizeof
(int), &$4); }
198 | tSET
'+' tIDENTIFIER
{ info_wine_dbg_channel
(TRUE
, NULL
, $3); }
199 | tSET
'-' tIDENTIFIER
{ info_wine_dbg_channel
(FALSE
, NULL
, $3); }
200 | tSET tIDENTIFIER
'+' tIDENTIFIER
{ info_wine_dbg_channel
(TRUE
, $2, $4); }
201 | tSET tIDENTIFIER
'-' tIDENTIFIER
{ info_wine_dbg_channel
(FALSE
, $2, $4); }
205 tEXAM expr_rvalue
{ memory_examine
((void*)$2, 1, 'x'); }
206 | tEXAM tFORMAT expr_rvalue
{ memory_examine
((void*)$3, $2 >> 8, $2 & 0xff); }
210 tPRINT expr_lvalue
{ print_value
(&$2, 0, 0); }
211 | tPRINT tFORMAT expr_lvalue
{ if
(($2 >> 8) == 1) print_value
(&$3, $2 & 0xff, 0); else dbg_printf
("Count is meaningless in print command\n"); }
215 tBREAK
'*' expr_lvalue
{ break_add_break_from_lvalue
(&$3); }
216 | tBREAK identifier
{ break_add_break_from_id
($2, -1); }
217 | tBREAK identifier
':' tNUM
{ break_add_break_from_id
($2, $4); }
218 | tBREAK tNUM
{ break_add_break_from_lineno
($2); }
219 | tBREAK
{ break_add_break_from_lineno
(-1); }
220 | tENABLE tNUM
{ break_enable_xpoint
($2, TRUE
); }
221 | tENABLE tBREAK tNUM
{ break_enable_xpoint
($3, TRUE
); }
222 | tDISABLE tNUM
{ break_enable_xpoint
($2, FALSE
); }
223 | tDISABLE tBREAK tNUM
{ break_enable_xpoint
($3, FALSE
); }
224 | tDELETE tNUM
{ break_delete_xpoint
($2); }
225 | tDELETE tBREAK tNUM
{ break_delete_xpoint
($3); }
229 tWATCH
'*' expr_lvalue
{ break_add_watch
(&$3, 1); }
230 | tWATCH identifier
{ break_add_watch_from_id
($2); }
234 tDISPLAY
{ display_print
(); }
235 | tDISPLAY expr
{ display_add
($2, 1, 0, FALSE
); }
236 | tDISPLAY tFORMAT expr
{ display_add
($3, $2 >> 8, $2 & 0xff, FALSE
); }
237 | tLOCAL tDISPLAY expr
{ display_add
($3, 1, 0, TRUE
); }
238 | tLOCAL tDISPLAY tFORMAT expr
{ display_add
($4, $3 >> 8, $3 & 0xff, TRUE
); }
239 | tENABLE tDISPLAY tNUM
{ display_enable
($3, TRUE
); }
240 | tDISABLE tDISPLAY tNUM
{ display_enable
($3, FALSE
); }
241 | tDELETE tDISPLAY tNUM
{ display_delete
($3); }
242 | tDELETE tDISPLAY
{ display_delete
(-1); }
243 | tUNDISPLAY tNUM
{ display_delete
($2); }
244 | tUNDISPLAY
{ display_delete
(-1); }
248 tINFO tBREAK
{ break_info
(); }
249 | tINFO tSHARE
{ info_win32_module
(0); }
250 | tINFO tSHARE expr_rvalue
{ info_win32_module
($3); }
251 | tINFO tREGS
{ be_cpu
->print_context
(dbg_curr_thread
->handle
, &dbg_context
); }
252 | tINFO tSEGMENTS expr_rvalue
{ info_win32_segments
($3, 1); }
253 | tINFO tSEGMENTS
{ info_win32_segments
(0, -1); }
254 | tINFO tSTACK
{ stack_info
(); }
255 | tINFO tSYMBOL tSTRING
{ symbol_info
($3); }
256 | tINFO tLOCAL
{ symbol_info_locals
(); }
257 | tINFO tDISPLAY
{ display_info
(); }
258 | tINFO tCLASS
{ info_win32_class
(NULL
, NULL
); }
259 | tINFO tCLASS tSTRING
{ info_win32_class
(NULL
, $3); }
260 | tINFO tWND
{ info_win32_window
(NULL
, FALSE
); }
261 | tINFO tWND expr_rvalue
{ info_win32_window
((HWND
)$3, FALSE
); }
262 | tINFO
'*' tWND
{ info_win32_window
(NULL
, TRUE
); }
263 | tINFO
'*' tWND expr_rvalue
{ info_win32_window
((HWND
)$4, TRUE
); }
264 | tINFO tPROCESS
{ info_win32_processes
(); }
265 | tINFO tTHREAD
{ info_win32_threads
(); }
266 | tINFO tEXCEPTION
{ info_win32_exceptions
(dbg_curr_tid
); }
267 | tINFO tEXCEPTION expr_rvalue
{ info_win32_exceptions
($3); }
268 | tINFO tMAPS
{ info_win32_virtual
(dbg_curr_pid
); }
269 | tINFO tMAPS expr_rvalue
{ info_win32_virtual
($3); }
273 tMAINTENANCE tTYPE
{ print_types
(); }
277 tNOPROCESS
{} /* <CR> shall not barf anything */
278 | tNOPROCESS tBACKTRACE tALL
{ stack_backtrace
(-1, TRUE
); } /* can backtrace all threads with no attached process */
279 | tNOPROCESS tSTRING
{ dbg_printf
("No process loaded, cannot execute '%s'\n", $2); }
283 tCHAR
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_char
; }
284 | tINT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_signed_int
; }
285 | tLONG tINT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_signed_long_int
; }
286 | tLONG
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_signed_long_int
; }
287 | tUNSIGNED tINT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_int
; }
288 | tUNSIGNED
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_int
; }
289 | tLONG tUNSIGNED tINT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_long_int
; }
290 | tLONG tUNSIGNED
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_long_int
; }
291 | tSHORT tINT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_signed_short_int
; }
292 | tSHORT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_signed_short_int
; }
293 | tSHORT tUNSIGNED tINT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_short_int
; }
294 | tSHORT tUNSIGNED
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_short_int
; }
295 | tSIGNED tCHAR
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_signed_char_int
; }
296 | tUNSIGNED tCHAR
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_char_int
; }
297 | tLONG tLONG tUNSIGNED tINT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_longlong_int
; }
298 | tLONG tLONG tUNSIGNED
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_unsigned_longlong_int
; }
299 | tLONG tLONG tINT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_signed_longlong_int
; }
300 | tLONG tLONG
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_signed_longlong_int
; }
301 | tFLOAT
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_short_real
; }
302 | tDOUBLE
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_real
; }
303 | tLONG tDOUBLE
{ $$.type
= type_expr_type_id
; $$.deref_count
= 0; $$.u.type.module
= 0; $$.u.type.id
= dbg_itype_long_real
; }
304 | type_expr
'*' { $$
= $1; $$.deref_count
++; }
305 | tCLASS identifier
{ $$.type
= type_expr_udt_class
; $$.deref_count
= 0; $$.u.name
= lexeme_alloc
($2); }
306 | tSTRUCT identifier
{ $$.type
= type_expr_udt_struct
; $$.deref_count
= 0; $$.u.name
= lexeme_alloc
($2); }
307 | tUNION identifier
{ $$.type
= type_expr_udt_union
; $$.deref_count
= 0; $$.u.name
= lexeme_alloc
($2); }
308 | tENUM identifier
{ $$.type
= type_expr_enumeration
; $$.deref_count
= 0; $$.u.name
= lexeme_alloc
($2); }
312 expr
{ $$
= expr_eval
($1); }
316 expr_lvalue
{ $$
= types_extract_as_integer
(&$1); }
320 * The expr rule builds an expression tree. When we are done, we call
321 * EvalExpr to evaluate the value of the expression. The advantage of
322 * the two-step approach is that it is possible to save expressions for
323 * use in 'display' commands, and in conditional watchpoints.
326 tNUM
{ $$
= expr_alloc_sconstant
($1); }
327 | tSTRING
{ $$
= expr_alloc_string
($1); }
328 | tINTVAR
{ $$
= expr_alloc_internal_var
($1); }
329 | identifier
{ $$
= expr_alloc_symbol
($1); }
330 | expr OP_DRF tIDENTIFIER
{ $$
= expr_alloc_pstruct
($1, $3); }
331 | expr
'.' tIDENTIFIER
{ $$
= expr_alloc_struct
($1, $3); }
332 | identifier
'(' ')' { $$
= expr_alloc_func_call
($1, 0); }
333 | identifier
'(' expr
')' { $$
= expr_alloc_func_call
($1, 1, $3); }
334 | identifier
'(' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 2, $3, $5); }
335 | identifier
'(' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 3, $3, $5, $7); }
336 | identifier
'(' expr
',' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 4, $3, $5, $7, $9); }
337 | identifier
'(' expr
',' expr
',' expr
',' expr
',' expr
')' { $$
= expr_alloc_func_call
($1, 5, $3, $5, $7, $9, $11); }
338 | expr
'[' expr
']' { $$
= expr_alloc_binary_op
(EXP_OP_ARR
, $1, $3); }
339 | expr
':' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SEG
, $1, $3); }
340 | expr OP_LOR expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LOR
, $1, $3); }
341 | expr OP_LAND expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LAND
, $1, $3); }
342 | expr
'|' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_OR
, $1, $3); }
343 | expr
'&' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_AND
, $1, $3); }
344 | expr
'^' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_XOR
, $1, $3); }
345 | expr OP_EQ expr
{ $$
= expr_alloc_binary_op
(EXP_OP_EQ
, $1, $3); }
346 | expr
'>' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_GT
, $1, $3); }
347 | expr
'<' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LT
, $1, $3); }
348 | expr OP_GE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_GE
, $1, $3); }
349 | expr OP_LE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_LE
, $1, $3); }
350 | expr OP_NE expr
{ $$
= expr_alloc_binary_op
(EXP_OP_NE
, $1, $3); }
351 | expr OP_SHL expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SHL
, $1, $3); }
352 | expr OP_SHR expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SHR
, $1, $3); }
353 | expr
'+' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_ADD
, $1, $3); }
354 | expr
'-' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_SUB
, $1, $3); }
355 | expr
'*' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_MUL
, $1, $3); }
356 | expr
'/' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_DIV
, $1, $3); }
357 | expr
'%' expr
{ $$
= expr_alloc_binary_op
(EXP_OP_REM
, $1, $3); }
358 |
'-' expr %prec OP_SIGN
{ $$
= expr_alloc_unary_op
(EXP_OP_NEG
, $2); }
359 |
'+' expr %prec OP_SIGN
{ $$
= $2; }
360 |
'!' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_NOT
, $2); }
361 |
'~' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_LNOT
, $2); }
362 |
'(' expr
')' { $$
= $2; }
363 |
'*' expr %prec OP_DEREF
{ $$
= expr_alloc_unary_op
(EXP_OP_DEREF
, $2); }
364 |
'&' expr %prec OP_DEREF
{ $$
= expr_alloc_unary_op
(EXP_OP_ADDR
, $2); }
365 |
'(' type_expr
')' expr %prec OP_DEREF
{ $$
= expr_alloc_typecast
(&$2, $4); }
369 * The lvalue rule builds an expression tree. This is a limited form
370 * of expression that is suitable to be used as an lvalue.
373 lvalue
{ $$
= expr_eval
($1); }
376 lvalue: tNUM
{ $$
= expr_alloc_sconstant
($1); }
377 | tINTVAR
{ $$
= expr_alloc_internal_var
($1); }
378 | identifier
{ $$
= expr_alloc_symbol
($1); }
379 | lvalue OP_DRF tIDENTIFIER
{ $$
= expr_alloc_pstruct
($1, $3); }
380 | lvalue
'.' tIDENTIFIER
{ $$
= expr_alloc_struct
($1, $3); }
381 | lvalue
'[' expr
']' { $$
= expr_alloc_binary_op
(EXP_OP_ARR
, $1, $3); }
382 |
'*' expr
{ $$
= expr_alloc_unary_op
(EXP_OP_FORCE_DEREF
, $2); }
387 static WINE_EXCEPTION_FILTER
(wine_dbg_cmd
)
389 switch
(GetExceptionCode
())
391 case DEBUG_STATUS_INTERNAL_ERROR
:
392 dbg_printf
("\nWineDbg internal error\n");
394 case DEBUG_STATUS_NO_SYMBOL
:
395 dbg_printf
("\nUndefined symbol\n");
397 case DEBUG_STATUS_DIV_BY_ZERO
:
398 dbg_printf
("\nDivision by zero\n");
400 case DEBUG_STATUS_BAD_TYPE
:
401 dbg_printf
("\nNo type or type mismatch\n");
403 case DEBUG_STATUS_NO_FIELD
:
404 dbg_printf
("\nNo such field in structure or union\n");
406 case DEBUG_STATUS_CANT_DEREF
:
407 dbg_printf
("\nDereference failed (not a pointer, or out of array bounds)\n");
409 case DEBUG_STATUS_ABORT
:
411 case DEBUG_STATUS_NOT_AN_INTEGER
:
412 dbg_printf
("\nNeeding an integral value\n");
415 /* this is generally sent by a ctrl-c when we run winedbg outside of wineconsole */
416 dbg_printf
("\nCtrl-C\n");
417 /* stop the debuggee, and continue debugger execution, we will be reentered by the
418 * debug events generated by stopping
420 dbg_interrupt_debuggee
();
421 return EXCEPTION_CONTINUE_EXECUTION
;
423 dbg_printf
("\nException %lx\n", GetExceptionCode
());
427 return EXCEPTION_EXECUTE_HANDLER
;
431 #define whitespace(c) (((c) == ' ') || ((c) == '\t'))
434 /* Strip whitespace from the start and end of STRING. */
435 static void stripwhite
(char *string)
439 for
(i
= 0; whitespace
(string[i
]); i
++);
440 if
(i
) strcpy
(string, string + i
);
442 last
= i
= strlen
(string) - 1;
443 if
(string[last
] == '\n') i
--;
445 while
(i
> 0 && whitespace
(string[i
])) i
--;
446 if
(string[last
] == '\n')
451 static HANDLE dbg_parser_input
;
452 static HANDLE dbg_parser_output
;
454 /* command passed in the command line arguments */
455 char *arg_command
= NULL
;
457 int input_fetch_entire_line
(const char* pfx
, char** line
, size_t* alloc
, BOOL check_nl
)
465 arg_command
= "quit\n"; /* we only run one command before exiting */
469 /* as of today, console handles can be file handles... so better use file APIs rather than
472 WriteFile
(dbg_parser_output
, pfx
, strlen
(pfx
), NULL
, NULL
);
477 if
(!ReadFile
(dbg_parser_input
, buf_line
, sizeof
(buf_line
) - 1, &nread
, NULL
) || nread
== 0)
479 buf_line
[nread
] = '\0';
481 if
(check_nl
&& len
== 0 && nread
== 1 && buf_line
[0] == '\n')
484 /* store stuff at the end of last_line */
485 if
(len
+ nread
+ 1 > *alloc
)
487 while
(len
+ nread
+ 1 > *alloc
) *alloc
*= 2;
488 *line
= dbg_heap_realloc
(*line
, *alloc
);
490 strcpy
(*line
+ len
, buf_line
);
492 } while
(nread
== 0 || buf_line
[nread
- 1] != '\n');
496 *line
= HeapReAlloc
(GetProcessHeap
(), 0, *line
, *alloc
= 1);
500 /* Remove leading and trailing whitespace from the line */
505 int input_read_line
(const char* pfx
, char* buf
, int size
)
510 /* first alloc of our current buffer */
511 line
= HeapAlloc
(GetProcessHeap
(), 0, len
= 2);
516 input_fetch_entire_line
(pfx
, &line
, &len
, FALSE
);
518 /* remove trailing \n */
519 if
(len
> 0 && line
[len
- 1] == '\n') len
--;
520 len
= min
(size
- 1, len
);
521 memcpy
(buf
, line
, len
);
523 HeapFree
(GetProcessHeap
(), 0, line
);
527 /***********************************************************************
530 * Debugger command line parser
532 void parser
(const char* filename
)
535 HANDLE in_copy
= dbg_parser_input
;
536 HANDLE out_copy
= dbg_parser_output
;
546 HANDLE h
= CreateFile
(filename
, GENERIC_READ
, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
, 0L, 0);
547 if
(h
== INVALID_HANDLE_VALUE
) return
;
548 dbg_parser_output
= 0;
549 dbg_parser_input
= h
;
553 dbg_parser_output
= GetStdHandle
(STD_OUTPUT_HANDLE
);
554 dbg_parser_input
= GetStdHandle
(STD_INPUT_HANDLE
);
564 __EXCEPT
(wine_dbg_cmd
)
572 if
(filename
) CloseHandle
(dbg_parser_input
);
573 dbg_parser_input
= in_copy
;
574 dbg_parser_output
= out_copy
;
577 int yyerror(const char* s
)
579 dbg_printf
("%s\n", s
);