gdb/cadillac-patches

   1 # Apply these patches to GDB to produce an Energize GDB.
   2 # To apply these patches, first cd to gdb-XX/gdb, then run patch -p0 < thisfile.
   3 ===================================================================
   4 diff -rc Makefile.in.orig Makefile.in
   5 *** Makefile.in.orig    Tue Jun 23 08:59:44 1992
   6 --- Makefile.in Tue Jun 23 12:00:54 1992
   7 ***************
   8 *** 182,188 ****
   9   # demangling.  For other demangling styles, such as the Annotated C++
  10   # Reference Manual (section 7.2.1c) style, set this define in the target-
  11   # dependent makefile fragment.
  12 ! DEMANGLE_OPTS=
  13
  14   # Host and target-dependent makefile fragments come in here.
  15   ####
  16 --- 182,193 ----
  17   # demangling.  For other demangling styles, such as the Annotated C++
  18   # Reference Manual (section 7.2.1c) style, set this define in the target-
  19   # dependent makefile fragment.
  20 ! #
  21 ! # For Energize, default to using style specified in the Annotated C++
  22 ! # Reference Manual, section 7.2.1c, which is what is used by the Lucid C++
  23 ! # compiler for most things.  But there are places where Lucid varies from
  24 ! # the ARM, so select the Lucid specific code also.
  25 ! DEMANGLE_OPTS=-DARM_DEMANGLING -DLUCID_DEMANGLING
  26
  27   # Host and target-dependent makefile fragments come in here.
  28   ####
  29 ===================================================================
  30 RCS file: /local/cvsfiles/devo/gdb/.Sanitize,v
  31 retrieving revision 2.55
  32 diff -c -r2.55 .Sanitize
  33 *** 2.55        1992/06/23 05:03:32
  34 --- .Sanitize   1992/06/23 05:03:51
  35 ***************
  36 *** 53,58 ****
  37 --- 53,59 ----
  38   buildsym.c
  39   buildsym.h
  40   c-exp.y
  41 + cadillac.c
  42   call-cmds.h
  43   coffread.c
  44   command.c
  45 ***************
  46 *** 70,75 ****
  47 --- 71,77 ----
  48   cplus-dem.c
  49   createtags
  50   dbxread.c
  51 + deblib
  52   defs.h
  53   demangle.h
  54   depend
  55 ===================================================================
  56 RCS file: /local/cvsfiles/devo/gdb/Makefile.in,v
  57 retrieving revision 1.158
  58 diff -c -r1.158 Makefile.in
  59 *** 1.158       1992/06/19 22:39:40
  60 --- Makefile.in 1992/06/23 04:22:01
  61 ***************
  62 *** 124,129 ****
  63 --- 124,134 ----
  64   READLINE_DEP = $$(READLINE_DIR)
  65   RL_LIB = ./../readline${subdir}/libreadline.a
  66
  67 + # Cadillac libraries
  68 + CADILLAC_DIR = ${srcdir}/deblib
  69 + CADILLAC_INCLUDES = -I${CADILLAC_DIR}/connection -I${CADILLAC_DIR}/debugger
  70 + CADILLAC_LIBS = ${srcdir}/deblib/connection/libconn.a
  71 +
  72   # All the includes used for CFLAGS and for lint.
  73   # -I. for config files.
  74   # -I${srcdir} possibly for regex.h also.
  75 ***************
  76 *** 156,162 ****
  77   # {X,T}M_CLIBS, defined in *config files, have host- and target-dependent libs.
  78   # TERMCAP comes after readline, since readline depends on it.
  79   CLIBS = ${BFD_LIB}  ${RL_LIB} ${TERMCAP} ${MMALLOC_LIB} ${LIBIBERTY} \
  80 !       ${XM_CLIBS} ${TM_CLIBS}
  81   CDEPS = ${XM_CDEPS} ${TM_CDEPS} ${BFD_LIB} ${MMALLOC_LIB} ${LIBIBERTY} \
  82         ${RL_LIB} ${MMALLOC_LIB}
  83
  84 --- 161,167 ----
  85   # {X,T}M_CLIBS, defined in *config files, have host- and target-dependent libs.
  86   # TERMCAP comes after readline, since readline depends on it.
  87   CLIBS = ${BFD_LIB}  ${RL_LIB} ${TERMCAP} ${MMALLOC_LIB} ${LIBIBERTY} \
  88 !       ${XM_CLIBS} ${TM_CLIBS} ${CADILLAC_LIBS}
  89   CDEPS = ${XM_CDEPS} ${TM_CDEPS} ${BFD_LIB} ${MMALLOC_LIB} ${LIBIBERTY} \
  90         ${RL_LIB} ${MMALLOC_LIB}
  91
  92 ***************
  93 *** 195,201 ****
  94          ${DEMANGLER}.c mem-break.c target.c inftarg.c \
  95          dbxread.c coffread.c elfread.c dwarfread.c xcoffread.c \
  96          ieee-float.c language.c parse.c buildsym.c objfiles.c \
  97 !        minsyms.c mipsread.c
  98
  99   # Source files in subdirectories (which will be handled separately by
 100   #  'make gdb.tar.Z').
 101 --- 200,206 ----
 102          ${DEMANGLER}.c mem-break.c target.c inftarg.c \
 103          dbxread.c coffread.c elfread.c dwarfread.c xcoffread.c \
 104          ieee-float.c language.c parse.c buildsym.c objfiles.c \
 105 !        minsyms.c mipsread.c cadillac.c
 106
 107   # Source files in subdirectories (which will be handled separately by
 108   #  'make gdb.tar.Z').
 109 ***************
 110 *** 280,286 ****
 111       command.o utils.o expprint.o environ.o version.o gdbtypes.o \
 112       copying.o $(DEPFILES) ${DEMANGLER}.o mem-break.o target.o \
 113       inftarg.o ieee-float.o putenv.o parse.o language.o $(YYOBJ) \
 114 !     buildsym.o objfiles.o minsyms.o \
 115       dbxread.o coffread.o elfread.o dwarfread.o xcoffread.o mipsread.o
 116
 117   RAPP_OBS = rgdb.o rudp.o rserial.o serial.o udp.o $(XDEPFILES)
 118 --- 285,291 ----
 119       command.o utils.o expprint.o environ.o version.o gdbtypes.o \
 120       copying.o $(DEPFILES) ${DEMANGLER}.o mem-break.o target.o \
 121       inftarg.o ieee-float.o putenv.o parse.o language.o $(YYOBJ) \
 122 !     buildsym.o objfiles.o minsyms.o cadillac.o \
 123       dbxread.o coffread.o elfread.o dwarfread.o xcoffread.o mipsread.o
 124
 125   RAPP_OBS = rgdb.o rudp.o rserial.o serial.o udp.o $(XDEPFILES)
 126 ***************
 127 *** 695,700 ****
 128 --- 700,708 ----
 129
 130   ttyflush.o: ${srcdir}/nindy-share/ttyflush.c
 131         ${CC} -c ${INTERNAL_CFLAGS} ${srcdir}/nindy-share/ttyflush.c
 132 +
 133 + cadillac.o: ${srcdir}/cadillac.c
 134 +       ${CC} -c ${INTERNAL_CFLAGS} ${CADILLAC_INCLUDES} ${srcdir}/cadillac.c
 135
 136   lint: $(LINTFILES)
 137         $(LINT) $(INCLUDE_CFLAGS) $(LINTFLAGS) $(LINTFILES) \
 138 ===================================================================
 139 RCS file: /local/cvsfiles/devo/gdb/breakpoint.c,v
 140 retrieving revision 1.36
 141 diff -c -r1.36 breakpoint.c
 142 *** 1.36        1992/06/17 21:53:28
 143 --- breakpoint.c        1992/06/23 04:19:21
 144 ***************
 145 *** 273,278 ****
 146 --- 273,280 ----
 147             b->cond_string = NULL;
 148             if (from_tty)
 149               printf_filtered ("Breakpoint %d now unconditional.\n", bnum);
 150 +           if (cadillac)
 151 +             cadillac_condition_breakpoint(b);
 152           }
 153         else
 154           {
 155 ***************
 156 *** 281,286 ****
 157 --- 283,290 ----
 158                typed in or the decompiled expression.  */
 159             b->cond_string = savestring (arg, strlen (arg));
 160             b->cond = parse_exp_1 (&arg, block_for_pc (b->address), 0);
 161 +           if (cadillac)
 162 +             cadillac_condition_breakpoint(b);
 163             if (*arg)
 164               error ("Junk at end of expression");
 165           }
 166 ***************
 167 *** 316,330 ****
 168     ALL_BREAKPOINTS (b)
 169       if (b->number == bnum)
 170         {
 171 !       if (from_tty && input_from_terminal_p ())
 172 !         {
 173 !           printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
 174   End with a line saying just \"end\".\n", bnum);
 175 -           fflush (stdout);
 176 -         }
 177         l = read_command_lines ();
 178         free_command_lines (&b->commands);
 179         b->commands = l;
 180         return;
 181         }
 182     error ("No breakpoint number %d.", bnum);
 183 --- 320,333 ----
 184     ALL_BREAKPOINTS (b)
 185       if (b->number == bnum)
 186         {
 187 !       if ((from_tty && input_from_terminal_p ()) || cadillac)
 188 !         printf_filtered ("Type commands for when breakpoint %d is hit, one per line.\n\
 189   End with a line saying just \"end\".\n", bnum);
 190         l = read_command_lines ();
 191         free_command_lines (&b->commands);
 192         b->commands = l;
 193 +       if (cadillac)
 194 +         cadillac_commands_breakpoint(b);
 195         return;
 196         }
 197     error ("No breakpoint number %d.", bnum);
 198 ***************
 199 *** 925,930 ****
 200 --- 928,935 ----
 201             {
 202               b->ignore_count--;
 203               this_bp_stop = 0;
 204 +             if (cadillac)
 205 +               cadillac_ignore_breakpoint(b);
 206             }
 207           else
 208             {
 209 ***************
 210 *** 1365,1370 ****
 211 --- 1370,1378 ----
 212   mention (b)
 213        struct breakpoint *b;
 214   {
 215 +   if (cadillac)
 216 +     cadillac_create_breakpoint(b);
 217 +
 218     switch (b->type)
 219       {
 220       case bp_watchpoint:
 221 ***************
 222 *** 2106,2111 ****
 223 --- 2114,2122 ----
 224     register struct breakpoint *b;
 225     register bpstat bs;
 226
 227 +   if (cadillac)
 228 +     cadillac_delete_breakpoint(bpt);
 229 +
 230     if (bpt->inserted)
 231         target_remove_breakpoint(bpt->address, bpt->shadow_contents);
 232
 233 ***************
 234 *** 2277,2282 ****
 235 --- 2288,2295 ----
 236       if (b->number == bptnum)
 237         {
 238         b->ignore_count = count;
 239 +       if (cadillac)
 240 +         cadillac_ignore_breakpoint(b);
 241         if (!from_tty)
 242           return;
 243         else if (count == 0)
 244 ***************
 245 *** 2301,2307 ****
 246     struct breakpoint *b;
 247
 248     ALL_BREAKPOINTS (b)
 249 !     b->ignore_count = 0;
 250   }
 251
 252   /* Command to set ignore-count of breakpoint N to COUNT.  */
 253 --- 2314,2324 ----
 254     struct breakpoint *b;
 255
 256     ALL_BREAKPOINTS (b)
 257 !     {
 258 !       b->ignore_count = 0;
 259 !       if (cadillac)
 260 !       cadillac_ignore_breakpoint(b);
 261 !     }
 262   }
 263
 264   /* Command to set ignore-count of breakpoint N to COUNT.  */
 265 ***************
 266 *** 2368,2373 ****
 267 --- 2385,2393 ----
 268   {
 269     bpt->enable = enabled;
 270
 271 +   if (cadillac)
 272 +     cadillac_enable_breakpoint(bpt);
 273 +
 274     if (xgdb_verbose && bpt->type == bp_breakpoint)
 275       printf ("breakpoint #%d enabled\n", bpt->number);
 276
 277 ***************
 278 *** 2415,2420 ****
 279 --- 2435,2443 ----
 280   disable_breakpoint (bpt)
 281        struct breakpoint *bpt;
 282   {
 283 +   if (cadillac)
 284 +     cadillac_disable_breakpoint(bpt);
 285 +
 286     bpt->enable = disabled;
 287
 288     if (xgdb_verbose && bpt->type == bp_breakpoint)
 289 ===================================================================
 290 RCS file: /local/cvsfiles/devo/gdb/command.c,v
 291 retrieving revision 1.15
 292 diff -c -r1.15 command.c
 293 *** 1.15        1992/06/23 03:33:41
 294 --- command.c   1992/06/23 04:19:26
 295 ***************
 296 *** 1149,1155 ****
 297       }
 298
 299     if (pid != -1)
 300 !     while ((rc = wait (&status)) != pid && rc != -1)
 301         ;
 302     else
 303       error ("Fork failed");
 304 --- 1149,1155 ----
 305       }
 306
 307     if (pid != -1)
 308 !     while ((rc = cadillac ? cadillac_wait(&status) : wait (&status)) != pid && rc != -1)
 309         ;
 310     else
 311       error ("Fork failed");
 312 ===================================================================
 313 RCS file: /local/cvsfiles/devo/gdb/defs.h,v
 314 retrieving revision 1.36
 315 diff -c -r1.36 defs.h
 316 *** 1.36        1992/06/15 14:26:55
 317 --- defs.h      1992/06/16 01:24:19
 318 ***************
 319 *** 774,777 ****
 320 --- 774,846 ----
 321   extern CORE_ADDR
 322   push_word ();
 323
 324 + /* Energize/Cadillac stuff */
 325 +
 326 + /* Non-zero means that we're doing the cadillac interface. */
 327 + extern int cadillac;
 328 +
 329 + /* Get a pty for use with cadillac */
 330 + extern char *cadillac_getpty PARAMS ((void));
 331 +
 332 + /* Notify cadillac of new process creation */
 333 + extern void cadillac_new_process PARAMS ((void));
 334 +
 335 + /* Low level wait routine for wait_for_inferior */
 336 + extern int cadillac_wait PARAMS ((int *));
 337 +
 338 + /* Initialize */
 339 + extern void cadillac_initialize PARAMS ((char *, char *));
 340 +
 341 + /* Main loop for cadillac protocol driver */
 342 + extern void cadillac_main_loop PARAMS ((void));
 343 +
 344 + struct cmd_list_element;
 345 +
 346 + /* Command hook for cadillac */
 347 + extern void cadillac_call_command PARAMS ((struct cmd_list_element *,
 348 +                                          char *, int));
 349 +
 350 + /* Read commands for the command command, and others */
 351 + extern char *cadillac_command_line_input PARAMS ((void));
 352 +
 353 + struct symbol;
 354 + struct type;
 355 +
 356 + extern void cadillac_start_variable_annotation PARAMS ((char *,
 357 +                                                       struct symbol *,
 358 +                                                       struct type *,
 359 +                                                       CORE_ADDR,
 360 +                                                       char *));
 361 +
 362 + extern void cadillac_end_variable_annotation PARAMS ((void));
 363 +
 364 + extern void cadillac_annotate_function PARAMS ((char *, int, int));
 365 +
 366 + struct objfile;
 367 + extern void cadillac_symbol_file PARAMS ((struct objfile *));
 368 +
 369 + /*extern void cadillac_query PARAMS ((char *, ...));*/
 370 + extern void cadillac_query ();        /* Prototypes for varargs don't work */
 371 +
 372 + extern char *cadillac_command_line_input PARAMS ((void));
 373 +
 374 + extern void cadillac_acknowledge_query PARAMS ((char *));
 375 +
 376 + extern void cadillac_fputs PARAMS ((const char *));
 377 +
 378 + struct breakpoint;
 379 + extern void cadillac_condition_breakpoint PARAMS ((struct breakpoint *));
 380 +
 381 + extern void cadillac_commands_breakpoint PARAMS ((struct breakpoint *));
 382 +
 383 + extern void cadillac_ignore_breakpoint PARAMS ((struct breakpoint *));
 384 +
 385 + extern void cadillac_create_breakpoint PARAMS ((struct breakpoint *));
 386 +
 387 + extern void cadillac_delete_breakpoint PARAMS ((struct breakpoint *));
 388 +
 389 + extern void cadillac_enable_breakpoint PARAMS ((struct breakpoint *));
 390 +
 391 + extern void cadillac_disable_breakpoint PARAMS ((struct breakpoint *));
 392 +
 393   #endif /* !defined (DEFS_H) */
 394 ===================================================================
 395 RCS file: /local/cvsfiles/devo/gdb/inflow.c,v
 396 retrieving revision 1.25
 397 diff -c -r1.25 inflow.c
 398 *** 1.25        1992/05/17 23:54:22
 399 --- inflow.c    1992/06/15 23:02:32
 400 ***************
 401 *** 81,87 ****
 402   static short pgrp_inferior;
 403   static short pgrp_ours;
 404   # else /* not def SHORT_PGRP */
 405 ! static int pgrp_inferior;
 406   static int pgrp_ours;
 407   # endif /* not def SHORT_PGRP */
 408   #else /* not def TIOCGPGRP */
 409 --- 81,87 ----
 410   static short pgrp_inferior;
 411   static short pgrp_ours;
 412   # else /* not def SHORT_PGRP */
 413 ! int pgrp_inferior;
 414   static int pgrp_ours;
 415   # endif /* not def SHORT_PGRP */
 416   #else /* not def TIOCGPGRP */
 417 ===================================================================
 418 RCS file: /local/cvsfiles/devo/gdb/infrun.c,v
 419 retrieving revision 1.49
 420 diff -c -r1.49 infrun.c
 421 *** 1.49        1992/06/23 00:24:50
 422 --- infrun.c    1992/06/23 04:19:35
 423 ***************
 424 *** 615,620 ****
 425 --- 615,622 ----
 426      Here we must get it up to actual execution of the real program.  */
 427
 428     inferior_pid = pid;         /* Needed for wait_for_inferior stuff below */
 429 +   if (cadillac)
 430 +     cadillac_new_process();
 431
 432     clear_proceed_status ();
 433
 434 ***************
 435 *** 753,758 ****
 436 --- 755,762 ----
 437
 438     attach (pid);
 439     inferior_pid = pid;
 440 +   if (cadillac)
 441 +     cadillac_new_process();
 442     push_target (&child_ops);
 443
 444     mark_breakpoints_out ();
 445 ===================================================================
 446 RCS file: /local/cvsfiles/devo/gdb/inftarg.c,v
 447 retrieving revision 1.11
 448 diff -c -r1.11 inftarg.c
 449 *** 1.11        1992/03/29 23:21:27
 450 --- inftarg.c   1992/06/15 23:56:08
 451 ***************
 452 *** 58,64 ****
 453   #ifdef USE_PROC_FS
 454       pid = proc_wait (status);
 455   #else
 456 !     pid = wait (status);
 457   #endif
 458       if (pid == -1)            /* No more children to wait for */
 459         {
 460 --- 58,67 ----
 461   #ifdef USE_PROC_FS
 462       pid = proc_wait (status);
 463   #else
 464 !     if (cadillac)
 465 !       pid = cadillac_wait (status);
 466 !     else
 467 !       pid = wait (status);
 468   #endif
 469       if (pid == -1)            /* No more children to wait for */
 470         {
 471 ===================================================================
 472 RCS file: /local/cvsfiles/devo/gdb/main.c,v
 473 retrieving revision 1.47
 474 diff -c -r1.47 main.c
 475 *** 1.47        1992/06/09 06:09:23
 476 --- main.c      1992/06/13 03:32:16
 477 ***************
 478 *** 397,402 ****
 479 --- 397,403 ----
 480     char *corearg = NULL;
 481     char *cdarg = NULL;
 482     char *ttyarg = NULL;
 483 +   char *cadillac_id = NULL;
 484
 485     /* Pointers to all arguments of +command option.  */
 486     char **cmdarg;
 487 ***************
 488 *** 492,497 ****
 489 --- 493,499 ----
 490         {"tty", required_argument, 0, 't'},
 491         {"baud", required_argument, 0, 'b'},
 492         {"b", required_argument, 0, 'b'},
 493 +       {"context", required_argument, 0, 12},
 494   /* Allow machine descriptions to add more options... */
 495   #ifdef ADDITIONAL_OPTIONS
 496         ADDITIONAL_OPTIONS
 497 ***************
 498 *** 524,529 ****
 499 --- 526,534 ----
 500           case 11:
 501             cdarg = optarg;
 502             break;
 503 +         case 12:
 504 +           cadillac_id = optarg;
 505 +           break;
 506           case 's':
 507             symarg = optarg;
 508             break;
 509 ***************
 510 *** 670,675 ****
 511 --- 675,683 ----
 512     free ((PTR)dirarg);
 513     do_cleanups (ALL_CLEANUPS);
 514
 515 +   if (cadillac_id)
 516 +     cadillac_initialize (cadillac_id, execarg);
 517 +
 518     if (execarg != NULL
 519         && symarg != NULL
 520         && strcmp (execarg, symarg) == 0)
 521 ***************
 522 *** 691,696 ****
 523 --- 699,705 ----
 524         if (!setjmp (to_top_level))
 525           symbol_file_command (symarg, 0);
 526       }
 527 +
 528     do_cleanups (ALL_CLEANUPS);
 529
 530     /* After the symbol file has been read, print a newline to get us
 531 ***************
 532 *** 818,824 ****
 533         if (!setjmp (to_top_level))
 534         {
 535           do_cleanups (ALL_CLEANUPS);           /* Do complete cleanup */
 536 !         command_loop ();
 537             quit_command ((char *)0, instream == stdin);
 538         }
 539       }
 540 --- 827,836 ----
 541         if (!setjmp (to_top_level))
 542         {
 543           do_cleanups (ALL_CLEANUPS);           /* Do complete cleanup */
 544 !         if (cadillac_id)
 545 !           cadillac_main_loop();
 546 !         else
 547 !           command_loop ();
 548             quit_command ((char *)0, instream == stdin);
 549         }
 550       }
 551 ***************
 552 *** 880,886 ****
 553         else if (c->function.cfunc == NO_FUNCTION)
 554         error ("That is not a command, just a help topic.");
 555         else
 556 !       (*c->function.cfunc) (arg, from_tty & caution);
 557      }
 558
 559     /* Tell the user if the language has changed (except first time).  */
 560 --- 892,901 ----
 561         else if (c->function.cfunc == NO_FUNCTION)
 562         error ("That is not a command, just a help topic.");
 563         else
 564 !       if (cadillac)
 565 !         cadillac_call_command (c, arg, from_tty & caution);
 566 !       else
 567 !         (*c->function.cfunc) (arg, from_tty & caution);
 568      }
 569
 570     /* Tell the user if the language has changed (except first time).  */
 571 ***************
 572 *** 1516,1522 ****
 573     while (1)
 574       {
 575         dont_repeat ();
 576 !       p = command_line_input ((char *) NULL, instream == stdin);
 577         if (p == NULL)
 578         /* Treat end of file like "end".  */
 579         break;
 580 --- 1531,1540 ----
 581     while (1)
 582       {
 583         dont_repeat ();
 584 !       if (cadillac)
 585 !       p = cadillac_command_line_input();
 586 !       else
 587 !       p = command_line_input ((char *) NULL, instream == stdin);
 588         if (p == NULL)
 589         /* Treat end of file like "end".  */
 590         break;
 591 ***************
 592 *** 1820,1826 ****
 593   void
 594   print_prompt ()
 595   {
 596 !   printf ("%s", prompt);
 597     fflush (stdout);
 598   }
 599   \f
 600 --- 1838,1844 ----
 601   void
 602   print_prompt ()
 603   {
 604 !   printf_filtered ("%s", prompt);
 605     fflush (stdout);
 606   }
 607   \f
 608 ===================================================================
 609 RCS file: /local/cvsfiles/devo/gdb/printcmd.c,v
 610 retrieving revision 1.28
 611 diff -c -r1.28 printcmd.c
 612 *** 1.28        1992/06/13 18:20:41
 613 --- printcmd.c  1992/06/14 22:11:35
 614 ***************
 615 *** 778,783 ****
 616 --- 778,792 ----
 617       {
 618         int histindex = record_latest_value (val);
 619
 620 +       if (cadillac)
 621 +       {
 622 +         char buf[20];
 623 +
 624 +         sprintf(buf, "$%d", histindex);
 625 +         cadillac_start_variable_annotation(buf, NULL, VALUE_TYPE(val),
 626 +                                            VALUE_ADDRESS(val), "");
 627 +       }
 628 +
 629         if (inspect)
 630         printf ("\031(gdb-makebuffer \"%s\"  %d '(\"", exp, histindex);
 631         else
 632 ***************
 633 *** 784,789 ****
 634 --- 793,800 ----
 635         if (histindex >= 0) printf_filtered ("$%d = ", histindex);
 636
 637         print_formatted (val, format, fmt.size);
 638 +       if (cadillac)
 639 +       cadillac_end_variable_annotation();
 640         printf_filtered ("\n");
 641         if (inspect)
 642         printf("\") )\030");
 643 ***************
 644 *** 1608,1618 ****
 645 --- 1619,1639 ----
 646          standard indentation here is 4 spaces, and val_print indents
 647          2 for each recurse.  */
 648         val = read_var_value (sym, FRAME_INFO_ID (fi));
 649 +
 650 +       if (cadillac)
 651 +       cadillac_start_variable_annotation(SYMBOL_NAME(sym), sym,
 652 +                                          VALUE_TYPE(val),
 653 +                                          VALUE_ADDRESS(val), "");
 654 +
 655         if (val)
 656           val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), VALUE_ADDRESS (val),
 657                    stream, 0, 0, 2, Val_no_prettyprint);
 658         else
 659         fputs_filtered ("???", stream);
 660 +
 661 +       if (cadillac)
 662 +       cadillac_end_variable_annotation();
 663 +
 664         first = 0;
 665       }
 666
 667 ===================================================================
 668 RCS file: /local/cvsfiles/devo/gdb/stack.c,v
 669 retrieving revision 1.30
 670 diff -c -r1.30 stack.c
 671 *** 1.30        1992/06/20 23:30:33
 672 --- stack.c     1992/06/23 04:19:48
 673 ***************
 674 *** 159,165 ****
 675         if (addressprint)
 676           printf_filtered ("%s in ", local_hex_string(fi->pc));
 677
 678 !       fputs_demangled (fname, stdout, 0);
 679         fputs_filtered (" (...)\n", stdout);
 680
 681         return;
 682 --- 159,168 ----
 683         if (addressprint)
 684           printf_filtered ("%s in ", local_hex_string(fi->pc));
 685
 686 !       if (cadillac)
 687 !       cadillac_annotate_function(fname, 0, level);
 688 !       else
 689 !       fputs_demangled (fname, stdout, 0);
 690         fputs_filtered (" (...)\n", stdout);
 691
 692         return;
 693 ***************
 694 *** 218,224 ****
 695         if (addressprint)
 696         if (fi->pc != sal.pc || !sal.symtab)
 697           printf_filtered ("%s in ", local_hex_string(fi->pc));
 698 !       fputs_demangled (funname ? funname : "??", stdout, 0);
 699         wrap_here ("   ");
 700         fputs_filtered (" (", stdout);
 701         if (args)
 702 --- 221,230 ----
 703         if (addressprint)
 704         if (fi->pc != sal.pc || !sal.symtab)
 705           printf_filtered ("%s in ", local_hex_string(fi->pc));
 706 !       if (cadillac)
 707 !       cadillac_annotate_function(funname ? funname : "??", 0, level);
 708 !       else
 709 !       fputs_demangled (funname ? funname : "??", stdout, 0);
 710         wrap_here ("   ");
 711         fputs_filtered (" (", stdout);
 712         if (args)
 713 ***************
 714 *** 255,261 ****
 715         {
 716           if (addressprint && mid_statement)
 717             printf_filtered ("%s\t", local_hex_string(fi->pc));
 718 !         print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
 719         }
 720         current_source_line = max (sal.line - lines_to_list/2, 1);
 721       }
 722 --- 261,268 ----
 723         {
 724           if (addressprint && mid_statement)
 725             printf_filtered ("%s\t", local_hex_string(fi->pc));
 726 !         if (!cadillac)
 727 !           print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
 728         }
 729         current_source_line = max (sal.line - lines_to_list/2, 1);
 730       }
 731 ***************
 732 *** 429,435 ****
 733     if (funname)
 734       {
 735         printf_filtered (" in ");
 736 !       fputs_demangled (funname, stdout, DMGL_ANSI | DMGL_PARAMS);
 737       }
 738     wrap_here ("   ");
 739     if (sal.symtab)
 740 --- 436,446 ----
 741     if (funname)
 742       {
 743         printf_filtered (" in ");
 744 !       if (cadillac)
 745 !       cadillac_annotate_function(funname, DMGL_ANSI | DMGL_PARAMS,
 746 !                                selected_frame_level);
 747 !       else
 748 !       fputs_demangled (funname, stdout, DMGL_ANSI | DMGL_PARAMS);
 749       }
 750     wrap_here ("   ");
 751     if (sal.symtab)
 752 ===================================================================
 753 RCS file: /local/cvsfiles/devo/gdb/symfile.c,v
 754 retrieving revision 1.53
 755 diff -c -r1.53 symfile.c
 756 *** 1.53        1992/06/13 16:20:12
 757 --- symfile.c   1992/06/14 22:11:39
 758 ***************
 759 *** 555,560 ****
 760 --- 555,563 ----
 761         fflush (stdout);
 762       }
 763
 764 +   if (cadillac)
 765 +     cadillac_symbol_file(objfile);
 766 +
 767     return (objfile);
 768   }
 769
 770 ===================================================================
 771 RCS file: /local/cvsfiles/devo/gdb/utils.c,v
 772 retrieving revision 1.50
 773 diff -c -r1.50 utils.c
 774 *** 1.50        1992/06/15 14:27:07
 775 --- utils.c     1992/06/16 01:24:28
 776 ***************
 777 *** 96,101 ****
 778 --- 96,102 ----
 779
 780   char *error_pre_print;
 781   char *warning_pre_print = "\nwarning: ";
 782 +
 783   \f
 784   /* Add a new cleanup to the cleanup_chain,
 785      and return the previous chain pointer
 786 ***************
 787 *** 694,700 ****
 788     register int ans2;
 789
 790     /* Automatically answer "yes" if input is not from a terminal.  */
 791 !   if (!input_from_terminal_p ())
 792       return 1;
 793
 794     while (1)
 795 --- 695,701 ----
 796     register int ans2;
 797
 798     /* Automatically answer "yes" if input is not from a terminal.  */
 799 !   if (!input_from_terminal_p () && !cadillac)
 800       return 1;
 801
 802     while (1)
 803 ***************
 804 *** 701,721 ****
 805       {
 806         va_start (args);
 807         ctlstr = va_arg (args, char *);
 808         vfprintf_filtered (stdout, ctlstr, args);
 809 -       va_end (args);
 810         printf_filtered ("(y or n) ");
 811 !       fflush (stdout);
 812 !       answer = fgetc (stdin);
 813 !       clearerr (stdin);               /* in case of C-d */
 814 !       if (answer == EOF)      /* C-d */
 815 !         return 1;
 816 !       if (answer != '\n')     /* Eat rest of input line, to EOF or newline */
 817 !       do
 818 !         {
 819 !           ans2 = fgetc (stdin);
 820 !           clearerr (stdin);
 821 !         }
 822 !         while (ans2 != EOF && ans2 != '\n');
 823         if (answer >= 'a')
 824         answer -= 040;
 825         if (answer == 'Y')
 826 --- 702,734 ----
 827       {
 828         va_start (args);
 829         ctlstr = va_arg (args, char *);
 830 +       if (cadillac)
 831 +       cadillac_query (ctlstr, args);
 832         vfprintf_filtered (stdout, ctlstr, args);
 833         printf_filtered ("(y or n) ");
 834 !       if (cadillac)
 835 !       {
 836 !         char *buf;
 837 !
 838 !         buf = cadillac_command_line_input();
 839 !         answer = buf ? *buf : 'Y';
 840 !         cadillac_acknowledge_query(buf);
 841 !       }
 842 !       else
 843 !       {
 844 !         fflush (stdout);
 845 !         answer = fgetc (stdin);
 846 !         clearerr (stdin);             /* in case of C-d */
 847 !         if (answer == EOF)    /* C-d */
 848 !           return 1;
 849 !         if (answer != '\n')   /* Eat rest of input line, to EOF or newline */
 850 !           do
 851 !             {
 852 !               ans2 = fgetc (stdin);
 853 !               clearerr (stdin);
 854 !             }
 855 !         while (ans2 != EOF && ans2 != '\n');
 856 !       }
 857         if (answer >= 'a')
 858         answer -= 040;
 859         if (answer == 'Y')
 860 ***************
 861 *** 723,728 ****
 862 --- 736,742 ----
 863         if (answer == 'N')
 864         return 0;
 865         printf_filtered ("Please answer y or n.\n");
 866 +       va_end (args);
 867       }
 868   }
 869
 870 ***************
 871 *** 989,994 ****
 872 --- 1003,1014 ----
 873     if (linebuffer == 0)
 874       return;
 875
 876 +   if (cadillac)
 877 +     {
 878 +       cadillac_fputs(linebuffer);
 879 +       return;
 880 +     }
 881 +
 882     /* Don't do any filtering if it is disabled.  */
 883     if (stream != stdout
 884      || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
 885 ===================================================================
 886 RCS file: /local/cvsfiles/devo/gdb/valprint.c,v
 887 retrieving revision 1.42
 888 diff -c -r1.42 valprint.c
 889 *** 1.42        1992/06/23 03:33:47
 890 --- valprint.c  1992/06/23 04:19:55
 891 ***************
 892 *** 485,490 ****
 893 --- 485,491 ----
 894        struct type **dont_print;
 895   {
 896     int i, len, n_baseclasses;
 897 +   char expr_tag[100];         /* Cadillac */
 898
 899     check_stub_type (type);
 900
 901 ***************
 902 *** 549,554 ****
 903 --- 550,563 ----
 904               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 905               fputs_filtered (" = ", stream);
 906             }
 907 +
 908 +         sprintf(expr_tag, ".%s", TYPE_FIELD_NAME(type, i));
 909 +
 910 +         if (cadillac)
 911 +           cadillac_start_variable_annotation(expr_tag, NULL,
 912 +                                              TYPE_FIELD_TYPE(type, i),
 913 +                                              (CORE_ADDR) (valaddr + TYPE_FIELD_BITPOS(type, i) / 8),
 914 +                                              "");
 915           if (TYPE_FIELD_PACKED (type, i))
 916             {
 917               value v;
 918 ***************
 919 *** 567,572 ****
 920 --- 576,583 ----
 921                          valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
 922                          0, stream, format, 0, recurse + 1, pretty);
 923             }
 924 +         if (cadillac)
 925 +           cadillac_end_variable_annotation();
 926         }
 927         if (pretty)
 928         {
 929 ***************
 930 *** 801,806 ****
 931 --- 812,818 ----
 932                   unsigned int rep1;
 933                   /* Number of repetitions we have detected so far.  */
 934                   unsigned int reps;
 935 +                 char expr_tag[100]; /* Cadillac */
 936
 937                   if (i != 0)
 938                     if (arrayprint)
 939 ***************
 940 *** 822,827 ****
 941 --- 834,845 ----
 942                       ++rep1;
 943                     }
 944
 945 +                 sprintf(expr_tag, "[%d]", i);
 946 +                 if (cadillac)
 947 +                   cadillac_start_variable_annotation(expr_tag, NULL,
 948 +                                                      elttype,
 949 +                                                      (CORE_ADDR) (valaddr + i * eltlen),
 950 +                                                      "");
 951                   if (reps > REPEAT_COUNT_THRESHOLD)
 952                     {
 953                       val_print (elttype, valaddr + i * eltlen,
 954 ***************
 955 *** 838,843 ****
 956 --- 856,863 ----
 957                                  recurse + 1, pretty);
 958                       things_printed++;
 959                     }
 960 +                 if (cadillac)
 961 +                   cadillac_end_variable_annotation();
 962                 }
 963               if (i < len)
 964                 fprintf_filtered (stream, "...");
 965 ===================================================================
 966 RCS file: /local/cvsfiles/devo/gdb/config/ncr3000.mh,v
 967 retrieving revision 1.4
 968 diff -c -r1.4 config/ncr3000.mh
 969 *** 1.4 1992/06/15 19:25:13
 970 --- config/ncr3000.mh   1992/06/16 01:28:40
 971 ***************
 972 *** 38,40 ****
 973 --- 38,46 ----
 974   # The /usr/ucb/install program is incompatible (complains about unknown
 975   # group staff).  Use good old cp...
 976   INSTALL = cp
 977 +
 978 + # These are the libs that are needed for the Cadillac version of gdb on
 979 + # SVR4.  Note that we MUST include the standard C library before libucb.a,
 980 + # otherwise we get lots of broken stuff we don't want.
 981 + CADILLAC_LIBS = ${srcdir}/deblib/connection/libconn.a -L/usr/lib -lm -lnet \
 982 +       -lresolv -lform -lsocket -lc /usr/ucblib/libucb.a -lnsl