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