?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Spelling and case fixes.
[wine.git] / programs / winedbg / expr.c
blob2bd10a0d62baa0853f93899f48f091cb803ed61e
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 #include <stdlib.h>
23 #include <string.h>
24 #include "winbase.h"
25 #include "wine/winbase16.h"
26 #include "debugger.h"
27 #include "expr.h"
28
29 #include <stdarg.h>
30
31 struct expr
32 {
33 unsigned int perm;
34 unsigned int type:31;
35 union
36 {
37 struct
38 {
39 int value;
40 } constant;
41
42 struct
43 {
44 const char * str;
45 } string;
46
47 struct
48 {
49 unsigned int value;
50 } u_const;
51
52 struct
53 {
54 const char * name;
55 } symbol;
56
57 struct
58 {
59 const char * name;
60 } intvar;
61
62 struct
63 {
64 int unop_type;
65 struct expr * exp1;
66 int result;
67 } unop;
68
69 struct
70 {
71 int binop_type;
72 int result;
73 struct expr * exp1;
74 struct expr * exp2;
75 } binop;
76
77 struct
78 {
79 struct datatype * cast;
80 struct expr * expr;
81 } cast;
82
83 struct
84 {
85 struct expr * exp1;
86 const char * element_name;
87 int result;
88 } structure;
89
90 struct
91 {
92 struct expr * base;
93 struct expr * index;
94 } array;
95
96 struct
97 {
98 const char * funcname;
99 int nargs;
100 int result;
101 struct expr * arg[5];
102 } call;
103
104 } un;
105 };
106
107 #define EXPR_TYPE_CONST 0
108 #define EXPR_TYPE_US_CONST 1
109 #define EXPR_TYPE_SYMBOL 2
110 #define EXPR_TYPE_INTVAR 3
111 #define EXPR_TYPE_BINOP 4
112 #define EXPR_TYPE_UNOP 5
113 #define EXPR_TYPE_STRUCT 6
114 #define EXPR_TYPE_PSTRUCT 7
115 #define EXPR_TYPE_ARRAY 8
116 #define EXPR_TYPE_CALL 9
117 #define EXPR_TYPE_STRING 10
118 #define EXPR_TYPE_CAST 11
119
120 static char expr_list[4096];
121 static unsigned int next_expr_free = 0;
122
123 /*
124 * This is how we turn an expression address into the actual value.
125 * This works well in the 32 bit domain - not sure at all about the
126 * 16 bit world.
127 */
128 #define VAL(_exp) DEBUG_GetExprValue(&_exp, NULL)
129
130 static
131 struct expr *
132 DEBUG_GetFreeExpr(void)
133 {
134 struct expr * rtn;
135
136 rtn = (struct expr *) &expr_list[next_expr_free];
137
138 next_expr_free += sizeof(struct expr);
139 assert(next_expr_free < sizeof(expr_list));
140
141 return rtn;
142 }
143
144 void
145 DEBUG_FreeExprMem(void)
146 {
147 next_expr_free = 0;
148 }
149
150 struct expr *
151 DEBUG_TypeCastExpr(struct datatype * dt, struct expr * exp)
152 {
153 struct expr * ex;
154
155 ex = DEBUG_GetFreeExpr();
156
157 ex->type = EXPR_TYPE_CAST;
158 ex->un.cast.cast = dt;
159 ex->un.cast.expr = exp;
160 return ex;
161 }
162
163 struct expr *
164 DEBUG_IntVarExpr(const char* name)
165 {
166 struct expr * ex;
167
168 ex = DEBUG_GetFreeExpr();
169
170 ex->type = EXPR_TYPE_INTVAR;
171 ex->un.intvar.name = name;
172 return ex;
173 }
174
175 struct expr *
176 DEBUG_SymbolExpr(const char * name)
177 {
178 struct expr * ex;
179
180 ex = DEBUG_GetFreeExpr();
181
182 ex->type = EXPR_TYPE_SYMBOL;
183 ex->un.symbol.name = name;
184 return ex;
185 }
186
187 struct expr *
188 DEBUG_ConstExpr(int value)
189 {
190 struct expr * ex;
191
192 ex = DEBUG_GetFreeExpr();
193
194 ex->type = EXPR_TYPE_CONST;
195 ex->un.constant.value = value;
196 return ex;
197 }
198
199 struct expr *
200 DEBUG_StringExpr(const char * str)
201 {
202 struct expr * ex;
203 char * pnt;
204 ex = DEBUG_GetFreeExpr();
205
206 ex->type = EXPR_TYPE_STRING;
207 ex->un.string.str = str+1;
208 pnt = strrchr(ex->un.string.str, '"');
209 if( pnt != NULL )
210 {
211 *pnt = '\0';
212 }
213 return ex;
214 }
215
216 struct expr *
217 DEBUG_USConstExpr(unsigned int value)
218 {
219 struct expr * ex;
220
221 ex = DEBUG_GetFreeExpr();
222
223 ex->type = EXPR_TYPE_CONST;
224 ex->un.u_const.value = value;
225 return ex;
226 }
227
228 struct expr *
229 DEBUG_BinopExpr(int operator_type, struct expr * exp1, struct expr * exp2)
230 {
231 struct expr * ex;
232
233 ex = DEBUG_GetFreeExpr();
234
235 ex->type = EXPR_TYPE_BINOP;
236 ex->un.binop.binop_type = operator_type;
237 ex->un.binop.exp1 = exp1;
238 ex->un.binop.exp2 = exp2;
239 return ex;
240 }
241
242 struct expr *
243 DEBUG_UnopExpr(int operator_type, struct expr * exp1)
244 {
245 struct expr * ex;
246
247 ex = DEBUG_GetFreeExpr();
248
249 ex->type = EXPR_TYPE_UNOP;
250 ex->un.unop.unop_type = operator_type;
251 ex->un.unop.exp1 = exp1;
252 return ex;
253 }
254
255 struct expr *
256 DEBUG_StructExpr(struct expr * exp, const char * element)
257 {
258 struct expr * ex;
259
260 ex = DEBUG_GetFreeExpr();
261
262 ex->type = EXPR_TYPE_STRUCT;
263 ex->un.structure.exp1 = exp;
264 ex->un.structure.element_name = element;
265 return ex;
266 }
267
268 struct expr *
269 DEBUG_StructPExpr(struct expr * exp, const char * element)
270 {
271 struct expr * ex;
272
273 ex = DEBUG_GetFreeExpr();
274
275 ex->type = EXPR_TYPE_PSTRUCT;
276 ex->un.structure.exp1 = exp;
277 ex->un.structure.element_name = element;
278 return ex;
279 }
280
281 struct expr *
282 DEBUG_CallExpr(const char * funcname, int nargs, ...)
283 {
284 struct expr * ex;
285 va_list ap;
286 int i;
287
288 ex = DEBUG_GetFreeExpr();
289
290 ex->type = EXPR_TYPE_CALL;
291 ex->un.call.funcname = funcname;
292 ex->un.call.nargs = nargs;
293
294 va_start(ap, nargs);
295 for(i=0; i < nargs; i++)
296 {
297 ex->un.call.arg[i] = va_arg(ap, struct expr *);
298 }
299 va_end(ap);
300 return ex;
301 }
302
303 DBG_VALUE DEBUG_EvalExpr(struct expr * exp)
304 {
305 DBG_VALUE rtn;
306 int i;
307 DBG_VALUE exp1;
308 DBG_VALUE exp2;
309 unsigned int cexp[5];
310 int scale1;
311 int scale2;
312 int scale3;
313 struct datatype * type1;
314 struct datatype * type2;
315
316 rtn.type = NULL;
317 rtn.cookie = DV_INVALID;
318 rtn.addr.off = 0;
319 rtn.addr.seg = 0;
320
321 switch(exp->type)
322 {
323 case EXPR_TYPE_CAST:
324 if (!exp->un.cast.cast)
325 {
326 DEBUG_Printf(DBG_CHN_MESG, "Can't cast to unknown type\n");
327 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
328 }
329 rtn = DEBUG_EvalExpr(exp->un.cast.expr);
330 rtn.type = exp->un.cast.cast;
331 break;
332 case EXPR_TYPE_STRING:
333 rtn.type = DEBUG_GetBasicType(DT_BASIC_STRING);
334 rtn.cookie = DV_HOST;
335 rtn.addr.off = (unsigned int) &exp->un.string.str;
336 rtn.addr.seg = 0;
337 break;
338 case EXPR_TYPE_CONST:
339 rtn.type = DEBUG_GetBasicType(DT_BASIC_CONST_INT);
340 rtn.cookie = DV_HOST;
341 rtn.addr.off = (unsigned int) &exp->un.constant.value;
342 rtn.addr.seg = 0;
343 break;
344 case EXPR_TYPE_US_CONST:
345 rtn.type = DEBUG_GetBasicType(DT_BASIC_USHORTINT);
346 rtn.cookie = DV_HOST;
347 rtn.addr.off = (unsigned int) &exp->un.u_const.value;
348 rtn.addr.seg = 0;
349 break;
350 case EXPR_TYPE_SYMBOL:
351 switch (DEBUG_GetSymbolValue(exp->un.symbol.name, -1, &rtn, FALSE))
352 {
353 case gsv_found:
354 break;
355 case gsv_unknown:
356 RaiseException(DEBUG_STATUS_NO_SYMBOL, 0, 0, NULL);
357 /* should never be here */
358 case gsv_aborted:
359 RaiseException(DEBUG_STATUS_ABORT, 0, 0, NULL);
360 /* should never be here */
361 }
362 break;
363 case EXPR_TYPE_PSTRUCT:
364 exp1 = DEBUG_EvalExpr(exp->un.structure.exp1);
365 if( exp1.type == NULL )
366 {
367 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
368 }
369 rtn.cookie = DV_TARGET;
370 rtn.addr.off = DEBUG_TypeDerefPointer(&exp1, &rtn.type);
371 if( rtn.type == NULL )
372 {
373 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
374 }
375 if (!DEBUG_FindStructElement(&rtn, exp->un.structure.element_name,
376 &exp->un.structure.result))
377 {
378 DEBUG_Printf(DBG_CHN_MESG, "%s\n", exp->un.structure.element_name);
379 RaiseException(DEBUG_STATUS_NO_FIELD, 0, 0, NULL);
380 }
381
382 break;
383 case EXPR_TYPE_STRUCT:
384 exp1 = DEBUG_EvalExpr(exp->un.structure.exp1);
385 if( exp1.type == NULL )
386 {
387 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
388 }
389 rtn = exp1;
390 if (!DEBUG_FindStructElement(&rtn, exp->un.structure.element_name,
391 &exp->un.structure.result))
392 {
393 DEBUG_Printf(DBG_CHN_MESG, "%s\n", exp->un.structure.element_name);
394 RaiseException(DEBUG_STATUS_NO_FIELD, 0, 0, NULL);
395 }
396 break;
397 case EXPR_TYPE_CALL:
398 /*
399 * First, evaluate all of the arguments. If any of them are not
400 * evaluable, then bail.
401 */
402 for(i=0; i < exp->un.call.nargs; i++)
403 {
404 exp1 = DEBUG_EvalExpr(exp->un.call.arg[i]);
405 if( exp1.type == NULL )
406 {
407 return rtn;
408 }
409 cexp[i] = DEBUG_GetExprValue(&exp1, NULL);
410 }
411
412 /*
413 * Now look up the address of the function itself.
414 */
415 switch (DEBUG_GetSymbolValue(exp->un.call.funcname, -1, &rtn, FALSE ))
416 {
417 case gsv_found:
418 break;
419 case gsv_unknown:
420 RaiseException(DEBUG_STATUS_NO_SYMBOL, 0, 0, NULL);
421 /* should never be here */
422 case gsv_aborted:
423 RaiseException(DEBUG_STATUS_ABORT, 0, 0, NULL);
424 /* should never be here */
425 }
426
427 #if 0
428 /* FIXME: NEWDBG NIY */
429 /* Anyway, I wonder how this could work depending on the calling order of
430 * the function (cdecl vs pascal for example)
431 */
432 int (*fptr)();
433
434 fptr = (int (*)()) rtn.addr.off;
435 switch(exp->un.call.nargs)
436 {
437 case 0:
438 exp->un.call.result = (*fptr)();
439 break;
440 case 1:
441 exp->un.call.result = (*fptr)(cexp[0]);
442 break;
443 case 2:
444 exp->un.call.result = (*fptr)(cexp[0], cexp[1]);
445 break;
446 case 3:
447 exp->un.call.result = (*fptr)(cexp[0], cexp[1], cexp[2]);
448 break;
449 case 4:
450 exp->un.call.result = (*fptr)(cexp[0], cexp[1], cexp[2], cexp[3]);
451 break;
452 case 5:
453 exp->un.call.result = (*fptr)(cexp[0], cexp[1], cexp[2], cexp[3], cexp[4]);
454 break;
455 }
456 #else
457 DEBUG_Printf(DBG_CHN_MESG, "Function call no longer implemented\n");
458 /* would need to set up a call to this function, and then restore the current
459 * context afterwards...
460 */
461 exp->un.call.result = 0;
462 #endif
463 rtn.type = DEBUG_GetBasicType(DT_BASIC_INT);
464 rtn.cookie = DV_HOST;
465 rtn.addr.off = (unsigned int) &exp->un.call.result;
466
467 break;
468 case EXPR_TYPE_INTVAR:
469 {
470
471 DBG_INTVAR* div = DEBUG_GetIntVar(exp->un.intvar.name);
472
473 if (!div) RaiseException(DEBUG_STATUS_NO_SYMBOL, 0, 0, NULL);
474 rtn.cookie = DV_HOST;
475 rtn.type = div->type;
476 rtn.addr.off = (unsigned int)div->pval;
477 /* EPP FIXME rtn.addr.seg = ?? */
478 }
479 break;
480 case EXPR_TYPE_BINOP:
481 exp1 = DEBUG_EvalExpr(exp->un.binop.exp1);
482 exp2 = DEBUG_EvalExpr(exp->un.binop.exp2);
483 rtn.cookie = DV_HOST;
484 if( exp1.type == NULL || exp2.type == NULL )
485 {
486 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
487 }
488 if( exp1.type == DEBUG_GetBasicType(DT_BASIC_CONST_INT) &&
489 exp2.type == DEBUG_GetBasicType(DT_BASIC_CONST_INT) )
490 {
491 rtn.type = exp1.type;
492 }
493 else
494 {
495 rtn.type = DEBUG_GetBasicType(DT_BASIC_INT);
496 }
497 rtn.addr.seg = 0;
498 rtn.addr.off = (unsigned int) &exp->un.binop.result;
499 switch(exp->un.binop.binop_type)
500 {
501 case EXP_OP_ADD:
502 type1 = DEBUG_GetPointerType(exp1.type);
503 type2 = DEBUG_GetPointerType(exp2.type);
504 scale1 = 1;
505 scale2 = 1;
506 if( type1 != NULL && type2 != NULL )
507 {
508 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
509 }
510 else if( type1 != NULL )
511 {
512 scale2 = DEBUG_GetObjectSize(type1);
513 rtn.type = exp1.type;
514 }
515 else if( type2 != NULL )
516 {
517 scale1 = DEBUG_GetObjectSize(type2);
518 rtn.type = exp2.type;
519 }
520 exp->un.binop.result = (VAL(exp1) * scale1 + scale2 * VAL(exp2));
521 break;
522 case EXP_OP_SUB:
523 type1 = DEBUG_GetPointerType(exp1.type);
524 type2 = DEBUG_GetPointerType(exp2.type);
525 scale1 = 1;
526 scale2 = 1;
527 scale3 = 1;
528 if( type1 != NULL && type2 != NULL )
529 {
530 if( type1 != type2 )
531 {
532 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
533 }
534 scale3 = DEBUG_GetObjectSize(type1);
535 }
536 else if( type1 != NULL )
537 {
538 scale2 = DEBUG_GetObjectSize(type1);
539 rtn.type = exp1.type;
540 }
541
542 else if( type2 != NULL )
543 {
544 scale1 = DEBUG_GetObjectSize(type2);
545 rtn.type = exp2.type;
546 }
547 exp->un.binop.result = (VAL(exp1) - VAL(exp2)) / scale3;
548 break;
549 case EXP_OP_SEG:
550 rtn.cookie = DV_TARGET;
551 rtn.type = NULL;
552 rtn.addr.seg = VAL(exp1);
553 rtn.addr.off = VAL(exp2);
554 break;
555 case EXP_OP_LOR:
556 exp->un.binop.result = (VAL(exp1) || VAL(exp2));
557 break;
558 case EXP_OP_LAND:
559 exp->un.binop.result = (VAL(exp1) && VAL(exp2));
560 break;
561 case EXP_OP_OR:
562 exp->un.binop.result = (VAL(exp1) | VAL(exp2));
563 break;
564 case EXP_OP_AND:
565 exp->un.binop.result = (VAL(exp1) & VAL(exp2));
566 break;
567 case EXP_OP_XOR:
568 exp->un.binop.result = (VAL(exp1) ^ VAL(exp2));
569 break;
570 case EXP_OP_EQ:
571 exp->un.binop.result = (VAL(exp1) == VAL(exp2));
572 break;
573 case EXP_OP_GT:
574 exp->un.binop.result = (VAL(exp1) > VAL(exp2));
575 break;
576 case EXP_OP_LT:
577 exp->un.binop.result = (VAL(exp1) < VAL(exp2));
578 break;
579 case EXP_OP_GE:
580 exp->un.binop.result = (VAL(exp1) >= VAL(exp2));
581 break;
582 case EXP_OP_LE:
583 exp->un.binop.result = (VAL(exp1) <= VAL(exp2));
584 break;
585 case EXP_OP_NE:
586 exp->un.binop.result = (VAL(exp1) != VAL(exp2));
587 break;
588 case EXP_OP_SHL:
589 exp->un.binop.result = ((unsigned) VAL(exp1) << VAL(exp2));
590 break;
591 case EXP_OP_SHR:
592 exp->un.binop.result = ((unsigned) VAL(exp1) >> VAL(exp2));
593 break;
594 case EXP_OP_MUL:
595 exp->un.binop.result = (VAL(exp1) * VAL(exp2));
596 break;
597 case EXP_OP_DIV:
598 if( VAL(exp2) == 0 )
599 {
600 RaiseException(DEBUG_STATUS_DIV_BY_ZERO, 0, 0, NULL);
601 }
602 exp->un.binop.result = (VAL(exp1) / VAL(exp2));
603 break;
604 case EXP_OP_REM:
605 if( VAL(exp2) == 0 )
606 {
607 RaiseException(DEBUG_STATUS_DIV_BY_ZERO, 0, 0, NULL);
608 }
609 exp->un.binop.result = (VAL(exp1) % VAL(exp2));
610 break;
611 case EXP_OP_ARR:
612 DEBUG_ArrayIndex(&exp1, &rtn, VAL(exp2));
613 break;
614 default:
615 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
616 break;
617 }
618 break;
619 case EXPR_TYPE_UNOP:
620 exp1 = DEBUG_EvalExpr(exp->un.unop.exp1);
621 rtn.cookie = DV_HOST;
622 if( exp1.type == NULL )
623 {
624 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
625 }
626 rtn.addr.seg = 0;
627 rtn.addr.off = (unsigned int) &exp->un.unop.result;
628 if( exp1.type == DEBUG_GetBasicType(DT_BASIC_CONST_INT) )
629 {
630 rtn.type = exp1.type;
631 }
632 else
633 {
634 rtn.type = DEBUG_GetBasicType(DT_BASIC_INT);
635 }
636 switch(exp->un.unop.unop_type)
637 {
638 case EXP_OP_NEG:
639 exp->un.unop.result = -VAL(exp1);
640 break;
641 case EXP_OP_NOT:
642 exp->un.unop.result = !VAL(exp1);
643 break;
644 case EXP_OP_LNOT:
645 exp->un.unop.result = ~VAL(exp1);
646 break;
647 case EXP_OP_DEREF:
648 /* FIXME: this is currently buggy.
649 * there is no way to tell were the deref:ed value is...
650 * for example:
651 * x is a pointer to struct s, x being on the stack
652 * => exp1 is target, result is target
653 * x is a pointer to struct s, x being optimized into a reg
654 * => exp1 is host, result is target
655 * x is a pointer to internal variable x
656 * => exp1 is host, result is host
657 * so we force DV_TARGET, because dereferencing pointers to
658 * internal variables is very unlikely. a correct fix would be
659 * rather large.
660 */
661 rtn.cookie = DV_TARGET;
662 rtn.addr.off = (unsigned int) DEBUG_TypeDerefPointer(&exp1, &rtn.type);
663 if (!rtn.type)
664 {
665 RaiseException(DEBUG_STATUS_BAD_TYPE, 0, 0, NULL);
666 }
667 break;
668 case EXP_OP_FORCE_DEREF:
669 rtn.cookie = exp1.cookie;
670 rtn.addr.seg = exp1.addr.seg;
671 if (exp1.cookie == DV_TARGET)
672 DEBUG_READ_MEM((void*)exp1.addr.off, &rtn.addr.off, sizeof(rtn.addr.off));
673 else
674 memcpy(&rtn.addr.off, (void*)exp1.addr.off, sizeof(rtn.addr.off));
675 break;
676 case EXP_OP_ADDR:
677 /* FIXME: even for a 16 bit entity ? */
678 rtn.type = DEBUG_FindOrMakePointerType(exp1.type);
679 exp->un.unop.result = exp1.addr.off;
680 break;
681 default:
682 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
683 }
684 break;
685 default:
686 DEBUG_Printf(DBG_CHN_MESG,"Unexpected expression (%d).\n", exp->type);
687 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
688 break;
689 }
690
691 assert(rtn.cookie == DV_TARGET || rtn.cookie == DV_HOST);
692
693 return rtn;
694 }
695
696
697 int
698 DEBUG_DisplayExpr(const struct expr * exp)
699 {
700 int i;
701
702 switch(exp->type)
703 {
704 case EXPR_TYPE_CAST:
705 DEBUG_Printf(DBG_CHN_MESG, "((");
706 DEBUG_PrintTypeCast(exp->un.cast.cast);
707 DEBUG_Printf(DBG_CHN_MESG, ")");
708 DEBUG_DisplayExpr(exp->un.cast.expr);
709 DEBUG_Printf(DBG_CHN_MESG, ")");
710 break;
711 case EXPR_TYPE_INTVAR:
712 DEBUG_Printf(DBG_CHN_MESG, "$%s", exp->un.intvar.name);
713 break;
714 case EXPR_TYPE_US_CONST:
715 DEBUG_Printf(DBG_CHN_MESG, "%ud", exp->un.u_const.value);
716 break;
717 case EXPR_TYPE_CONST:
718 DEBUG_Printf(DBG_CHN_MESG, "%d", exp->un.u_const.value);
719 break;
720 case EXPR_TYPE_STRING:
721 DEBUG_Printf(DBG_CHN_MESG, "\"%s\"", exp->un.string.str);
722 break;
723 case EXPR_TYPE_SYMBOL:
724 DEBUG_Printf(DBG_CHN_MESG, "%s" , exp->un.symbol.name);
725 break;
726 case EXPR_TYPE_PSTRUCT:
727 DEBUG_DisplayExpr(exp->un.structure.exp1);
728 DEBUG_Printf(DBG_CHN_MESG, "->%s", exp->un.structure.element_name);
729 break;
730 case EXPR_TYPE_STRUCT:
731 DEBUG_DisplayExpr(exp->un.structure.exp1);
732 DEBUG_Printf(DBG_CHN_MESG, ".%s", exp->un.structure.element_name);
733 break;
734 case EXPR_TYPE_CALL:
735 DEBUG_Printf(DBG_CHN_MESG, "%s(",exp->un.call.funcname);
736 for(i=0; i < exp->un.call.nargs; i++)
737 {
738 DEBUG_DisplayExpr(exp->un.call.arg[i]);
739 if( i != exp->un.call.nargs - 1 )
740 {
741 DEBUG_Printf(DBG_CHN_MESG, ", ");
742 }
743 }
744 DEBUG_Printf(DBG_CHN_MESG, ")");
745 break;
746 case EXPR_TYPE_BINOP:
747 DEBUG_Printf(DBG_CHN_MESG, "( ");
748 DEBUG_DisplayExpr(exp->un.binop.exp1);
749 switch(exp->un.binop.binop_type)
750 {
751 case EXP_OP_ADD:
752 DEBUG_Printf(DBG_CHN_MESG, " + ");
753 break;
754 case EXP_OP_SUB:
755 DEBUG_Printf(DBG_CHN_MESG, " - ");
756 break;
757 case EXP_OP_SEG:
758 DEBUG_Printf(DBG_CHN_MESG, ":");
759 break;
760 case EXP_OP_LOR:
761 DEBUG_Printf(DBG_CHN_MESG, " || ");
762 break;
763 case EXP_OP_LAND:
764 DEBUG_Printf(DBG_CHN_MESG, " && ");
765 break;
766 case EXP_OP_OR:
767 DEBUG_Printf(DBG_CHN_MESG, " | ");
768 break;
769 case EXP_OP_AND:
770 DEBUG_Printf(DBG_CHN_MESG, " & ");
771 break;
772 case EXP_OP_XOR:
773 DEBUG_Printf(DBG_CHN_MESG, " ^ ");
774 break;
775 case EXP_OP_EQ:
776 DEBUG_Printf(DBG_CHN_MESG, " == ");
777 break;
778 case EXP_OP_GT:
779 DEBUG_Printf(DBG_CHN_MESG, " > ");
780 break;
781 case EXP_OP_LT:
782 DEBUG_Printf(DBG_CHN_MESG, " < ");
783 break;
784 case EXP_OP_GE:
785 DEBUG_Printf(DBG_CHN_MESG, " >= ");
786 break;
787 case EXP_OP_LE:
788 DEBUG_Printf(DBG_CHN_MESG, " <= ");
789 break;
790 case EXP_OP_NE:
791 DEBUG_Printf(DBG_CHN_MESG, " != ");
792 break;
793 case EXP_OP_SHL:
794 DEBUG_Printf(DBG_CHN_MESG, " << ");
795 break;
796 case EXP_OP_SHR:
797 DEBUG_Printf(DBG_CHN_MESG, " >> ");
798 break;
799 case EXP_OP_MUL:
800 DEBUG_Printf(DBG_CHN_MESG, " * ");
801 break;
802 case EXP_OP_DIV:
803 DEBUG_Printf(DBG_CHN_MESG, " / ");
804 break;
805 case EXP_OP_REM:
806 DEBUG_Printf(DBG_CHN_MESG, " %% ");
807 break;
808 case EXP_OP_ARR:
809 DEBUG_Printf(DBG_CHN_MESG, "[");
810 break;
811 default:
812 break;
813 }
814 DEBUG_DisplayExpr(exp->un.binop.exp2);
815 if( exp->un.binop.binop_type == EXP_OP_ARR )
816 {
817 DEBUG_Printf(DBG_CHN_MESG, "]");
818 }
819 DEBUG_Printf(DBG_CHN_MESG, " )");
820 break;
821 case EXPR_TYPE_UNOP:
822 switch(exp->un.unop.unop_type)
823 {
824 case EXP_OP_NEG:
825 DEBUG_Printf(DBG_CHN_MESG, "-");
826 break;
827 case EXP_OP_NOT:
828 DEBUG_Printf(DBG_CHN_MESG, "!");
829 break;
830 case EXP_OP_LNOT:
831 DEBUG_Printf(DBG_CHN_MESG, "~");
832 break;
833 case EXP_OP_DEREF:
834 DEBUG_Printf(DBG_CHN_MESG, "*");
835 break;
836 case EXP_OP_ADDR:
837 DEBUG_Printf(DBG_CHN_MESG, "&");
838 break;
839 }
840 DEBUG_DisplayExpr(exp->un.unop.exp1);
841 break;
842 default:
843 DEBUG_Printf(DBG_CHN_MESG,"Unexpected expression.\n");
844 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
845 break;
846 }
847
848 return TRUE;
849 }
850
851 struct expr *
852 DEBUG_CloneExpr(const struct expr * exp)
853 {
854 int i;
855 struct expr * rtn;
856
857 rtn = (struct expr *) DBG_alloc(sizeof(struct expr));
858
859 /*
860 * First copy the contents of the expression itself.
861 */
862 *rtn = *exp;
863
864
865 switch(exp->type)
866 {
867 case EXPR_TYPE_CAST:
868 rtn->un.cast.expr = DEBUG_CloneExpr(exp->un.cast.expr);
869 break;
870 case EXPR_TYPE_INTVAR:
871 rtn->un.intvar.name = DBG_strdup(exp->un.intvar.name);
872 break;
873 case EXPR_TYPE_US_CONST:
874 case EXPR_TYPE_CONST:
875 break;
876 case EXPR_TYPE_STRING:
877 rtn->un.string.str = DBG_strdup(exp->un.string.str);
878 break;
879 case EXPR_TYPE_SYMBOL:
880 rtn->un.symbol.name = DBG_strdup(exp->un.symbol.name);
881 break;
882 case EXPR_TYPE_PSTRUCT:
883 case EXPR_TYPE_STRUCT:
884 rtn->un.structure.exp1 = DEBUG_CloneExpr(exp->un.structure.exp1);
885 rtn->un.structure.element_name = DBG_strdup(exp->un.structure.element_name);
886 break;
887 case EXPR_TYPE_CALL:
888 for(i=0; i < exp->un.call.nargs; i++)
889 {
890 rtn->un.call.arg[i] = DEBUG_CloneExpr(exp->un.call.arg[i]);
891 }
892 rtn->un.call.funcname = DBG_strdup(exp->un.call.funcname);
893 break;
894 case EXPR_TYPE_BINOP:
895 rtn->un.binop.exp1 = DEBUG_CloneExpr(exp->un.binop.exp1);
896 rtn->un.binop.exp2 = DEBUG_CloneExpr(exp->un.binop.exp2);
897 break;
898 case EXPR_TYPE_UNOP:
899 rtn->un.unop.exp1 = DEBUG_CloneExpr(exp->un.unop.exp1);
900 break;
901 default:
902 DEBUG_Printf(DBG_CHN_MESG,"Unexpected expression.\n");
903 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
904 break;
905 }
906
907 return rtn;
908 }
909
910
911 /*
912 * Recursively go through an expression tree and free all memory associated
913 * with it.
914 */
915 int
916 DEBUG_FreeExpr(struct expr * exp)
917 {
918 int i;
919
920 switch(exp->type)
921 {
922 case EXPR_TYPE_CAST:
923 DEBUG_FreeExpr(exp->un.cast.expr);
924 break;
925 case EXPR_TYPE_INTVAR:
926 DBG_free((char *) exp->un.intvar.name);
927 break;
928 case EXPR_TYPE_US_CONST:
929 case EXPR_TYPE_CONST:
930 break;
931 case EXPR_TYPE_STRING:
932 DBG_free((char *) exp->un.string.str);
933 break;
934 case EXPR_TYPE_SYMBOL:
935 DBG_free((char *) exp->un.symbol.name);
936 break;
937 case EXPR_TYPE_PSTRUCT:
938 case EXPR_TYPE_STRUCT:
939 DEBUG_FreeExpr(exp->un.structure.exp1);
940 DBG_free((char *) exp->un.structure.element_name);
941 break;
942 case EXPR_TYPE_CALL:
943 for(i=0; i < exp->un.call.nargs; i++)
944 {
945 DEBUG_FreeExpr(exp->un.call.arg[i]);
946 }
947 DBG_free((char *) exp->un.call.funcname);
948 break;
949 case EXPR_TYPE_BINOP:
950 DEBUG_FreeExpr(exp->un.binop.exp1);
951 DEBUG_FreeExpr(exp->un.binop.exp2);
952 break;
953 case EXPR_TYPE_UNOP:
954 DEBUG_FreeExpr(exp->un.unop.exp1);
955 break;
956 default:
957 DEBUG_Printf(DBG_CHN_MESG,"Unexpected expression.\n");
958 RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
959 break;
960 }
961
962 DBG_free(exp);
963 return TRUE;
964 }
Windows API implementation