gdb/gdb-events.sh

   1 #!/bin/sh
   2
   3 # User Interface Events.
   4 # Copyright 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   5 #
   6 # Contributed by Cygnus Solutions.
   7 #
   8 # This file is part of GDB.
   9 #
  10 # This program is free software; you can redistribute it and/or modify
  11 # it under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 2 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # This program is distributed in the hope that it will be useful,
  16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with this program; if not, write to the Free Software
  22 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23
  24 #
  25 # What happens next:
  26 #
  27
  28 # The gdb-events.h/gdb-events.c files this script generates are commited
  29 # and published.
  30
  31 # Any UI module that is installing events is changed so that the
  32 # events are installed using the ``set_gdb_events()'' and
  33 # ``gdb_event_hooks()'' interfaces.  There could prove to be an issue
  34 # here with respect to annotate.  We might need to accomodate a hook
  35 # stack that allows several ui blocks to install their own events.
  36
  37 # Each of the variable events (as currently generated) is converted
  38 # to either a straight function call or a function call with a
  39 # predicate.
  40
  41
  42 IFS=:
  43
  44 read="class returntype function formal actual attrib"
  45
  46 function_list ()
  47 {
  48   # category:
  49   #        # -> disable
  50   #        * -> compatibility - pointer variable that is initialized
  51   #             by set_gdb_events().
  52   #        ? -> Predicate and function proper.
  53   #        f -> always call (must have a void returntype)
  54   # return-type
  55   # name
  56   # formal argument list
  57   # actual argument list
  58   # attributes
  59   # description
  60   cat <<EOF |
  61 f:void:breakpoint_create:int b:b
  62 f:void:breakpoint_delete:int b:b
  63 f:void:breakpoint_modify:int b:b
  64 f:void:tracepoint_create:int number:number
  65 f:void:tracepoint_delete:int number:number
  66 f:void:tracepoint_modify:int number:number
  67 f:void:architecture_changed:void
  68 f:void:target_changed:void
  69 f:void:selected_frame_level_changed:int level:level
  70 #*:void:annotate_starting_hook:void
  71 #*:void:annotate_stopped_hook:void
  72 #*:void:annotate_signalled_hook:void
  73 #*:void:annotate_signal_hook:void
  74 #*:void:annotate_exited_hook:void
  75 ##*:void:print_register_hook:int
  76 ##*:CORE_ADDR:find_toc_address_hook:CORE_ADDR
  77 ##*:void:sparc_print_register_hook:int regno:regno
  78 #*:void:target_resume_hook:void
  79 #*:void:target_wait_loop_hook:void
  80 #*:void:init_gdb_hook:char *argv0:argv0
  81 #*:void:command_loop_hook:void
  82 #*:void:fputs_unfiltered_hook:const char *linebuff,struct ui_file *stream:linebuff, stream
  83 #*:void:print_frame_info_listing_hook:struct symtab *s, int line, int stopline, int noerror:s, line, stopline, noerror
  84 #*:int:query_hook:const char *query, va_list args:query, args
  85 #*:void:warning_hook:const char *string, va_list args:string, args
  86 #*:void:target_output_hook:char *b:b
  87 #*:void:interactive_hook:void
  88 #*:void:registers_changed_hook:void
  89 #*:void:readline_begin_hook:char *format, ...:format
  90 #*:char *:readline_hook:char *prompt:prompt
  91 #*:void:readline_end_hook:void
  92 #*:int:target_wait_hook:int pid, struct target_waitstatus *status:pid, status
  93 #*:void:call_command_hook:struct cmd_list_element *c, char *cmd, int from_tty:c, cmd, from_tty
  94 #*:NORETURN void:error_hook:void:: ATTR_NORETURN
  95 #*:void:error_begin_hook:void
  96 ##*:int:target_architecture_hook:const struct bfd_arch_info *
  97 #*:void:exec_file_display_hook:char *filename:filename
  98 #*:void:file_changed_hook:char *filename:filename
  99 ##*:void:specify_exec_file_hook:
 100 #*:int:gdb_load_progress_hook:char *section, unsigned long num:section, num
 101 #*:void:pre_add_symbol_hook:char *name:name
 102 #*:void:post_add_symbol_hook:void
 103 #*:void:selected_frame_level_changed_hook:int level:level
 104 #*:int:gdb_loop_hook:int signo:signo
 105 ##*:void:solib_create_inferior_hook:void
 106 ##*:void:xcoff_relocate_symtab_hook:unsigned int
 107 EOF
 108   grep -v '^#'
 109 }
 110
 111 copyright ()
 112 {
 113   cat <<EOF
 114 /* User Interface Events.
 115
 116    Copyright 1999, 2001, 2002 Free Software Foundation, Inc.
 117
 118    Contributed by Cygnus Solutions.
 119
 120    This file is part of GDB.
 121
 122    This program is free software; you can redistribute it and/or modify
 123    it under the terms of the GNU General Public License as published by
 124    the Free Software Foundation; either version 2 of the License, or
 125    (at your option) any later version.
 126
 127    This program is distributed in the hope that it will be useful,
 128    but WITHOUT ANY WARRANTY; without even the implied warranty of
 129    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 130    GNU General Public License for more details.
 131
 132    You should have received a copy of the GNU General Public License
 133    along with this program; if not, write to the Free Software
 134    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 135
 136 /* Work in progress */
 137
 138 /* This file was created with the aid of \`\`gdb-events.sh''.
 139
 140    The bourn shell script \`\`gdb-events.sh'' creates the files
 141    \`\`new-gdb-events.c'' and \`\`new-gdb-events.h and then compares
 142    them against the existing \`\`gdb-events.[hc]''.  Any differences
 143    found being reported.
 144
 145    If editing this file, please also run gdb-events.sh and merge any
 146    changes into that script. Conversely, when making sweeping changes
 147    to this file, modifying gdb-events.sh and using its output may
 148    prove easier. */
 149
 150 EOF
 151 }
 152
 153 #
 154 # The .h file
 155 #
 156
 157 exec > new-gdb-events.h
 158 copyright
 159 cat <<EOF
 160
 161 #ifndef GDB_EVENTS_H
 162 #define GDB_EVENTS_H
 163
 164 #ifndef WITH_GDB_EVENTS
 165 #define WITH_GDB_EVENTS 1
 166 #endif
 167 EOF
 168
 169 # pointer declarations
 170 echo ""
 171 echo ""
 172 cat <<EOF
 173 /* COMPAT: pointer variables for old, unconverted events.
 174    A call to set_gdb_events() will automatically update these. */
 175 EOF
 176 echo ""
 177 function_list | while eval read $read
 178 do
 179   case "${class}" in
 180     "*" )
 181         echo "extern ${returntype} (*${function}_event) (${formal})${attrib};"
 182         ;;
 183   esac
 184 done
 185
 186 # function typedef's
 187 echo ""
 188 echo ""
 189 cat <<EOF
 190 /* Type definition of all hook functions.
 191    Recommended pratice is to first declare each hook function using
 192    the below ftype and then define it. */
 193 EOF
 194 echo ""
 195 function_list | while eval read $read
 196 do
 197   echo "typedef ${returntype} (gdb_events_${function}_ftype) (${formal});"
 198 done
 199
 200 # gdb_events object
 201 echo ""
 202 echo ""
 203 cat <<EOF
 204 /* gdb-events: object. */
 205 EOF
 206 echo ""
 207 echo "struct gdb_events"
 208 echo "  {"
 209 function_list | while eval read $read
 210 do
 211   echo "    gdb_events_${function}_ftype *${function}${attrib};"
 212 done
 213 echo "  };"
 214
 215 # function declarations
 216 echo ""
 217 echo ""
 218 cat <<EOF
 219 /* Interface into events functions.
 220    Where a *_p() predicate is present, it must be called before
 221    calling the hook proper. */
 222 EOF
 223 function_list | while eval read $read
 224 do
 225   case "${class}" in
 226     "*" ) continue ;;
 227     "?" )
 228         echo "extern int ${function}_p (void);"
 229         echo "extern ${returntype} ${function}_event (${formal})${attrib};"
 230         ;;
 231     "f" )
 232         echo "extern ${returntype} ${function}_event (${formal})${attrib};"
 233         ;;
 234   esac
 235 done
 236
 237 # function macros
 238 echo ""
 239 echo ""
 240 cat <<EOF
 241 /* When GDB_EVENTS are not being used, completly disable them. */
 242 EOF
 243 echo ""
 244 echo "#if !WITH_GDB_EVENTS"
 245 function_list | while eval read $read
 246 do
 247   case "${class}" in
 248     "*" ) continue ;;
 249     "?" )
 250         echo "#define ${function}_event_p() 0"
 251         echo "#define ${function}_event(${actual}) 0"
 252         ;;
 253     "f" )
 254         echo "#define ${function}_event(${actual}) 0"
 255         ;;
 256   esac
 257 done
 258 echo "#endif"
 259
 260 # our set function
 261 cat <<EOF
 262
 263 /* Install custom gdb-events hooks. */
 264 extern struct gdb_events *set_gdb_event_hooks (struct gdb_events *vector);
 265
 266 /* Deliver any pending events. */
 267 extern void gdb_events_deliver (struct gdb_events *vector);
 268
 269 /* Clear event handlers */
 270 extern void clear_gdb_event_hooks (void);
 271
 272 #if !WITH_GDB_EVENTS
 273 #define set_gdb_events(x) 0
 274 #define set_gdb_event_hooks(x) 0
 275 #define gdb_events_deliver(x) 0
 276 #endif
 277 EOF
 278
 279 # close it off
 280 echo ""
 281 echo "#endif"
 282 exec 1>&2
 283 #../move-if-change new-gdb-events.h gdb-events.h
 284 if test -r gdb-events.h
 285 then
 286   diff -c gdb-events.h new-gdb-events.h
 287   if [ $? = 1 ]
 288   then
 289     echo "gdb-events.h changed? cp new-gdb-events.h gdb-events.h" 1>&2
 290   fi
 291 else
 292   echo "File missing? mv new-gdb-events.h gdb-events.h" 1>&2
 293 fi
 294
 295
 296
 297 #
 298 # C file
 299 #
 300
 301 exec > new-gdb-events.c
 302 copyright
 303 cat <<EOF
 304
 305 #include "defs.h"
 306 #include "gdb-events.h"
 307 #include "gdbcmd.h"
 308
 309 #if WITH_GDB_EVENTS
 310 static struct gdb_events null_event_hooks;
 311 static struct gdb_events queue_event_hooks;
 312 static struct gdb_events *current_event_hooks = &null_event_hooks;
 313 #endif
 314
 315 int gdb_events_debug;
 316 EOF
 317
 318 # global pointer variables - always have this
 319 #echo ""
 320 #function_list | while eval read $read
 321 #do
 322 #  case "${class}" in
 323 #    "*" )
 324 #       echo "${returntype} (*${function}_event) (${formal})${attrib} = 0;"
 325 #       ;;
 326 #  esac
 327 #done
 328
 329 # function bodies
 330 echo ""
 331 echo "#if WITH_GDB_EVENTS"
 332 function_list | while eval read $read
 333 do
 334   case "${class}" in
 335     "*" ) continue ;;
 336     "?" )
 337 cat <<EOF
 338
 339 int
 340 ${function}_event_p (${formal})
 341 {
 342   return current_event_hooks->${function};
 343 }
 344
 345 ${returntype}
 346 ${function}_event (${formal})
 347 {
 348   return current_events->${function} (${actual});
 349 }
 350 EOF
 351         ;;
 352      "f" )
 353 cat <<EOF
 354
 355 void
 356 ${function}_event (${formal})
 357 {
 358   if (gdb_events_debug)
 359     fprintf_unfiltered (gdb_stdlog, "${function}_event\n");
 360   if (!current_event_hooks->${function})
 361     return;
 362   current_event_hooks->${function} (${actual});
 363 }
 364 EOF
 365         ;;
 366   esac
 367 done
 368 echo ""
 369 echo "#endif"
 370
 371 # Set hooks function
 372 echo ""
 373 cat <<EOF
 374 #if WITH_GDB_EVENTS
 375 struct gdb_events *
 376 set_gdb_event_hooks (struct gdb_events *vector)
 377 {
 378   struct gdb_events *old_events = current_event_hooks;
 379   if (vector == NULL)
 380     current_event_hooks = &queue_event_hooks;
 381   else
 382     current_event_hooks = vector;
 383   return old_events;
 384 EOF
 385 function_list | while eval read $read
 386 do
 387   case "${class}" in
 388     "*" )
 389       echo "  ${function}_event = hooks->${function};"
 390       ;;
 391   esac
 392 done
 393 cat <<EOF
 394 }
 395 #endif
 396 EOF
 397
 398 # Clear hooks function
 399 echo ""
 400 cat <<EOF
 401 #if WITH_GDB_EVENTS
 402 void
 403 clear_gdb_event_hooks (void)
 404 {
 405   set_gdb_event_hooks (&null_event_hooks);
 406 }
 407 #endif
 408 EOF
 409
 410 # event type
 411 echo ""
 412 cat <<EOF
 413 enum gdb_event
 414 {
 415 EOF
 416 function_list | while eval read $read
 417 do
 418   case "${class}" in
 419     "f" )
 420       echo "  ${function},"
 421       ;;
 422   esac
 423 done
 424 cat <<EOF
 425   nr_gdb_events
 426 };
 427 EOF
 428
 429 # event data
 430 echo ""
 431 function_list | while eval read $read
 432 do
 433   case "${class}" in
 434     "f" )
 435       if test ${actual}
 436       then
 437         echo "struct ${function}"
 438         echo "  {"
 439         echo "    `echo ${formal} | tr '[,]' '[;]'`;"
 440         echo "  };"
 441         echo ""
 442       fi
 443       ;;
 444   esac
 445 done
 446
 447 # event queue
 448 cat <<EOF
 449 struct event
 450   {
 451     enum gdb_event type;
 452     struct event *next;
 453     union
 454       {
 455 EOF
 456 function_list | while eval read $read
 457 do
 458   case "${class}" in
 459     "f" )
 460       if test ${actual}
 461       then
 462         echo "        struct ${function} ${function};"
 463       fi
 464       ;;
 465   esac
 466 done
 467 cat <<EOF
 468       }
 469     data;
 470   };
 471 struct event *pending_events;
 472 struct event *delivering_events;
 473 EOF
 474
 475 # append
 476 echo ""
 477 cat <<EOF
 478 static void
 479 append (struct event *new_event)
 480 {
 481   struct event **event = &pending_events;
 482   while ((*event) != NULL)
 483     event = &((*event)->next);
 484   (*event) = new_event;
 485   (*event)->next = NULL;
 486 }
 487 EOF
 488
 489 # schedule a given event
 490 function_list | while eval read $read
 491 do
 492   case "${class}" in
 493     "f" )
 494       echo ""
 495       echo "static void"
 496       echo "queue_${function} (${formal})"
 497       echo "{"
 498       echo "  struct event *event = XMALLOC (struct event);"
 499       echo "  event->type = ${function};"
 500       for arg in `echo ${actual} | tr '[,]' '[:]' | tr -d '[ ]'`; do
 501         echo "  event->data.${function}.${arg} = ${arg};"
 502       done
 503       echo "  append (event);"
 504       echo "}"
 505       ;;
 506   esac
 507 done
 508
 509 # deliver
 510 echo ""
 511 cat <<EOF
 512 void
 513 gdb_events_deliver (struct gdb_events *vector)
 514 {
 515   /* Just zap any events left around from last time. */
 516   while (delivering_events != NULL)
 517     {
 518       struct event *event = delivering_events;
 519       delivering_events = event->next;
 520       xfree (event);
 521     }
 522   /* Process any pending events.  Because one of the deliveries could
 523      bail out we move everything off of the pending queue onto an
 524      in-progress queue where it can, later, be cleaned up if
 525      necessary. */
 526   delivering_events = pending_events;
 527   pending_events = NULL;
 528   while (delivering_events != NULL)
 529     {
 530       struct event *event = delivering_events;
 531       switch (event->type)
 532         {
 533 EOF
 534 function_list | while eval read $read
 535 do
 536   case "${class}" in
 537     "f" )
 538       echo "        case ${function}:"
 539       if test ${actual}
 540       then
 541         echo "          vector->${function}"
 542         sep="            ("
 543         ass=""
 544         for arg in `echo ${actual} | tr '[,]' '[:]' | tr -d '[ ]'`; do
 545           ass="${ass}${sep}event->data.${function}.${arg}"
 546           sep=",
 547                "
 548         done
 549         echo "${ass});"
 550       else
 551         echo "          vector->${function} ();"
 552       fi
 553       echo "          break;"
 554       ;;
 555   esac
 556 done
 557 cat <<EOF
 558         }
 559       delivering_events = event->next;
 560       xfree (event);
 561     }
 562 }
 563 EOF
 564
 565 # Finally the initialization
 566 echo ""
 567 cat <<EOF
 568 void _initialize_gdb_events (void);
 569 void
 570 _initialize_gdb_events (void)
 571 {
 572   struct cmd_list_element *c;
 573 #if WITH_GDB_EVENTS
 574 EOF
 575 function_list | while eval read $read
 576 do
 577   case "${class}" in
 578     "f" )
 579       echo "  queue_event_hooks.${function} = queue_${function};"
 580       ;;
 581   esac
 582 done
 583 cat <<EOF
 584 #endif
 585
 586   c = add_set_cmd ("eventdebug", class_maintenance, var_zinteger,
 587                    (char *) (&gdb_events_debug), "Set event debugging.\n\\
 588 When non-zero, event/notify debugging is enabled.", &setlist);
 589   deprecate_cmd (c, "set debug event");
 590   deprecate_cmd (add_show_from_set (c, &showlist), "show debug event");
 591
 592   add_show_from_set (add_set_cmd ("event",
 593                                   class_maintenance,
 594                                   var_zinteger,
 595                                   (char *) (&gdb_events_debug),
 596                                   "Set event debugging.\n\\
 597 When non-zero, event/notify debugging is enabled.", &setdebuglist),
 598                      &showdebuglist);
 599 }
 600 EOF
 601
 602 # close things off
 603 exec 1>&2
 604 #../move-if-change new-gdb-events.c gdb-events.c
 605 # Replace any leading spaces with tabs
 606 sed < new-gdb-events.c > tmp-gdb-events.c \
 607     -e 's/\(    \)*        /\1  /g'
 608 mv tmp-gdb-events.c new-gdb-events.c
 609 # Move if changed?
 610 if test -r gdb-events.c
 611 then
 612   diff -c gdb-events.c new-gdb-events.c
 613   if [ $? = 1 ]
 614   then
 615     echo "gdb-events.c changed? cp new-gdb-events.c gdb-events.c" 1>&2
 616   fi
 617 else
 618   echo "File missing? mv new-gdb-events.c gdb-events.c" 1>&2
 619 fi