remove trailing whitespace + remove some useless comments

llvm-svn: 212411

1 files changed, 172 insertions, 174 deletions

diff --git a/lldb/source/Expression/ClangUserExpression.cpp b/lldb/source/Expression/ClangUserExpression.cpp
index 53b9ad3c3c6..8f580024821 100644
--- a/lldb/source/Expression/ClangUserExpression.cpp
+++ b/lldb/source/Expression/ClangUserExpression.cpp
@@ -7,13 +7,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-// C Includes
 #include <stdio.h>
 #if HAVE_SYS_TYPES_H
 #  include <sys/types.h>
 #endif
 
-// C++ Includes
 #include <cstdlib>
 #include <string>
 #include <map>
@@ -112,7 +110,7 @@ ClangUserExpression::ASTTransformer (clang::ASTConsumer *passthrough)
 {
     m_result_synthesizer.reset(new ASTResultSynthesizer(passthrough,
                                                         *m_target));
-    
+
     return m_result_synthesizer.get();
 }
 
@@ -123,16 +121,16 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
 
     if (log)
         log->Printf("ClangUserExpression::ScanContext()");
-    
+
     m_target = exe_ctx.GetTargetPtr();
-    
+
     if (!(m_allow_cxx || m_allow_objc))
     {
         if (log)
             log->Printf("  [CUE::SC] Settings inhibit C++ and Objective-C");
         return;
     }
-    
+
     StackFrame *frame = exe_ctx.GetFramePtr();
     if (frame == NULL)
     {
@@ -140,19 +138,19 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
             log->Printf("  [CUE::SC] Null stack frame");
         return;
     }
-    
+
     SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction | lldb::eSymbolContextBlock);
-    
+
     if (!sym_ctx.function)
     {
         if (log)
             log->Printf("  [CUE::SC] Null function");
         return;
     }
-    
+
     // Find the block that defines the function represented by "sym_ctx"
     Block *function_block = sym_ctx.GetFunctionBlock();
-    
+
     if (!function_block)
     {
         if (log)
@@ -168,7 +166,7 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
             log->Printf("  [CUE::SC] Null decl context");
         return;
     }
-    
+
     if (clang::CXXMethodDecl *method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl_context))
     {
         if (m_allow_cxx && method_decl->isInstance())
@@ -176,60 +174,60 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
             if (m_enforce_valid_object)
             {
                 lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true));
-                
+
                 const char *thisErrorString = "Stopped in a C++ method, but 'this' isn't available; pretending we are in a generic context";
-                
+
                 if (!variable_list_sp)
                 {
                     err.SetErrorString(thisErrorString);
                     return;
                 }
-                
+
                 lldb::VariableSP this_var_sp (variable_list_sp->FindVariable(ConstString("this")));
-                
+
                 if (!this_var_sp ||
-                    !this_var_sp->IsInScope(frame) || 
+                    !this_var_sp->IsInScope(frame) ||
                     !this_var_sp->LocationIsValidForFrame (frame))
                 {
                     err.SetErrorString(thisErrorString);
                     return;
                 }
             }
-            
+
             m_cplusplus = true;
             m_needs_object_ptr = true;
         }
     }
     else if (clang::ObjCMethodDecl *method_decl = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_context))
-    {        
+    {
         if (m_allow_objc)
         {
             if (m_enforce_valid_object)
             {
                 lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true));
-                
+
                 const char *selfErrorString = "Stopped in an Objective-C method, but 'self' isn't available; pretending we are in a generic context";
-                
+
                 if (!variable_list_sp)
                 {
                     err.SetErrorString(selfErrorString);
                     return;
                 }
-                
+
                 lldb::VariableSP self_variable_sp = variable_list_sp->FindVariable(ConstString("self"));
-                
-                if (!self_variable_sp || 
-                    !self_variable_sp->IsInScope(frame) || 
+
+                if (!self_variable_sp ||
+                    !self_variable_sp->IsInScope(frame) ||
                     !self_variable_sp->LocationIsValidForFrame (frame))
                 {
                     err.SetErrorString(selfErrorString);
                     return;
                 }
             }
-            
+
             m_objectivec = true;
             m_needs_object_ptr = true;
-            
+
             if (!method_decl->isInstanceMethod())
                 m_static_method = true;
         }
@@ -240,7 +238,7 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
         // object pointer.  The best way to deal with getting to the ivars at present it by pretending
         // that this is a method of a class in whatever runtime the debug info says the object pointer
         // belongs to.  Do that here.
-        
+
         ClangASTMetadata *metadata = ClangASTContext::GetMetadata (&decl_context->getParentASTContext(), function_decl);
         if (metadata && metadata->HasObjectPtr())
         {
@@ -250,17 +248,17 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
                 if (m_enforce_valid_object)
                 {
                     lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true));
-                    
+
                     const char *thisErrorString = "Stopped in a context claiming to capture a C++ object pointer, but 'this' isn't available; pretending we are in a generic context";
-                    
+
                     if (!variable_list_sp)
                     {
                         err.SetErrorString(thisErrorString);
                         return;
                     }
-                    
+
                     lldb::VariableSP this_var_sp (variable_list_sp->FindVariable(ConstString("this")));
-                    
+
                     if (!this_var_sp ||
                         !this_var_sp->IsInScope(frame) ||
                         !this_var_sp->LocationIsValidForFrame (frame))
@@ -269,7 +267,7 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
                         return;
                     }
                 }
-                
+
                 m_cplusplus = true;
                 m_needs_object_ptr = true;
             }
@@ -278,17 +276,17 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
                 if (m_enforce_valid_object)
                 {
                     lldb::VariableListSP variable_list_sp (function_block->GetBlockVariableList (true));
-                    
+
                     const char *selfErrorString = "Stopped in a context claiming to capture an Objective-C object pointer, but 'self' isn't available; pretending we are in a generic context";
-                    
+
                     if (!variable_list_sp)
                     {
                         err.SetErrorString(selfErrorString);
                         return;
                     }
-                    
+
                     lldb::VariableSP self_variable_sp = variable_list_sp->FindVariable(ConstString("self"));
-                    
+
                     if (!self_variable_sp ||
                         !self_variable_sp->IsInScope(frame) ||
                         !self_variable_sp->LocationIsValidForFrame (frame))
@@ -296,23 +294,23 @@ ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Error &err)
                         err.SetErrorString(selfErrorString);
                         return;
                     }
-                    
+
                     Type *self_type = self_variable_sp->GetType();
-                    
+
                     if (!self_type)
                     {
                         err.SetErrorString(selfErrorString);
                         return;
                     }
-                    
+
                     ClangASTType self_clang_type = self_type->GetClangForwardType();
-                    
+
                     if (!self_clang_type)
                     {
                         err.SetErrorString(selfErrorString);
                         return;
                     }
-                                        
+
                     if (self_clang_type.IsObjCClassType())
                     {
                         return;
@@ -342,9 +340,9 @@ void
 ClangUserExpression::InstallContext (ExecutionContext &exe_ctx)
 {
     m_process_wp = exe_ctx.GetProcessSP();
-    
+
     lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
-    
+
     if (frame_sp)
         m_address = frame_sp->GetFrameCodeAddress();
 }
@@ -360,11 +358,11 @@ ClangUserExpression::LockAndCheckContext (ExecutionContext &exe_ctx,
 
     if (process_sp != expected_process_sp)
         return false;
-    
+
     process_sp = exe_ctx.GetProcessSP();
     target_sp = exe_ctx.GetTargetSP();
     frame_sp = exe_ctx.GetFrameSP();
-    
+
     if (m_address.IsValid())
     {
         if (!frame_sp)
@@ -372,7 +370,7 @@ ClangUserExpression::LockAndCheckContext (ExecutionContext &exe_ctx,
         else
             return (0 == Address::CompareLoadAddress(m_address, frame_sp->GetFrameCodeAddress(), target_sp.get()));
     }
-    
+
     return true;
 }
 
@@ -382,7 +380,7 @@ ClangUserExpression::MatchesContext (ExecutionContext &exe_ctx)
     lldb::TargetSP target_sp;
     lldb::ProcessSP process_sp;
     lldb::StackFrameSP frame_sp;
-    
+
     return LockAndCheckContext(exe_ctx, target_sp, process_sp, frame_sp);
 }
 
@@ -397,7 +395,7 @@ ApplyObjcCastHack(std::string &expr)
 #define OBJC_CAST_HACK_TO   "(int)(long long)["
 
     size_t from_offset;
-    
+
     while ((from_offset = expr.find(OBJC_CAST_HACK_FROM)) != expr.npos)
         expr.replace(from_offset, sizeof(OBJC_CAST_HACK_FROM) - 1, OBJC_CAST_HACK_TO);
 
@@ -426,84 +424,84 @@ ApplyObjcCastHack(std::string &expr)
 //}
 
 bool
-ClangUserExpression::Parse (Stream &error_stream, 
+ClangUserExpression::Parse (Stream &error_stream,
                             ExecutionContext &exe_ctx,
                             lldb_private::ExecutionPolicy execution_policy,
                             bool keep_result_in_memory,
                             bool generate_debug_info)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-    
+
     Error err;
- 
+
     InstallContext(exe_ctx);
-    
+
     ScanContext(exe_ctx, err);
-    
+
     if (!err.Success())
     {
         error_stream.Printf("warning: %s\n", err.AsCString());
     }
-    
+
     StreamString m_transformed_stream;
-    
+
     ////////////////////////////////////
     // Generate the expression
     //
-    
+
     ApplyObjcCastHack(m_expr_text);
     //ApplyUnicharHack(m_expr_text);
 
     std::unique_ptr<ExpressionSourceCode> source_code (ExpressionSourceCode::CreateWrapped(m_expr_prefix.c_str(), m_expr_text.c_str()));
-    
+
     lldb::LanguageType lang_type;
-    
+
     if (m_cplusplus)
         lang_type = lldb::eLanguageTypeC_plus_plus;
     else if(m_objectivec)
         lang_type = lldb::eLanguageTypeObjC;
     else
         lang_type = lldb::eLanguageTypeC;
-    
+
     if (!source_code->GetText(m_transformed_text, lang_type, m_const_object, m_static_method, exe_ctx))
     {
         error_stream.PutCString ("error: couldn't construct expression body");
         return false;
     }
-    
+
     if (log)
         log->Printf("Parsing the following code:\n%s", m_transformed_text.c_str());
-    
+
     ////////////////////////////////////
     // Set up the target and compiler
     //
-    
+
     Target *target = exe_ctx.GetTargetPtr();
-    
+
     if (!target)
     {
         error_stream.PutCString ("error: invalid target\n");
         return false;
     }
-    
+
     //////////////////////////
     // Parse the expression
     //
-        
+
     m_materializer_ap.reset(new Materializer());
-        
+
     m_expr_decl_map.reset(new ClangExpressionDeclMap(keep_result_in_memory, exe_ctx));
-    
+
     class OnExit
     {
     public:
         typedef std::function <void (void)> Callback;
-        
+
         OnExit (Callback const &callback) :
             m_callback(callback)
         {
         }
-        
+
         ~OnExit ()
         {
             m_callback();
@@ -511,52 +509,52 @@ ClangUserExpression::Parse (Stream &error_stream,
     private:
         Callback m_callback;
     };
-    
+
     OnExit on_exit([this]() { m_expr_decl_map.reset(); });
-    
+
     if (!m_expr_decl_map->WillParse(exe_ctx, m_materializer_ap.get()))
     {
         error_stream.PutCString ("error: current process state is unsuitable for expression parsing\n");
-        
+
         m_expr_decl_map.reset(); // We are being careful here in the case of breakpoint conditions.
-        
+
         return false;
     }
-    
+
     Process *process = exe_ctx.GetProcessPtr();
     ExecutionContextScope *exe_scope = process;
-    
+
     if (!exe_scope)
         exe_scope = exe_ctx.GetTargetPtr();
-    
+
     ClangExpressionParser parser(exe_scope, *this, generate_debug_info);
-    
+
     unsigned num_errors = parser.Parse (error_stream);
-    
+
     if (num_errors)
     {
         error_stream.Printf ("error: %d errors parsing expression\n", num_errors);
-        
+
         m_expr_decl_map.reset(); // We are being careful here in the case of breakpoint conditions.
-        
+
         return false;
     }
-    
+
     //////////////////////////////////////////////////////////////////////////////////////////
     // Prepare the output of the parser for execution, evaluating it statically if possible
     //
-            
+
     Error jit_error = parser.PrepareForExecution (m_jit_start_addr,
                                                   m_jit_end_addr,
                                                   m_execution_unit_sp,
                                                   exe_ctx,
                                                   m_can_interpret,
                                                   execution_policy);
-    
+
     if (generate_debug_info)
     {
         lldb::ModuleSP jit_module_sp ( m_execution_unit_sp->GetJITModule());
-    
+
         if (jit_module_sp)
         {
             ConstString const_func_name(FunctionName());
@@ -583,9 +581,9 @@ ClangUserExpression::Parse (Stream &error_stream,
 //            jit_sym_vendor->Dump(&strm);
 //        }
     }
-    
+
     m_expr_decl_map.reset(); // Make this go away since we don't need any of its state after parsing.  This also gets rid of any ClangASTImporter::Minions.
-        
+
     if (jit_error.Success())
     {
         if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
@@ -609,16 +607,16 @@ GetObjectPointer (lldb::StackFrameSP frame_sp,
                   Error &err)
 {
     err.Clear();
-    
+
     if (!frame_sp)
     {
         err.SetErrorStringWithFormat("Couldn't load '%s' because the context is incomplete", object_name.AsCString());
         return LLDB_INVALID_ADDRESS;
     }
-    
+
     lldb::VariableSP var_sp;
     lldb::ValueObjectSP valobj_sp;
-    
+
     valobj_sp = frame_sp->GetValueForVariableExpressionPath(object_name.AsCString(),
                                                             lldb::eNoDynamicValues,
                                                             StackFrame::eExpressionPathOptionCheckPtrVsMember ||
@@ -628,18 +626,18 @@ GetObjectPointer (lldb::StackFrameSP frame_sp,
                                                             StackFrame::eExpressionPathOptionsNoSyntheticArrayRange,
                                                             var_sp,
                                                             err);
-    
+
     if (!err.Success())
         return LLDB_INVALID_ADDRESS;
-    
+
     lldb::addr_t ret = valobj_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
-    
+
     if (ret == LLDB_INVALID_ADDRESS)
     {
         err.SetErrorStringWithFormat("Couldn't load '%s' because its value couldn't be evaluated", object_name.AsCString());
         return LLDB_INVALID_ADDRESS;
     }
-    
+
     return ret;
 }
 
@@ -653,22 +651,22 @@ ClangUserExpression::PrepareToExecuteJITExpression (Stream &error_stream,
     lldb::TargetSP target;
     lldb::ProcessSP process;
     lldb::StackFrameSP frame;
-    
+
     if (!LockAndCheckContext(exe_ctx,
                              target,
-                             process, 
+                             process,
                              frame))
     {
         error_stream.Printf("The context has changed before we could JIT the expression!\n");
         return false;
     }
-    
+
     if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret)
-    {        
+    {
         if (m_needs_object_ptr)
         {
             ConstString object_name;
-            
+
             if (m_cplusplus)
             {
                 object_name.SetCString("this");
@@ -682,23 +680,23 @@ ClangUserExpression::PrepareToExecuteJITExpression (Stream &error_stream,
                 error_stream.Printf("Need object pointer but don't know the language\n");
                 return false;
             }
-            
+
             Error object_ptr_error;
-            
+
             object_ptr = GetObjectPointer(frame, object_name, object_ptr_error);
-            
+
             if (!object_ptr_error.Success())
             {
                 error_stream.Printf("warning: couldn't get required object pointer (substituting NULL): %s\n", object_ptr_error.AsCString());
                 object_ptr = 0;
             }
-            
+
             if (m_objectivec)
             {
                 ConstString cmd_name("_cmd");
-                
+
                 cmd_ptr = GetObjectPointer(frame, cmd_name, object_ptr_error);
-                
+
                 if (!object_ptr_error.Success())
                 {
                     error_stream.Printf("warning: couldn't get cmd pointer (substituting NULL): %s\n", object_ptr_error.AsCString());
@@ -706,53 +704,53 @@ ClangUserExpression::PrepareToExecuteJITExpression (Stream &error_stream,
                 }
             }
         }
-        
+
         if (m_materialized_address == LLDB_INVALID_ADDRESS)
         {
             Error alloc_error;
-            
+
             IRMemoryMap::AllocationPolicy policy = m_can_interpret ? IRMemoryMap::eAllocationPolicyHostOnly : IRMemoryMap::eAllocationPolicyMirror;
-            
+
             m_materialized_address = m_execution_unit_sp->Malloc(m_materializer_ap->GetStructByteSize(),
                                                                  m_materializer_ap->GetStructAlignment(),
                                                                  lldb::ePermissionsReadable | lldb::ePermissionsWritable,
                                                                  policy,
                                                                  alloc_error);
-            
+
             if (!alloc_error.Success())
             {
                 error_stream.Printf("Couldn't allocate space for materialized struct: %s\n", alloc_error.AsCString());
                 return false;
             }
         }
-        
+
         struct_address = m_materialized_address;
-        
+
         if (m_can_interpret && m_stack_frame_bottom == LLDB_INVALID_ADDRESS)
         {
             Error alloc_error;
 
             const size_t stack_frame_size = 512 * 1024;
-            
+
             m_stack_frame_bottom = m_execution_unit_sp->Malloc(stack_frame_size,
                                                                8,
                                                                lldb::ePermissionsReadable | lldb::ePermissionsWritable,
                                                                IRMemoryMap::eAllocationPolicyHostOnly,
                                                                alloc_error);
-            
+
             m_stack_frame_top = m_stack_frame_bottom + stack_frame_size;
-            
+
             if (!alloc_error.Success())
             {
                 error_stream.Printf("Couldn't allocate space for the stack frame: %s\n", alloc_error.AsCString());
                 return false;
             }
         }
-                
+
         Error materialize_error;
-        
+
         m_dematerializer_sp = m_materializer_ap->Materialize(frame, *m_execution_unit_sp, struct_address, materialize_error);
-        
+
         if (!materialize_error.Success())
         {
             error_stream.Printf("Couldn't materialize: %s\n", materialize_error.AsCString());
@@ -770,18 +768,18 @@ ClangUserExpression::FinalizeJITExecution (Stream &error_stream,
                                            lldb::addr_t function_stack_top)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
-    
+
     if (log)
         log->Printf("-- [ClangUserExpression::FinalizeJITExecution] Dematerializing after execution --");
-        
+
     if (!m_dematerializer_sp)
     {
         error_stream.Printf ("Couldn't apply expression side effects : no dematerializer is present");
         return false;
     }
-    
+
     Error dematerialize_error;
-    
+
     m_dematerializer_sp->Dematerialize(dematerialize_error, result, function_stack_bottom, function_stack_top);
 
     if (!dematerialize_error.Success())
@@ -789,14 +787,14 @@ ClangUserExpression::FinalizeJITExecution (Stream &error_stream,
         error_stream.Printf ("Couldn't apply expression side effects : %s\n", dematerialize_error.AsCString("unknown error"));
         return false;
     }
-        
+
     if (result)
         result->TransferAddress();
-    
+
     m_dematerializer_sp.reset();
-    
+
     return true;
-}        
+}
 
 lldb::ExpressionResults
 ClangUserExpression::Execute (Stream &error_stream,
@@ -812,24 +810,24 @@ ClangUserExpression::Execute (Stream &error_stream,
     if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret)
     {
         lldb::addr_t struct_address = LLDB_INVALID_ADDRESS;
-                
+
         lldb::addr_t object_ptr = 0;
         lldb::addr_t cmd_ptr = 0;
-        
+
         if (!PrepareToExecuteJITExpression (error_stream, exe_ctx, struct_address, object_ptr, cmd_ptr))
         {
             error_stream.Printf("Errored out in %s, couldn't PrepareToExecuteJITExpression", __FUNCTION__);
             return lldb::eExpressionSetupError;
         }
-        
+
         lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS;
         lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS;
-        
+
         if (m_can_interpret)
-        {            
+        {
             llvm::Module *module = m_execution_unit_sp->GetModule();
             llvm::Function *function = m_execution_unit_sp->GetFunction();
-            
+
             if (!module || !function)
             {
                 error_stream.Printf("Supposed to interpret, but nothing is there");
@@ -837,22 +835,22 @@ ClangUserExpression::Execute (Stream &error_stream,
             }
 
             Error interpreter_error;
-            
+
             llvm::SmallVector <lldb::addr_t, 3> args;
-            
+
             if (m_needs_object_ptr)
             {
                 args.push_back(object_ptr);
-                
+
                 if (m_objectivec)
                     args.push_back(cmd_ptr);
             }
-            
+
             args.push_back(struct_address);
-            
+
             function_stack_bottom = m_stack_frame_bottom;
             function_stack_top = m_stack_frame_top;
-            
+
             IRInterpreter::Interpret (*module,
                                       *function,
                                       args,
@@ -860,7 +858,7 @@ ClangUserExpression::Execute (Stream &error_stream,
                                       interpreter_error,
                                       function_stack_bottom,
                                       function_stack_top);
-            
+
             if (!interpreter_error.Success())
             {
                 error_stream.Printf("Supposed to interpret, but failed: %s", interpreter_error.AsCString());
@@ -874,54 +872,54 @@ ClangUserExpression::Execute (Stream &error_stream,
                 error_stream.Printf("ClangUserExpression::Execute called with no thread selected.");
                 return lldb::eExpressionSetupError;
             }
-                
+
             Address wrapper_address (m_jit_start_addr);
-            
+
             llvm::SmallVector <lldb::addr_t, 3> args;
-            
+
             if (m_needs_object_ptr) {
                 args.push_back(object_ptr);
                 if (m_objectivec)
                     args.push_back(cmd_ptr);
             }
-            
+
             args.push_back(struct_address);
-            
-            lldb::ThreadPlanSP call_plan_sp(new ThreadPlanCallUserExpression (exe_ctx.GetThreadRef(), 
-                                                                              wrapper_address, 
+
+            lldb::ThreadPlanSP call_plan_sp(new ThreadPlanCallUserExpression (exe_ctx.GetThreadRef(),
+                                                                              wrapper_address,
                                                                               args,
                                                                               options,
                                                                               shared_ptr_to_me));
-            
+
             if (!call_plan_sp || !call_plan_sp->ValidatePlan (&error_stream))
                 return lldb::eExpressionSetupError;
-            
+
             lldb::addr_t function_stack_pointer = static_cast<ThreadPlanCallFunction *>(call_plan_sp.get())->GetFunctionStackPointer();
 
             function_stack_bottom = function_stack_pointer - Host::GetPageSize();
             function_stack_top = function_stack_pointer;
-            
+
             if (log)
                 log->Printf("-- [ClangUserExpression::Execute] Execution of expression begins --");
-            
+
             if (exe_ctx.GetProcessPtr())
                 exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
-                
+
             lldb::ExpressionResults execution_result = exe_ctx.GetProcessRef().RunThreadPlan (exe_ctx,
                                                                                        call_plan_sp,
                                                                                        options,
                                                                                        error_stream);
-            
+
             if (exe_ctx.GetProcessPtr())
                 exe_ctx.GetProcessPtr()->SetRunningUserExpression(false);
-                
+
             if (log)
                 log->Printf("-- [ClangUserExpression::Execute] Execution of expression completed --");
 
             if (execution_result == lldb::eExpressionInterrupted || execution_result == lldb::eExpressionHitBreakpoint)
             {
                 const char *error_desc = NULL;
-                
+
                 if (call_plan_sp)
                 {
                     lldb::StopInfoSP real_stop_info_sp = call_plan_sp->GetRealStopInfo();
@@ -932,7 +930,7 @@ ClangUserExpression::Execute (Stream &error_stream,
                     error_stream.Printf ("Execution was interrupted, reason: %s.", error_desc);
                 else
                     error_stream.PutCString ("Execution was interrupted.");
-                    
+
                 if ((execution_result == lldb::eExpressionInterrupted && options.DoesUnwindOnError())
                     || (execution_result == lldb::eExpressionHitBreakpoint && options.DoesIgnoreBreakpoints()))
                     error_stream.PutCString ("\nThe process has been returned to the state before expression evaluation.");
@@ -955,7 +953,7 @@ ClangUserExpression::Execute (Stream &error_stream,
                 return execution_result;
             }
         }
-        
+
         if  (FinalizeJITExecution (error_stream, exe_ctx, result, function_stack_bottom, function_stack_top))
         {
             return lldb::eExpressionCompleted;
@@ -986,7 +984,7 @@ ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
     const lldb::LanguageType language = options.GetLanguage();
     const ResultType desired_type = options.DoesCoerceToId() ? ClangUserExpression::eResultTypeId : ClangUserExpression::eResultTypeAny;
     lldb::ExpressionResults execution_results = lldb::eExpressionSetupError;
-    
+
     Process *process = exe_ctx.GetProcessPtr();
 
     if (process == NULL || process->GetState() != lldb::eStateStopped)
@@ -995,33 +993,33 @@ ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
         {
             if (log)
                 log->Printf("== [ClangUserExpression::Evaluate] Expression may not run, but is not constant ==");
-            
+
             error.SetErrorString ("expression needed to run but couldn't");
-            
+
             return execution_results;
         }
     }
-    
+
     if (process == NULL || !process->CanJIT())
         execution_policy = eExecutionPolicyNever;
-    
+
     ClangUserExpressionSP user_expression_sp (new ClangUserExpression (expr_cstr, expr_prefix, language, desired_type));
 
     StreamString error_stream;
-        
+
     if (log)
         log->Printf("== [ClangUserExpression::Evaluate] Parsing expression %s ==", expr_cstr);
-    
+
     const bool keep_expression_in_memory = true;
     const bool generate_debug_info = options.GetGenerateDebugInfo();
-    
+
     if (options.InvokeCancelCallback (lldb::eExpressionEvaluationParse))
     {
         error.SetErrorString ("expression interrupted by callback before parse");
         result_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), error);
         return lldb::eExpressionInterrupted;
     }
-    
+
     if (!user_expression_sp->Parse (error_stream,
                                     exe_ctx,
                                     execution_policy,
@@ -1042,7 +1040,7 @@ ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
         {
             if (log)
                 log->Printf("== [ClangUserExpression::Evaluate] Expression may not run, but is not constant ==");
-            
+
             if (error_stream.GetString().empty())
                 error.SetExpressionError (lldb::eExpressionSetupError, "expression needed to run but couldn't");
         }
@@ -1054,34 +1052,34 @@ ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
                 result_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), error);
                 return lldb::eExpressionInterrupted;
             }
-            
+
             error_stream.GetString().clear();
-            
+
             if (log)
                 log->Printf("== [ClangUserExpression::Evaluate] Executing expression ==");
 
-            execution_results = user_expression_sp->Execute (error_stream, 
+            execution_results = user_expression_sp->Execute (error_stream,
                                                              exe_ctx,
                                                              options,
                                                              user_expression_sp,
                                                              expr_result);
-            
+
             if (execution_results != lldb::eExpressionCompleted)
             {
                 if (log)
                     log->Printf("== [ClangUserExpression::Evaluate] Execution completed abnormally ==");
-                
+
                 if (error_stream.GetString().empty())
                     error.SetExpressionError (execution_results, "expression failed to execute, unknown error");
                 else
                     error.SetExpressionError (execution_results, error_stream.GetString().c_str());
             }
-            else 
+            else
             {
                 if (expr_result)
                 {
                     result_valobj_sp = expr_result->GetValueObject();
-                    
+
                     if (log)
                         log->Printf("== [ClangUserExpression::Evaluate] Execution completed normally with result %s ==",
                                     result_valobj_sp->GetValueAsCString());
@@ -1090,19 +1088,19 @@ ClangUserExpression::Evaluate (ExecutionContext &exe_ctx,
                 {
                     if (log)
                         log->Printf("== [ClangUserExpression::Evaluate] Execution completed normally with no result ==");
-                    
+
                     error.SetError(ClangUserExpression::kNoResult, lldb::eErrorTypeGeneric);
                 }
             }
         }
     }
-    
+
     if (options.InvokeCancelCallback(lldb::eExpressionEvaluationComplete))
     {
         error.SetExpressionError (lldb::eExpressionInterrupted, "expression interrupted by callback after complete");
         return lldb::eExpressionInterrupted;
     }
-    
+
     if (result_valobj_sp.get() == NULL)
     {
         result_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), error);