Mercurial > hg > octave-lyh
changeset 13380:6fd5e06285da
Renamed methods, added comments and TODOs.
author | Jacob Dawid <jacob.dawid@googlemail.com> |
---|---|
date | Fri, 08 Apr 2011 15:23:21 +0200 |
parents | 6b3780a781d5 |
children | 7519e2efaf31 |
files | gui//src/OctaveLink.cpp gui//src/OctaveLink.h |
diffstat | 2 files changed, 209 insertions(+), 204 deletions(-) [+] |
line wrap: on
line diff
--- a/gui//src/OctaveLink.cpp +++ b/gui//src/OctaveLink.cpp @@ -117,7 +117,7 @@ // TODO: No need to run too quickly. The documentation says it will run // at most 10 times per second. This may be too fast and we will need to // artificially slow it down somehow. Not sure at this time how. - oct_octave_server.process_octave_server_data(); + oct_octave_server.processOctaveServerData(); return 0; } @@ -131,12 +131,12 @@ OctaveLink::OctaveLink() { // Create the mutexes - pthread_mutex_init(&server_mutex,NULL); - pthread_mutex_init(&octave_lock_mutex,NULL); + pthread_mutex_init(&m_serverMutex,NULL); + pthread_mutex_init(&m_octaveLockMutex,NULL); - prevHistLen = 0; + m_previousHistoryLength = 0; - is_processing_server_data = false; + m_isProcessingServerData = false; } @@ -153,166 +153,166 @@ *******************************************************************************/ //************************************************************************* -std::vector<OctaveLink::VariableMetaData> OctaveLink::get_variable_info_list(void) +std::vector<OctaveLink::VariableMetaData> OctaveLink::variableInfoList(void) { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) return std::vector<VariableMetaData>(); // Copy the list of variable information - std::vector<VariableMetaData> retval( variable_symtab_list.size() ); - std::copy( variable_symtab_list.begin(), variable_symtab_list.end(), retval.begin() ); - variable_symtab_list = std::vector<VariableMetaData>(); + std::vector<VariableMetaData> retval( m_variableSymbolTableList.size() ); + std::copy( m_variableSymbolTableList.begin(), m_variableSymbolTableList.end(), retval.begin() ); + m_variableSymbolTableList = std::vector<VariableMetaData>(); // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); return retval; } //************************************************************************* -std::vector<OctaveLink::RequestedVariable> OctaveLink::get_requested_variables(void) +std::vector<OctaveLink::RequestedVariable> OctaveLink::requestedVariables(void) { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) return std::vector<RequestedVariable>(); // Copy the list of requested variables - std::vector<RequestedVariable> retval( requested_variables.size() ); - std::copy( requested_variables.begin(), requested_variables.end(), retval.begin() ); - requested_variables = std::vector<RequestedVariable>(); + std::vector<RequestedVariable> retval( m_requestedVariables.size() ); + std::copy( m_requestedVariables.begin(), m_requestedVariables.end(), retval.begin() ); + m_requestedVariables = std::vector<RequestedVariable>(); // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); return retval; } //************************************************************************* -int OctaveLink::set_requested_variables_names( std::vector<std::string> variables_names ) +int OctaveLink::setRequestedVariableNames( std::vector<std::string> variables_names ) { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) return -1; // Set the list of requested variables - variables_request_list = std::vector<std::string>( variables_names.size() ); - std::copy( variables_names.begin(), variables_names.end(), variables_request_list.begin() ); + m_variablesRequestList = std::vector<std::string>( variables_names.size() ); + std::copy( variables_names.begin(), variables_names.end(), m_variablesRequestList.begin() ); // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); return 0; } //************************************************************************* -string_vector OctaveLink::get_history_list(void) +string_vector OctaveLink::getHistoryList(void) { // Acquire mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) return string_vector(); // Copy the list of command history items - string_vector retval( history_list ); - history_list = string_vector(); + string_vector retval( m_historyList ); + m_historyList = string_vector(); // Release mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); return retval; } -std::vector<OctaveLink::BreakPoint> OctaveLink::get_breakpoint_list(int& status) +std::vector<OctaveLink::BreakPoint> OctaveLink::breakPointList(int& status) { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) { status = -1; return std::vector<BreakPoint>(); } // Copy the list of variable information - std::vector<BreakPoint> retval (current_breakpoints.size()); - std::copy( current_breakpoints.begin(), current_breakpoints.end(), retval.begin() ); + std::vector<BreakPoint> retval (m_currentBreakpoints.size()); + std::copy( m_currentBreakpoints.begin(), m_currentBreakpoints.end(), retval.begin() ); // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); status = 0; return retval; } -bool OctaveLink::is_breakpoint_reached (int& status) +bool OctaveLink::isBreakpointReached (int& status) { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) { status = -1; return false; } // Copy the list of variable information - bool retval = (breakpoint_reached.size()>0); + bool retval = (m_reachedBreakpoints.size()>0); //if (retval) // octave_stdout << "Breakpoint reached" << std::endl; // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); status = 0; return retval; } -std::vector<OctaveLink::BreakPoint> OctaveLink::get_breakpoint_reached() +std::vector<OctaveLink::BreakPoint> OctaveLink::reachedBreakpoint() { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) return std::vector<BreakPoint>(); // Copy the list of variable information - std::vector<BreakPoint> retval (breakpoint_reached.size()); - std::copy (breakpoint_reached.begin(), breakpoint_reached.end(), retval.begin() ); + std::vector<BreakPoint> retval (m_reachedBreakpoints.size()); + std::copy (m_reachedBreakpoints.begin(), m_reachedBreakpoints.end(), retval.begin() ); //if (breakpoint_reached.size()>0) // octave_stdout << "Breakpoint reached" << std::endl; // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); return retval; } -int OctaveLink::add_breakpoint( BreakPoint bp_info ) +int OctaveLink::addBreakpoint( BreakPoint bp_info ) { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) return -1; // Copy the list of variable information - added_breakpoints.push_back (bp_info); + m_addedBreakpoints.push_back (bp_info); // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); return 0; } -int OctaveLink::remove_breakpoint( BreakPoint bp_info ) +int OctaveLink::removeBreakpoint( BreakPoint bp_info ) { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) return -1; // Copy the list of variable information - removed_breakpoints.push_back (bp_info); + m_removedBreakpoints.push_back (bp_info); // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); return 0; } @@ -321,16 +321,16 @@ status_t modify_breakpoint( bp_info_t old_bp_info, bp_info_t new_bp_info ); */ -int OctaveLink::set_breakpoint_action (BreakPointAction action) +int OctaveLink::setBreakpointAction (BreakPointAction action) { // Acquire the mutex - if( pthread_mutex_trylock( &server_mutex ) != 0 ) + if( pthread_mutex_trylock( &m_serverMutex ) != 0 ) return -1; - bp_action = action; + m_breakPointAction = action; // Release the mutex - pthread_mutex_unlock( &server_mutex ); + pthread_mutex_unlock( &m_serverMutex ); return 0; } @@ -343,7 +343,7 @@ *******************************************************************************/ //************************************************************************* -int OctaveLink::process_octave_server_data(void) +int OctaveLink::processOctaveServerData(void) { struct timeval start, stop; #ifndef __WIN32__ @@ -351,23 +351,23 @@ #endif // Acquire mutex - if( pthread_mutex_lock( &server_mutex ) != 0 ) + if( pthread_mutex_lock( &m_serverMutex ) != 0 ) { octave_stdout << "Error acquiring the octave_server data lock mutex" << std::endl; return -1; } - is_processing_server_data = true; + m_isProcessingServerData = true; process_breakpoint_action(); - process_breakpoint_add_remove_modify(); - process_requested_variables(); - set_variable_info_list(); - set_history_list(); - set_breakpoint_list(); + processBreakpointAndRemoveModify(); + processRequestedVariables(); + setVariableInfoList(); + setHistoryList(); + setBreakPointList(); // Release mutex - pthread_mutex_unlock( &server_mutex ); - is_processing_server_data = false; + pthread_mutex_unlock( &m_serverMutex ); + m_isProcessingServerData = false; #ifndef __WIN32__ gettimeofday(&stop, NULL); @@ -381,7 +381,7 @@ //************************************************************************* -int OctaveLink::set_variable_info_list( void ) +int OctaveLink::setVariableInfoList( void ) { static std::vector<VariableMetaData> lastVars; std::vector<VariableMetaData> currVars; @@ -398,11 +398,11 @@ dim_vector dims = varval.dims (); VariableMetaData tempVar; - tempVar.variable_name = it->name(); - tempVar.size.push_back( varval.rows() ); - tempVar.size.push_back( varval.columns() ); - tempVar.byte_size = varval.byte_size(); - tempVar.type_name = varval.type_name(); + tempVar.variableName = it->name(); + tempVar.dimensionalSize.push_back( varval.rows() ); + tempVar.dimensionalSize.push_back( varval.columns() ); + tempVar.byteSize = varval.byte_size(); + tempVar.typeName = varval.type_name(); currVars.push_back(tempVar); } @@ -412,9 +412,9 @@ lastVars = currVars; // Copy currVars into octave_server::variable_symtab_list - variable_symtab_list = std::vector<VariableMetaData>( currVars.size() ); + m_variableSymbolTableList = std::vector<VariableMetaData>( currVars.size() ); - std::copy( currVars.begin(), currVars.end(), variable_symtab_list.begin() ); + std::copy( currVars.begin(), currVars.end(), m_variableSymbolTableList.begin() ); } @@ -423,7 +423,7 @@ //************************************************************************* -int OctaveLink::process_requested_variables( void ) +int OctaveLink::processRequestedVariables( void ) { /* @@ -482,26 +482,26 @@ //************************************************************************* -int OctaveLink::set_history_list( void ) +int OctaveLink::setHistoryList( void ) { // Build up the current list int currentLen = command_history::length(); - if ( currentLen != prevHistLen ) + if ( currentLen != m_previousHistoryLength ) { - for( int i = prevHistLen ; i < currentLen ; i++ ) - history_list.append( command_history::get_entry(i) ); - prevHistLen = currentLen; + for( int i = m_previousHistoryLength ; i < currentLen ; i++ ) + m_historyList.append( command_history::get_entry(i) ); + m_previousHistoryLength = currentLen; } return 0; } //************************************************************************* -int OctaveLink::set_breakpoint_list( void ) +int OctaveLink::setBreakPointList( void ) { // Set the list of breakpoints - current_breakpoints = std::vector<BreakPoint>(); + m_currentBreakpoints = std::vector<BreakPoint>(); octave_value_list zz; @@ -514,15 +514,15 @@ { BreakPoint tmp; - tmp.filename = it->first; - tmp.line_number = m[j]; + tmp.fileName = it->first; + tmp.lineNumber = m[j]; - current_breakpoints.push_back (tmp); + m_currentBreakpoints.push_back (tmp); } } // If in debug mode, set the location of the break - breakpoint_reached = std::vector<BreakPoint>(); + m_reachedBreakpoints = std::vector<BreakPoint>(); octave_user_code *dbg_fcn = get_user_code (); @@ -560,12 +560,12 @@ { funcName = shortName.substr (0,dot); } - tmp.filename = funcName; - tmp.line_number = l; + tmp.fileName = funcName; + tmp.lineNumber = l; // octave_stdout << "BP reached at " << tmp.filename << ":" << tmp.line_number << std::endl; - breakpoint_reached.push_back (tmp); + m_reachedBreakpoints.push_back (tmp); } else octave_stdout << " <unknown line>" << std::endl; @@ -582,7 +582,7 @@ if (Vdebugging) { - if (bp_action==StepInto) + if (m_breakPointAction==StepInto) { Vdebugging = false; tree_evaluator::dbstep_flag = -1; @@ -592,7 +592,7 @@ rl_done = 1; rl_forced_update_display (); } - else if (bp_action==StepOver) + else if (m_breakPointAction==StepOver) { Vdebugging = false; tree_evaluator::dbstep_flag = 1; @@ -602,7 +602,7 @@ rl_done = 1; rl_forced_update_display (); } - else if (bp_action==StepOut) + else if (m_breakPointAction==StepOut) { Vdebugging = false; tree_evaluator::dbstep_flag = -2; @@ -614,7 +614,7 @@ } - else if (bp_action==Continue) + else if (m_breakPointAction==Continue) { Vdebugging = false; tree_evaluator::dbstep_flag = 0; @@ -624,7 +624,7 @@ rl_done = 1; rl_forced_update_display (); } - else if (bp_action==Break) + else if (m_breakPointAction==Break) { tree_evaluator::dbstep_flag = 0; octave_throw_interrupt_exception (); @@ -634,37 +634,37 @@ rl_done = 1; rl_forced_update_display (); } - bp_action = None; + m_breakPointAction = None; } return 0; } //************************************************************************* -int OctaveLink::process_breakpoint_add_remove_modify(void) +int OctaveLink::processBreakpointAndRemoveModify(void) { //octave_stdout << "Processing breakpoints changes" << std::endl; // Process added breakpoints - for (int i = 0 ; i < added_breakpoints.size() ; i++) + for (int i = 0 ; i < m_addedBreakpoints.size() ; i++) { - std::string funcName = added_breakpoints[i].filename; + std::string funcName = m_addedBreakpoints[i].fileName; bp_table::intmap lines; - lines[0] = added_breakpoints[i].line_number; + lines[0] = m_addedBreakpoints[i].lineNumber; bp_table::add_breakpoint (funcName,lines); octave_stdout << "Adding breakpoint: " << funcName << " : " << lines[0] << std::endl; } - added_breakpoints = std::vector<BreakPoint>(); + m_addedBreakpoints = std::vector<BreakPoint>(); // Process removed breakpoints - for (int i = 0 ; i < removed_breakpoints.size() ; i++) + for (int i = 0 ; i < m_removedBreakpoints.size() ; i++) { - std::string funcName = removed_breakpoints[i].filename; + std::string funcName = m_removedBreakpoints[i].fileName; bp_table::intmap lines; - lines[0] = removed_breakpoints[i].line_number; + lines[0] = m_removedBreakpoints[i].lineNumber; bp_table::remove_breakpoint (funcName,lines); //octave_stdout << "Removing breakpoint: " << funcName << " : " << lines[0] << std::endl; } - removed_breakpoints = std::vector<BreakPoint>(); + m_removedBreakpoints = std::vector<BreakPoint>(); // Process modified breakpoints // TODO:
--- a/gui//src/OctaveLink.h +++ b/gui//src/OctaveLink.h @@ -40,19 +40,19 @@ #include <vector> #if defined (HAVE_PTHREAD_H) -#include <pthread.h> + #include <pthread.h> #elif defined (__WIN32__) -#include <windows.h> -typedef CRITICAL_SECTION pthread_mutex_t; -#define pthread_mutex_init(x,a) InitializeCriticalSection(x) -inline int pthread_mutex_trylock(pthread_mutex_t *x) -{ - EnterCriticalSection(x); - return 0; -} -#define pthread_mutex_lock(x) pthread_mutex_trylock(x) -#define pthread_mutex_unlock(x) LeaveCriticalSection(x) -typedef HANDLE pthread_t; + #include <windows.h> + typedef CRITICAL_SECTION pthread_mutex_t; + #define pthread_mutex_init(x,a) InitializeCriticalSection(x) + inline int pthread_mutex_trylock(pthread_mutex_t *x) + { + EnterCriticalSection(x); + return 0; + } + #define pthread_mutex_lock(x) pthread_mutex_trylock(x) + #define pthread_mutex_unlock(x) LeaveCriticalSection(x) + typedef HANDLE pthread_t; #endif /** @@ -85,14 +85,14 @@ /** * The full path and filename where the breakpoint resides. */ - std::string filename; + std::string fileName; /** * The line number where the breakpoint resides. * In the future, -1 can indicate an existing but disabled breakpoint. This * assumes that no one will ever have an M file longer than 2Million lines. */ - int line_number; + int lineNumber; } BreakPoint; typedef struct RequestedVariable @@ -103,75 +103,80 @@ typedef struct VariableMetaData { - /** - * The name of the variable - */ - std::string variable_name; + /** The name of the variable. */ + std::string variableName; - /** - * The dimensional size of the variable. - */ - std::vector<int> size; + /** The dimensional size of the variable. */ + std::vector<int> dimensionalSize; - /** - * The size of the variable in bytes. - */ - unsigned long long byte_size; + /** The size of the variable in bytes. */ + unsigned long long byteSize; - /** - * The name of the variable type. - */ - std::string type_name; + /** The name of the variable type. */ + std::string typeName; friend int operator==(const VariableMetaData& left, - const VariableMetaData& right) - { - return (left.variable_name==right.variable_name) && - (left.size==right.size) && - (left.byte_size==right.byte_size) && - (left.type_name==right.type_name); + const VariableMetaData& right) { + return (left.variableName == right.variableName) && + (left.dimensionalSize == right.dimensionalSize) && + (left.byteSize == right.byteSize) && + (left.typeName == right.typeName); } } VariableMetaData; OctaveLink(); ~OctaveLink(); - bool isProcessing(void) {return is_processing_server_data;}; + bool isProcessing(void) { return m_isProcessingServerData; } // Functions used to access data form the client side. - /** - * Debugging related methods. - */ - std::vector<BreakPoint> get_breakpoint_list(int& status); - bool is_breakpoint_reached(int& status); - std::vector<BreakPoint> get_breakpoint_reached(); - int add_breakpoint( BreakPoint bp_info ); - int remove_breakpoint( BreakPoint bp_info ); - int modify_breakpoint( BreakPoint old_bp_info, BreakPoint new_bp_info ); - int set_breakpoint_action( BreakPointAction action ); + /** Debugging related methods. */ + + /** TODO: Describe. */ + std::vector<BreakPoint> breakPointList(int& status); + + /** TODO: Describe. */ + std::vector<BreakPoint> reachedBreakpoint(); + + /** TODO: Describe. */ + bool isBreakpointReached(int& status); + + /** TODO: Describe. */ + int addBreakpoint(BreakPoint bp_info); - /** - * Variable related methods. - */ - std::vector<VariableMetaData> get_variable_info_list(void); - std::vector<RequestedVariable> get_requested_variables(void); - int set_requested_variables_names( std::vector<std::string> variable_names ); + /** TODO: Describe. */ + int removeBreakpoint(BreakPoint bp_info); + + /** TODO: Describe. */ + int modifyBreakpoint(BreakPoint old_bp_info, BreakPoint new_bp_info); + + /** TODO: Describe. */ + int setBreakpointAction(BreakPointAction action); + + /** Variable related methods. */ + std::vector<VariableMetaData> variableInfoList(void); + + /** TODO: Describe. */ + std::vector<RequestedVariable> requestedVariables(void); + + /** TODO: Describe. */ + int setRequestedVariableNames(std::vector<std::string> variableNames); /** * History related methods. */ - string_vector get_history_list(void); + string_vector getHistoryList(void); -// FUNCTIONS USED TO ACCESS DATA FROM THE OCTAVE SERVER SIDE + // FUNCTIONS USED TO ACCESS DATA FROM THE OCTAVE SERVER SIDE -// NOTE: THIS IMPLIES THAT THESE ARE ONLY CALLED FROM -// OCTAVE DURING A TIME IN WHICH THINGS ARE KNOWN TO -// BE "THREAD-SAFE". PROPOSED LOCATIONS: -// src/toplev.cc - main_loop() at the end of the do...while -// src/pt-bp.h - MAYBE_DO_BREAKPOINT just prior to the do_keyboard -// Most of these will call octave API functions to "pull" the data, rather -// than having octave pass in the data. This will help make changes -// exlusive to this class if/when the Octave API changes. + // NOTE: THIS IMPLIES THAT THESE ARE ONLY CALLED FROM + // OCTAVE DURING A TIME IN WHICH THINGS ARE KNOWN TO + // BE "THREAD-SAFE". PROPOSED LOCATIONS: + // src/toplev.cc - main_loop() at the end of the do...while + // src/pt-bp.h - MAYBE_DO_BREAKPOINT just prior to the do_keyboard + // Most of these will call octave API functions to "pull" the data, rather + // than having octave pass in the data. This will help make changes + // exlusive to this class if/when the Octave API changes. /** * Calls all the appropriate functions that follow to update Octave * according to the data sent from the client in a thread-safe manner. @@ -184,32 +189,36 @@ * ... * Release lock */ - int process_octave_server_data(void); + int processOctaveServerData(void); + + /** Debugging related methods. */ + /** TODO: Describe. */ + int setBreakPointList(void); - /** - * Debugging related methods. - */ - int set_breakpoint_list(void); - int set_current_breakpoint(std::string filename, int line_number); // duplicate of process_breakpoint_action or helper function??? - int process_breakpoint_add_remove_modify(void); + /** TODO: Describe. */ + // duplicate of process_breakpoint_action or helper function??? + int setCurrentBreakpoint(std::string filename, int line_number); + + /** TODO: Describe. */ + int processBreakpointAndRemoveModify(void); + + /** TODO: Describe. */ int process_breakpoint_action(void); - /** - * Variable related methods. - */ - int set_variable_info_list(void); - int process_requested_variables(void); + /** Variable related methods. */ + /** TODO: Describe. */ + int setVariableInfoList(void); - /** - * History related methods. - */ - int set_history_list(void); + /** TODO: Describe. */ + int processRequestedVariables(void); + + /** History related methods. */ + /** TODO: Describe. */ + int setHistoryList(void); private: - /** - * Mutex variable used to protect access to internal class data. - */ - pthread_mutex_t server_mutex; + /** Mutex variable used to protect access to internal class data. */ + pthread_mutex_t m_serverMutex; /** * Mutex variable used to protect access to octave internals on asynchronous requests. @@ -218,34 +227,30 @@ * in a debugger mouse-over, inspection of matrix variables by double-clicking in the * main window, etc. */ - pthread_mutex_t octave_lock_mutex; + pthread_mutex_t m_octaveLockMutex; - std::vector<BreakPoint> current_breakpoints; - std::vector<BreakPoint> breakpoint_reached; - std::vector<BreakPoint> added_breakpoints; - std::vector<BreakPoint> removed_breakpoints; - std::vector<BreakPoint> modify_breakpoints_old; - std::vector<BreakPoint> modify_breakpoints_new; - BreakPointAction bp_action; + std::vector<BreakPoint> m_currentBreakpoints; + std::vector<BreakPoint> m_reachedBreakpoints; + std::vector<BreakPoint> m_addedBreakpoints; + std::vector<BreakPoint> m_removedBreakpoints; + std::vector<BreakPoint> m_modifiedBreakpointsOld; + std::vector<BreakPoint> m_modifiedBreakpointsNew; + BreakPointAction m_breakPointAction; - /** - * Variable related member variables. - */ - std::vector<VariableMetaData> variable_symtab_list; - std::vector<std::string> variables_request_list; + /** Variable related member variables. */ + std::vector<VariableMetaData> m_variableSymbolTableList; + std::vector<std::string> m_variablesRequestList; // NOTE: Create an overloaded operator<< for octave_value to do the // flattening. This will allow us to append easily to an ostringstream // for output. - std::vector<RequestedVariable> requested_variables; + std::vector<RequestedVariable> m_requestedVariables; - /** - * History related member variables. - */ - int prevHistLen; - string_vector history_list; + /** History related member variables. */ + string_vector m_historyList; + int m_previousHistoryLength; - bool is_processing_server_data; + bool m_isProcessingServerData; }; int server_rl_event_hook_function(void);