debugger/expr.c

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