[ob] i*.c white space

[Michael Snyder <msnyder at vmware dot com>]

add blank line between decls and statements
2010-05-14  Michael Snyder  <msnyder@vmware.com>

	* infcall.c: White space.
	* inf-child.c: White space.
	* infcmd.c: White space.
	* inferior.c: White space.
	* inf-loop.c: White space.
	* inflow.c: White space.
	* inline-frame.c: White space.
	* interps.c: White space.

Index: infcall.c
===================================================================
RCS file: /cvs/src/src/gdb/infcall.c,v
retrieving revision 1.130
diff -u -p -r1.130 infcall.c
--- infcall.c	6 May 2010 19:14:08 -0000	1.130
+++ infcall.c	14 May 2010 21:24:49 -0000
@@ -268,10 +268,12 @@ find_function_addr (struct value *functi
 	{
 	  /* Handle function descriptors lacking debug info.  */
 	  int found_descriptor = 0;
+
 	  funaddr = 0;	/* pacify "gcc -Werror" */
 	  if (VALUE_LVAL (function) == lval_memory)
 	    {
 	      CORE_ADDR nfunaddr;
+
 	      funaddr = value_as_address (value_addr (function));
 	      nfunaddr = funaddr;
 	      funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
@@ -321,6 +323,7 @@ get_function_name (CORE_ADDR funaddr, ch
 {
   {
     struct symbol *symbol = find_pc_function (funaddr);
+
     if (symbol)
       return SYMBOL_PRINT_NAME (symbol);
   }
@@ -328,6 +331,7 @@ get_function_name (CORE_ADDR funaddr, ch
   {
     /* Try the minimal symbols.  */
     struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
+
     if (msymbol)
       return SYMBOL_PRINT_NAME (msymbol);
   }
@@ -335,6 +339,7 @@ get_function_name (CORE_ADDR funaddr, ch
   {
     char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
                             hex_string (funaddr));
+
     gdb_assert (strlen (tmp) + 1 <= buf_size);
     strcpy (buf, tmp);
     xfree (tmp);
@@ -483,6 +488,7 @@ call_function_by_hand (struct value *fun
   /* Ensure that the initial SP is correctly aligned.  */
   {
     CORE_ADDR old_sp = get_frame_sp (frame);
+
     if (gdbarch_frame_align_p (gdbarch))
       {
 	sp = gdbarch_frame_align (gdbarch, old_sp);
@@ -641,6 +647,7 @@ call_function_by_hand (struct value *fun
 
   {
     int i;
+
     for (i = nargs - 1; i >= 0; i--)
       {
 	int prototyped;
@@ -675,6 +682,7 @@ call_function_by_hand (struct value *fun
   if (struct_return || lang_struct_return)
     {
       int len = TYPE_LENGTH (values_type);
+
       if (gdbarch_inner_than (gdbarch, 1, 2))
 	{
 	  /* Stack grows downward.  Align STRUCT_ADDR and SP after
@@ -737,6 +745,7 @@ call_function_by_hand (struct value *fun
   {
     struct breakpoint *bpt;
     struct symtab_and_line sal;
+
     init_sal (&sal);		/* initialize to zeroes */
     sal.pspace = current_program_space;
     sal.pc = bp_addr;
Index: inf-child.c
===================================================================
RCS file: /cvs/src/src/gdb/inf-child.c,v
retrieving revision 1.23
diff -u -p -r1.23 inf-child.c
--- inf-child.c	1 Jan 2010 07:31:36 -0000	1.23
+++ inf-child.c	14 May 2010 21:24:49 -0000
@@ -174,6 +174,7 @@ struct target_ops *
 inf_child_target (void)
 {
   struct target_ops *t = XZALLOC (struct target_ops);
+
   t->to_shortname = "child";
   t->to_longname = "Unix child process";
   t->to_doc = "Unix child process (started by the \"run\" command).";
Index: infcmd.c
===================================================================
RCS file: /cvs/src/src/gdb/infcmd.c,v
retrieving revision 1.266
diff -u -p -r1.266 infcmd.c
--- infcmd.c	6 May 2010 19:14:08 -0000	1.266
+++ infcmd.c	14 May 2010 21:24:49 -0000
@@ -197,6 +197,7 @@ show_inferior_tty_command (struct ui_fil
   /* Note that we ignore the passed-in value in favor of computing it
      directly.  */
   const char *inferior_io_terminal = get_inferior_io_terminal ();
+
   if (inferior_io_terminal == NULL)
     inferior_io_terminal = "";
   fprintf_filtered (gdb_stdout,
@@ -669,7 +670,7 @@ continue_1 (int all_threads)
   if (non_stop && all_threads)
     {
       /* Don't error out if the current thread is running, because
-        there may be other stopped threads.  */
+	 there may be other stopped threads.  */
       struct cleanup *old_chain;
 
       /* Backup current thread and selected frame.  */
@@ -875,6 +876,7 @@ step_1 (int skip_subroutines, int single
       for (; count > 0; count--)
 	{
 	  struct thread_info *tp;
+
 	  step_once (skip_subroutines, single_inst, count, thread);
 
 	  if (target_has_execution
@@ -968,6 +970,7 @@ step_once (int skip_subroutines, int sin
 	 INFERIOR_PTID thread instead, which is the same thread when
 	 THREAD is set.  */
       struct thread_info *tp = inferior_thread ();
+
       clear_proceed_status ();
       set_step_frame ();
 
@@ -998,6 +1001,7 @@ step_once (int skip_subroutines, int sin
 	  else if (tp->step_range_end == 0)
 	    {
 	      char *name;
+
 	      if (find_pc_partial_function (pc, &name,
 					    &tp->step_range_start,
 					    &tp->step_range_end) == 0)
@@ -1625,6 +1629,7 @@ finish_command (char *arg, int from_tty)
 	 and not step over the rest of this inlined function call.  */
       struct thread_info *tp = inferior_thread ();
       struct symtab_and_line empty_sal;
+
       init_sal (&empty_sal);
       set_step_info (frame, empty_sal);
       tp->step_range_start = tp->step_range_end = get_frame_pc (frame);
@@ -1684,6 +1689,7 @@ program_info (char *args, int from_tty)
   else
     {
       struct target_waitstatus ws;
+
       get_last_target_status (&ptid, &ws);
     }
 
@@ -1737,6 +1743,7 @@ environment_info (char *var, int from_tt
   if (var)
     {
       char *val = get_in_environ (current_inferior ()->environment, var);
+
       if (val)
 	{
 	  puts_filtered (var);
@@ -1754,6 +1761,7 @@ environment_info (char *var, int from_tt
   else
     {
       char **vector = environ_vector (current_inferior ()->environment);
+
       while (*vector)
 	{
 	  puts_filtered (*vector++);
@@ -1861,6 +1869,7 @@ path_command (char *dirname, int from_tt
 {
   char *exec_path;
   char *env;
+
   dont_repeat ();
   env = get_in_environ (current_inferior ()->environment, path_var_name);
   /* Can be null if path is not set */
@@ -1954,6 +1963,7 @@ default_print_registers_info (struct gdb
 	  for (j = 0; j < register_size (gdbarch, i); j++)
 	    {
 	      int idx;
+
 	      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
 		idx = j;
 	      else
@@ -2036,6 +2046,7 @@ registers_info (char *addr_exp, int fpre
       /* A register name?  */
       {
 	int regnum = user_reg_map_name_to_regnum (gdbarch, start, end - start);
+
 	if (regnum >= 0)
 	  {
 	    /* User registers lie completely outside of the range of
@@ -2064,6 +2075,7 @@ registers_info (char *addr_exp, int fpre
       /* A register group?  */
       {
 	struct reggroup *group;
+
 	for (group = reggroup_next (gdbarch, NULL);
 	     group != NULL;
 	     group = reggroup_next (gdbarch, group))
@@ -2077,6 +2089,7 @@ registers_info (char *addr_exp, int fpre
 	if (group != NULL)
 	  {
 	    int regnum;
+
 	    for (regnum = 0;
 		 regnum < gdbarch_num_regs (gdbarch)
 			  + gdbarch_num_pseudo_regs (gdbarch);
@@ -2339,6 +2352,7 @@ static void
 attach_command_continuation (void *args)
 {
   struct attach_command_continuation_args *a = args;
+
   attach_command_post_wait (a->args, a->from_tty, a->async_exec);
 }
 
@@ -2346,6 +2360,7 @@ static void
 attach_command_continuation_free_args (void *args)
 {
   struct attach_command_continuation_args *a = args;
+
   xfree (a->args);
   xfree (a);
 }
@@ -2583,6 +2598,7 @@ void 
 interrupt_target_1 (int all_threads)
 {
   ptid_t ptid;
+
   if (all_threads)
     ptid = minus_one_ptid;
   else
Index: inferior.c
===================================================================
RCS file: /cvs/src/src/gdb/inferior.c,v
retrieving revision 1.17
diff -u -p -r1.17 inferior.c
--- inferior.c	7 May 2010 02:09:54 -0000	1.17
+++ inferior.c	14 May 2010 21:24:49 -0000
@@ -68,6 +68,7 @@ static void
 restore_inferior (void *arg)
 {
   struct inferior *saved_inferior = arg;
+
   set_current_inferior (saved_inferior);
 }
 
@@ -80,6 +81,7 @@ save_current_inferior (void)
 {
   struct cleanup *old_chain = make_cleanup (restore_inferior,
 					    current_inferior_);
+
   return old_chain;
 }
 
@@ -283,6 +285,7 @@ void
 exit_inferior (int pid)
 {
   struct inferior *inf = find_inferior_pid (pid);
+
   exit_inferior_1 (inf, 0);
 
   if (print_inferior_events)
@@ -293,6 +296,7 @@ void
 exit_inferior_silent (int pid)
 {
   struct inferior *inf = find_inferior_pid (pid);
+
   exit_inferior_1 (inf, 1);
 }
 
@@ -308,6 +312,7 @@ void
 detach_inferior (int pid)
 {
   struct inferior *inf = find_inferior_pid (pid);
+
   exit_inferior_1 (inf, 1);
 
   if (print_inferior_events)
Index: inf-loop.c
===================================================================
RCS file: /cvs/src/src/gdb/inf-loop.c,v
retrieving revision 1.26
diff -u -p -r1.26 inf-loop.c
--- inf-loop.c	1 Jan 2010 07:31:36 -0000	1.26
+++ inf-loop.c	14 May 2010 21:24:49 -0000
@@ -46,6 +46,7 @@ inferior_event_handler (enum inferior_ev
 {
   struct gdb_exception e;
   int was_sync = 0;
+
   switch (event_type)
     {
     case INF_ERROR:
Index: inflow.c
===================================================================
RCS file: /cvs/src/src/gdb/inflow.c,v
retrieving revision 1.58
diff -u -p -r1.58 inflow.c
--- inflow.c	24 Feb 2010 07:51:44 -0000	1.58
+++ inflow.c	14 May 2010 21:24:49 -0000
@@ -121,6 +121,7 @@ static PROCESS_GROUP_TYPE
 gdb_getpgrp (void)
 {
   int process_group = -1;
+
 #ifdef HAVE_TERMIOS
   process_group = tcgetpgrp (0);
 #endif
Index: infrun.c
===================================================================
RCS file: /cvs/src/src/gdb/infrun.c,v
retrieving revision 1.438
diff -u -p -r1.438 infrun.c
--- infrun.c	6 May 2010 19:14:08 -0000	1.438
+++ infrun.c	14 May 2010 21:24:49 -0000
@@ -709,6 +709,7 @@ follow_exec (ptid_t pid, char *execd_pat
       char *name = alloca (strlen (gdb_sysroot)
 			    + strlen (execd_pathname)
 			    + 1);
+
       strcpy (name, gdb_sysroot);
       strcat (name, execd_pathname);
       execd_pathname = name;
@@ -1210,6 +1211,7 @@ static void
 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
 {
   struct cleanup *ptid_cleanup = save_inferior_ptid ();
+
   inferior_ptid = ptid;
   write_memory (memaddr, myaddr, len);
   do_cleanups (ptid_cleanup);
@@ -1236,6 +1238,7 @@ displaced_step_fixup (ptid_t event_ptid,
   /* Restore the contents of the copy area.  */
   {
     ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch);
+
     write_memory_ptid (displaced->step_ptid, displaced->step_copy,
 		       displaced->step_saved_copy, len);
     if (debug_displaced)
@@ -1260,6 +1263,7 @@ displaced_step_fixup (ptid_t event_ptid,
          relocate the PC.  */
       struct regcache *regcache = get_thread_regcache (event_ptid);
       CORE_ADDR pc = regcache_read_pc (regcache);
+
       pc = displaced->step_original + (pc - displaced->step_copy);
       regcache_write_pc (regcache, pc);
     }
@@ -1416,6 +1420,18 @@ set_schedlock_func (char *args, int from
     }
 }
 
+/* reset_schedlock -- public */
+ 
+void
+reset_schedlock ()
+{
+  if (scheduler_mode == schedlock_on)
+    {
+      warning ("Resetting scheduler-lock mode to 'off'");
+      scheduler_mode = schedlock_off;
+    }
+}
+
 /* True if execution commands resume all threads of all processes by
    default; otherwise, resume only threads of the current inferior
    process.  */
@@ -1990,8 +2006,8 @@ void
 start_remote (int from_tty)
 {
   struct inferior *inferior;
-  init_wait_for_inferior ();
 
+  init_wait_for_inferior ();
   inferior = current_inferior ();
   inferior->stop_soon = STOP_QUIETLY_REMOTE;
 
@@ -2252,6 +2268,7 @@ delete_step_thread_step_resume_breakpoin
 	 longjmp-resume breakpoint of the thread that just stopped
 	 stepping.  */
       struct thread_info *tp = inferior_thread ();
+
       delete_step_resume_breakpoint (tp);
     }
   else
@@ -2724,6 +2741,7 @@ adjust_pc_after_break (struct execution_
       || (non_stop && moribund_breakpoint_here_p (aspace, breakpoint_pc)))
     {
       struct cleanup *old_cleanups = NULL;
+
       if (RECORD_IS_USED)
 	old_cleanups = record_gdb_operation_disable_set ();
 
@@ -2877,6 +2895,7 @@ handle_inferior_event (struct execution_
       && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED)
     {
       struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid));
+
       gdb_assert (inf);
       stop_soon = inf->stop_soon;
     }
@@ -3348,6 +3367,7 @@ targets should add new threads to the th
       if (target_stopped_by_watchpoint ())
 	{
           CORE_ADDR addr;
+
 	  fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n");
 
           if (target_stopped_data_address (&current_target, &addr))
@@ -3686,6 +3706,7 @@ targets should add new threads to the th
 	 the instruction and once for the delay slot.  */
       int step_through_delay
 	= gdbarch_single_step_through_delay (gdbarch, frame);
+
       if (debug_infrun && step_through_delay)
 	fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n");
       if (ecs->event_thread->step_range_end == 0 && step_through_delay)
@@ -4137,6 +4158,7 @@ infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME (
   if (!non_stop)
     {
       struct thread_info *tp;
+
       tp = iterate_over_threads (currently_stepping_or_nexting_callback,
 				 ecs->event_thread);
       if (tp)
@@ -4325,6 +4347,7 @@ infrun: not switching back to stepped th
 	  /* Set up a step-resume breakpoint at the address
 	     indicated by SKIP_SOLIB_RESOLVER.  */
 	  struct symtab_and_line sr_sal;
+
 	  init_sal (&sr_sal);
 	  sr_sal.pc = pc_after_resolver;
 	  sr_sal.pspace = get_frame_program_space (frame);
@@ -4463,6 +4486,7 @@ infrun: not switching back to stepped th
       if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc))
 	{
 	  struct symtab_and_line sr_sal;
+
 	  init_sal (&sr_sal);
 	  sr_sal.pc = ecs->stop_func_start;
 	  sr_sal.pspace = get_frame_program_space (frame);
@@ -4511,6 +4535,7 @@ infrun: not switching back to stepped th
 	  /* Set a breakpoint at callee's start address.
 	     From there we can step once and be back in the caller.  */
 	  struct symtab_and_line sr_sal;
+
 	  init_sal (&sr_sal);
 	  sr_sal.pc = ecs->stop_func_start;
 	  sr_sal.pspace = get_frame_program_space (frame);
@@ -4549,6 +4574,7 @@ infrun: not switching back to stepped th
 	     Set a breakpoint at its start and continue, then
 	     one more step will take us out.  */
 	  struct symtab_and_line sr_sal;
+
 	  init_sal (&sr_sal);
 	  sr_sal.pc = ecs->stop_func_start;
 	  sr_sal.pspace = get_frame_program_space (frame);
@@ -4566,6 +4592,7 @@ infrun: not switching back to stepped th
     {
       /* Determine where this trampoline returns.  */
       CORE_ADDR real_stop_pc;
+
       real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
 
       if (debug_infrun)
@@ -5074,6 +5101,7 @@ keep_going (struct execution_control_sta
       if (ecs->event_thread->stepping_over_breakpoint)
 	{
 	  struct regcache *thread_regcache = get_thread_regcache (ecs->ptid);
+
 	  if (!use_displaced_stepping (get_regcache_arch (thread_regcache)))
 	    /* Since we can't do a displaced step, we have to remove
 	       the breakpoint while we step it.  To keep things
@@ -5083,6 +5111,7 @@ keep_going (struct execution_control_sta
       else
 	{
 	  struct gdb_exception e;
+
 	  /* Stop stepping when inserting breakpoints
 	     has failed.  */
 	  TRY_CATCH (e, RETURN_MASK_ERROR)
@@ -5450,6 +5479,7 @@ Further execution is probably impossible
 	 This also restores inferior state prior to the call
 	 (struct inferior_thread_state).  */
       struct frame_info *frame = get_current_frame ();
+
       gdb_assert (get_frame_type (frame) == DUMMY_FRAME);
       frame_pop (frame);
       /* frame_pop() calls reinit_frame_cache as the last thing it does
@@ -5537,6 +5567,7 @@ int
 signal_stop_update (int signo, int state)
 {
   int ret = signal_stop[signo];
+
   signal_stop[signo] = state;
   return ret;
 }
@@ -5545,6 +5576,7 @@ int
 signal_print_update (int signo, int state)
 {
   int ret = signal_print[signo];
+
   signal_print[signo] = state;
   return ret;
 }
@@ -5553,6 +5585,7 @@ int
 signal_pass_update (int signo, int state)
 {
   int ret = signal_program[signo];
+
   signal_program[signo] = state;
   return ret;
 }
@@ -5836,6 +5869,7 @@ static void
 signals_info (char *signum_exp, int from_tty)
 {
   enum target_signal oursig;
+
   sig_print_header ();
 
   if (signum_exp)
@@ -5934,6 +5968,7 @@ siginfo_make_value (struct gdbarch *gdba
       && gdbarch_get_siginfo_type_p (gdbarch))
     {
       struct type *type = gdbarch_get_siginfo_type (gdbarch);
+
       return allocate_computed_value (type, &siginfo_value_funcs, NULL);
     }
 
@@ -6330,6 +6365,7 @@ static void
 restore_inferior_ptid (void *arg)
 {
   ptid_t *saved_ptid_ptr = arg;
+
   inferior_ptid = *saved_ptid_ptr;
   xfree (arg);
 }
Index: inline-frame.c
===================================================================
RCS file: /cvs/src/src/gdb/inline-frame.c,v
retrieving revision 1.5
diff -u -p -r1.5 inline-frame.c
--- inline-frame.c	1 Jan 2010 07:31:36 -0000	1.5
+++ inline-frame.c	14 May 2010 21:24:49 -0000
@@ -75,6 +75,7 @@ find_inline_frame_state (ptid_t ptid)
 	{
 	  struct regcache *regcache = get_thread_regcache (ptid);
 	  CORE_ADDR current_pc = regcache_read_pc (regcache);
+
 	  if (current_pc != state->saved_pc)
 	    {
 	      /* PC has changed - this context is invalid.  Use the
@@ -124,6 +125,7 @@ clear_inline_frame_state (ptid_t ptid)
     {
       VEC (inline_state_s) *new_states = NULL;
       int pid = ptid_get_pid (ptid);
+
       for (ix = 0; VEC_iterate (inline_state_s, inline_states, ix, state); ix++)
 	if (pid != ptid_get_pid (state->ptid))
 	  VEC_safe_push (inline_state_s, new_states, state);
Index: interps.c
===================================================================
RCS file: /cvs/src/src/gdb/interps.c,v
retrieving revision 1.34
diff -u -p -r1.34 interps.c
--- interps.c	1 Jan 2010 07:31:36 -0000	1.34
+++ interps.c	14 May 2010 21:24:49 -0000
@@ -306,6 +306,7 @@ static int
 interp_set_quiet (struct interp *interp, int quiet)
 {
   int old_val = interp->quiet_p;
+
   interp->quiet_p = quiet;
   return old_val;
 }
@@ -400,6 +401,7 @@ interpreter_exec_cmd (char *args, int fr
   for (i = 1; i < nrules; i++)
     {
       struct gdb_exception e = interp_exec (interp_to_use, prules[i]);
+
       if (e.reason < 0)
 	{
 	  interp_set (old_interp, 0);