?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winedbg: Enhance printing of variables or fields.
[wine.git] / programs / winedbg / expr.c
blob85e28331864aad92f8164e84057a4f6b1c9e23d4
1 /*
2 * File expr.c - expression handling for Wine internal debugger.
3 *
4 * Copyright (C) 1997, Eric Youngdale.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdlib.h>
22 #include <string.h>
23 #include <stdarg.h>
24
25 #include "debugger.h"
26 #include "expr.h"
27 #include "wine/debug.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(winedbg);
30
31 struct expr
32 {
33 unsigned int type;
34 union
35 {
36 struct
37 {
38 dbg_lgint_t value;
39 } s_const;
40
41 struct
42 {
43 dbg_lguint_t value;
44 } u_const;
45
46 struct
47 {
48 const char* str;
49 } string;
50
51 struct
52 {
53 const char* name;
54 } symbol;
55
56 struct
57 {
58 const char* name;
59 } intvar;
60
61 struct
62 {
63 int unop_type;
64 struct expr* exp1;
65 dbg_lgint_t result;
66 } unop;
67
68 struct
69 {
70 int binop_type;
71 struct expr* exp1;
72 struct expr* exp2;
73 dbg_lgint_t result;
74 } binop;
75
76 struct
77 {
78 struct dbg_type cast_to;
79 struct expr* expr;
80 dbg_lgint_t result;
81 } cast;
82
83 struct
84 {
85 struct expr* exp1;
86 const char* element_name;
87 } structure;
88
89 struct
90 {
91 const char* funcname;
92 int nargs;
93 struct expr* arg[5];
94 dbg_lguint_t result;
95 } call;
96
97 } un;
98 };
99
100 #define EXPR_TYPE_S_CONST 0
101 #define EXPR_TYPE_U_CONST 1
102 #define EXPR_TYPE_SYMBOL 2
103 #define EXPR_TYPE_INTVAR 3
104 #define EXPR_TYPE_BINOP 4
105 #define EXPR_TYPE_UNOP 5
106 #define EXPR_TYPE_STRUCT 6
107 #define EXPR_TYPE_PSTRUCT 7
108 #define EXPR_TYPE_CALL 8
109 #define EXPR_TYPE_STRING 9
110 #define EXPR_TYPE_CAST 10
111
112 static char expr_list[4096];
113 static unsigned int next_expr_free = 0;
114
115 static struct expr* expr_alloc(void)
116 {
117 struct expr* rtn;
118
119 rtn = (struct expr*)&expr_list[next_expr_free];
120
121 next_expr_free += sizeof(struct expr);
122 assert(next_expr_free < sizeof(expr_list));
123
124 return rtn;
125 }
126
127 void expr_free_all(void)
128 {
129 next_expr_free = 0;
130 }
131
132 struct expr* expr_alloc_typecast(struct dbg_type* type, struct expr* exp)
133 {
134 struct expr* ex;
135
136 ex = expr_alloc();
137
138 ex->type = EXPR_TYPE_CAST;
139 ex->un.cast.cast_to = *type;
140 ex->un.cast.expr = exp;
141 return ex;
142 }
143
144 struct expr* expr_alloc_internal_var(const char* name)
145 {
146 struct expr* ex;
147
148 ex = expr_alloc();
149
150 ex->type = EXPR_TYPE_INTVAR;
151 ex->un.intvar.name = name;
152 return ex;
153 }
154
155 struct expr* expr_alloc_symbol(const char* name)
156 {
157 struct expr* ex;
158
159 ex = expr_alloc();
160
161 ex->type = EXPR_TYPE_SYMBOL;
162 ex->un.symbol.name = name;
163 return ex;
164 }
165
166 struct expr* expr_alloc_sconstant(dbg_lgint_t value)
167 {
168 struct expr* ex;
169
170 ex = expr_alloc();
171
172 ex->type = EXPR_TYPE_S_CONST;
173 ex->un.s_const.value = value;
174 return ex;
175 }
176
177 struct expr* expr_alloc_uconstant(dbg_lguint_t value)
178 {
179 struct expr* ex;
180
181 ex = expr_alloc();
182
183 ex->type = EXPR_TYPE_U_CONST;
184 ex->un.u_const.value = value;
185 return ex;
186 }
187
188 struct expr* expr_alloc_string(const char* str)
189 {
190 struct expr* ex;
191
192 ex = expr_alloc();
193
194 ex->type = EXPR_TYPE_STRING;
195 ex->un.string.str = str;
196 return ex;
197 }
198
199 struct expr* expr_alloc_binary_op(int op_type, struct expr* exp1, struct expr* exp2)
200 {
201 struct expr* ex;
202
203 ex = expr_alloc();
204
205 ex->type = EXPR_TYPE_BINOP;
206 ex->un.binop.binop_type = op_type;
207 ex->un.binop.exp1 = exp1;
208 ex->un.binop.exp2 = exp2;
209 return ex;
210 }
211
212 struct expr* expr_alloc_unary_op(int op_type, struct expr* exp1)
213 {
214 struct expr* ex;
215
216 ex = expr_alloc();
217
218 ex->type = EXPR_TYPE_UNOP;
219 ex->un.unop.unop_type = op_type;
220 ex->un.unop.exp1 = exp1;
221 return ex;
222 }
223
224 struct expr* expr_alloc_struct(struct expr* exp, const char* element)
225 {
226 struct expr* ex;
227
228 ex = expr_alloc();
229
230 ex->type = EXPR_TYPE_STRUCT;
231 ex->un.structure.exp1 = exp;
232 ex->un.structure.element_name = element;
233 return ex;
234 }
235
236 struct expr* expr_alloc_pstruct(struct expr* exp, const char* element)
237 {
238 struct expr* ex;
239
240 ex = expr_alloc();
241
242 ex->type = EXPR_TYPE_PSTRUCT;
243 ex->un.structure.exp1 = exp;
244 ex->un.structure.element_name = element;
245 return ex;
246 }
247
248 struct expr* WINAPIV expr_alloc_func_call(const char* funcname, int nargs, ...)
249 {
250 struct expr* ex;
251 va_list ap;
252 int i;
253
254 ex = expr_alloc();
255
256 ex->type = EXPR_TYPE_CALL;
257 ex->un.call.funcname = funcname;
258 ex->un.call.nargs = nargs;
259
260 va_start(ap, nargs);
261 for (i = 0; i < nargs; i++)
262 {
263 ex->un.call.arg[i] = va_arg(ap, struct expr*);
264 }
265 va_end(ap);
266 return ex;
267 }
268
269 /******************************************************************
270 * expr_eval
271 *
272 */
273 struct dbg_lvalue expr_eval(struct expr* exp)
274 {
275 struct dbg_lvalue rtn;
276 struct dbg_lvalue exp1;
277 struct dbg_lvalue exp2;
278 DWORD64 scale1, scale2, scale3;
279 struct dbg_type type1, type2;
280 DWORD tag;
281 const struct dbg_internal_var* div;
282 BOOL ret;
283
284 init_lvalue_in_debugger(&rtn, 0, dbg_itype_none, NULL);
285
286 switch (exp->type)
287 {
288 case EXPR_TYPE_CAST:
289 exp1 = expr_eval(exp->un.cast.expr);
290 if (exp1.type.id == dbg_itype_none)
291 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
292 rtn = exp1;
293 rtn.type = exp->un.cast.cast_to;
294 init_lvalue_in_debugger(&rtn, exp->un.cast.cast_to.module, exp->un.cast.cast_to.id, &exp->un.cast.result);
295 if (types_is_float_type(&exp1))
296 {
297 double dbl;
298 ret = memory_fetch_float(&exp1, &dbl);
299 if (ret)
300 {
301 if (types_is_float_type(&rtn))
302 ret = memory_store_float(&rtn, &dbl);
303 else if (types_is_integral_type(&rtn))
304 ret = memory_store_integer(&rtn, (dbg_lgint_t)dbl);
305 else
306 ret = FALSE;
307 }
308 }
309 else if (types_is_integral_type(&exp1))
310 {
311 dbg_lgint_t val = types_extract_as_integer(&exp1);
312 if (types_is_float_type(&rtn))
313 {
314 double dbl = val;
315 ret = memory_store_float(&rtn, &dbl);
316 }
317 else if (types_is_integral_type(&rtn) || types_is_pointer_type(&rtn))
318 ret = memory_store_integer(&rtn, val);
319 else
320 ret = FALSE;
321 }
322 else if (types_is_pointer_type(&exp1))
323 {
324 dbg_lgint_t val = types_extract_as_integer(&exp1);
325
326 if (types_is_integral_type(&rtn) || types_is_pointer_type(&rtn))
327 ret = memory_store_integer(&rtn, val);
328 else
329 ret = FALSE;
330 }
331 else
332 ret = FALSE;
333 if (!ret)
334 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
335 break;
336 case EXPR_TYPE_STRING:
337 init_lvalue_in_debugger(&rtn, 0, dbg_itype_astring, &exp->un.string.str);
338 break;
339 case EXPR_TYPE_U_CONST:
340 init_lvalue_in_debugger(&rtn, 0, dbg_itype_lguint, &exp->un.u_const.value);
341 break;
342 case EXPR_TYPE_S_CONST:
343 init_lvalue_in_debugger(&rtn, 0, dbg_itype_lgint, &exp->un.s_const.value);
344 break;
345 case EXPR_TYPE_SYMBOL:
346 switch (symbol_get_lvalue(exp->un.symbol.name, -1, &rtn, FALSE))
347 {
348 case sglv_found:
349 break;
350 case sglv_unknown:
351 RaiseException(DEBUG_STATUS_NO_SYMBOL, 0, 0, NULL);
352 /* should never be here */
353 case sglv_aborted:
354 RaiseException(DEBUG_STATUS_ABORT, 0, 0, NULL);
355 /* should never be here */
356 }
357 break;
358 case EXPR_TYPE_PSTRUCT:
359 exp1 = expr_eval(exp->un.structure.exp1);
360 if (exp1.type.id == dbg_itype_none || !types_array_index(&exp1, 0, &rtn) ||
361 rtn.type.id == dbg_itype_none)
362 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
363 if (!types_udt_find_element(&rtn, exp->un.structure.element_name))
364 {
365 dbg_printf("%s\n", exp->un.structure.element_name);
366 RaiseException(DEBUG_STATUS_NO_FIELD, 0, 0, NULL);
367 }
368 break;
369 case EXPR_TYPE_STRUCT:
370 exp1 = expr_eval(exp->un.structure.exp1);
371 if (exp1.type.id == dbg_itype_none) RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
372 rtn = exp1;
373 if (!types_udt_find_element(&rtn, exp->un.structure.element_name))
374 {
375 dbg_printf("%s\n", exp->un.structure.element_name);
376 RaiseException(DEBUG_STATUS_NO_FIELD, 0, 0, NULL);
377 }
378 break;
379 case EXPR_TYPE_CALL:
380 #if 0
381 /*
382 * First, evaluate all of the arguments. If any of them are not
383 * evaluable, then bail.
384 */
385 for (i = 0; i < exp->un.call.nargs; i++)
386 {
387 exp1 = expr_eval(exp->un.call.arg[i]);
388 if (exp1.type.id == dbg_itype_none)
389 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
390 cexp[i] = types_extract_as_integer(&exp1);
391 }
392
393 /*
394 * Now look up the address of the function itself.
395 */
396 switch (symbol_get_lvalue(exp->un.call.funcname, -1, &rtn, FALSE))
397 {
398 case sglv_found:
399 break;
400 case sglv_unknown:
401 RaiseException(DEBUG_STATUS_NO_SYMBOL, 0, 0, NULL);
402 /* should never be here */
403 case sglv_aborted:
404 RaiseException(DEBUG_STATUS_ABORT, 0, 0, NULL);
405 /* should never be here */
406 }
407
408 /* FIXME: NEWDBG NIY */
409 /* Anyway, I wonder how this could work depending on the calling order of
410 * the function (cdecl vs pascal for example)
411 */
412 int (*fptr)();
413
414 fptr = (int (*)()) rtn.addr.off;
415 switch (exp->un.call.nargs)
416 {
417 case 0:
418 exp->un.call.result = (*fptr)();
419 break;
420 case 1:
421 exp->un.call.result = (*fptr)(cexp[0]);
422 break;
423 case 2:
424 exp->un.call.result = (*fptr)(cexp[0], cexp[1]);
425 break;
426 case 3:
427 exp->un.call.result = (*fptr)(cexp[0], cexp[1], cexp[2]);
428 break;
429 case 4:
430 exp->un.call.result = (*fptr)(cexp[0], cexp[1], cexp[2], cexp[3]);
431 break;
432 case 5:
433 exp->un.call.result = (*fptr)(cexp[0], cexp[1], cexp[2], cexp[3], cexp[4]);
434 break;
435 }
436 #else
437 dbg_printf("Function call no longer implemented\n");
438 /* would need to set up a call to this function, and then restore the current
439 * context afterwards...
440 */
441 exp->un.call.result = 0;
442 #endif
443 init_lvalue_in_debugger(&rtn, 0, dbg_itype_none, &exp->un.call.result);
444 /* get return type from function signature type */
445 /* FIXME rtn.type.module should be set to function's module... */
446 types_get_info(&rtn.type, TI_GET_TYPE, &rtn.type);
447 break;
448 case EXPR_TYPE_INTVAR:
449 if (!(div = dbg_get_internal_var(exp->un.intvar.name)))
450 RaiseException(DEBUG_STATUS_NO_SYMBOL, 0, 0, NULL);
451 init_lvalue_in_debugger(&rtn, 0, div->typeid, div->pval);
452 break;
453 case EXPR_TYPE_BINOP:
454 exp1 = expr_eval(exp->un.binop.exp1);
455 exp2 = expr_eval(exp->un.binop.exp2);
456 if (exp1.type.id == dbg_itype_none || exp2.type.id == dbg_itype_none)
457 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
458 init_lvalue_in_debugger(&rtn, 0, dbg_itype_lgint, &exp->un.binop.result);
459 type1 = exp1.type;
460 type2 = exp2.type;
461 switch (exp->un.binop.binop_type)
462 {
463 case EXP_OP_ADD:
464 if (!types_get_info(&exp1.type, TI_GET_SYMTAG, &tag) ||
465 tag != SymTagPointerType ||
466 !types_get_info(&exp1.type, TI_GET_TYPE, &type1))
467 type1.id = dbg_itype_none;
468 if (!types_get_info(&exp2.type, TI_GET_SYMTAG, &tag) ||
469 tag != SymTagPointerType ||
470 !types_get_info(&exp2.type, TI_GET_TYPE, &type2))
471 type2.id = dbg_itype_none;
472 scale1 = 1;
473 scale2 = 1;
474 if (type1.id != dbg_itype_none && type2.id != dbg_itype_none)
475 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
476 if (type1.id != dbg_itype_none)
477 {
478 types_get_info(&type1, TI_GET_LENGTH, &scale2);
479 rtn.type = exp1.type;
480 }
481 else if (type2.id != dbg_itype_none)
482 {
483 types_get_info(&type2, TI_GET_LENGTH, &scale1);
484 rtn.type = exp2.type;
485 }
486 exp->un.binop.result = types_extract_as_integer(&exp1) * (dbg_lguint_t)scale1 +
487 (dbg_lguint_t)scale2 * types_extract_as_integer(&exp2);
488 break;
489 case EXP_OP_SUB:
490 if (!types_get_info(&exp1.type, TI_GET_SYMTAG, &tag) ||
491 tag != SymTagPointerType ||
492 !types_get_info(&exp1.type, TI_GET_TYPE, &type1))
493 type1.id = dbg_itype_none;
494 if (!types_get_info(&exp2.type, TI_GET_SYMTAG, &tag) ||
495 tag != SymTagPointerType ||
496 !types_get_info(&exp2.type, TI_GET_TYPE, &type2))
497 type2.id = dbg_itype_none;
498 scale1 = 1;
499 scale2 = 1;
500 scale3 = 1;
501 if (type1.id != dbg_itype_none && type2.id != dbg_itype_none)
502 {
503 WINE_FIXME("This may fail (if module base address are wrongly calculated)\n");
504 if (memcmp(&type1, &type2, sizeof(struct dbg_type)))
505 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
506 types_get_info(&type1, TI_GET_LENGTH, &scale3);
507 }
508 else if (type1.id != dbg_itype_none)
509 {
510 types_get_info(&type1, TI_GET_LENGTH, &scale2);
511 rtn.type = exp1.type;
512 }
513 else if (type2.id != dbg_itype_none)
514 {
515 types_get_info(&type2, TI_GET_LENGTH, &scale1);
516 rtn.type = exp2.type;
517 }
518 exp->un.binop.result = (types_extract_as_integer(&exp1) * (dbg_lguint_t)scale1 -
519 types_extract_as_integer(&exp2) * (dbg_lguint_t)scale2) / (dbg_lguint_t)scale3;
520 break;
521 case EXP_OP_SEG:
522 rtn.type.id = dbg_itype_segptr;
523 rtn.type.module = 0;
524 dbg_curr_process->be_cpu->build_addr(dbg_curr_thread->handle, &dbg_context, &rtn.addr,
525 types_extract_as_integer(&exp1), types_extract_as_integer(&exp2));
526 break;
527 case EXP_OP_LOR:
528 exp->un.binop.result = (types_extract_as_integer(&exp1) || types_extract_as_integer(&exp2));
529 break;
530 case EXP_OP_LAND:
531 exp->un.binop.result = (types_extract_as_integer(&exp1) && types_extract_as_integer(&exp2));
532 break;
533 case EXP_OP_OR:
534 exp->un.binop.result = (types_extract_as_integer(&exp1) | types_extract_as_integer(&exp2));
535 break;
536 case EXP_OP_AND:
537 exp->un.binop.result = (types_extract_as_integer(&exp1) & types_extract_as_integer(&exp2));
538 break;
539 case EXP_OP_XOR:
540 exp->un.binop.result = (types_extract_as_integer(&exp1) ^ types_extract_as_integer(&exp2));
541 break;
542 case EXP_OP_EQ:
543 exp->un.binop.result = (types_extract_as_integer(&exp1) == types_extract_as_integer(&exp2));
544 break;
545 case EXP_OP_GT:
546 exp->un.binop.result = (types_extract_as_integer(&exp1) > types_extract_as_integer(&exp2));
547 break;
548 case EXP_OP_LT:
549 exp->un.binop.result = (types_extract_as_integer(&exp1) < types_extract_as_integer(&exp2));
550 break;
551 case EXP_OP_GE:
552 exp->un.binop.result = (types_extract_as_integer(&exp1) >= types_extract_as_integer(&exp2));
553 break;
554 case EXP_OP_LE:
555 exp->un.binop.result = (types_extract_as_integer(&exp1) <= types_extract_as_integer(&exp2));
556 break;
557 case EXP_OP_NE:
558 exp->un.binop.result = (types_extract_as_integer(&exp1) != types_extract_as_integer(&exp2));
559 break;
560 case EXP_OP_SHL:
561 exp->un.binop.result = types_extract_as_integer(&exp1) << types_extract_as_integer(&exp2);
562 break;
563 case EXP_OP_SHR:
564 exp->un.binop.result = types_extract_as_integer(&exp1) >> types_extract_as_integer(&exp2);
565 break;
566 case EXP_OP_MUL:
567 exp->un.binop.result = (types_extract_as_integer(&exp1) * types_extract_as_integer(&exp2));
568 break;
569 case EXP_OP_DIV:
570 if (types_extract_as_integer(&exp2) == 0) RaiseException(DEBUG_STATUS_DIV_BY_ZERO, 0, 0, NULL);
571 exp->un.binop.result = (types_extract_as_integer(&exp1) / types_extract_as_integer(&exp2));
572 break;
573 case EXP_OP_REM:
574 if (types_extract_as_integer(&exp2) == 0) RaiseException(DEBUG_STATUS_DIV_BY_ZERO, 0, 0, NULL);
575 exp->un.binop.result = (types_extract_as_integer(&exp1) % types_extract_as_integer(&exp2));
576 break;
577 case EXP_OP_ARR:
578 if (!types_array_index(&exp1, types_extract_as_integer(&exp2), &rtn))
579 RaiseException(DEBUG_STATUS_CANT_DEREF, 0, 0, NULL);
580 break;
581 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
582 }
583 break;
584 case EXPR_TYPE_UNOP:
585 exp1 = expr_eval(exp->un.unop.exp1);
586 if (exp1.type.id == dbg_itype_none) RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
587 init_lvalue_in_debugger(&rtn, 0, dbg_itype_lgint, &exp->un.unop.result);
588 switch (exp->un.unop.unop_type)
589 {
590 case EXP_OP_NEG:
591 exp->un.unop.result = -types_extract_as_integer(&exp1);
592 break;
593 case EXP_OP_NOT:
594 exp->un.unop.result = !types_extract_as_integer(&exp1);
595 break;
596 case EXP_OP_LNOT:
597 exp->un.unop.result = ~types_extract_as_integer(&exp1);
598 break;
599 case EXP_OP_DEREF:
600 if (!types_array_index(&exp1, 0, &rtn))
601 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
602 break;
603 case EXP_OP_ADDR:
604 /* only do it on linear addresses */
605 if (exp1.addr.Mode != AddrModeFlat)
606 RaiseException(DEBUG_STATUS_CANT_DEREF, 0, 0, NULL);
607 exp->un.unop.result = (ULONG_PTR)memory_to_linear_addr(&exp1.addr);
608 if (!types_find_pointer(&exp1.type, &rtn.type))
609 RaiseException(DEBUG_STATUS_CANT_DEREF, 0, 0, NULL);
610 break;
611 default: RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
612 }
613 break;
614 default:
615 WINE_FIXME("Unexpected expression (%d).\n", exp->type);
616 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
617 break;
618 }
619
620 return rtn;
621 }
622
623 BOOL expr_print(const struct expr* exp)
624 {
625 int i;
626
627 switch (exp->type)
628 {
629 case EXPR_TYPE_CAST:
630 dbg_printf("((");
631 types_print_type(&exp->un.cast.cast_to, FALSE, NULL);
632 dbg_printf(")");
633 expr_print(exp->un.cast.expr);
634 dbg_printf(")");
635 break;
636 case EXPR_TYPE_INTVAR:
637 dbg_printf("$%s", exp->un.intvar.name);
638 break;
639 case EXPR_TYPE_U_CONST:
640 dbg_printf("%I64u", exp->un.u_const.value);
641 break;
642 case EXPR_TYPE_S_CONST:
643 dbg_printf("%I64d", exp->un.s_const.value);
644 break;
645 case EXPR_TYPE_STRING:
646 dbg_printf("\"%s\"", exp->un.string.str);
647 break;
648 case EXPR_TYPE_SYMBOL:
649 dbg_printf("%s" , exp->un.symbol.name);
650 break;
651 case EXPR_TYPE_PSTRUCT:
652 expr_print(exp->un.structure.exp1);
653 dbg_printf("->%s", exp->un.structure.element_name);
654 break;
655 case EXPR_TYPE_STRUCT:
656 expr_print(exp->un.structure.exp1);
657 dbg_printf(".%s", exp->un.structure.element_name);
658 break;
659 case EXPR_TYPE_CALL:
660 dbg_printf("%s(",exp->un.call.funcname);
661 for (i = 0; i < exp->un.call.nargs; i++)
662 {
663 expr_print(exp->un.call.arg[i]);
664 if (i != exp->un.call.nargs - 1) dbg_printf(", ");
665 }
666 dbg_printf(")");
667 break;
668 case EXPR_TYPE_BINOP:
669 dbg_printf("(");
670 expr_print(exp->un.binop.exp1);
671 switch (exp->un.binop.binop_type)
672 {
673 case EXP_OP_ADD: dbg_printf(" + "); break;
674 case EXP_OP_SUB: dbg_printf(" - "); break;
675 case EXP_OP_SEG: dbg_printf(":"); break;
676 case EXP_OP_LOR: dbg_printf(" || "); break;
677 case EXP_OP_LAND: dbg_printf(" && "); break;
678 case EXP_OP_OR: dbg_printf(" | "); break;
679 case EXP_OP_AND: dbg_printf(" & "); break;
680 case EXP_OP_XOR: dbg_printf(" ^ "); break;
681 case EXP_OP_EQ: dbg_printf(" == "); break;
682 case EXP_OP_GT: dbg_printf(" > "); break;
683 case EXP_OP_LT: dbg_printf(" < "); break;
684 case EXP_OP_GE: dbg_printf(" >= "); break;
685 case EXP_OP_LE: dbg_printf(" <= "); break;
686 case EXP_OP_NE: dbg_printf(" != "); break;
687 case EXP_OP_SHL: dbg_printf(" << "); break;
688 case EXP_OP_SHR: dbg_printf(" >> "); break;
689 case EXP_OP_MUL: dbg_printf(" * "); break;
690 case EXP_OP_DIV: dbg_printf(" / "); break;
691 case EXP_OP_REM: dbg_printf(" %% "); break;
692 case EXP_OP_ARR: dbg_printf("["); break;
693 default: break;
694 }
695 expr_print(exp->un.binop.exp2);
696 if (exp->un.binop.binop_type == EXP_OP_ARR) dbg_printf("]");
697 dbg_printf(")");
698 break;
699 case EXPR_TYPE_UNOP:
700 switch (exp->un.unop.unop_type)
701 {
702 case EXP_OP_NEG: dbg_printf("-"); break;
703 case EXP_OP_NOT: dbg_printf("!"); break;
704 case EXP_OP_LNOT: dbg_printf("~"); break;
705 case EXP_OP_DEREF: dbg_printf("*"); break;
706 case EXP_OP_ADDR: dbg_printf("&"); break;
707 }
708 expr_print(exp->un.unop.exp1);
709 break;
710 default:
711 WINE_FIXME("Unexpected expression (%u).\n", exp->type);
712 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
713 break;
714 }
715
716 return TRUE;
717 }
718
719 struct expr* expr_clone(const struct expr* exp, BOOL *local_binding)
720 {
721 int i;
722 struct expr* rtn;
723
724 rtn = malloc(sizeof(struct expr));
725
726 /*
727 * First copy the contents of the expression itself.
728 */
729 *rtn = *exp;
730
731 switch (exp->type)
732 {
733 case EXPR_TYPE_CAST:
734 rtn->un.cast.expr = expr_clone(exp->un.cast.expr, local_binding);
735 break;
736 case EXPR_TYPE_INTVAR:
737 rtn->un.intvar.name = strdup(exp->un.intvar.name);
738 break;
739 case EXPR_TYPE_U_CONST:
740 case EXPR_TYPE_S_CONST:
741 break;
742 case EXPR_TYPE_STRING:
743 rtn->un.string.str = strdup(exp->un.string.str);
744 break;
745 case EXPR_TYPE_SYMBOL:
746 rtn->un.symbol.name = strdup(exp->un.symbol.name);
747 if (local_binding && symbol_is_local(exp->un.symbol.name))
748 *local_binding = TRUE;
749 break;
750 case EXPR_TYPE_PSTRUCT:
751 case EXPR_TYPE_STRUCT:
752 rtn->un.structure.exp1 = expr_clone(exp->un.structure.exp1, local_binding);
753 rtn->un.structure.element_name = strdup(exp->un.structure.element_name);
754 break;
755 case EXPR_TYPE_CALL:
756 for (i = 0; i < exp->un.call.nargs; i++)
757 {
758 rtn->un.call.arg[i] = expr_clone(exp->un.call.arg[i], local_binding);
759 }
760 rtn->un.call.funcname = strdup(exp->un.call.funcname);
761 break;
762 case EXPR_TYPE_BINOP:
763 rtn->un.binop.exp1 = expr_clone(exp->un.binop.exp1, local_binding);
764 rtn->un.binop.exp2 = expr_clone(exp->un.binop.exp2, local_binding);
765 break;
766 case EXPR_TYPE_UNOP:
767 rtn->un.unop.exp1 = expr_clone(exp->un.unop.exp1, local_binding);
768 break;
769 default:
770 WINE_FIXME("Unexpected expression (%u).\n", exp->type);
771 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
772 break;
773 }
774
775 return rtn;
776 }
777
778
779 /*
780 * Recursively go through an expression tree and free all memory associated
781 * with it.
782 */
783 BOOL expr_free(struct expr* exp)
784 {
785 int i;
786
787 switch (exp->type)
788 {
789 case EXPR_TYPE_CAST:
790 expr_free(exp->un.cast.expr);
791 break;
792 case EXPR_TYPE_INTVAR:
793 free((char*)exp->un.intvar.name);
794 break;
795 case EXPR_TYPE_U_CONST:
796 case EXPR_TYPE_S_CONST:
797 break;
798 case EXPR_TYPE_STRING:
799 free((char*)exp->un.string.str);
800 break;
801 case EXPR_TYPE_SYMBOL:
802 free((char*)exp->un.symbol.name);
803 break;
804 case EXPR_TYPE_PSTRUCT:
805 case EXPR_TYPE_STRUCT:
806 expr_free(exp->un.structure.exp1);
807 free((char*)exp->un.structure.element_name);
808 break;
809 case EXPR_TYPE_CALL:
810 for (i = 0; i < exp->un.call.nargs; i++)
811 {
812 expr_free(exp->un.call.arg[i]);
813 }
814 free((char*)exp->un.call.funcname);
815 break;
816 case EXPR_TYPE_BINOP:
817 expr_free(exp->un.binop.exp1);
818 expr_free(exp->un.binop.exp2);
819 break;
820 case EXPR_TYPE_UNOP:
821 expr_free(exp->un.unop.exp1);
822 break;
823 default:
824 WINE_FIXME("Unexpected expression (%u).\n", exp->type);
825 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
826 break;
827 }
828
829 free(exp);
830 return TRUE;
831 }
Windows API implementation