gdb/gdb-events.sh

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