/*************************************************************************/
                        TURBO DEBUGGER & TOOLS 2.5
                      MANUAL REFERENCE & CORRECTIONS

CONTENTS:
1.  Turbo Debugger/Profiler 2.5: Answers to Common Questions
2.  Turbo Assembler 2.5: Answers to Common Questions  (To get to this
    section directly, search for 'TASM:')


TURBO DEBUGGER/PROFILER 2.5:  ANSWERS TO COMMON QUESTIONS
---------------------------------------------------------
  Below is a list of the most commonly asked questions about Turbo Debugger
  and Turbo Profiler.  Following this list is some information on mouse
  features in Turbo Debugger/Profiler 2.5 as well as some information on
  using TDW with Microsoft Windows.

  1. How do TD/TPROF handle screen output for graphics- and text-based
     programs?

     There are a number of strategies that can be used to control
     how and when the screen gets refreshed. If you are debugging or
     profiling a program that uses a graphics display mode, if
     you want to use a Borland pop-up utilities such as SideKick
     and SideKick Plus while inside Turbo Debugger/Profiler, or if
     you want to run programs from Turbo Debugger's DOS Shell that
     write directly to video memory, you should review the following
     tips.

     The default screen-updating mode is "Swap"; this means that
     Turbo Debugger/Profiler use a single display adapter and display
     page, and swap the contents of the User and Turbo Debugger/Profiler
     screens in software.  This is the slowest method of display
     swapping, but it is the most protective and least disruptive.

     Pop-up utilities may not appear on the screen if your screen
     updating is set to Flip, even though they are active and proces-
     sing your keystrokes. You must select "Swap" mode for display
     updating in order for these programs to work properly. Use Turbo
     Debugger's/Profiler's -ds command-line option to do this, or use
     the TDINST/TFINST utilities to permanently set this mode. "Swap"
     mode makes screen updating slower, but it makes sure that Turbo
     Debugger's/Profiler's screen does not interfere with either your
     program's or any other program's display.

     You may also need to use "Swap" when you use the DOS Shell
     command or run an editor from within TD/TPROF. Most programs
     expect to run on video page 0, and do not check to see what
     the current video page is. TD's/TPROF's DOS Shell and any
     editors that TD/TPROF runs in "Flip" mode do not run from
     video page 0, and the programs may appear to hang, even though
     you will be able to type in keystrokes normally. If this happens,
     use the -ds command-line option when you run TD/TPROF or reinstall
     TD/TPROF to use "Swap" instead of "Flip."

     If you are debugging/profiling a graphics mode application,
     you must specify the -ds command-line option ("Swap" contents)
     and you may want to use Turbo Debugger's/Profiler's -vg command-
     line option (Graphics Save). This causes additional memory to be
     set aside for saving the entire graphics image your program produces.
     If you don't use this option, a "red cloud" may appear on your
     program's screen. These options can also be set permanently by
     using the TDINST/TFINST program. The Graphics Save option takes an
     additional 8K of memory and slows screen-swapping.

     If you are running a graphics program that changes the EGA
     palette, make sure you use the -vp command-line option to
     save the palette.

  2. Can Turbo Debugger/Profiler execute other programs while you are
     still debugging or profiling?

     The DOS Shell and Edit commands in the Module and File
     windows can swap the program you are debugging to disk in
     order to make room to run DOS or your editor. The default
     amount of memory to swap is 128K. You can use TDINST/TFINST
     to set a different amount if that's not enough memory to run
     your editor or other programs. Setting the swap size to 0K
     tells Turbo Debugger/Profiler to swap the entire user program
     to disk before running the DOS command processor.

     Only your program gets swapped to disk; Turbo Debugger/Profiler
     remain in memory.

  3. How can I break out of a program even though interrupts are
     disabled?

     If you have an 80386-chip-based computer and are using TD386/TF386,
     the -B option allows a break even when interrupts are disabled. For
     example, this option enables a break from

       CLI
       JMP $

  4. Why can't I press Ctrl-Break to get out of a program
     running on a remote machine?

     The program running in the remote machine has taken control
     of Interrupt 1B (Ctrl-Break). TDREMOTE/TFREMOTE do not take
     back control of Interrupt 1B until you stop execution of the
     running program on the debugger/profiler side by completing the
     program or pressing Ctrl-F2 (Program Reset).


  5. What are some of the syntactic and parsing differences
     between Turbo Debugger's built-in assembler and the
     standalone Turbo Assembler?

     A discussion follows this short example program:

              .model small
              .data

       abc    struc
       mem1   dd      ?
       mem2   db      ?
       mem3   db      "   "
       abc    ends

              align   16
       a      abc     <1,2,"xyz">

       msg1   db      "testing 1 2 3", 0
       msg2   db      "hello world", 0
       nmptr  dw      msg1
       fmptr  dd      msg1,msg2
       nfmptr dw      fmptr
       xx     dw      seg a

              .code

              push   cs
              pop    ds
              mov    bx,offset a
              mov    bx,nmptr
              les    si,fmptr
              mov    ah,4ch
              int    21h
              end

     The assembler expression parser does not accept all legal
     TASM instruction operands. This allows TD's assembler
     expressions to be more general and allows multiple levels of
     memory-referencing, more like that used in C and Pascal.
     However, there are a few constructs that you may be used to
     that you'll have to specify differently for the TD assembler
     expression parser to accept them:

       a. Size overrides should always appear inside the
          brackets; PTR is optional after the size. Also, when
          referring to a structure, you must use the name of the
          struc, not the name of the variable:

            OK:  [byte ptr bx]   [dword si]        [abc bx]

            BAD: byte ptr[bx]    [struc abc bx]    [a bx]

       b. You must specify a structure name when accessing the
          members of a structure via a register pointer:

            OK:  [abc ptr bx].mem1  [abc bx].mem3 + 1

            BAD: [bx].mem1

       c. You can't use multiple instances of [] unless they are
          adjacent, and you can only follow an [] expression with
          a dot and a structure member name or another []
          expression:

            OK:  4[bx][si]    [abc bx].mem2

            BAD: [bx]4[si]    [bx]+4

       d. If you use a register as part of a memory expression
          and you don't specify a size, WORD is assumed:

            [bx] is the same as [word bx]

       e. You can use any register you want between [], not just
          the combinations of BX, BP, SI, and DI allowed in
          instruction operands:

            OK:  [ax+bx]   [bx+sp]

       f. You can use multiple levels of [] to follow chains of
          pointers:

            OK:  [byte [[nfmptr]+4]]

       g. Be careful using registers to access memory locations.
          You may get unexpected results if your segment
          registers are not set up properly. If you don't
          explicitly specify a segment register, Turbo Debugger
          uses the DS register to reference memory.

       h. When you do specify a segment register, make sure you
          follow the same rule for size overrides: put it
          INSIDE the brackets:

            OK:  [byte es:di]    [es:fmptr]

            BAD: es:[byte di]

       i. Use the OFFSET operator to get the address of a
          variable or structure. Turbo Debugger automatically
          supplies the [] around a variable name if you just type
          the variable name alone:

            a            contents of structure a
            [a]          contents of structure a
            offset a     address of structure a

       j. You can use the type overrides and the format control
          count to examine any area of memory displayed as you
          wish:

            [byte es:bx],10  10 bytes pointed to by es:bx
            [dword ds:si],4  4 dwords pointed to by ds:si

          This is very useful when specifying watch expressions.

       k. Sometimes you use a word memory location or register to
          point to a paragraph in memory that contains a data
          structure. Access the structure with expressions like

            [abc [xx]:0].mem1
            [abc es:0].mem3

  6. Are there any syntactic or parsing differences between Turbo
     Debugger's C expression evaluation and Turbo C++'s?

     You can't pass constant-string arguments when evaluating
     functions.

       OK:   myfunc(123)   myfunc(string_variable)

       BAD:  myfunc("constant")

  7. Are there any syntactic or parsing differences between Turbo
     Debugger's Pascal expression evaluation and Turbo Pascal's?

     a. Turbo Debugger does not support expressions for set
        constructors:

          OK:   [4..7]

          BAD:  [myvar1..myvar2]   [3+4..7+8]

     b. You can't pass constant-string arguments when evaluating
        functions or procedures.

          OK:   MyFunc(123)   MyFunc(StringVariable)

          BAD:  MyFunc('Constant')

                MyFunc(StringConstant), where StringConstant is
                defined with a "const" declaration and is not a
                typed constant.

     c. You can't evaluate procedures or functions that have
        structure VALUE parameters. You can evaluate procedures or
        functions that have structure VARIABLE parameters, though.

  8. What should I be aware of when I am debugging multilanguage
     programs with Turbo Debugger?

     Turbo Debugger's default source language is "Source," which
     means it chooses the expression language based on the current
     source module. This can cause some confusion if your program
     has source modules written in different languages (like C
     and assembler). Since you are actually entering a language
     expression any time Turbo Debugger prompts you for a value
     or an address, this can cause some unexpected results:

     a. Even if you are in a CPU window or a Dump window, you
        must still enter addresses in the source language,
        despite the fact that the window is displaying in hex.
        For example, to display the contents of memory address
        1234:5678, you must type one of the following
        expressions, depending on your current source language:

          C            0x1234:0x5678
          Pascal        $1234:$5678
          Assembler     1234H:5678H

     b. When your current language is assembler, you must be
        careful when entering hex numbers, since they are
        interpreted EXACTLY as they would be in an assembler
        source file. This means that if you want to enter a
        number that starts with one of the hex digits A - F, you
        must first precede the letter with a 0 so Turbo Debugger
        knows you are entering a number. Likewise, if your
        number ends in B or D (indicating a binary or decimal
        number), you must add an H to indicate that you really want
        a hex number:

          OK:   0aaaa   123dh   89abh

          BAD:  aaaa    123d    89ab

  9. Why does the text "Cannot be changed" come up when I do an
     assignment in the Data/Evaluate/Modify "New value" pane?

     If you use the Data/Evaluate/Modify command (Ctrl-F4) to
     change a variable by direct assignment, the "New value" pane
     will say "Cannot be changed." This doesn't mean the
     assignment didn't take effect. What it does mean is that the
     assignment expression as a whole is not a memory-referencing
     expression whose value you can change by moving to the
     bottom pane. Here are some examples of direct assignment
     expressions:

       C              x = 4
       Pascal         ratio := 1.234
       Assembler      wval = 4 shl 2

     If you had typed just "x," "ratio," or "wval" into the top
     pane, then you would be able to move to the bottom pane and
     enter a new value. The direct assignment method using the
     "=" or ":=" assignment operator is quicker and more
     convenient if you don't care about examining the value of
     the variable before modifying it.

 10. Why does an inspector occasionally display question marks
     when inspecting a Turbo C++ register variable?

     If you inspect a register variable that is not in the
     current scope, you'll see ???? for the value. A register
     variable only displays a value if the register is in your
     current scope (valid at the current location in your
     program).

 11. What is the most likely reason for Turbo Debugger/Profiler to hang
     when starting up on a PC-compatible computer?

     If your computer is a Tandy 1000A, IBM PC Convertible, or
     NEC MultiSpeed, or if TD/TPROF hang when loading on your system,
     run TDINST/TFINST and change an item in the Options\Miscellaneous
     menu so that NMI Intercept is not set. Some computers use the NMI
     (Non-Maskable Interrupt) in ways that conflict with TD/TPROF, so
     you must disable TD's/TPROF's use of this interrupt in order to
     run the program.

     Also, if you are using a 80386-based machine and have the
     SuperKey utility loaded, be careful not to press a key when
     TD386/TF386 are loading, since SuperKey may capture the keystroke
     and cause unexpected results.

 12. What could happen when global breakpoints are set on local
     variables?

     When you set global breakpoints using local variables, make
     sure the breakpoints are cleared before you exit the
     procedure or function that the variables are defined in. The
     best way to do this is to put a breakpoint on the last line
     of the procedure or function. If you do not clear the
     breakpoints, your program will break unexpectedly and may
     even hang on some machines because the breakpoints are being
     set in memory that is not currently being used by the
     procedure or function.

 13. How can I save options set in TDINST to TD286.EXE?

     If you have a configuration file (tdconfig.td) already made for
     TD.EXE, TD286.EXE will automatically use this configuration file.
     You can save a configuration made in TDINST to TD286.EXE directly
     if you state this on the command line. For instance,

       TDINST TD286.EXE

     When you want to save this configuration in TDINST, just select
     Save\Modify td.exe.

 14. Why is execution slower when tracing (F7) than when stepping
     (F8) through my programs?

     Turbo Debugger now has the capability for reverse execution. This
     means that when you are tracing through your program TD is saving
     all the information about the source line you just traced over. If
     you want faster execution you can (F8) step over the instruction or
     toggle the Full History option to 'No' in the Execution History
     window. (Although reverse execution is always available in the CPU
     viewer this option must be toggle to 'Yes' to work in the Module
     viewer.  The default setting is 'No')


*    Common questions about using mouse support in Turbo Debugger 2.5.

Turbo Debugger/Profiler 2.5 provides mouse support that allows you to
manipulate elements within the user interface. The following lists mouse-
related terms to help you become accustomed to using Turbo Debugger's/
Profiler's mouse support.

If you have a mouse driver installed by default, The Debugger, Profiler,
and installation utilities will try to use your mouse. If you do not wish
to use your mouse during a debugging session, you can use the command-line
switch '-p-' to turn the mouse off. This can also be set in TDINST/TFINST
in the Options\Input & prompting dialog box.

Clicking and Dragging
    Most mice provide two or three buttons that allow for various
    functions inside an application. In Turbo Debugger you can,
    among other things, use the left mouse button to select options,
    move items around on the screen, and set breakpoints. The right
    mouse button has some of the same functionality as the left mouse
    button, but you can also open local menus within windows using
    this button. Double clicking the mouse on options in a list will
    select that item. For instance, in the File|Open dialog box you
    can highlight a file by clicking the mouse once on the file
    name. You can load the file by double clicking on the name.
    The commands shown at the bottom of the screen, like F1-Help,
    can also be selected using the mouse. Dragging the mouse consists
    of depressing the mouse button and moving the mouse cursor to a
    new location.

Mouse drivers
    Your mouse driver is the application that you install to make your
    mouse active inside Turbo Debugger and other programs. Most mouse
    drivers will work with Turbo Debugger but may have to be updated
    to a newer version if you are having problems using an older version.
    If you have problems with the mouse once you have loaded TD or
    TDINST, you might try using the Display Swap option that can be
    specified either in TDINST or on the command-line with the -ds
    switch. Consult your mouse manual to ensure proper use of the
    mouse and its driver. Early versions of mouse drivers don't support
    screen display modes larger than 80 columns by 24 lines. As a result,
    your mouse driver might not work correctly when you use Turbo Debugger's
    enhanced display modes EGA 80x43, VGA 80x50, or EGA/VGA graphics modes.

Scroll bars
    Scroll bars, located at the right and bottom of all windows, allow you
    to specify a new position within a window by clicking the mouse on an
    indicator on the scroll bar and dragging it to a new location. Arrows
    located at either end of a scroll bar also allow you to scroll through
    the window when you click and hold the mouse on the arrow heads.

Icons
    An icon is a window that has been shrunk down to a smaller
    representation of the window. These icons can be moved with the
    mouse by clicking on the border of the icon and dragging it to a
    new location. Arrows located at the top right of each viewer allow
    you to zoom and unzoom the viewer when you click the mouse on the
    arrows. When you iconize a window, it is stored at the bottom right
    side of the screen. If any other windows are currently showing at
    this position the icon will be put behind that window. The global
    Window menu allows you to pick from a list of currently open windows.
    This will also take you to an iconized window.

Resize box
    The resize box is located at the bottom right of each window. You can
    click the mouse on the box and drag the mouse to resize the viewer.
    Using the mouse you can also resize the viewer by clicking the mouse
    on the right border of any window and dragging it. Windows and
    inspectors can be moved using the mouse by clicking on the top and
    left borders and dragging the window to a new location. Double clicking
    the mouse on the top border is a short cut to zoom/unzoom the current
    window.

Dialog boxes
    Dialog boxes allow you to select options, specify files to save or
    restore, and choose different settings. You can click the mouse to
    make prompts or panes within the dialog box active. Help for the
    current dialog box is available in by clicking on the Help button
    in the box.

Close buttons
     A Close button is located at the top left of all windows and dialog
     boxes. It lets you close the current window or dialog box when you
     click the mouse on it. If you have entered any information into a
     dialog box and you use the Close button to close it, the settings
     you specified in the dialog box will not be saved. This is the same
     as clicking the mouse on the Cancel button inside a dialog box. You
     must select the OK button in dialog boxes in order to save these
     settings.

Mouse when using Microsoft Windows functions
-	When resetting a program which uses the mouse, mouse clicks
	are not accepted when the program is run until a keyboard
	entry is made.

-	When the mouse driver is disabled for Windows, it will be
	disabled for TDW as well.  Starting TDW with the mouse
	support option (-p) has no effect.



*    Common questions about using Turbo Debugger 2.5 with Microsoft
     Windows

View|Windows Messages
-	If you set up View|Windows Messages to display messages for
	more than one procedure or handle or both, do not log all
	messages.  Instead, log specific messages for each procedure
	or handle.  If you log all messages, the system might hang, in
	which case you will have to reboot to continue.  This behavior
	is due to the large number of messages being transferred between
	Windows and TDW.

-	When setting a break on mouse messages, be aware that a "mouse
	down" message must be followed by a "mouse up" message before the
	keyboard will become active again.  When you return to the
	application, you might have to press the mouse button several
	times to get Windows to receive a "mouse up" messages.  You'll
	know Windows has received the message when you see it in the
	bottom pane of the Windows Message window.

-	If you enter a handle name and indicate that it's a procedure,
	TDW will accept your input and will not complain.  However,
	when you run your program, TDW will not log any messages.  If TDW
	is not logging messages when you think you've set a handle, 
	check to see if you've pressed the Handle button.

View|Module
-	The Debug Startup radio buttons are used for DLLs only.  To
	debug EXE startup, begin TDW with the Assembler-mode Startup
	command-line option (-l).

-	When a program loaded into TDW is reset, the Load symbols radio
	buttons default to YES for all DLLs and applications with symbols. 
	This occurs even if you specified NO for a given DLL or
	application prior to resetting the program.




TASM: TURBO ASSEMBLER 2.5: ANSWERS TO COMMON QUESTIONS
------------------------------------------------------

  The following are tips, tricks, and hints you may find useful
  when using Turbo Assembler.


 Q. How do I install Turbo Assembler?
 A. Run the INSTALL program from the TURBO ASSEMBLER/INSTALLATION
    disk. To start the installation, change your current drive to
    the one that has the install program on it and type INSTALL.
    You will be given instructions in a box at the bottom of the
    screen for each prompt. For example, if you will be
    installing from drive A:, type

      A:
      INSTALL

    At this point, the INSTALL program will appear with menu
    selections and descriptions to guide you through the
    installation process.

 Q. When should I use the different assembly modes TASM provides
    for existing assembly programs?
 A. Mode                   Conditions for Use
    -------------------------------------------------------------
    Normal(MASM)         - Program assembles under MASM 4.00 or
                           MASM 5.00.
    Quirks               - Program assembles under MASM 4.00 or
                           MASM 5.00, but won't assemble under
                           TASM without MASM51 or QUIRKS.
    Masm51               - Program requires MASM 5.1 for assembly.
    Masm51 and Quirks    - Program requires MASM 5.1 for
                           assembly, but will not assemble
                           under TASM with only the MASM51
                           switch set.

 Q. Do I have to use MASM51 to assemble files written for MASM
    5.1?
 A. Most files will assemble even without using the MASM51
    directive. However if your assembly code utilizes features
    only found in MASM 5.1, you will need to use the MASM51 mode.
    Check the table in the next Q&A to see which features of MASM51
    emulation are enabled by combinations of MASM51 and QUIRKS
    modes.

 Q. What items are controlled by the QUIRKS and MASM51 modes?
 A. The following table lists what the various combinations of
    QUIRKS and MASM51 modes do:

    Mode                   Operations
    -------------------------------------------------------------
    Quirks               - Allows FAR jumps to be generated as
                           NEAR or SHORT if CS assumes agree.
                         - Allows all instruction sizes to be
                           determined in a binary operation solely
                           by a register, if present.
                         - Destroys OFFSET, segment override,
                           etc., information on '=' or numeric 'EQU'
                           assignments.
                         - Forces EQU assignments to expressions
                           that contain "PTR" or ":" to be text.

    Masm51               - Instr, Catstr, Substr, Sizestr, and
                           "\" line continuation are all enabled.
                         - EQU's to keywords are made TEXT
                           instead of ALIASes.
                         - Leading whitespace is not discarded
                           on %textmacro in macro arguments.

    Masm51 and Quirks    - Everything listed under QUIRKS above.
                         - Everything listed under MASM51 above.
                         - @@, @F, and @B local labels are
                           enabled.
                         - Procedure names are PUBLIC'ed
                           automatically in extended MODELs.
                         - Near labels in PROCs are redefinable
                           in other PROCs.
                         - "::" operator is enabled to define
                           symbols that can be reached outside of
                           current proc.

    Masm51 and Ideal     - Ideal mode syntax and the Masm51 text
                           macro directives are supported, i.e.,
                           Instr, Catstr, Substr, and Sizestr.

  Q. When should I use the DOSSEG or .STACK directives?
  A. When you're developing Turbo Assembler modules to link with
     high-level languages like Turbo C++ and Turbo Pascal, you
     don't need the DOSSEG or .STACK directives because these
     compilers will handle segment-ordering and stack setup.
     These directives define segment names and order that might
     conflict with those used by the high-level language. You
     only need, however, to define these once in any module of a
     standalone assembler program. DOSSEG is only needed if you
     want your segments to be ordered using Microsoft's
     conventions. You can define your own segment-ordering by
     ensuring that your segments are encountered by TLINK in the
     order that you wish. See the TLINK section of the manual for
     a full description of how this works.

  Q. What options should I use when I use Turbo Assembler to
     assemble the files that came with the Microsoft C Compiler?
  A. When assembling the assembly language modules provided with the
     Microsoft compilers, make sure to use the MASM51 and QUIRKS
     modes. For example,

       tasm /jmasm51 /jquirks filename

  Q. How do I create a .COM file?
  A. Your assembler source should be assembled in the tiny model
     (.MODEL TINY) and should include an ORG 100h following the
     opening of the code segment, as shown below:

                .MODEL  TINY
                .CODE
                ORG     100h
        start:
                ....          ; body of program
        END     start         ; defines the entry point as start

     Don't include a .STACK directive in a program designed to be
     a .COM.

     TLINK will create a .COM file instead of an .EXE file if the /t
     option is specified. For example,

        tlink /t SHOW87

     will create SHOW87.COM instead of SHOW87.EXE.

     There are certain limitations in converting an .EXE file to a
     .COM file. These limitations are documented in the IBM Disk
     Operating System manual under EXE2BIN.

  Q. How do I assemble multiple files with Turbo Assembler?
  A. Turbo Assembler will assemble multiple files using wildcard
     characters or separating them by the plus (+) character.
     As an example, the following command line

       tasm filt + o*

     would assemble the file FILT.ASM, as well as all the .ASM
     files beginning with the letter 'o'.

  Q. How can I assemble multiple files if they don't all use the
     same command-line options?
  A. Turbo Assembler uses the semicolon (;) character as a
     command-line separator so that you can actually have
     multiple assembler command lines on a single DOS command
     line. As an example, the following command line

       tasm /zi filt; o*

     would assemble the file FILT.ASM with debug information
     turned on, then assemble all the .ASM files beginning with
     the letter 'o' without debug information.

  Q. Microsoft's Macro Assembler allows me to define environment
     variables so I don't have to enter them on every command
     line. Can I do this with Turbo Assembler as well?
  A. No, but Turbo Assembler provides an even more flexible way
     to eliminate typing in command-line options every time.
     Whenever you run Turbo Assembler, it looks in the current
     directory, then in the directory from which it was started
     (DOS 3.x and greater) for a special file called TASM.CFG.
     This file can contain anything that the command line
     contains. This file is processed first and then the command
     line so that the command-line options take priority over
     those found in the TASM.CFG configuration file. If, for
     instance, your command-line options are always

       /t /ml /zi /jJUMPS /jLOCALS

     you could create TASM.CFG file containing these lines

       /t
       /ml
       /zi
       /jJUMPS
       /jLOCALS

     Now, every time you run Turbo Assembler, those will be the
     default options. This means that, if you need to, you can
     have separate TASM.CFG files for each of your projects. If
     you have multiple projects residing in a single subdirectory,
     then you could create a separate configuration file for each
     and use them as Turbo Assembler indirect command files.

  Q. What are Turbo Assembler indirect command files?
  A. These are files that contain partial or complete Turbo
     Assembler command lines and are preceded with an at-sign (@)
     on the command line. For example, if you have a file named
     "FILE.CMD" that contains the following,

       /t
       /ml
       /zi
       /jJUMPS
       /jLOCALS
       file1 +
       file2 +
       file3 +
       file4

     then you could use the command line

       tasm @FILE.CMD

     instead of the command line

       tasm /t /ml /zi /jJUMPS /jLOCALS file1+file2+file3+file4

     Note that the at-sign (@) is not actually part of the file's
     name. In fact, if you name a file with an at-sign at the
     beginning, Turbo Assembler will treat it as an indirect
     command file.

  Q. I am linking my own assembly language functions with Turbo C.
     Why does the linker report that all of my functions are
     undefined?
  A. Make sure you've put an underbar character (_) in front
     of all assembly language function names to be called
     by Turbo C. If you use simplified segmentation and include
     the C language specifier on the .MODEL directive, Turbo
     Assembler will pre-append the underbar automatically for you.
     Your assembly language program should be assembled with Case
     Sensitivity (/ML or /MX). See Chapter 7, "Interfacing
     Turbo Assembler with Turbo C" in the Turbo Assembler User's
     Guide for details.

  Q. Can I use the backslash (\) instead of the slash (/) as a
     option specifier?
  A. NO! Turbo Assembler (and MASM) will treat that as a file
     that resides in the root directory of the default drive.
     Since both assemblers treat the space character ( ) as a
     comma (,) this could result in the loss of files. If you
     accidentally gave this command line,

      tasm \zi prid&joy.asm

     Turbo Assembler (and MASM) would treat this command line as
     instructions to assemble a file called ZI.ASM that can be
     found in the root directory and create an output file in the
     current directory called PRID&JOY.ASM. (Note that the
     assemblers think the default extension for the object file
     of .OBJ has been explicitly overridden to .ASM.) The file
     PRID&JOY.ASM will either be overwritten with the object file
     or deleted if the file \ZI.ASM can't be found and success-
     fully assembled. In either case, the original contents of
     PRID&JOY.ASM are now lost.

/**************************** END OF FILE ********************************/

