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