Return to cvp CVS log

Up to [OS/2 SDKs] / pmsdk / samples / notes

Annotation of pmsdk/samples/notes/cvp, revision 1.1

1.1     ! root        1:                      Differences Document for the
        !             2:                   Microsoft (R) CodeView (R) Debugger
        !             3:                            for Version 2.3
        !             4: 
        !             5:                  (C) Copyright Microsoft Corporation, 1989
        !             6: 
        !             7: 
        !             8: This file contains release notes for the Microsoft (R) CodeView (R),
        !             9: and notes differences between Version 2.3 and 2.2 of the debugger.
        !            10: 
        !            11: 
        !            12: ===========================< Contents >==========================
        !            13: 
        !            14: This file has two parts.
        !            15: 
        !            16:     Part    Note
        !            17:     ----    ----
        !            18:     1       Improved general capabilities of the debugger
        !            19:     2       Debugging child processes
        !            20:     3       Viewing process status
        !            21:     4       Switching to a child processes
        !            22: 
        !            23: 
        !            24: =========< Part 1: Improved Capabilities of the Debugger >=======
        !            25: 
        !            26: 
        !            27: While running under Version 2.3 of CodeView the program being debugged
        !            28: has complete access to environment variables, including the PATH
        !            29: variable. Previous versions of CodeView did not guarantee access to the
        !            30: environment.
        !            31: 
        !            32: Version 2.3 of CodeView is VIO-window compatible, and can therefore
        !            33: run as a Presentation Manager application under OS/2 systems.
        !            34: 
        !            35: 
        !            36: ============< Part 2: Debugging Multiple Processes >=============
        !            37: 
        !            38: 
        !            39: To enable debugging of multiple processes, you must first start up 
        !            40: CodeView with the /O (offspring) option. The syntax of this option 
        !            41: is simple, as it takes no arguments.
        !            42: 
        !            43: If you do not use the /O option, CodeView lets your program spawn new
        !            44: processes, but you will not be able to view or trace through these
        !            45: processes. They run in the background as far as CodeView is concerned.
        !            46: 
        !            47: For example, to debug multiple processes of the program SPACEMAN.EXE you
        !            48: would use the following command:
        !            49: 
        !            50: CVP /O SPACEMAN
        !            51: 
        !            52: The /O option has two limitations:
        !            53: 
        !            54: 1. You must have OS/2 Version 1.1 or later to use it.
        !            55: 
        !            56: 2. This option is incompatible with the /2 option.
        !            57: 
        !            58: The rest of this section assumes that you have successfully started 
        !            59: CodeView with the /O option.
        !            60: 
        !            61: Every time your program executes a line of code that spawns a child
        !            62: process, CodeView responds by displaying the process ID number (Pid) and
        !            63: asking if you wish to debug the child process. The message displayed is
        !            64: similar to the following:
        !            65: 
        !            66: Pid 24 started. Do you wish to debug (y/n)?
        !            67: 
        !            68: To debug the child process, type Y and then press ENTER. Type any other
        !            69: letter for no. CodeView takes a different course of action depending on
        !            70: your response:
        !            71: 
        !            72: 1. If you respond yes (Y), CodeView spawns a new CodeView process. This
        !            73:    process controls execution of your program's child process. Each
        !            74:    instance of CodeView spawned in this way becomes a separate debugging
        !            75:    session.
        !            76: 
        !            77:    A new process runs in the same screen group as its parent process
        !            78:    (unless you call the DosStartSession system function). Using CodeView
        !            79:    does not change this. However, each new instance of CodeView always
        !            80:    runs in its own screen group. Since OS/2 supports a maximum of 16
        !            81:    screen groups, the number of child processes that you can debug at
        !            82:    one time is limited.
        !            83: 
        !            84: 2. If you respond no (N), CodeView lets the program spawn the child process.
        !            85:    However, you will not be able to control or trace the child process
        !            86:    with CodeView. The child process is active but not accessible to
        !            87:    CodeView commands.
        !            88: 
        !            89: You can move between different CodeView processes in the following two
        !            90: ways: by using the OS/2 Session Manager or the Process command (|). The
        !            91: Process command, in turn, has two forms. You can use this command to
        !            92: view status of child processes or to switch directly to the debugging
        !            93: session of the child process.
        !            94: 
        !            95: You may need to make note of process ID numbers when CodeView spawns a
        !            96: process. CodeView identifies multiple processes only by their ID
        !            97: numbers.
        !            98: 
        !            99: 
        !           100: ==============< Part 3: Viewing Process Status >================
        !           101: 
        !           102: 
        !           103: To view the status of the child processes (of the current process), 
        !           104: enter the Process command followed by no arguments:
        !           105: 
        !           106: |
        !           107: 
        !           108: CodeView responds by displaying three fields: process ID number, session 
        !           109: (screen group) ID number, and yes or no, depending on whether or not 
        !           110: each process has its own instance of CodeView. The following example 
        !           111: shows a sample process status for a process with three children:
        !           112: 
        !           113: 001>|
        !           114: ProcessID   SessionID   Debugging
        !           115: 00024       00006       Yes
        !           116: 00026       00006       Yes
        !           117: 00028       00006       No
        !           118: 
        !           119: In the example above, only processes 24 and 26 can be debugged. Each 
        !           120: of these processes corresponds to a different instance of CodeView, 
        !           121: and each instance runs in a separate screen group. Process 28 is active 
        !           122: but cannot be debugged.
        !           123: 
        !           124: 
        !           125: ============< Part 4: Debugging Multiple Processes >=============
        !           126: 
        !           127: 
        !           128: If a child process can be debugged, you can switch to that process 
        !           129: directly by using the Process command. Use of this command accomplishes 
        !           130: the same end as using the Session Manager but is more direct.
        !           131: 
        !           132: To switch to the debugging session for a child process, enter the 
        !           133: Process command with the following syntax:
        !           134: 
        !           135: | <processID>
        !           136: 
        !           137: in which <processID> is the process ID (Pid) of the process you wish to
        !           138: debug.
        !           139: 
        !           140: The Process command only works with direct children. In other words, you
        !           141: can spawn a child which in turns spawns another child. The Process
        !           142: command does not give you direct access to the <169>grandchild.<170>
        !           143: Instead, you must switch to the intermediate parent.
        !           144: 
        !           145: To return to debugging a parent or grandparent, you must use the OS/2
        !           146: Session Manager.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.