home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / pascal / turbo55 / tp55 / td / helpme!.doc next >
Text File  |  1989-05-01  |  14KB  |  347 lines
  1.              TURBO DEBUGGER 1.5 COMMON QUESTIONS AND ANSWERS
  2.              -----------------------------------------------
  3.  
  4.   1. How does TD handle screen output for graphics- and text-based
  5.      programs?
  6.  
  7.      Turbo debugger has a number of strategies that it can use to
  8.      control how and when the screen gets refreshed. If you are
  9.      debugging a program that uses a graphics display mode or if
  10.      you want to use Borland pop-up utilities such as SideKick
  11.      and SideKick+ while inside Turbo Debugger, you should review
  12.      the following tips.
  13.  
  14.      The default screen-updating mode is "Flip"; this means that
  15.      Turbo Debugger uses an alternate video display page on
  16.      adapters that support multiple display pages. This results
  17.      in fast screen-swapping between Turbo Debugger and your
  18.      program, but it also can interfere with the operation of
  19.      pop-up utilities and graphics programs.
  20.  
  21.      Pop-up utilities may not appear on the screen, even though
  22.      they are active and processing your keystrokes. You must
  23.      select "Swap" mode for display-updating in order for pop-ups
  24.      to work properly. Use Turbo Debugger's -ds command-line
  25.      option to do this, or use the TDINST utility to permanently
  26.      set this mode. "Swap" mode makes screen updating slower, but
  27.      it makes sure that Turbo Debugger's screen does not
  28.      interfere with either your program's or any pop-up's
  29.      display.
  30.  
  31.      You may also need to use "Swap" when you use the OS Shell
  32.      command or run an editor from within TD. Most programs
  33.      expect to run on video page 0, and do not check to see what
  34.      the current video page is. TD's OS Shell and any editors
  35.      that TD runs in "Flip" mode do not run from video page 0,
  36.      and the programs may appear to hang, even though you will be
  37.      able to type in keystrokes normally. If this happens, use
  38.      the -ds command-line option when you run TD or reinstall TD
  39.      to use "Swap" instead of "Flip."
  40.  
  41.      If you are debugging a graphics mode application, you must
  42.      specify the -ds command-line option ("Swap" contents) and
  43.      you may want to use Turbo Debugger's -vg command-line
  44.      option (Graphics Save). This causes additional memory to be
  45.      set aside for saving the entire graphics image your
  46.      program produces. If you don't use this option, a "red
  47.      cloud" may appear on your program's screen. These options
  48.      can also be set permanently by using the TDINST program.
  49.      The Graphics Save option takes an additional 8K of memory
  50.      and slows screen-swapping.
  51.  
  52.      If you are running a graphics program that changes the EGA
  53.      palette, make sure you use the -vp command line option to
  54.      save the palette.
  55.  
  56.   2. Can Turbo Debugger execute other programs while you are
  57.      still using the debugger?
  58.  
  59.      The OS Shell and Edit commands in the Module and File
  60.      windows can swap the program you are debugging to disk in
  61.      order to make room to run DOS or your editor. The default
  62.      amount of memory to swap is 128K. You can use TDINST to set a
  63.      different amount if that's not enough memory to run your
  64.      editor or other programs. Setting the swap size to 0K tells
  65.      Turbo Debugger to swap the entire user program to disk
  66.      before running the DOS command processor.
  67.  
  68.      Only your program gets swapped to disk; Turbo Debugger
  69.      remains in memory.
  70.  
  71.   3. How can I break out of a program even though interrupts are
  72.      disabled?
  73.  
  74.      If you have an 80386-chip-based computer and are using
  75.      TD386, option -B allows break even when interrupts are
  76.      disabled. For example, this option enables a break from
  77.  
  78.        CLI
  79.        JMP $
  80.  
  81.   4. Why can't I hit Ctrl-Break to get out of a program
  82.      running on a remote machine?
  83.  
  84.      The program running in the remote machine has taken control
  85.      of Interrupt 1B (Ctrl-Break). TDREMOTE does not take back
  86.      control of Interrupt 1B until you stop execution of the
  87.      running program on the debugger side by completing the
  88.      program or hitting Ctrl-F2 (Program Reset).
  89.  
  90.  
  91.   5. What are some of the syntactic and parsing differences
  92.      between Turbo Debugger's built-in assembler and the
  93.      standalone Turbo Assembler?
  94.  
  95.      A discussion follows this short example program:
  96.  
  97.               .model small
  98.               .data
  99.  
  100.        abc    struc
  101.        mem1   dd      ?
  102.        mem2   db      ?
  103.        mem3   db      "   "
  104.        abc    ends
  105.  
  106.               align   16
  107.        a      abc     <1,2,"xyz">
  108.  
  109.        msg1   db      "testing 1 2 3", 0
  110.        msg2   db      "hello world", 0
  111.        nmptr  dw      msg1
  112.        fmptr  dd      msg1,msg2
  113.        nfmptr dw      fmptr
  114.        xx     dw      seg a
  115.  
  116.               .code
  117.  
  118.               push   cs
  119.               pop    ds
  120.               mov    bx,offset a
  121.               mov    bx,nmptr
  122.               les    si,fmptr
  123.               mov    ah,4ch
  124.               int    21h
  125.               end
  126.  
  127.      The assembler expression parser does not accept all legal
  128.      TASM instruction operands. This allows TD's assembler
  129.      expressions to be more general and allows multiple levels of
  130.      memory-referencing, more like that used in C and Pascal.
  131.      However, there are a few constructs that you may be used to
  132.      that you'll have to specify differently for the TD assembler
  133.      expression parser to accept them:
  134.  
  135.        a. Size overrides should always appear inside the
  136.           brackets; PTR is optional after the size. Also, when
  137.           referring to a structure, you must use the name of the
  138.           struc, not the name of the variable:
  139.  
  140.             OK:  [byte ptr bx]   [dword si]        [abc bx]
  141.  
  142.             BAD: byte ptr[bx]    [struc abc bx]    [a bx]
  143.  
  144.        b. You must specify a structure name when accessing the
  145.           members of a structure via a register pointer:
  146.  
  147.             OK:  [abc ptr bx].mem1  [abc bx].mem3 + 1
  148.  
  149.             BAD: [bx].mem1
  150.  
  151.        c. You can't use multiple instances of [] unless they are
  152.           adjacent, and you can only follow an [] expression with
  153.           a dot and a structure member name or another []
  154.           expression:
  155.  
  156.             OK:  4[bx][si]    [abc bx].mem2
  157.  
  158.             BAD: [bx]4[si]    [bx]+4
  159.  
  160.        d. If you use a register as part of a memory expression
  161.           and you don't specify a size, WORD is assumed:
  162.  
  163.             [bx] is the same as [word bx]
  164.  
  165.        e. You can use any register you want between [], not just
  166.           the combinations of BX, BP, SI, and DI allowed in
  167.           instruction operands:
  168.  
  169.             OK:  [ax+bx]   [bx+sp]
  170.  
  171.        f. You can use multiple levels of [] to follow chains of
  172.           pointers:
  173.  
  174.             OK:  [byte [[nfmptr]+4]]
  175.  
  176.        g. Be careful using registers to access memory locations.
  177.           You may get unexpected results if your segment
  178.           registers are not set up properly. If you don't
  179.           explicitly specify a segment register, Turbo Debugger
  180.           uses the DS register to reference memory.
  181.  
  182.        h. When you do specify a segment register, make sure you
  183.           follow the same rule for size overrides: put it
  184.           INSIDE the brackets:
  185.  
  186.             OK:  [byte es:di]    [es:fmptr]
  187.  
  188.             BAD: es:[byte di]
  189.  
  190.        i. Use the OFFSET operator to get the address of a
  191.           variable or structure. Turbo Debugger automatically
  192.           supplies the [] around a variable name if you just type
  193.           the variable name alone:
  194.  
  195.             a            contents of structure a
  196.             [a]          contents of structure a
  197.             offset a     address of structure a
  198.  
  199.        j. You can use the type overrides and the format control
  200.           count to examine any area of memory displayed as you
  201.           wish:
  202.  
  203.             [byte es:bx],10  10 bytes pointed to by es:bx
  204.             [dword ds:si],4  4 dwords pointed to by ds:si
  205.  
  206.           This is very useful when specifying watch expressions.
  207.  
  208.        k. Sometimes you use a word memory location or register to
  209.           point to a paragraph in memory that contains a data
  210.           structure. Access the structure with expressions like
  211.  
  212.             [abc [xx]:0].mem1
  213.             [abc es:0].mem3
  214.  
  215.   6. Are there any syntactic or parsing differences between Turbo
  216.      Debugger's C expression evaluation and Turbo C's?
  217.  
  218.      You can't pass constant-string arguments when evaluating
  219.      functions.
  220.  
  221.        OK:   myfunc(123)   myfunc(string_variable)
  222.  
  223.        BAD:  myfunc("constant")
  224.  
  225.   7. Are there any syntactic or parsing differences between Turbo
  226.      Debugger's Pascal expression evaluation and Turbo Pascal's?
  227.  
  228.      a. Turbo Debugger does not support expressions for set
  229.         constructors:
  230.  
  231.           OK:   [4..7]
  232.  
  233.           BAD:  [myvar1..myvar2]   [3+4..7+8]
  234.  
  235.      b. You can't pass constant-string arguments when evaluating
  236.         functions or procedures.
  237.  
  238.           OK:   MyFunc(123)   MyFunc(StringVariable)
  239.  
  240.           BAD:  MyFunc('Constant')
  241.  
  242.                 MyFunc(StringConstant), where StringConstant is
  243.                 defined with a "const" declaration and is not a
  244.                 typed constant.
  245.  
  246.      c. You can't evaluate procedures or functions that have
  247.         structure VALUE parameters. You can evaluate procedures or
  248.         functions that have structure VARIABLE parameters, though.
  249.  
  250.   8. What should I be aware of when I am debugging multilanguage
  251.      programs with Turbo Debugger?
  252.  
  253.      Turbo Debugger's default source language is "Auto," which
  254.      means it chooses the expression language based on the current
  255.      source module. This can cause some confusion if your program
  256.      has source modules written in different languages (like C
  257.      and assembler). Since you are actually entering a language
  258.      expression any time Turbo Debugger prompts you for a value
  259.      or an address, this can cause some unexpected results:
  260.  
  261.      a. Even if you are in a CPU window or a Dump window, you
  262.         must still enter addresses in the source language,
  263.         despite the fact that the window is displaying in hex.
  264.         For example, to display the contents of memory address
  265.         1234:5678, you must type one of the following
  266.         expressions, depending on your current source language:
  267.  
  268.           C            0x1234:0x5678
  269.           Pascal        $1234:$5678
  270.           Assembler      1234:5678
  271.  
  272.      b. When your current language is assembler, you must be
  273.         careful when entering hex numbers, since they are
  274.         interpreted EXACTLY as they would be in an assembler
  275.         source file. This means that if you want to enter a
  276.         number that starts with one of the hex digits A - F, you
  277.         must first precede the letter with a 0 so Turbo Debugger
  278.         knows you are entering a number. Likewise, if your
  279.         number ends in B or D (indicating a binary or decimal
  280.         number), you must add an H to indicate that you really want
  281.         a hex number:
  282.  
  283.           OK:   0aaaa   123dh   89abh
  284.  
  285.           BAD:  aaaa    123d    89ab
  286.  
  287.   9. Why does the text "Cannot be changed" come up when I do an
  288.      assignment in the Data/Evaluate/Modify "New value" pane?
  289.  
  290.      If you use the Data/Evaluate/Modify command (Ctrl-F4) to
  291.      change a variable by direct assignment, the "New value" pane
  292.      will say "Cannot be changed." This doesn't mean the
  293.      assignment didn't take effect. What it does mean is that the
  294.      assignment expression as a whole is not a memory-referencing
  295.      expression whose value you can change by moving to the
  296.      bottom pane. Here are some examples of direct assignment
  297.      expressions:
  298.  
  299.        C              x = 4
  300.        Pascal         ratio := 1.234
  301.        Assembler      wval = 4 shl 2
  302.  
  303.      If you had typed just "x," "ratio," or "wval" into the top
  304.      pane, then you would be able to move to the bottom pane and
  305.      enter a new value. The direct assignment method using the
  306.      "=" or ":=" assignment operator is quicker and more
  307.      convenient if you don't care about examining the value of
  308.      the variable before modifying it.
  309.  
  310.  10. Why does an inspector occasionally display question marks
  311.      when inspecting a Turbo C register variable?
  312.  
  313.      If you inspect a register variable that is not in the
  314.      current scope, you'll see ???? for the value. A register
  315.      variable only displays a value if the register is in your
  316.      current scope (valid at the current location in your
  317.      program).
  318.  
  319.  11. What is the most likely reason for Turbo Debugger to hang
  320.      when starting up on a PC-compatible computer?
  321.  
  322.      If your computer is a Tandy 1000A, IBM PC Convertible, or
  323.      NEC MultiSpeed, or if TD hangs when loading on your system,
  324.      run TDINST and change the last item in the Options menu so
  325.      that NMI Intercept is set to "No." Some computers use the
  326.      NMI (Non-Maskable Interrupt) in ways that conflict with TD,
  327.      so you must disable TD's use of this interrupt in order to
  328.      run the program.
  329.  
  330.      Also, if you are using a 80386-based machine and have the
  331.      SuperKey utility loaded, be careful not to press a key when
  332.      TD386 is loading, since SuperKey may capture the keystroke
  333.      and cause unexpected results.
  334.  
  335.  12. What could happen when global breakpoints are set on local
  336.      variables?
  337.  
  338.      When you set global breakpoints using local variables, make
  339.      sure the breakpoints are cleared before you exit the
  340.      procedure or function that the variables are defined in. The
  341.      best way to do this is to put a breakpoint on the last line
  342.      of the procedure or function.  If you do not clear the
  343.      breakpoints, your program will break unexpectedly and may
  344.      even hang on some machines because the breakpoints are being
  345.      set in memory that is not currently being used by the
  346.      procedure or function.
  347.