Fix a some silly warnings

[artagnon]

Er, silly mistake (build failure)

lldb/trunk/tools/debugserver/source/debugserver.cpp

while (pid != INVALID_NUB_PROCESS)
         {
             if (set_events & (eEventProcessRunningStateChanged | eEventProcessStoppedStateChanged))
             {
                 nub_state_t pid_state = DNBProcessGetState (pid);
                 DNBLogThreadedIf (LOG_RNB_EVENTS, "%s process %4.4x state changed (eEventProcessStateChanged): %s", __FUNCTION__, pid, DNBStateAsString(pid_state));
 
                 switch (pid_state)
                 {
-                    default:
                     case eStateInvalid:
                     case eStateUnloaded:
                     case eStateAttaching:
                     case eStateLaunching:
                     case eStateSuspended:
                         break;  // Ignore
 
                     case eStateRunning:

 RNBRunLoopPlatform (RNBRemote *remote)
 {
     RNBRunLoopMode mode = eRNBRunLoopModePlatformMode;
     RNBContext& ctx = remote->Context();
 
     while (mode == eRNBRunLoopModePlatformMode)
     {
         std::string set_events_str;
-        const uint32_t event_mask = RNBContext::event_read_packet_available | 
+        const uint32_t event_mask = RNBContext::event_read_packet_available |
                                     RNBContext::event_read_thread_exiting;
-                
         DNBLogThreadedIf (LOG_RNB_EVENTS, "%s ctx.Events().WaitForSetEvents(0x%08x) ...",__FUNCTION__, event_mask);
         nub_event_t set_events = ctx.Events().WaitForSetEvents(event_mask);
         DNBLogThreadedIf (LOG_RNB_EVENTS, "%s ctx.Events().WaitForSetEvents(0x%08x) => 0x%08x (%s)",__FUNCTION__, event_mask, set_events, ctx.EventsAsString(set_events, set_events_str));
-        
         if (set_events)
         {
             if (set_events & RNBContext::event_read_packet_available)
             {
                 if (remote->HandleReceivedPacket() == rnb_not_connected)
                     mode = eRNBRunLoopModeExit;
             }
-            
             if (set_events & RNBContext::event_read_thread_exiting)
             {
                 mode = eRNBRunLoopModeExit;
             }
             ctx.Events().ResetEvents(set_events);
         }
-    }    
+    }
     return eRNBRunLoopModeExit;
 }
 
 //----------------------------------------------------------------------
 // Convenience function to set up the remote listening port
 // Returns 1 for success 0 for failure.
 //----------------------------------------------------------------------
 
 static void
 PortWasBoundCallbackUnixSocket (const void *baton, in_port_t port)
 {
     //::printf ("PortWasBoundCallbackUnixSocket (baton = %p, port = %u)\n", baton, port);
-    
     const char *unix_socket_name = (const char *)baton;
-    
     if (unix_socket_name && unix_socket_name[0])
     {
         // We were given a unix socket name to use to communicate the port
         // that we ended up binding to back to our parent process
         struct sockaddr_un saddr_un;
         int s = ::socket (AF_UNIX, SOCK_STREAM, 0);
         if (s < 0)
         {
             perror("error: socket (AF_UNIX, SOCK_STREAM, 0)");
             exit(1);
         }
-        
         saddr_un.sun_family = AF_UNIX;
         ::strncpy(saddr_un.sun_path, unix_socket_name, sizeof(saddr_un.sun_path) - 1);
         saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
         saddr_un.sun_len = SUN_LEN (&saddr_un);
-        
         if (::connect (s, (struct sockaddr *)&saddr_un, static_cast<socklen_t>(SUN_LEN (&saddr_un))) < 0)
         {
             perror("error: connect (socket, &saddr_un, saddr_un_len)");
             exit(1);
         }
-        
         //::printf ("connect () sucess!!\n");
-        
-        
         // We were able to connect to the socket, now write our PID so whomever
         // launched us will know this process's ID
         RNBLogSTDOUT ("Listening to port %i...\n", port);
-        
         char pid_str[64];
         const int pid_str_len = ::snprintf (pid_str, sizeof(pid_str), "%u", port);
         const ssize_t bytes_sent = ::send (s, pid_str, pid_str_len, 0);
-        
         if (pid_str_len != bytes_sent)
         {
             perror("error: send (s, pid_str, pid_str_len, 0)");
             exit (1);
         }
-        
         //::printf ("send () sucess!!\n");
-        
         // We are done with the socket
         close (s);
     }
 }
 
 static void
 PortWasBoundCallbackNamedPipe (const void *baton, uint16_t port)
 {

 {
     const char *argv_sub_zero = argv[0]; // save a copy of argv[0] for error reporting post-launch
 
 #if defined (__APPLE__)
     pthread_setname_np ("main thread");
 #if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
     struct sched_param thread_param;
     int thread_sched_policy;
-    if (pthread_getschedparam(pthread_self(), &thread_sched_policy, &thread_param) == 0) 
+    if (pthread_getschedparam(pthread_self(), &thread_sched_policy, &thread_param) == 0)
     {
         thread_param.sched_priority = 47;
         pthread_setschedparam(pthread_self(), thread_sched_policy, &thread_param);
     }
 
     ::proc_set_wakemon_params (getpid(), 500, 0); // Allow up to 500 wakeups/sec to avoid EXC_RESOURCE for normal use.
 #endif
 #endif
 
     g_isatty = ::isatty (STDIN_FILENO);
 
     //  ::printf ("uid=%u euid=%u gid=%u egid=%u\n",
     //            getuid(),
     //            geteuid(),
     //            getgid(),
     //            getegid());
 
 
     //    signal (SIGINT, signal_handler);
     signal (SIGPIPE, signal_handler);
     signal (SIGHUP, signal_handler);
-    
     // We're always sitting in waitpid or kevent waiting on our target process' death,
     // we don't need no stinking SIGCHLD's...
-    
     sigset_t sigset;
     sigemptyset(&sigset);
     sigaddset(&sigset, SIGCHLD);
     sigprocmask(SIG_BLOCK, &sigset, NULL);
 
     g_remoteSP.reset (new RNBRemote ());
-    
-    
     RNBRemote *remote = g_remoteSP.get();
     if (remote == NULL)
     {
         RNBLogSTDERR ("error: failed to create a remote connection class\n");
         return -1;
     }
-    
     RNBContext& ctx = remote->Context();
 
     int i;
     int attach_pid = INVALID_NUB_PROCESS;
 
     FILE* log_file = NULL;
     uint32_t log_flags = 0;
     // Parse our options

 #if !defined (DNBLOG_ENABLED)
     compile_options += "(no-logging) ";
 #endif
 
     RNBRunLoopMode start_mode = eRNBRunLoopModeExit;
 
     char short_options[512];
     uint32_t short_options_idx = 0;
-    
      // Handle the two case that don't have short options in g_long_options
     short_options[short_options_idx++] = 'k';
     short_options[short_options_idx++] = 't';
-    
     for (i=0; g_long_options[i].name != NULL; ++i)
     {
         if (isalpha(g_long_options[i].val))
         {
             short_options[short_options_idx++] = g_long_options[i].val;
             switch (g_long_options[i].has_arg)
             {
                 default:
-                case no_argument: 
+                case no_argument:
                     break;
 
                 case optional_argument:
                     short_options[short_options_idx++] = ':';
                     // Fall through to required_argument case below...
                 case required_argument:
                     short_options[short_options_idx++] = ':';
                     break;
             }
         }
     }
     // NULL terminate the short option string.
     short_options[short_options_idx++] = '\0';
-    
 #if __GLIBC__
     optind = 0;
 #else
     optreset = 1;
     optind = 1;
 #endif
 
     while ((ch = getopt_long_only(argc, argv, short_options, g_long_options, &long_option_index)) != -1)
while ((ch = getopt_long_only(argc, argv, short_options, g_long_options, &long_option_index)) != -1)
                     waitfor_duration = static_cast<useconds_t>(strtoul(optarg, &end, 0));
                     if (end == NULL || *end != '\0')
                     {
                         RNBLogSTDERR ("error: invalid waitfor-duration option value '%s'.\n", optarg);
                         exit (7);
                     }
                 }
                 break;
-                
             case 'K':
                 g_detach_on_error = false;
 
             case 'W':
                 if (optarg && optarg[0])
                     working_dir.assign(optarg);
                 break;
 
#endif
                     else if (strcasecmp(optarg, "stderr") == 0)
                         log_file = stderr;
                     else
                     {
                         log_file = fopen(optarg, "w");
                         if (log_file != NULL)
                             setlinebuf(log_file);
                     }
-                    
                     if (log_file == NULL)
                     {
                         const char *errno_str = strerror(errno);
                         RNBLogSTDERR ("Failed to open log file '%s' for writing: errno = %i (%s)", optarg, errno, errno_str ? errno_str : "unknown error");
                     }
                 }
                 break;
 
#endif
 
             case 'I':
                 ctx.GetSTDIN().assign(optarg);
                 break;
 
             case 'O':
                 ctx.GetSTDOUT().assign(optarg);
                 break;
-            
             case 'E':
                 ctx.GetSTDERR().assign(optarg);
                 break;
 
             case 'n':
                 no_stdio = true;
                 break;
-                
             case 'S':
                 // Put debugserver into a new session. Terminals group processes
                 // into sessions and when a special terminal key sequences
                 // (like control+c) are typed they can cause signals to go out to
                 // all processes in a session. Using this --setsid (-S) option
                 // will cause debugserver to run in its own sessions and be free
                 // from such issues.
                 //
                 // This is useful when debugserver is spawned from a command
                 // line application that uses debugserver to do the debugging,
                 // yet that application doesn't want debugserver receiving the
                 // signals sent to the session (i.e. dying when anyone hits ^C).
                 setsid();
                 break;
             case 'D':
                 g_disable_aslr = 1;
                 break;
-            
             case 'p':
                 start_mode = eRNBRunLoopModePlatformMode;
                 break;
 
             case 'u':
                 unix_socket_name.assign (optarg);
                 break;
 
             case 'P':
                 named_pipe_path.assign (optarg);
                 break;
-                
             case 'e':
                 // Pass a single specified environment variable down to the process that gets launched
                 remote->Context().PushEnvironment(optarg);
                 break;
-            
             case 'F':
                 // Pass the current environment down to the process that gets launched
                 {
                     char **host_env = *_NSGetEnviron();
                     char *env_entry;
                     size_t i;
                     for (i=0; (env_entry = host_env[i]) != NULL; ++i)
                         remote->Context().PushEnvironment(env_entry);
                 }
                 break;
         }
     }
-    
     if (arch_name.empty())
     {
-#if defined (__arm__) 
+#if defined (__arm__)
         arch_name.assign ("arm");
 #endif
     }
     else
     {
         DNBSetArchitecture (arch_name.c_str());
     }
 
if (!working_dir.empty())
         if (remote->Context().SetWorkingDirectory (working_dir.c_str()) == false)
         {
             RNBLogSTDERR ("error: working directory doesn't exist '%s'.\n", working_dir.c_str());
             exit (8);
         }
     }
 
     remote->Context().SetDetachOnError(g_detach_on_error);
-    
     remote->Initialize();
 
     // It is ok for us to set NULL as the logfile (this will disable any logging)
 
     if (log_file != NULL)
     {
         DNBLogSetLogCallback(FileLogCallback, log_file);
         // If our log file was set, yet we have no log flags, log everything!
#endif
                     }
                     if (mode != eRNBRunLoopModeExit)
                         RNBLogSTDOUT ("Waiting for debugger instructions for process %d.\n", attach_pid);
                 }
                 break;
 
             case eRNBRunLoopModeInferiorLaunching:
                 {
-                    mode = RNBRunLoopLaunchInferior (remote, 
+                    mode = RNBRunLoopLaunchInferior (remote,
                                                      ctx.GetSTDINPath(),
                                                      ctx.GetSTDOUTPath(),
                                                      ctx.GetSTDERRPath(),
                                                      no_stdio);
 
                     if (mode == eRNBRunLoopModeInferiorExecuting)
                     {
                         if (port != INT32_MAX)
#endif
                     if (!ConnectRemote (remote, host.c_str(), port, reverse_connect, named_pipe_path.c_str(), unix_socket_name.c_str()))
                         mode = eRNBRunLoopModeExit;
                 }
                 else if (str[0] == '/')
                 {
                     if (remote->Comm().OpenFile (str))
                         mode = eRNBRunLoopModeExit;
                 }
-                
                 if (mode != eRNBRunLoopModeExit)
                     mode = RNBRunLoopPlatform (remote);
                 break;
 
             default:
                 mode = eRNBRunLoopModeExit;
             case eRNBRunLoopModeExit:
                 break;