Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4b5c7fe7e1
haiku/headers/private/debugger/MessageCodes.h

69 lines
2.2 KiB
C
Raw Normal View History

* Changed the layout of the team window. Trying a single window approach. * Added Run/Step* buttons. * Added some handling for selection in the thread list. * Extended listener mechanisms all over the place (in models and views). * The team debugger now gets the initial states for the team's threads. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31097 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-06-18 04:35:12 +04:00
/*
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
Debugger: Cleanup. - Split MessageCodes.h into a second file that separates out the application-specific message codes from those used by the core. Adjust includes accordingly. No functional change.
2016-12-01 06:18:26 +03:00
* Copyright 2013-2016, Rene Gollent, rene@gollent.com.
* Changed the layout of the team window. Trying a single window approach. * Added Run/Step* buttons. * Added some handling for selection in the thread list. * Extended listener mechanisms all over the place (in models and views). * The team debugger now gets the initial states for the team's threads. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31097 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-06-18 04:35:12 +04:00
* Distributed under the terms of the MIT License.
*/
#ifndef MESSAGE_CODES_H
#define MESSAGE_CODES_H
enum {
* EnumerationValue -> EnumeratorValue * Since some types don't have names (e.g. pointer types or anonymous structs or unions), each type does now also have a unique ID. The global type cache registers types by ID and by name (if they have one). This fixes clashes of types with empty names. * Completely refactored the code dealing with variable values. Formerly we had Variable and TypeComponentPath to navigate to a component, mapped to a BVariant representing the value. Now we have: * Interface Value with various subclasses (BoolValue, IntegerValue, etc.) to represent a value, with the flexibility for more esoteric values. * A tree of ValueNode+ValueNodeChild objects to represent the components of a variable. On top of each ValueNodeChild sits a ValueNode representing the value of the component, potentially having ValueNodeChild children. This should allow casting a component value, simply by replacing its ValueNode. * Interface ValueHandler and various implementations for the different value types. It is basically a factory for classes allowing to format/display a value. * ValueHandlerRoster -- a registry for ValueHandlers, finding the best one for a given value. * Interface TypeHandler and various implementions for the different type kinds (primitive, compound, address, etc.). It is basically a factory for ValueNodes for that type. * TypeHandlerRoster -- a registry for TypeHandlers, finding the best one for a given type. That's still a bit work in progress. It introduces at least one regression: The VariablesView doesn't save/restore its state anymore. Will take a while until that is added back. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33907 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-11-05 21:15:21 +03:00
MSG_THREAD_RUN = 'run_',
Add MSG_THREAD_SET_ADDRESS and implement handling.
2013-05-17 05:16:45 +04:00
MSG_THREAD_SET_ADDRESS = 'sead',
* EnumerationValue -> EnumeratorValue * Since some types don't have names (e.g. pointer types or anonymous structs or unions), each type does now also have a unique ID. The global type cache registers types by ID and by name (if they have one). This fixes clashes of types with empty names. * Completely refactored the code dealing with variable values. Formerly we had Variable and TypeComponentPath to navigate to a component, mapped to a BVariant representing the value. Now we have: * Interface Value with various subclasses (BoolValue, IntegerValue, etc.) to represent a value, with the flexibility for more esoteric values. * A tree of ValueNode+ValueNodeChild objects to represent the components of a variable. On top of each ValueNodeChild sits a ValueNode representing the value of the component, potentially having ValueNodeChild children. This should allow casting a component value, simply by replacing its ValueNode. * Interface ValueHandler and various implementations for the different value types. It is basically a factory for classes allowing to format/display a value. * ValueHandlerRoster -- a registry for ValueHandlers, finding the best one for a given value. * Interface TypeHandler and various implementions for the different type kinds (primitive, compound, address, etc.). It is basically a factory for ValueNodes for that type. * TypeHandlerRoster -- a registry for TypeHandlers, finding the best one for a given type. That's still a bit work in progress. It introduces at least one regression: The VariablesView doesn't save/restore its state anymore. Will take a while until that is added back. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33907 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-11-05 21:15:21 +03:00
MSG_THREAD_STOP = 'stop',
MSG_THREAD_STEP_OVER = 'stov',
MSG_THREAD_STEP_INTO = 'stin',
MSG_THREAD_STEP_OUT = 'stou',
MSG_SET_BREAKPOINT = 'sbrk',
MSG_CLEAR_BREAKPOINT = 'cbrk',
MSG_ENABLE_BREAKPOINT = 'ebrk',
MSG_DISABLE_BREAKPOINT = 'dbrk',
Debugger: Add UI for configuring breakpoint conditions. General: - Add message codes for requesting breakpoint configuration. UserInterfaceListener/TeamDebugger: - Add/implement hooks for requesting breakpoint condition changes. BreakpointsView: - Add button to request editing the currently selected breakpoint's condition. TeamWindow: - Handle request to show breakpoint edit window. BreakpointEditWindow: - Implement simple radio-based UI for modifying the current breakpoint's condition. Still missing: Actually handling/evaluating the breakpoint conditions in the ThreadHandler when the breakpoint is hit.
2014-10-30 21:23:26 +03:00
MSG_SET_BREAKPOINT_CONDITION = 'sbpc',
MSG_CLEAR_BREAKPOINT_CONDITION = 'cbpc',
Start adding the underlying infrastructure for watchpoint support.
2012-11-06 14:45:26 +04:00
MSG_SET_WATCHPOINT = 'swpt',
MSG_CLEAR_WATCHPOINT = 'cwpt',
MSG_ENABLE_WATCHPOINT = 'ewpt',
MSG_DISABLE_WATCHPOINT = 'dwpt',
Implement #9855. The Team menu now has a menu item allowing one to tell the debugger to stop whenever a new executable image is loaded by the debugged team. This setting is not currently persisted, though that can be changed if desired.
2013-07-04 18:39:34 +04:00
MSG_STOP_ON_IMAGE_LOAD = 'tsil',
Implement debugger infrastructure for stop on... ...image load with name matching. - Move the stop on image load setting to Team, along with a new setting governing the use of the (also newly added) name list. - Add accessors for maintaining the name list, and events/notifications for listeners with regards to changes to all stop on image load settings. - Adjust user interface listener hooks for additional functionality.
2013-07-07 08:31:22 +04:00
MSG_ADD_STOP_IMAGE_NAME = 'asin',
MSG_REMOVE_STOP_IMAGE_NAME = 'rsin',
Debugger: Add signal settings and listener hooks. Team: - Add settings and accessors for signal dispositions. - Add event definitions and listener hooks for signal disposition changes.
2015-06-30 06:26:08 +03:00
MSG_SET_DEFAULT_SIGNAL_DISPOSITION = 'sdsd',
MSG_SET_CUSTOM_SIGNAL_DISPOSITION = 'scsd',
MSG_REMOVE_CUSTOM_SIGNAL_DISPOSITION = 'rcsd',
* EnumerationValue -> EnumeratorValue * Since some types don't have names (e.g. pointer types or anonymous structs or unions), each type does now also have a unique ID. The global type cache registers types by ID and by name (if they have one). This fixes clashes of types with empty names. * Completely refactored the code dealing with variable values. Formerly we had Variable and TypeComponentPath to navigate to a component, mapped to a BVariant representing the value. Now we have: * Interface Value with various subclasses (BoolValue, IntegerValue, etc.) to represent a value, with the flexibility for more esoteric values. * A tree of ValueNode+ValueNodeChild objects to represent the components of a variable. On top of each ValueNodeChild sits a ValueNode representing the value of the component, potentially having ValueNodeChild children. This should allow casting a component value, simply by replacing its ValueNode. * Interface ValueHandler and various implementations for the different value types. It is basically a factory for classes allowing to format/display a value. * ValueHandlerRoster -- a registry for ValueHandlers, finding the best one for a given value. * Interface TypeHandler and various implementions for the different type kinds (primitive, compound, address, etc.). It is basically a factory for ValueNodes for that type. * TypeHandlerRoster -- a registry for TypeHandlers, finding the best one for a given type. That's still a bit work in progress. It introduces at least one regression: The VariablesView doesn't save/restore its state anymore. Will take a while until that is added back. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33907 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-11-05 21:15:21 +03:00
Debugger: Add rename event for Team. Team: - Add listener hook and event type for rename events. These occur on exec() since at this point we're running a different executable. TeamWindow: - Factor out code for generating window title into a helper, and use from both window initialization and newly implemented rename listener hook.
2015-07-26 19:57:15 +03:00
MSG_TEAM_RENAMED = 'tera',
* EnumerationValue -> EnumeratorValue * Since some types don't have names (e.g. pointer types or anonymous structs or unions), each type does now also have a unique ID. The global type cache registers types by ID and by name (if they have one). This fixes clashes of types with empty names. * Completely refactored the code dealing with variable values. Formerly we had Variable and TypeComponentPath to navigate to a component, mapped to a BVariant representing the value. Now we have: * Interface Value with various subclasses (BoolValue, IntegerValue, etc.) to represent a value, with the flexibility for more esoteric values. * A tree of ValueNode+ValueNodeChild objects to represent the components of a variable. On top of each ValueNodeChild sits a ValueNode representing the value of the component, potentially having ValueNodeChild children. This should allow casting a component value, simply by replacing its ValueNode. * Interface ValueHandler and various implementations for the different value types. It is basically a factory for classes allowing to format/display a value. * ValueHandlerRoster -- a registry for ValueHandlers, finding the best one for a given value. * Interface TypeHandler and various implementions for the different type kinds (primitive, compound, address, etc.). It is basically a factory for ValueNodes for that type. * TypeHandlerRoster -- a registry for TypeHandlers, finding the best one for a given type. That's still a bit work in progress. It introduces at least one regression: The VariablesView doesn't save/restore its state anymore. Will take a while until that is added back. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33907 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-11-05 21:15:21 +03:00
MSG_THREAD_STATE_CHANGED = 'tsch',
MSG_THREAD_CPU_STATE_CHANGED = 'tcsc',
MSG_THREAD_STACK_TRACE_CHANGED = 'tstc',
MSG_IMAGE_DEBUG_INFO_CHANGED = 'idic',
Implement #9758. - Add ConsoleOutputView for showing the debugged team's console output. The view presents checkboxes for controlling whether or not stdout and/or stderr output is captured and shown, as well as the ability to clear the current output.
2013-06-28 05:05:42 +04:00
MSG_CONSOLE_OUTPUT_RECEIVED = 'core',
* EnumerationValue -> EnumeratorValue * Since some types don't have names (e.g. pointer types or anonymous structs or unions), each type does now also have a unique ID. The global type cache registers types by ID and by name (if they have one). This fixes clashes of types with empty names. * Completely refactored the code dealing with variable values. Formerly we had Variable and TypeComponentPath to navigate to a component, mapped to a BVariant representing the value. Now we have: * Interface Value with various subclasses (BoolValue, IntegerValue, etc.) to represent a value, with the flexibility for more esoteric values. * A tree of ValueNode+ValueNodeChild objects to represent the components of a variable. On top of each ValueNodeChild sits a ValueNode representing the value of the component, potentially having ValueNodeChild children. This should allow casting a component value, simply by replacing its ValueNode. * Interface ValueHandler and various implementations for the different value types. It is basically a factory for classes allowing to format/display a value. * ValueHandlerRoster -- a registry for ValueHandlers, finding the best one for a given value. * Interface TypeHandler and various implementions for the different type kinds (primitive, compound, address, etc.). It is basically a factory for ValueNodes for that type. * TypeHandlerRoster -- a registry for TypeHandlers, finding the best one for a given type. That's still a bit work in progress. It introduces at least one regression: The VariablesView doesn't save/restore its state anymore. Will take a while until that is added back. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33907 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-11-05 21:15:21 +03:00
MSG_IMAGE_FILE_CHANGED = 'ifch',
MSG_FUNCTION_SOURCE_CODE_CHANGED = 'fnsc',
MSG_USER_BREAKPOINT_CHANGED = 'ubrc',
More UI support for watchpointgs. - BreakpointTableModel now encapsulates both breakpoints and watchpoints. - Extended BreakpointView and TeamWindow to handle enable/disable/removing watchpoints as well.
2012-11-07 17:50:17 +04:00
MSG_WATCHPOINT_CHANGED = 'wapc',
Debugger: Add memory write support. - Implements various support classes and functions that will be needed in order to marshal requests to write to memory in the target team.
2015-05-23 23:12:43 +03:00
MSG_MEMORY_DATA_CHANGED = 'mdac',
* EnumerationValue -> EnumeratorValue * Since some types don't have names (e.g. pointer types or anonymous structs or unions), each type does now also have a unique ID. The global type cache registers types by ID and by name (if they have one). This fixes clashes of types with empty names. * Completely refactored the code dealing with variable values. Formerly we had Variable and TypeComponentPath to navigate to a component, mapped to a BVariant representing the value. Now we have: * Interface Value with various subclasses (BoolValue, IntegerValue, etc.) to represent a value, with the flexibility for more esoteric values. * A tree of ValueNode+ValueNodeChild objects to represent the components of a variable. On top of each ValueNodeChild sits a ValueNode representing the value of the component, potentially having ValueNodeChild children. This should allow casting a component value, simply by replacing its ValueNode. * Interface ValueHandler and various implementations for the different value types. It is basically a factory for classes allowing to format/display a value. * ValueHandlerRoster -- a registry for ValueHandlers, finding the best one for a given value. * Interface TypeHandler and various implementions for the different type kinds (primitive, compound, address, etc.). It is basically a factory for ValueNodes for that type. * TypeHandlerRoster -- a registry for TypeHandlers, finding the best one for a given type. That's still a bit work in progress. It introduces at least one regression: The VariablesView doesn't save/restore its state anymore. Will take a while until that is added back. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33907 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-11-05 21:15:21 +03:00
MSG_DEBUGGER_EVENT = 'dbge',
MSG_LOAD_SETTINGS = 'ldst',
MSG_VALUE_NODE_CHANGED = 'vnch',
MSG_VALUE_NODE_CHILDREN_CREATED = 'vncc',
MSG_VALUE_NODE_CHILDREN_DELETED = 'vncd',
MSG_VALUE_NODE_VALUE_CHANGED = 'vnvc',
Start adding support for typecast support. Not yet complete/working.
2012-11-04 12:37:16 +04:00
MSG_INSPECT_ADDRESS = 'isad',
Debugger: Add memory write support. - Implements various support classes and functions that will be needed in order to marshal requests to write to memory in the target team.
2015-05-23 23:12:43 +03:00
MSG_WRITE_TARGET_MEMORY = 'wtam',
Debugger: Add asynchronous expression evaluation interface. - Add UserInterfaceListener hook to request expression evaluation. - Add corresponding events/handlers in Team and TeamDebugger. These allow callers to request evaluation of expressions by the debugger core's worker threads with asynchronous notifications of results. While not strictly necessary right now, this paves the way for further changes to come, as handling of variables will potentially require resolving their values if they haven't been already, and this shouldn't be done from user interface threads.
2014-10-28 22:24:34 +03:00
MSG_EVALUATE_EXPRESSION = 'evex',
Debugger: Implement remainder of #12729. UserInterfaceListener: - Add request hook for writing a core file. Implement in TeamDebugger. Jobs/WriteCoreFileJob: - Add new job to actually dispatch the core file request via the debugger interface. Team{::Listener} - Add listener event + hook for notifications when a core file gets written. Implement in CLI. CliContext: - Add event flag for core file changed. CommandLineUserInterface: - Add 'write-core' command. This optionally takes a path to write the core to, otherwise one is automatically generated by, similarly to debug reports. As such, one can now generate cores for things like app_server and registrar crashes if desired, in addition to reports.
2016-04-27 05:35:54 +03:00
MSG_WRITE_CORE_FILE = 'wrcf',
Debugger: Add file prompt hook to UserInterface. In some circumstances, it may be necessary to ask the user to locate a file from the lower layers. Adds the corresponding hook to UserInterface, and a stub implementation for CommandLineUserInterface. Adds full implementation for GraphicalUserInterface.
2014-06-11 03:10:53 +04:00
Debugger: Cleanup. - Split MessageCodes.h into a second file that separates out the application-specific message codes from those used by the core. Adjust includes accordingly. No functional change.
2016-12-01 06:18:26 +03:00
MSG_TEAM_DEBUGGER_QUIT = 'dbqt',
MSG_TEAM_RESTART_REQUESTED = 'trrq',
MSG_GENERATE_DEBUG_REPORT = 'gdrp',
Debugger: Add file prompt hook to UserInterface. In some circumstances, it may be necessary to ask the user to locate a file from the lower layers. Adds the corresponding hook to UserInterface, and a stub implementation for CommandLineUserInterface. Adds full implementation for GraphicalUserInterface.
2014-06-11 03:10:53 +04:00
MSG_DEBUG_INFO_NEEDS_USER_INPUT = 'dnui',
Debugger: Fix #14375, #12343. TeamDebugger: - When a job is aborted, instead of calling into the user interface directly to reset the status message, post a message to do so. Also, only post the message if we aren't already in a terminating state. Otherwise, if jobs were still running while the team debugger is executing its destructor, it would attempt to make calls to the already destroyed user interface. This bug has likely been with us for quite some time, but was hidden by incorrect ref counting in the past (see #12343).
2018-08-20 23:42:55 +03:00
MSG_USER_INTERFACE_FILE_CHOSEN = 'uifc',
MSG_RESET_USER_BACKGROUND_STATUS = 'rubs'
* Changed the layout of the team window. Trying a single window approach. * Added Run/Step* buttons. * Added some handling for selection in the thread list. * Extended listener mechanisms all over the place (in models and views). * The team debugger now gets the initial states for the team's threads. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31097 a95241bf-73f2-0310-859d-f6bbb57e9c96
2009-06-18 04:35:12 +04:00
};
#endif // MESSAGE_CODES_H
Reference in New Issue Copy Permalink