• IBM PC XT, AT, PS/2 or compatible computer
• MS-DOS 2.0 or later
• At least 256K of memory

Article: Borland goes for Code Pros ComputerWorld August 29, 1988

Borland Languages Advertisement w/ TASM 1.0 InfoWorld September 9, 1988

Article: Turbo Debugger and Turbo Assembler 1.0 InfoWorld September 12, 1988

Article: Borland Unveils New Programmers Tools InfoWorld September 22, 1988

Article: TASM, Debugger: Innovative Software, Unworthy Documentation PC Magazine November 15, 1988

Article: Borland Disputes Microsoft's Assembler Benchmark Claim InfoWorld - February 6, 1989

TASM 1.0

• Listing files generated with /LA will now contain the mnemonics for the opcodes inserted as a result of the use of high level language directives. The listing is changed only for things that actually generate code such as the first instruction of a PROC with arguments. The listing of things such as .MODEL, .CODE, and other instructions that do not actually generate any code will not be changed. /LA also overrides other directives that turn off listing. If certain parts of listing need to be supressed use /L instead of /LA.
• If a string is defined with a DB instruction, and a comma is the last thing on the line, a null byte will be assumed at the end of the string. A warning will be generated. For example:
  

  db 'ABCDEF',
  

  will generate the following, with a warning "Trailing null assumed"

  41 42 43 44 45 46 00
  

• If a structure instance does not have any initializer specified the "Trailing null assumed" warning will be generated. No extra zeros are placed in the emitted code.
• Segment alignment and padding now match MASM.
• Confusion about certain features of TYPE used in IDEAL mode should be cleared up by the following addition to the manual:
  

     Function  Returns a number indicating the size of a symbol
               (Masm mode), or returns the type of a  symbol 
               (Ideal mode)
  
     Mode      MASM, Ideal
  
     Syntax    Masm mode: TYPE <expression>
               Ideal mode:  TYPE <symbol>
  
     Remarks   Masm mode:
               (Keep discussion as exists now)
  
               Ideal mode:
                   TYPE is used to get the type of an
                   existing symbol.  In Ideal mode, this
                   operation can only be used where a type
                   specifier is needed.
  
     Example   Masm mode:
                   (Keep discussion as exists now)
  
               Ideal mode:
  
                   ideal
  
                   ...
  
                   bvar    db 1    ;Byte storage.
                   tempvr  dt ?    ;Scratch area.
  
                   ...
  
                   mov     [bvar],0 ;Clear byte variable.
                   mov     [type bvar ptr tempvr],0
                                    ;Clear scratch area of 
                                    ;same size.
                                    ;Equivalent to 'BYTE PTR'.
  

• TED.ASM from PCMAGNET will now assemble and link properly. Be sure to use the /t switch with TLINK to produce a .COM file.
• Existence of ">" character within a string passed to IFB macro directive causes TASM 1.0 to report that extra characters are on line. This will now be handled without an error if QUIRKS directive is used. All characters past the embedded ">" will be ignored.
• Colons within label names passed to IFDEF macro directive are now ignored if QUIRKS directive is used. All characters past the colon are ignored.
• In tiny model programs, all registers should be pointing to the same DGROUP. If unwanted SS: overrides occur when referencing variables in the DGROUP, use the statement ASSUME SS:NOTHING to causes CS: overrides to be used.
• [bytepointer.com edit] The PUBLICDLL directive appears in the binary and it assembles without error, although the feature is not officially available until version 2.0.

Turbo Assembler  Version 2.0  Copyright (c) 1988, 1990 Borland International

Assembling file:   ver_dos.ASM
Error messages:    None
Warning messages:  None
Passes:            1
Remaining memory:  475k

• PUBLICDLL directive:
  The PUBLICDLL directive lets you define program labels and procedures to be dynamic link entry points as well as publicizing them to your other modules, which allows you to build dynamic link libraries in assembly code.
  [bytepointer.com edit] Support unofficially available in version 1.01, but first documented here. This is an IDEAL mode only directive.
• Multiple pass capability - NOP removal:
  Turbo Assembler 2.0 can pass over your source code more than once either for compatibility with some of MASM's pass-dependent constructions or to remove NOP instructions that were added to the code because of forward references. This feature is enabled by the command-line switch /m#, where # is the maximum number of passes allowed. Turbo Assembler automatically assesses the need to perform extra passes up to the maximum that you specify.
• CALL extensions:
  The CALL instruction has been extended in Turbo Assembler to allow high-level language routines to be called in a language-independent manner. Any CALL instruction can now specify a language and an argument list for the routine being called. Turbo Assembler automatically generates the necessary stack setup and cleanup code required to pass the arguments to a high-level routine written in the specified language.
• PUSH, POP instruction extensions:
  The PUSH and POP instructions have been extended in Turbo Assembler to allow more than one argument to appear in a single PUSH or POP instruction. For example,
  

      push ax dx       ;equivalent to PUSH AX then PUSH DX
      pop  dx ax       ;equivalent to POP DX then POP AX
  

  In addition, the PUSH instruction allows constant arguments even when generating code for the 8086 processor. Such instructions are replaced in the object code by a 10-byte sequence that simulates the 80186/286/386 PUSH immediate value instruction.
• COMM extension:
  The COMM directive has been extended to allow the array element size and the array element count to be selected independently of each other for FAR communal variables. This supports Turbo C++'s inline code generation, and can be used advantageously by a native assembly language programmer.
• Generalized line-continuation character:
  In TASM 2.0, a line-continuation feature has been added that works in TASM's Ideal mode and is available even when the MASM 5.1 mode is off. A backslash (\) can be placed almost anywhere as a line-continuation character. It cannot be used to break up strings or identifiers. Its meaning is "read the next line in at this point and continue processing." It can thus be used in a natural way without losing the ability to comment each line as desired.
• Language-specific procedures, extrns, publics:
  TASM 2.0 allows procedures, publics, extrns, and calls to be overridden with a language specifier. This causes wide flexibility in writing assembler code that interfaces with multiple language models. The MODEL statement has also been extended.
  [bytepointer.com edit] Binary analysis suggests that the language modifier keyword "ASSEMBLER" was renamed to "NOLANGUAGE" in this version.
• New MODEL language modifier - WINDOWS:
  Example:

      .MODEL large,windows pascal
      .code
  
      foo proc
      arg abc:word,def:word
              xor ax,ax       ;Generates FAR WINDOWS PASCAL sequences.
              ret
      endp
  
      foo proc normal c
      arg ghi:word,jkl:word
              xor ax,ax       ;Generates FAR NORMAL C sequences.
              ret
      endp
  

  [bytepointer.com edit] This modifier was an important feature for 16-bit Windows programming. It allowed the declaration of a high-level FAR PROC for a 16-bit Windows callback function; something never supported by MASM (without the use of additional includes). The User's Guide describes the modifiers as follows:
  
  
  [The language modifier of the model directive is used] to specify additional prolog and epilog code when you write procedures for Windows, or for the Borland Overlay loader.
  
  Barry Kauler's book, "Windows Assembly Language and Systems Programming" describes the WINDOWS qualifier as:
  
  
  The WINDOWS qualifier takes care of generation of the special prolog and epilog required for a [16-bit Windows 3.x] callback function.
  ...
  ...only applies to 16-bit TASM applications.
  
  The WINDOWS qualifier was never supported in MASM. To get the same result in MASM, one had to include CMACROS.INC and PROLOGUE.INC and enable the OPTION PROLOGUE/EPILOGUE features. For reference, Barry Kauler's book provided the prologue and epilogue code sequences the WINDOWS language modifier causes the assembler to generate:
  

      push ds    ;prologue for Windows 16-bit callback function
      pop ax
      nop
      inc  bp
      push bp
      mov  bp,sp
      push ds
      mov  ds,ax
      ...
      dec  bp    ;epilog for Windows 16-bit callback function
      dec  bp
      mov  sp,bp
      pop  ds
      pop  bp
      dec  bp
      ret  10
  

• Virtual segments:
  A new keyword VIRTUAL has been added to the SEGMENT statement. VIRTUAL defines a special kind of segment that will be treated as a common area and attached to another segment at link time.
• QASM Compatibility Additions:
  TASM 2.0 has new and modified directives to support source code for QASM:
  
  .STARTUP and STARTUPCODE
  These commands generate startup code for the particular model in effect at the time. These also define the near label @@Startup and cause the END statement at the end of the module to generate the equivalent of 'END @@Startup'. Note that only the 'STARTUPCODE' directive is available in IDEAL mode.
  
  .MODEL and MODEL
  It is now possible to select a third field in the .MODEL statement to specify the stack association with DGROUP: NEARSTACK or FARSTACK. For example, .MODEL SMALL,C,FARSTACK would specify that the stack not be included in DGROUP. This capability is already provided in TASM through the language modifiers of the same name. The additional field is provided only for MASM compatibility.
  
  Two new predefined variables have been added:
  
  
  @Startup: Defined by the .STARTUP and STARTUPCODE directives
  @Model: An integer representing the model currently in effect.
  

      0 = TINY   1 = SMALL    2 = COMPACT    3 = MEDIUM
      4 = LARGE  5 = HUGE
  

• New Intel 486 (80486) directives:
  
  
  • .486,.486c,.486p (MASM mode only)
  • P486N - Enables assembly of non-protected instructions for the 486 processor.
  • P486 - Enables assembly of protected instructions for the 486 processor.
• New Intel 486 (80486) instructions:
  
  

  BSWAP <32-bit register>	- 486 byte swap instruction.
  XADD <r/m>,<reg>	- 486 exchange and add instruction.
  CMPXCHG <r/m>,<reg>	- 486 compare and exchange instruction.
  INVD	- 486 invalidate data cache instruction.
  WBINVD	- 486 write back and invalidate data cache inst.
  INVLPG <memptr>	- 486 invalidate TLB entry for address inst.

• New test registers:
  
  
  • TR3
  • TR4
  • TR5
• New error messages:
  
  • Global type doesn't match symbol type
  • Illegal segment address
  • Module is pass-dependent--compatibility pass was done.
  • Near jump or call to different CS
  • Only one startup sequence allowed
  • Smart code generation must be enabled
  • Text macro expansion exceeds maximum line length
  • USES has no effect without language
• CODEPTR type:
  CODEPTR returns the default procedure address size depending on the current model (WORD for models with NEAR code; DWORD for models with FAR code). CODEPTR can be used wherever DATAPTR is used. Here is its syntax:

      CODEPTR expression
  

• RETCODE instruction:
  The RETCODE instruction is exactly equivalent to RETN or RETF, depending on the specified model. RETCODE syntax follows:

      RETCODE {<expression>}
  

  RETCODE is available in both MASM and Ideal modes.
• SMART/NOSMART directives:
  The SMART/NOSMART directives control the generation of optimized object code. These are the areas that the SMART and NOSMART directives apply to:
  
  
  1. OR, AND, or XOR of a signed immediate byte
  2. PUSH <constant>
  3. PUSH <large pointer>
     POP <large pointer>
  4. CALL <far address in same segment>
  5. JMP <far address in same segment>
  6. LEA <constant effective address>
  The default condition is SMART enabled. When SMART is enabled, a qualifying FAR jump will be replaced by a NEAR or a SHORT jump. Also, when SMART is enabled, a qualifying FAR call will be replaced by a PUSH CS instruction and a NEAR call.
  
  When NOSMART is selected, the following code generation changes occur:
  
  
  • AND, OR, XOR of an immediate word value are no longer done using the signed-extended immediate byte version of these instructions where possible, but rather the longer immediate word version that MASM uses.
  • PUSH of a constant value on the 8086 processor using the special 10-byte code sequence (which preserves all registers and flags) is not allowed.
  • PUSH and POP of a DWORD memory variable (or PWORD variable on a 386) are not allowed.
  • Far JMPs and CALLs within the same segment are no longer optimized by replacing the FAR JMP or CALL with the NEAR version.
  • LEA instructions that refer to a constant effective address will no longer be converted to the equivalent MOV operations.
  For maximum MASM compatibility, you must select NOSMART and QUIRKS.
• Overlay object code:
  Turbo Assembler 2.0 supports overlays. Specifying the /o switch on the command line causes overlay- compatible fixups to be generated. When this switch is used, 386 references to USE32 segments should not be made since they won't link properly.
• Updated QUIRKS mode list:
  The following apply to QUIRKS mode:
  
  • NEAR or SHORT jumps are generated even if FAR is specified, if source and destination segments are the same.
  • Type checking for some two-argument instructions is disabled, for example, MOV ES,BYTEPTR is allowed.
  • Forces an EQU to an expression with PTR in it to be a text macro.
  • Forces an EQU to an expression with : in it to be a text macro.
  • Forces an EQU to an expression with OFFSET in it to be a text macro.
  • Forces SHL operator to lose track of sign info.
  • Forces numeric equates (= or numeric EQU) to lose complex expression information such as segment, fixup type.
  • Reduces priority of GLOBAL, UNION keywords so that they may be overridden.
  • Causes warning instead of error to be generated if the second argument is missing in a two-argument instruction.
  • Allows REPT without argument to be interpreted as REPT 0.
  • Disables test for extra stuff on line after IF conditional.
  The following apply to QUIRKS with MASM51:
  
  • @@, @F, and @B are enabled.
  • Trailing language ID after NEAR or FAR in procedure declaration is allowed.
  • All procedure symbols are published globally.
  • :: label definitions are allowed.
• Command Line Options Added:
  [bytepointer.com edit] Some of these explained above.
  
  

  /mv#	- Set maximum valid length for symbols
  /m#	- Allow # multiple passes to resolve forward references
  /o,/op	- Generate overlay object code, Phar Lap-style 32-bit fixups
  /q	- Suppress OBJ records not needed for linking

• Language_modifier Keywords Added:
  [bytepointer.com edit] The following keywords were found to be new in this version by binary analysis, but undocumented in the changelists; they were all language modifiers in addition to the documented WINDOWS keyword.
  
  
  • NORMAL (u)
  • ODDNEAR (u) - used in connection with the VROOM overlay manager
  • ODDFAR (u) - used in connection with the VROOM overlay manager
  The description below came from the TASM 4.0 User's Guide:
  
  
  Use language_modifier to specify additional prolog and epilog code when you write procedures for Windows, or for the Borland Overlay loader. These options are: NORMAL, WINDOWS, ODDNEAR and ODDFAR. If you don't specify an option, Turbo Assembler assumes the default to be NORMAL.
  ...
  The ODDNEAR and ODDFAR language modifiers are used in connection with the VROOM overlay manager. VROOM has'two modes of operation: oddnear and oddfar. You can use the Ila switch option on the Turbo Assembler command line to see the prolog and epilog code that these language modifiers produce.
• New Warning Class Identifiers:
  
  
  • GTP (u) - Global type doesn't match symbol type
  • MCP (u) - MASM compatibility pass
• Possible Undocumented-Feature Keywords:
  
  
  • CALLPROC (u)

Article: Turbo Tools from Borland Highlight Conference InfoWorld February 12, 1990

Article: Three Turbo- charged Programming Tools from Borland PC Magazine September 11, 1990

TASM 2.0 Manuals

• Command Line Options Deleted:
  The /ks# option (String space capacity) was removed. This was previously on the same line with the /kh option (Hash table capacity) which now reads "Hash table capacity # symbols".

• Beta Feature Instructions?:
  [bytepointer.com edit] Binary analysis showed the presence of the following instructions, which were not officially supported until version 2.5, but will assemble without error in this version:
  
  
  • ENTERW (u)
  • ENTERD (u)
  • LEAVEW (u)
  • LEAVED (u)
• New Segment Alignment Attribute
  
  
  • MEMPAGE (u) - Start a segment on the next memory page (4Kb aligned) address.
• New Segment Access Attributes
  
  
  For any segment in protected mode, you can control access so that certain kinds of memory operations are not permitted. (Note that this feature is currently supported only by the Phar Lap linker. You must generate object code compatible with it using the /op switch if you want to be able to use the segment access attribute.) The segment access attribute tells the linker to apply specific access restrictions to a segment. The legal values for this attribute are listed below.
  
  
  • EXECONLY (u) - the segment is executable only
  • EXECREAD (u) - the segment is readable and executable
  • READONLY (u) - the segment is readable only
  • READWRITE (u) - the segment is readable and writable
• New Memory Model
  
  
  • TCHUGE (u) - this is the recommended memory model (for use with .MODEL directive) when linking with modules built with the Borland C++ huge memory model; this is the same as the LARGE model, but with different segment register assumptions.
• New Error Message (u) - "32-bit value truncated to 16 bits"

• Introduction of TASMX.EXE (DOS Protected Mode Assembler):
  [bytepointer.com edit] This appears to be the first version distributed with TASMX.EXE, designed for assembling 16 and 32-bit binaries. The Borland C++ 2.0 README described TASMX.EXE as follows:
  
  
  Two versions of Turbo Assembler have been provided. TASMX.EXE can be run from the Windows DOS prompt, and takes advantage of the DOS Protected Mode Interface (DPMI) that Windows 3.0 provides. This allows the assembler to take advantage of Windows' memory management and to dramatically increase capacity. TASM.EXE uses standard DOS memory, and is provided for operation in environments without DPMI support such as DOS and the non-386 enhanced modes of Windows.
  ...
  In order to take advantage of DPMI support feature, you must be running Windows in 386 enhanced mode.
  ...
  Enhanced mode is not available when Windows 3.0 is run on processor less than a 386.) Also, DPMILOAD.EXE must be somewhere in your path.
  ...
  TASMX is not designed to be a Windows application, so you must enter a Windows 3.0 DOS prompt to use TASMX. Then to use TASMX, just type TASMX wherever you would normally type TASM. All command-line options are the same as the previous version of TASM. When run within the Windows 3.0 DOS prompt, TASMX will be able to use almost all the free memory in the system, if neccessary, for assembling large programs.
  ...
  TASM 2.5 will still run without Windows 3.0 DPMI. If DPMI support is not found, you must have TASM.EXE somewhere in your path. Then if you load TASMX, it will run TASM.EXE within the normal 640K DOS environment. Turbo Assembler will not be able to assemble programs larger than normal without DPMI support.
  ...
  We encourage you to try TASMX on all your assembler source code, both from the normal DOS prompt and from within a Windows 3.0 DOS prompt. TASMX should be able to handle all programs that work properly with TASM 2.01.


• New Instructions (available in 2.02, but official in this version):
  
  
  • ENTERD
  • LEAVED
  • ENTERW
  • LEAVEW
  Additional 80386 ENTER and LEAVE instructions:
  Use the ENTER and LEAVE instructions for setting up and removing a procedure's frame on the stack. Depending on whether the current code segment is a 32-bit segment or a 16-bit segment, the standard ENTER and LEAVE instructions will modify either the EBP and ESP 32-bit registers, or the BP and SP 16-bit registers. These instructions might be inappropriate if the stack segment is a 32-bit segment and the code segment is a 16-bit segment, or the reverse.
  
  Turbo Assembler provides four additional instructions that always select a particular stack frame size regardless of the code segment size. The ENTERW and LEAVEW instructions always use BP and SP as the stack frame registers, while the ENTERD and the LEAVED instructions always use EBP and ESP.

• Directives:
  
  
  • VERSION:
    The VERSION directive allows you to emulate a specific version of Turbo Assembler or MASM you've written particular modules for. This is helpful for upward and downward compatibility of various versions of TASM and MASM. The VERSION directive also puts you into the operating mode for the specified version. You can specify the VERSION directive as either a command-line switch (/u) or within the source code. Previous versions of Turbo Assembler controlled MASM compatibility with directives such as MASM51, NOMASM51, QUIRKS, SMART, and NOSMART. The VERSION directive supersedes these older directives.
    
    
    • M400 - MASM 4.0
    • M500 - MASM 5.0
    • M510 - MASM 5.1
    • M520 - MASM 5.2 (Quick Assembler)
    • T100 - Turbo Assembler 1.0
    • T101 - Turbo Assembler 1.01
    • T200 - Turbo Assembler 2.0
    • T250 - Turbo Assembler 2.5
    • T300 - Turbo Assembler 3.0
  • GOTO:
    Using macro tags and the GOTO directive lets you control the sequence in which lines within the macro body expand. You can place a macro tag at any place within the macro body. The tag occupies an entire line in the macro, with the following syntax:
    

        :tag_symbol
    

    When the macro expands, all macro tags are discarded. The GOTO directive tells the assembler to go to a specified point in your code, namely the tag_symbol. GOTO has the following syntax:
    

        GOTO tag_symbol
    

    GOTO also terminates any conditional block that contains another GOTO. This lets you place GOTO inside conditional assembly blocks. For example,
    

        IF foo
           GOTO tag1
        ENDIF
           DISPLAY "foo was false!"
       :tag1
                  ;resume macro here...
                  ;works the same whether foo was false or true
    

    NOTE: Be careful not to create infinite macro loops when you use the GOTO directive. Infinite loops can cause Turbo Assembler to run out of memory, or even appear to stop functioning.
  • TYPEDEF:
    Named types represent simple or complex types. You can use the TYPEDEF directive to define named types. Here's the Ideal mode syntax:
    

       TYPEDEF type_name complex_type
    

    The MASM mode syntax is:
    

       type_name TYPEDEF complex_type
    

    complex_type describes any type or multiple levels of pointer indirection. type_name is the name of the specified type. When you use a named type in an expression, it functions as if it were a simple type of the appropriate size. For example,
    

           MOV ax,word ptr [bx]    ;Simple statement;
        foo TYPEDEF near ptr byte     ;FOO is basically a word
           MOV ax,foo ptr [bx]     ;so this works too
    

  • ENUM:
    An enumerated data type represents a collection of values that can be stored in a certain number of bits. The maximum value stored determines the actual number of bits required. Here is the Ideal mode syntax for declaring an enumerated data type:
    

        ENUM name [enum_var [,enum_var...]]
    

    You can use the following syntax in MASM mode:
    

        name ENUM [enum_var [,enum_var...]]
    

    The syntax of each enum_var is:
    

        var_name [=value]
    

    Turbo Assembler will assign a value equal to that of the last variable in the list plus one if value isn't present when you assign the specified value to the variable var_name. Values can't be relative or forward referenced. Variables that ENUM created are redefinable numeric variables of global scope. name is the name of the ENUM data type. You can use it later in the module to obtain a variety of information about the values assigned to the variables detailed. You can also use enumerated data type names to create variables and allocate memory.
    
    Enumerated data types are redefinable. You can define the same name as an enumerated data type more than once in a module. Turbo Assembler provides a multiline syntax for enumerated data type definitions requiring a large number of variables. The symbol { starts the multiline definition, and the symbol } stops it. The Ideal mode syntax follows:
    

        ENUM name [enum_var [,enum_var...]] {
        [enum_var [,enum_var]...]
        .
        .
        .
        [enum_var [,enum_var]...] }
    

    You can use the following syntax in MASM mode:
    

        name ENUM [enum_var [,enum_var...]] {
        [enum_var [,enum_var]...]
        .
        .
        .
        [enum_var [,enum_var]...] }
    

    For example, all of the following enumerated data type definitions are equivalent:
    

        foo ENUM  fl,f2,f3,f4       ;Original version
        foo ENUM {                  ;Multiline version
             fl
             f2
             f3
             f4
             }
    
       foo ENUM fl,f2,{             ;More compact multiline version
           f3,f4}
    

    Beware: If you use the same variable name in two enumerated data types, the first value of the variable will be lost and errors could result.
    
    NOTE: Turbo Assembler doesn't recognize any pseudo ops inside the multiline enumerated data type definition.
    
    You can create an instance of an enumerated data type by using the name of the enumerated data type as a data allocation directive. For example, assume you have defined the following:
    

        ETYPE ENUM FEE,FIE,FOO,FUM
    

    Then the statement
    

                    
       ETEST ETYPE ?
    

    would create an instance of the enumerated data type etype (defining the variable etest). In this example, no initial data is emitted to the current segment because the ? uninitialized data value is specified. Enumerated data type instances are always either a byte, a word, or a doubleword, depending on the maximum value present in the enumerated data type definition.
    
    You can use any expression that evaluates to a number that will fit within the enumerated data type instance; for example,

                    
        ETYPE ?     ;uninitialized instance
        ETYPE FOO   ;initialized instance, value FOO
        ETYPE 255   ;a number outside the ENUM that also fits
    

  • SMALLSTACK and LARGESTACK directives:
    A procedure's prolog and epilog code manipulates registers that point into the stack. On the 80386 or 80486 processor, the stack segment can be either 16 bits or 32 bits. Turbo Assembler therefore must know the correct size of the stack before it can generate correct prolog and epilog code for a procedure. The stack size is automatically selected if you selected a standard model using the MODEL statement. Turbo Assembler provides directives that can set or override the default stack size for procedure prolog and epilog generation. The following table lists these directives.
    
    

    SMALLSTACK	- Indicates that the stack is 16 bit
    LARGESTACK	- Indicates that the stack is 32 bit

    
    
  • TBLINST:
    The virtual method table (VMT) is a table of addresses of the procedures that perform virtual methods. Usually this table is placed in the program's data segment. Any object having virtual methods requires an instance of the VMT somewhere in the program. A number of factors determine the proper placement of this table, including what program model you're using, whether you want near or far tables, and so forth. Use the TBLINST directive to create the instance of the VMT for an object. Since this directive creates a table for the most recently declared object, you should place this directive immediately after the object declaration, as in the following:
    

        INCLUDE list.aso
        DATASEG
        TBLINST
    

    TBLINST defines @TableAddr_<object_name> as the address of the virtual table for the object. It is equivalent to
    

        @TableAddr_<object_name> @Table_<object_name> {}
    

  • TBLINIT:
    Simply creating the instance of the VMT is not enough to let you make calls to virtual methods. Every object with virtual methods includes a pointer to the VMT in its data structure. You must initialize this pointer whenever you create an instance of an object, and can use TBLINIT to do so. The syntax of the TBLINIT instruction is
    

       TBLINIT object_instance_pointer
    

    The object_instance_pointer field is the address of the object whose virtual table pointer is to be initialized. The TBLINIT instruction assumes that the object instance should be of the current object type (in other words, the immediately preceding object definition determines the object type that TBLINIT initializes). For example,
    

                    
        TBLINIT DS:SI
    

    would initialize the virtual table pointer of the object at DS:SI, if it has one.
    
    The following example initializes the VMT pointer in an object's init method:
    

        ;Initialize a Linked List object.
        ;This is the method "init".
        ;This must be a static method!
        list_init PROC PASCAL FAR
        ARG @@list:dword
        USES ds,bx
             lds bx,@@list
             ;-- Initialize any virtual method table for the object at ds:bx
             TBLINIT ds:bx
             ;-- Initialize the object's data --
             ;;<<initialize any data for the object here...>>
             ret
        ENDP
    

    Notice that the init method must be static because you can't call a virtual method for an object instance until after you initialize the virtual table pointer.
    
    Note that you can use the TBLINST and TBLINIT directives even when there are currently no virtual methods in the object; in that case, no action is taken. It is therefore recommended to using the TBLINST and TBLINIT directives regardless of whether virtual methods are currently present in an object: Place the TBLINST directive in an appropriate data segment and the TBLINIT directive in the object's initialization method (which must be a static method). You must call this method before using any other methods for the object.
  • TBLPTR:
    Inherent in the idea of objects is the concept of the virtual method table. An instance of this table exists once for any object having virtual methods. The data structure for any object having virtual methods also must contain a pointer to the virtual method table for that object. Turbo Assembler automatically provides a virtual method table pointer in an object's data structure (if required) and if you don't specify it explicitly using the TBLPTR directive. You should use the TBLPTR directive within an object data structure definition. TBLPTR lets you explicitly locate the virtual table pointer wherever you want. Here's its syntax:
    

        TBLPTR
    

    The size of the pointer that TBLPTR reserves is determined by whether the current model is USE16 or USE32, and what modifiers you used in the object definition.
  • TABLE:
    A table data type represents a collection of table members. Each member has a specific size (in bytes) and an initial value. A table member can be either virtual or static. A virtual member of a table is assigned an offset within the table data type; space is reserved for it in any instance of the table. A static member does not have an offset; space isn't reserved for it in an instance of the table. The size of the table data type as a whole is the sum of the sizes of all of the virtual members. Table data types represent method tables, used in object-oriented programming. An object usually has a number of methods associated with it, which are pointers to procedures that manipulate instances of the object. Method procedures can either be called directly (static methods) or indirectly, using a table of method procedure pointers (virtual methods). You can use the following Ideal mode syntax for declaring a table data type:
    

                    
        TABLE name [table_member [,table_member...]]
    

    The following syntax works only in MASM mode:
    

                    
        name TABLE [table_member [,table_member...]]
    

    Here's the syntax of each table_member field:
    

        table_name
    

    or
    

                    
        [VIRTUAL] member_name [[count1_expression]]
            [: complex_type [:count2_expression]] [= expression ]
    

    table_name is the name of an existing table data type whose members are incorporated entirely in the table you define. Use this syntax wherever you want inheritance to occur. member_name is the name of the table member. The optional VIRTUAL keyword indicates that the member is virtual and should be assigned to a table offset. complex_type can be any legal complex type expression. If you don't specify a complex_type field, Turbo Assembler assumes it to be WORD (DWORD is assumed if the currently selected model is a 32-bit model). count2_expression specifies how many items of this type the table member defines. A table member definition of
    

                    
        foo TABLE VIRTUAL tmp:DWORD:4
    

    defines a table member called tmp, consisting of four doublewords. The default value for count2_expression is 1 if you don't specify it. count1_expression is an array element size multiplier. The total space reserved for the member is count2_expression times the length specified by the memtype field, times count1_expression. The default value for count1_expression is also 1 if you don't specify one. count1_expression multiplied by count2_expression specifies the total count of the table member. Table member names are local to a table in Ideal mode, but are global in scope in MASM mode. name is the name of the table data type. You can use it later in the module to get a variety of information about the table data type. You can also use the names of individual table members to obtain information. Table data types are redefinable. You can define the same name as a table data type more than once in a module. You can also use table data type names to create variables and allocate memory. Alternatively, Turbo Assembler provides a multiline syntax for table data type definitions requiring a large number of members. This syntax is similar to that of enumerated data type definitions. Here's an example:
    

                    
        foo TABLE t1:WORD,t2:WORD,t3:WORD,t4:WORD ;Original version
    
        foo TABLE {       ;Multiline version
           t1:WORD
           t2:WORD
           t3:WORD
           t4:WORD
           }
    
        foo TABLE tl:WORD,t2:WORD,{      ;More compact multiline version
           t3:WORD,t4:WORD}
    

    If you declare two or more members of the same name as part of the same table data type, Turbo Assembler will check to be sure that their types and sizes agree. If they don't, it will generate an error. Turbo Assembler will use the last initial value occurring in the table definition for the member. In this way, you can override the initial value of a table after it is incorporated into another. For example,
    

                    
        FOO TABLE VIRTUAL MEM1:WORD=MEM1PROC, VIRTUAL MEM2:WORD=MEM2PROC
        FOO2 TABLE FOO, VIRTUAL MEM1:WORD=MEM3PROC ;Overrides inherited
                                                   ;MEM1
    

    To create an instance of a table data type, use the table name as a data allocation directive. For example, assume you have defined the following table:
    

                    
        TTYPE TABLE  VIRTUAL MoveProc:WORD=MoveRtn,     \
             VIRTUAL MsgProc:DWORD=MsgRtn,              \
             VIRTUAL DoneProc:WORD=DoneRtn
    

    Then, the statement
    

                    
        TTEST TTYPE ?
    

    would create an instance of the table ttype (defining the variable ttest). No initial data will be emitted to the current segment in this example because the ? uninitialized data value was specified.
    
    When you define a table, you must specify an initial value for all table members. The simplest initialized instance of a table contains just the initial data specified in the definition. For example,
    

                    
        TTYPE {}
    

    is equivalent to
    

                    
        DW MoveRtn
        DD MsgRtn
        DW DoneRtn
    

    The braces ({ }) represent a null initializer' value for the structure. The initializer value determines what members (if any) have initial values that should be overridden, and by what new values, as you allocate data for the table instance. Here's the syntax of the brace initializer:

                    
        { [member_name = value [,member_name = value...]] }
    

    member_name is the name of a member of the table. value is the value that you want the member to have in this instance. A blank value indicates that you'll use the initial value of the member from the table definition. A ? value indicates that the member should be uninitialized. Turbo Assembler sets any member that doesn't appear in the initializer to the initial value of the member from the table definition. For example,
    

                    
        TTYPE {MoveProc=MoveRtn2,DoneProc=?}
    

    is equivalent to
    

                    
        DW MoveRtn2
        DD MsgRtn
        DW ?
    

    When you declare an object, Turbo Assembler creates a STRUC that declares the data for the object, and a TABLE that declares the methods for the object. The object's data declaration is a structure with the same name as the object. The object's method declarations are stored in a TABLE data type, named @Table_<objectnarne>. For example, for the list object, two data types are declared:
    

    list           A STRUC declaring the following members:
                   list_head    dword pointer to head of list
                   list_tail    dword pointer to tail of list
    
    @Table_list    A TABLE declaring the following methods:
                   construct    dword pointer to the procedure list_construct
                   destroy      dword pointer to the procedure list_destroy
                   and so on ...
    

    STRUC declares the data for the object that is created whenever you create an instance of the object. TABLE declares the table of default method procedures for the declaration. Turbo Assembler maintains this data type; it does not create an instance of the table anywhere in your program memory. However, you'll see later that you must include an instance of the table for any object that uses virtual methods.
  • Object-Oriented Symbols/Types:
    The extended STRUC directive defines or uses several symbols, which reflect the object being defined. The following table shows these symbols:
    
    

    @Object		•	A text macro containing the name of the current object (the object last declared).
    <objectname>		•	A STRUC data type that describes the object's data structure.
    @Table_<objectname>		•	A TABLE data type containing the object's method table, which is not the same as an instance of the virtual method table.
    @TableAddr_<objectname>		•	A label describing the address of the instance of the object's virtual method table, if there is one.
    @Mptr_<objectname>		•	this is an object member that points to a table of virtual method pointers; present in objects with virtual methods.

    
    
  • WHILE:
    You can use the WHILE macro directive to repeat a macro body until a certain expression evaluates to 0 (false). WHILE has the following syntax:
    

                    
        WHILE while_expression
        macro_body
        ENDM
    

    Turbo Assembler evaluates while_expression before each iteration of the macro body. Be careful to avoid infinite loops, which can cause Turbo Assembler to run out of memory or appear to stop functioning. Here's an example using WHILE:
    

                    
        WHILE 1
            ;; Do nothing
        ENDM
            ; We never make it this far
    

  • EXITCODE:
    You can use the EXITCODE directive to produce termination code appropriate for the current operating system. You can use it more than once in a module, for each desired exit point. Here's its syntax:
    

        EXITCODE [return_value_expr]
    

    You can use the following syntax only in MASM mode:

        .EXIT [return_value_expr]
    

    The optional return_value_expr describes the number to be returned to the operating system. If you don't specify a return value, Turbo Assembler assumes the value in the AX register.
  • .EXIT (u):
    (see description in EXITCODE above)
  • EXIT (u):
    [bytepointer.com edit] Undocumented but likely a synonym for .EXIT
• Instructions:
  
  
  • FASTIMUL (Fast Immediate Multiply Instruction):
    Turbo Assembler provides a special immediate multiply operation for efficient array indexing. FASTIMUL addresses a typical problem that occurs when you create an array of structures. There is no immediate multiply operation available for the 8086 processor. Even for the more advanced processors, multiplication using shifts and adds is significantly faster in some circumstances than using the standard immediate IMUL instruction. Based on the currently specified processor, Turbo Assembler's FASTIMUL instruction chooses between the most efficient sequence of shifts and adds available, and the current processor's immediate IMUL operation (if any). FASTIMUL has the following syntax:
    

                    
        FASTIMUL dest_reg, source_r/m, value
    

    This instruction is much like the trinary IMUL operation available on the 80186, 80286, and 80386 processors. The dest_reg destination register is a WORD register (or it can be DWORD on the 80386). source_r/m is a register or memory address that must match the size of the destination. value is a fixed, signed constant multiplicand. FASTIMUL uses a combination of IMUL, MOV, NEG, SHL, ADD, and SUB instructions to perform its function. This function destroys the source register or memory address, and leaves the processor flags in an indeterminate state.
  • SETFLAG - a "smart-flag" instruction implementing OR
  • TESTFLAG - a "smart-flag" instruction implementing TEST
  • FLIPFLAG - a "smart-flag" instruction implementing XOR
  • CLRFLAG - [bytepointer.com edit] I think this is a doc bug where the writers meant to specify MASKFLAG as CLRFLAG does not exist and likely never existed; there is no CLRFLAG identifier embedded within this version or any version of TASM; CLRFLAG is also not documented anywhere else but the one place it was ever mentioned: the keywords table for version 3.0.
  • MASKFLAG (u) - a "smart-flag" instruction implementing AND; accidentally documented in the new keywords for version 3.0 table as CLRFLAG
  • SETFIELD:
    SETFIELD generates code that sets a value in a record field. Its syntax follows:
    

                    
        SETFIELD field_name destination_r/m, source_reg
    

    field_name is the name of a record member field. destination_r/m for SETFIELD is a register or memory address of type BYTE or WORD (or DWORD for the 80386). source_reg must be a register of the same size or smaller. If the source is smaller than the destination, the source register must be the least significant part of another register that is the same size as the destination. This full-size register is called the operating register. Use this register to shift the value in the source register so that it's aligned with the destination. For example,
    

                    
        FOO    RECORD R0:1,R1:4,R2:3,R3:1
           .
           .
           .
           SETFIELD R1 AX,BL                ;operating register is BX
           SETFIELD R1 AX,BH                ;illegal!
    

    SETFIELD shifts the source register efficiently to align it with the field in the destination, and ORs the result into the destination register. Otherwise, SETFIELD modifies only the operating register and the processor flags. To perform its function, SETFIELD generates an efficient but extended series of the following instructions: XOR, XCHG, ROL, ROR, OR, and MOVZX. The entire contents of the operating register are destroyed by the SETFIELD operation.
    
    If you're using SETFIELD when your source and target registers are the same, the instruction does not OR the source value to itself. Instead, SETFIELD ensures that the fields of the target register not being set will be zero. SETFIELD does not attempt to clear the target field before ORing the new value. If this is necessary, you must explicitly clear the field using the MASKFLAG instruction.
  • GETFIELD:
    GETFIELD retrieves data from a record field. It functions as the logical reverse of the SETFIELD instruction. Its syntax follows:
    

                     
        GETFIELD field_name destination_reg, source_r/m
    

    field_name and destination_reg function as they do for SETFIELD. You can use source_r/m as you would for source_reg (for SETFIELD). For example,
    

                    
        FOO    RECORD R0:1,R1:4,R2:3,R3:1
           .
           .
           .
           GETFIELD R1 BL,AX                 ;operating register is BX
           GETFIELD R1 BH,AX                 ;illegal!
    

    Note that GETFIELD destroys the entire contents of the operating register. GETFIELD retrieves the value of a field found in the source register or memory address, and sets the pertinent portion of the destination register to that value. This instruction affects no other registers than the operating register and the processor flags. To accomplish its function, GETFIELD generates an efficient but extended series of the following instructions: MOV, XCHG, ROL, and ROR. If you're using the GETFIELD instruction when your source and target registers are the same, the instruction will not generate the nonfunctional MOV target, source instruction.
• Symbols:
  
  
  • @32Bit (u):
    The @32Bit symbol contains an indication of whether segments in the currently specified model are declared as 16 bit or 32 bit. The symbol has a value of 0 if you specified 16-bit segments in the, MODEL directive, or 1 if you indicated 32-bit segments.
  • @Interface (u):
    The @Interface symbol provides information about the language and operating system selected by the MODEL statement. This text macro contains a number whose bits represent the following values:
    
    

    Value in bits 0-6		Meaning
    0		NOLANGUAGE
    1		C
    2		SYSCALL
    3		STDCALL
    4		PASCAL
    5		FORTRAN
    6		BASIC
    7		PROLOG
    8		CPP

    
    Bit 7 can have a value of 0 for DOS/Windows, or 1 for Windows NT. For example, the value 81h for @Interface shows that you selected the Windows NT operating system and the C language.
  • @stack (u):
    a "simplified segment directives" symbol containing the segment or group that SS is assumed to be.
• Keywords:
  
  
  • METHOD (u):
    Consider the following example declaration:
    

        list STRUC GLOBAL METHOD {
          construct:dword = list_construct   ;list constructor procedure
          destroy:dword = list_destroy       ;list destructor procedure
          init:dword = list_init             ;list initializer procedure
          deinit:dword = list_deinit         ;list deinitializer procedure
          virtual insert:word = list_insert  ;list node insert procedure
          virtual append:word = list_append  ;list node append procedure
          virtual remove:word = list_delete   ;list node remove procedure
          virtual first:word = list_first    ;list first node procedure
          virtual last:word = list_last      ;list last node procedure
          }
          list_head   dd ?                   ;list head pointer
          list_tail   dd ?                   ;list tail pointer
        ENDS
    

    Let's look at this example to see what's happening.
    
    The METHOD keyword shows that you're using an extended form of STRUC, and are defining an object called list. Each entry consists of a method name, a colon, and the size of a pointer to the method procedure (WORD for near procedures, DWORD for far procedures). This is followed by an equal sign, and the name of the procedure to call for that method.
    
    METHOD indicates an object method call and is followed by a list of the method procedure declarations for the object. These declarations are 'enclosed in braces ({ }) because the list of methods requires more than one line. Each method declaration tells Turbo Assembler which procedure it should use to manipulate the object when invoking that method name. For example, the first method procedure declaration
    

                    
        construct:dword = list_construct
    

    declares a method named construct that is a far procedure (because a DWORD stores the pointer to it). The actual procedure name of the method is list_construct, which should be defined elsewhere in the source code. Turbo Assembler considers a method to be virtual if it's preceded by the keyword VIRTUAL. When you call such a method, Turbo Assembler will locate the method's procedure address by looking it up from a table present in memory at run time. Otherwise, the method is a static method, meaning that Turbo Assembler can determine its address at compile time. For example, the method construct is a static method, while the method insert is declared as a virtual method. The data structure for the method immediately follows the method procedure declaration section. This definition uses the syntax for the standard STRUC directive. This example contains declarations for the linked list's head and tail pointers. The method declaration portion of the object declaration doesn't place any data in the object's data structure unless you've used virtual methods. Instead, these declarations cause Turbo Assembler to build a separate table data structure that contains the specified method procedure addresses as default values. You should have an instance of this table for every object, and you must explicitly place the table.
• Memory Models:
  
  
  • FLAT (u) - This is the same as the SMALL model, but tailored for use under OS/2.
• Model Modifiers:
  
  
  • OS_DOS (u) and DOS (u) - Both keywords specify that DOS is the platform for the application.
  • OS_OS2 (u) and OS2 (u) - Both keywords specify that OS/2 is the platform for the application.
• Dummy Argument Types:
  
  Each dummy argument has the following syntax:
  

          
      dummy_name[:dummy_type]
  

  dummy_name is a symbolic name used as a place holder for the actual argument passed to the macro when it's invoked. The optional dummy_type specifies something about the form the actual argument must take when you invoke the macro. The following types are supported:
  
  
  • REQ (u) - Argument cannot be null or spaces.
  • =<text_string> - Bracketed text string is the default value for the dummy argument when the actual argument is null or contains spaces.
  • REST (u) - Actual argument consists of the rest of the macro invocation, interpreted as raw text.
  • VARARG (u) - Actual argument consists of the rest of the macro invocation, interpreted as a list of arguments. Commas and angle brackets are added to ensure this interpretation.
• Calling Conventions:
  
  
  • CPP (u) - specifies the C/C++ calling convention; name must start with _. The rest of name should be in lowercase characters (_name).
    [bytepointer.com edit] Besides the use of CPP returning a different bit pattern in @Interface, the manual essentially describes this as a synonym for C and PROLOG conventions.
  • SYSCALL (u) - specifies C calling conventions, but without prepending underscores to symbol names (like Pascal naming conventions).
• Command Line Options added:
  

  /uxxxx	- Set version emulation, version xxxx
  /zi,/zd,/zn	- Debug info: zi=full, zd=line numbers only, zn=none

  
  [bytepointer.com edit] In the "Debug info" line above, only the /zn option was new with this version.
  
  
• @Model Symbol:
  [bytepointer.com edit] Although undocumented as to the exact version between 2.0 and 3.0, by version 3.0, the @Model codes (as listed in the 3.0 User's Guide) had been changed to:

      1 = tiny model is in effect
      2 = small or flat
      3 = compact
      4 = medium
      5 = large
      6 = huge
      7 = tchuge
      0 = tpascal
  

• Possible Undocumented-Feature Keywords:
  
  
  • CALLMETHOD (u)
  • JMPMETHOD (u)
  • OBJDEF (u)
  • OBJEND (u)
  • PROCBEG (u)
  • PROCEND (u)

TASM 3.0 User's Guide

• New Keywords Introduced:
  
  
  • PUSHSTATE:
    The PUSHSTATE directive saves the current operating state on an internal stack that is 16 levels deep. PUSHSTATE is particularly useful if you have code inside a macro that functions independently of the current operating state, but does not affect the current operating mode. Note that you can use PUSHSTATE outside of macros. This can be useful for include files. The state information that Turbo Assembler saves consists of:
    
    
    • current emulation version (for example, T310)
    • mode selection (for example, IDEAL, MASM, QUIRKS, MASM51)
    • EMUL or NOEMUL switches
    • current processor or coprocessor selection
    • MULTERRS or NOMULTERRS switches
    • SMART or NOSMART switches
    • the current radix
    • JUMPS or NOJUMPS switches
    • LOCALS or NOLOCALS switches
    • the current local symbol prefix
  • POPSTATE:
    Use the POPSTATE directive to return to the last saved state (from PUSHSTATE) from the stack.
  • P487 (u):
    Enables assembly of 487 numeric processor instructions. This instruction works in both MASM and Ideal modes.
  • .487 (u):
    Enables assembly of 487 numeric processor instructions. This instruction works only in MASM mode.
  • UNINIT (u):
    This segment combination attribute produces a warning message to let you know that you have inadvertently written initialized data to uninitialized data segments. For example, you can specify the following to produce a warning message: BSS SEGMENT PUBLIC WORD UNINIT 'BSS'. To disable this warning message, use the NOWARN UNI directive. You can reenable the message by using the WARN UNI directive.
  • T310 (u):
    VERSION directive identifier for [the current] Turbo Assembler 3.1
• New Warning Class Identifiers:
  
  
  • INT (u) - INT 3 generation
  • UNI (u) - For turning off uninitialized segment warning
• Command Line Options Changed:
  
  Standard and IBM overlay options added. The overlay command line options were previously listed as:
  

  /o,/op            Generate overlay object code, Phar Lap-style 32-bit fixups
  

  With the addition of /os (standard) and /oi (IBM), the options now read as follows:
  

  /os,/o,/op,/oi    Object code: standard, standard w/overlays, Phar Lap, or IBM
  

Serial No:   Tester:

• Greater MASM Compatibility for text equate substitutions:
  Whenever a line requires the expansion of a text macro, use the % operator at the beginning of the line to specifically indicate that the text macros should be expanded before the line is parsed. In previous versions of Turbo Assembler, some instances of text macros (particularly where text macros had the same names as assembly language keywords) would not be expanded. For example, this situation could occur when you define a model on the command line. You could assemble
  

      .MODEL M
      .CODE
          NOP
       END
  

  with the following command line:

       TASM /dM=SMALL A.ASM
  

  Since Turbo Assembler now requires you to place the % operator at the beginning of the line containing the text equate substitution, this program would change to:

      %  .MODEL M
         .CODE
             NOP
         END
  

  If you omit the %, you might receive an "Invalid Model Type" error.
• New Keywords Introduced:
  
  
  • PROCTYPE (u):
    This directive allows you to use user-defined data types (called a procedure type) to describe the arguments and calling conventions of a procedure. Turbo Assembler treats procedure types like any other types; you can use it wherever types are allowed. Note that since procedure types don't allocate data, you can't create an instance of a procedure type. The Ideal mode syntax is:
    

        PROCTYPE name [procedure_description]
    

    The MASM mode syntax is:
    

        name PROCTYPE [procedure_description]
    

    procedure_description is similar to the language and argument specification for the PROC directive. You can use a procedure type (defined with PROCTYPE) as a template for the procedure declaration itself. For example,

        footype PROCTYPE pascal near :word, :dword,:word
        .
        .
        .
        foo PROC footype                    ;pascal near procedure
        arg a1:word,a2:dword,a3:word        ;an error would occur if
                                            ;arguments did not match
                                            ;those of footype
    

    When you declare a procedure using a named procedure description, the number and types of the arguments declared for PROC are checked against those declared by PROCTYPE. The procedure description supplies the language and distance of the procedure declaration.
  • PROCDESC (u):
    This directive allows you to declare procedure prototypes much like procedure prototypes in C. Turbo Assembler treats the procedure name as if it were a GLOBAL symbol. If you've defined the procedure within the module, it is treated as PUBLIC. Otherwise, Turbo Assembler assumes it to be EXTRN. You can place PROCDESC directives in an include file. The Ideal mode syntax of PROCDESC is:
    

        PROCDESC name [procedure_description]
    

    Use the following syntax in MASM mode:
    

        name PROCDESC [procedure_description]
    

    procedure_description is similar to the language and argument specification used in the PROC directive.
  • PUSHAW (u) - forces a WORD-style PUSHA instruction
  • POPAW (u) - forces a WORD-style POPA instruction
  • PUSHFW (u) - forces a WORD-style PUSHF instruction
  • POPFW (u) - forces a WORD-style POPF instruction
  • IRETW (u) - forces a WORD-style flags POP for the IRET instruction
  • T320 (u) - VERSION directive identifier for [the current] Turbo Assembler 3.2
  • STDCALL (u) - uses C calling conventions for procedures with variable arguments, and Pascal calling conventions for procedures with fixed arguments. It always uses the C naming convention.
    [bytepointer.com edit] STDCALL is missing from the official version 3.2 New Keywords list in the User's Guides

• Variable Argument Lists:
  Syntax for defining arguments passed to a procedure:
  

      ARG argument [,argument] ... [=symbol]
        [RETURNS argument [,argument]]
  

  An individual argument has the following syntax:
  

      argname [[ countl_expression]] [: complex_type [: count2_expression]]
  

  You can specify count2_expression using the ? keyword to indicate that a variable number of arguments are passed to the procedure. For example, an argument definition of

      ARG tmp:WORD:?
  

  defines an argument called tmp, consisting of a variable number of words.
• Segment Overrides:
  Turbo Assembler 3.2 now handles segment overrides in a more consistent manner. All segment overrides in MASM mode programs must occur outside the [] of a memory expression. For example, this line that previous versions of TASM would accept,

      MOV AX,[ES:BX]
  

  will now generate a warning:

      *Warning* segment.ASM(3) ":" operator ignored
  

  Also, the segment override will not be generated.
  
  To fix this warning, and to cause the expected segment override, it is important to move the ES: outside of the memory [], like this:

      MOV AX,ES:[BX]
  

• New Keywords present in 3.2i, now official in this version:
  
  
  • PROCTYPE
  • PROCDESC
  • PUSHAW
  • POPAW
  • PUSHFW
  • POPFW
  • IRETW

**Fatal** Command line: Can't locate file

.386
.MODEL FLAT
ExitProcess PROCDESC STDCALL :DWORD
.CODE
start:
    call ExitProcess,0
END start

• 4 MB Extended Memory
• 80386 processor or higher
• DOS 4.01 or later
• Windows 3.1 or later
• Approximately 2 MB hard disk space

• Introduction of TASM32 (32-bit Protected Mode Assembler):
  [bytepointer.com edit] This was the first version distributed with TASM32.EXE, designed for running in a 32-bit operating system (as well as building 32-bit Windows binaries). The printed 4.0 manual describes TASM32.EXE as follows:
  
  
  Protected-mode assembler. Assembles 16-and 32-bit applications using memory above 640K. Produces only 32-bit debug information.
• Pentium Directives:
  
  
  • P586 - Enables assembly of all Pentium instructions.
  • P586N - Enables assembly of nonprivileged Pentium instructions.
  • .586 (u) - Enables assembly of the additional instructions supported by the Pentium processor in nonprivileged mode.
  • .586C (u) - Enables assembly of all Pentium instructions.
  • .586P (u) - Enables assembly of all the additional instructions supported by the Pentium processor, including the privileged mode instructions.
  • .587 (u) - Enables assembly of Pentium numeric processor instructions. This instruction works only in MASM mode.
  • P587 - Enables assembly of Pentium numeric processor instructions. This instruction works in both MASM and Ideal modes.
• Pentium Instructions:
  
  
  • CMPXCHG8B
  • CPUID
  • RDMSR
  • WRMSR
• Model Modifiers:
  
  
  • OS_NT (u) and NT (u) - Both keywords specify that Windows NT is the platform for the application.
• Other Keywords Introduced:
  
  
  • ALIAS:
    This directive allows the association of an alias name with a substitute name. When the linker encounters an alias name, it resolves the alias by referring to the substitute name.
    [bytepointer.com edit] The README.TXT supplied with the ALIASWIN example contains more information on aliasing. Although I pulled this example from the TASM 5.0 distribution because a full 4.0 distribution was not available to me, the year listed in the README is 1993. This example was clearly introduced in TASM 4.0 for this 4.0 feature.
  • T321 (u) - VERSION directive identifier for Turbo Assembler 3.21
    [bytepointer.com edit] an unknown/undocumented version?
  • T400 (u) - VERSION directive identifier for [the current] Turbo Assembler 4.0
• Text Equate Substitution:
  TASM 4.0 has changed the way text equates are substituted since the TASM 3.0 version. This makes some TASM 3.0 code produce errors when assembled with TASM 4.0. To remedy this problem, do one of the following:
  1. Use the /UT300 command line directive to select TASM 3.0 style processing.
  2. Explicitly use the % text macro substitution operator at the start of lines that cause errors with TASM 4.0.
  [bytepointer.com edit] It is not clear if this change occured between 4.0 and 3.2 or another 3.x version.
• Additional x86 privileged-mode Register Support
  
  
  • CR4 (u) - Used in protected mode to control operations such as virtual-8086 support, enabling I/O breakpoints, page size extension and machine check exceptions.
  • DR5 (u) - 32-bit "Debug Control" register (accessible in ring 0); obsolete synonym for DR7 register
• Possible Undocumented-Feature Keywords:
  
  
  • FNLDENV (u) - [bytepointer.com edit] related to the FLDENV instruction (8087) ?
  • FNRSTOR (u) - [bytepointer.com edit] related to the FRSTOR instruction (8087) ?

TASM 4.0 Box Images

    Updates Turbo Assembler 4.0 for Chicago compatibility.

    ta4p01.zip - Tasm 4.0 patch 1 (50KB). Fixes long filenames use under Win95

• DISTRIBUTED AS PATCH (TA4P01.ZIP) for version 4.0 TASM32.EXE
  AFFECTED FILES: TASM32.EXE, H2ASH.EXE, H2ASH32.EXE
  LAST OFFICIAL DOWNLOAD LOCATION: ftp://ftp.inprise.com/pub/borlandcpp/devsupport/patches/tasm/ta4p01.zip
  OLDER DOWNLOAD LOCATION: ftp://ftp.borland.com/pub/techinfo/techdocs/language/tools/turboasm/ta4p01.zip
  REQUIREMENTS: RPatch 3.20 last officially available as ftp://ftp.inprise.com/pub/borlandcpp/devsupport/patches/bc5/patch.zip
  
  NOTE: All of the official download links are dead. RPatch 3.20 (PATCH.EXE) is needed to apply the patch above; it can be found in the TASMPT.ZIP package shown below for version 5.0r.
  

• Long filename support for Windows 95 (Chicago)
• Other Keywords Introduced:
  
  
  • T410 - VERSION directive identifier for [the current] Turbo Assembler 4.1
• Possible Undocumented-Feature Keywords:
  
  
  • STACKALIGN (u)
  • STACKUNALIGN (u)
  
  [bytepointer.com edit] The official manuals do not describe how exactly these keywords behave but the feature list found on the last working Lazy Assembler page (version 0.56 from 8/6/2007) describes them in their TASM implementation as "control of stack alignment with stackalign, stackunalign directives".

Turbo Assembler  Version 5.0  Copyright (c) 1988, 1996 Borland International

Assembling file:   ver_dos.ASM
Error messages:    None
Warning messages:  None
Passes:            1

Turbo Assembler  Version 4.1  Copyright (c) 1988, 1996 Borland International

Assembling file:   ver_dos.ASM
Error messages:    None
Warning messages:  None
Passes:            1
Remaining memory:  452k

Turbo Assembler 5.0 is a full featured stand-alone assembler. This product includes all the tools needed to create and debug assembly programs for 16 and 32 bit DOS and Windows platforms, including Windows 3.X, Win95, Win98, and NT. Some of the tools included are assemblers, linkers, console style debuggers, and resource compilers. Each of these tools comes in a 16 bit and a 32 bit version.

C++Builder 5 Professional and Enterprise both include and integrate TASM32, the 32 bit assembler, with the IDE, allowing you to write or add inline assembly code or assembly sources to your 32bit Windows C/C++ projects. For building and debugging stand alone assembly programs for DOS and Windows, Turbo Assembler 5.0 is recommended.

Create Fast Applications, Faster
Order the world-standard Borland Turbo Assembler® and see how lightning-fast assembly speeds can turbocharge your turnaround times. In tests, the Borland Turbo Assembler proved itself up to 70% faster than other popular macro assemblers, with assembly speeds of up to 48,000 lines per minute! And it's versatile, with full Intel chip set support-from 8086 to Pentium.

IDEAL for Beginners and Pros
If you're just starting out in assembly language programming, Turbo Assembler's innovative IDEAL assembly mode will help you get productive faster and catch more errors sooner. And if you're a C++ professional, Turbo Assembler's advanced coding instructions will help you get the most from your assembly language programs. You'll especially like how Turbo Assembler's MASM compatibility mode lets you add new life to legacy code.

Specifications

• Up to 48,000 lines-per-minute assembly
• Full 8088, 8086, 80286, 80386, i486, and Pentium support
• IDEAL and MASM assembly modes
• Interface support for C, C++, Pascal, FORTRAN, and COBOL
• Multi-pass assembler with forward-reference resolution
• Fast 16- and 32-bit Turbo Linker®
• Turbo Debugger® for DOS and Windows

• 8 MB system memory (req. to run Win32)
• Intel 386 or higher
• DOS 5.01 or later
• Windows 3.1 or later (to access Turbo Assembler help file)
• Windows '95 or Windows NT (for targeting those environments)
• Approximately 10 MB hard disk space
• 3.5" High Density Disk Drive

• IBM PC-compatible PC running DOS 3.31 or higher
• Minimum 2Mb memory and 1Mb disk space required for 16-bit development
• Minimum 8Mb memory and 2Mb disk space required for 32-bit development

• Thunk Compiler compatibility for Windows 95 flat thunking VIA the TASM32.EXE command-line option: -utthk
  The TASM 5.0 User's Guide refers you to the sample program and documentation: \EXAMPLES\THUNK95.TXT for more information on thunking.
  [bytepointer.com edit] This -utthk command-line option is not listed in the command-line help!


• Enhanced compatibility for MASM 6.1
  
  
  • Data Declarations:
    
    Turbo Assembler now supports the use of type names as directives when defining variables. For example, the line:
    

       var DB 10
    

    can now be written as:
    

       var   BYTE 10
    

    The table below shows the type names and their equivalent directives.
    
    

    Type		Equivalent directive
    BYTE		DB
    DWORD		DD
    FWORD		DF
    QWORD		DQ
    TBYTE		DT
    WORD		DW

  • New Signed Data Types:
    
    

    Type		Bytes		Value range
    SBYTE		1		-128 to +127
    SWORD		2		-32,768 to +32,767
    SDWORD		4		-2,147,483,648 to +2,147,483,647

  • New Floating-point Data Types:
    
    

    Type		Description		Bits		Significant digits		Approximate range
    REAL4		Short real		32		6-7		1.18 x 10-38 to 3.40 x 1038
    REAL8		Long real		64		15-16		2.23 x 10-308 to 1.79 x 10308
    REAL10		10-byte real		80		19		3.37 x 10-4932 to 1.18 x 104932

    
    Floating point constants can be designated as decimal constants or encoded hexadecimal constants, as shown in the following examples:
    

        ; Real decimal numbers
        dshort   REAL4       34.56       ;IEEE format
        ddouble  REAL8       3.456E1     ;IEEE format
        dtenbyte REAL10      3456.0E-2   ;10-byte format real format
    
        ; Hexadecimals, note the required trailing "r" and leading decimal digit
        hexshort       REAL4       4E700000r            ;IEEE short
        hexdouble      REAL8       4E70000000000000r    ;IEEE long
        hextenbyte     REAL10      4E776000000000000000r;10-byte real
    

  • New conditionals and looping directives:
    
    Turbo Assembler now supports several high level directives to permit program structures similar to those in higher level languages, such as C++ and Object Pascal. These directives generate code for loops and decisions, which are executed depending on the status of a conditional statement. The conditions are tested at run time, and can use the new run-time operators ==, !=, >=, <=, >, <, &&, ||, and !.
    
    
    • .IF .ELSE .ELSEIF .ENDIF
      
      The directives .IF, .ELSE, .ENDIF generate conditional jumps. If the expression following .IF evaluates to true, then the statements following the .IF are executed until an .ELSE (if any), .ELSEIF (if any), or .ENDIF directive is encountered. If the .IF expression evaluates to false, the statements following the .ELSE (if any) are executed until an .ENDIF directive is encountered. Use .ELSEIF to cause a secondary expression to be evaluated if the .IF expression evaluates to false.
      
      The syntax for the .IF directives is:
      

      .IF expression1
      statements
      [.ELSEIF expression2
      statements]
      [.ELSE
      statements]
      .ENDIF
      

      Example
      

        .IF bx == 16   ; if the value in bx equals 16
        mov   ax,20
        .ELSE          ; if the Value in bx does not equal 16
        mov   ax,30
        .ENDIF
      

    • .WHILE .ENDW
      
      The .WHILE directive executes the statements between the .WHILE and the .ENDW as long as the expression following .WHILE evaluates to true, or until a .BREAK directive is encountered. Because the expression is evaluated at the beginning of the loop, the statements within the loop will not execute at all if the expression initially evaluates to false. If a .CONTINUE directive is encountered within the body of the loop, control is passed immediately back to the .WHILE where the expression is re-evaluated. If .BREAK is encountered, control is immediately passed to the statement following the .ENDW directive.
      
      The syntax for the .WHILE directives is:
      

      .WHILE expression
      statements
      .ENDW
      

      Example
      

        mov ax, 0               ; initialize ax to 0
        .WHILE ax < 128         ; while ax is less than 128
        mov dx, cx              ; put the value of cx in dx
        .IF dx == bx            ; if dx and bx are equal
        mov ax,dx               ; put the value of dx in ax
        .CONTINUE               ; re-evaluate .WHILE expression
        .ELSEIF ax == dx        ; if ax equals dx
        .BREAK                  ; break out of the .WHILE loop
        .ENDIF
        inc ax                  ; increment ax by 1
        .ENDW                   ; end of .WHILE loop
      

    • .REPEAT .UNTIL .UNTILCXZ
      
      The .REPEAT directive executes the statements between the .REPEAT and the .UNTIL as long as the expression following the .UNTIL (or .UNTILCXZ) evaluates to true, or until a .BREAK directive is encountered. Because the expression is evaluated at the end of the loop, the statements within the loop will execute at least once, even if the expression initially evaluates to false. If a .CONTINUE directive is encountered within the body of the loop, control is passed immediately to the .UNTIL where the expression is re-evaluated. If .BREAK is encountered, control is immediately passed to the statement following the .UNTIL (or .UNTILCXZ) directive. The .UNTIL directive generates conditional jumps. The .UNTILCXZ directive generates a LOOP instruction.
      
      The syntax for the .REPEAT directives is:
      

      .REPEAT
      statements
      .UNTIL expression
      

      Example
      

        mov ax, O              ; initialize ax to 0
        .REPEAT                ; while ax is less than 128
        inc ax                 ; increment by 1
        .UNTIL ax >= 128       ; end of .REPEAT loop
      

    • .BREAK .CONTINUE
      
      As noted above, .BREAK and .CONTINUE can be used to alter the program flow within a loop. .CONTINUE causes the loop to immediately re-evaluate its expression, bypassing any remaining statements in the loop. .BREAK terminates the loop and passes control to the statement following the end of the loop. Both .BREAK and .CONTINUE can be combined with an optional .IF directive. If the .IF expression evaluates to true, the .BREAK or .CONTINUE are carried out, otherwise they are ignored.
      
      Example
      

        mov ax, bz
        .WHILE ax != cx
        .BREAK .IF ax == dx
        .CONTINUE .IF ax > dx
        inc ax
        .ENDW
      

    • Logical "C-like" Operators:
      
      

      Operator		Meaning
      ==		is equal to
      !=		is not equal to
      >=		is greater than or equal to
      <=		is less than or equal to
      >		is greater than
      <		is less than
      &&		and
      ||		or
      !		not
      &		bit test

    • Flags in Conditions
      
      Turbo Assembler permits the use of flag values in conditions. The supported flag names are ZERO?, CARRY?, OVERFLOW?,SIGN?, and PARITY?. For example, to use the value of the CARRY flag in a loop expression, use:
      

      .WHILE (CARRY?)   ; if the CARRY flag is set...
      statements
      .ENDW
      

  • Macro Repeat Blocks with Loop Directives
    
    Turbo Assembler supports "repeat blocks", or unnamed macros within a loop directive. The loop directive generates the statements inside the repeat block a specified number of times.
    
    
    • REPEAT loops:
      
      Use REPEAT to specify the number of times to generate the statements inside the macro. The syntax is:
      

                              
        REPEAT constant
        statements
        ENDM
      

      Example
      

        number   LABEL BYTE     ; name the generated data
        counter = O             ; initialize counter
        REPEAT 128              ; repeat 128 times
           BYTE  counter        ; allocate a new number
           counter = counter + 1; increment counter
        ENDM
      

    • FOR loops:
      
      Use the FOR loop to iterate through a list of arguments, using the first argument the first time through, the second argument the second time through, and so on. The syntax is:
      

                              
      FOR parameter,<argumentList>
      statements
      ENDM
      

      The parameter represents the name of each argument inside the FOR block. The argumentList is comma separated and enclosed in angle brackets.
      
      Example:
      

        powers   LABEL BYTE
        FOR arg, <1,2,4,8,16,32,64,128>
           BYTE arg DUP (arg)
        ENDM
      

      The first iteration through the FOR loop sets arg to 1. The second iteration sets arg to 2. The third sets arg to 4, and so on. Text macros may be used in place of literal strings of values. The VARARG directive can be used in the argumentList to create a variable number of arguments.
    • FORC loops:
      
      FORC loops are almost identical to FOR loops, except that the argumentList is given a string, rather than as a comma separated list. The loop reads the string, character by character (including spaces), and uses one character per iteration. The syntax is:
      

                              
        FORC parameter, <text>
        statements
        ENDM
      

      The parameter represents the name of each argument inside the FOR block. The text is a character string and enclosed in angle brackets.
      
      Example
      

                              
        alphabet LABEL BYTE
        FORC arg, <ABCDEFGHIJKLMNOPQRSTUVWXYZ>
           BYTE '&arg'    ; allocate letter
        ENDM
      

  • Text Macro Support:
    
    A string of characters can be given a symbolic name, and have that name used in the source code rather than the string itself. The named text is referred to as a text macro. Use the TEXTEQU directive to define a text macro. To assign a literal string to a text macro, enclose the string in angle brackets (<>). For example:
    

      myString TEXTEQU <This is my string>
    

    To assign one macro to another text macro, assign the macro name as in the example below:
    

      myString    TEXTEQU <This is my string>
      myNewString TEXTEQU myString           ;value of myString now in myNewString as well
    

    To assign a text representation of a constant expression to a text macro, precede the expression with a percent sign (%). For example:
    

      value TEXTEQU %(1 + num);assigns text representation of resolved expression to value
    

    Text macros are useful for naming strings of text that do not evaluate to integers. For example:
    

      pi      TEXTEQU  <3.14159>   ; floating point constant
      WPT     TEXTEQU  <WORD PTR>  ; keywords
      arg     TEXTEQU  <[bp+4]>    ; expression
    

  • New Directives:
    
    For MASM compatibility, Turbo Assembler now supports the directive STRUCT, EXTERN, and PROTO. These directives are synonyms for the STRUC, EXTRN, and PROCDESC directives, respectively.
    
    
    • ECHO directive:
      The ECHO directive displays its argument to the standard output device during assembly. It is useful for debugging purposes. The syntax is:
      

        ECHO argument
      

    • EXTERNDEF directive:
      Turbo Assembler treats EXTERNDEF as a PUBLIC declaration in the defining module, and as an external declaration in the referencing module(s). Use EXTERNDEF to make a variable or procedure common to two or more modules. If an EXTERNDEF variable or procedure is defined but not referenced in a given module, the EXTERNDEF is ignored; you need not create a symbol as you would using EXTERN. The syntax of the EXTERNDEF statement is:
      

                              
        EXTERNDEF [langType] name : type
      

    • OPTION directive:
      
      The OPTION directive lets you make global changes to the behavior of the assembler. The basic syntax of the directive is:
      

                              
        OPTION argument
      

      For example, to make the expression word size 16 bits, use the statement:

                              
        OPTION EXPR16
      

      To make the expression word size 32 bits, use the statement:

                              
        OPTION EXPR32
      

      The available options are listed below:
      
      
      • CASEMAP: NONE/NOTPUBLIC/ALL
        NONE causes internal symbol recognition to be case sensitive, and causes the case of identifiers in the .OBJ file to be the same as specified in the EXTERNDEF,PUBLIC, or COMM statement.
        NOTPUBLIC (default) causes case insensitivity for internal symbol recognition and has the same behavior as NONE for identifiers in .OBJ files.
        ALL specifies universal case insensitivity and converts all identifiers to uppercase.
      • DOTNAME/NODOTNAME
        Enables or disables the use of the dot (.) as the leading character in variable, macro, structure, union, and member names. The default is disabled.
      • EMULATOR/NOEMULATOR
        NOEMULATOR (default) tells the assembler to generate floating point math coprocessor instructions directly.
        EMULATOR generates floating point math instructions with special fixups for linking with a coprocessor emulator library.
      • EXPR16/EXPR32
        Sets the expression word size to 16 or 32 bits. The default is 32 bits.
      • LJMP/NOLJMP
        Enables or disables automatic conditional-jump lengthening. The default is enabled.
      • NOKEYWORD:<keywordList>
        Disables the keywords listed in keywordList. For example:
        

                                        
          OPTION NOKEYWORD:<MASK EXPORT NAME>
        

      • PROC: PRIVATE/PUBLIC/EXPORT
        Allows you to set the default PROC visibility as PRIVATE, PUBLIC, or EXPORT. The default is PUBLIC.
      • SCOPED/NOSCOPED
        SCOPED (the default) guarantees that all labels inside procedures are local to the procedure.
      • SEGMENT: USE16/USE32/FLAT
        Sets the global default segment size and the default address size for external symbols defined outside any segment.
      
      OPTION arguments for MASM 6.x Compatibility (Most only documented in the TASM 5.0 keyword changelist but no descriptions available; descriptions in this section were derived from MASM 6.1 Reference Guide unless stated otherwise):
      
      
      • .DOSSEG - MASM 6.0 equivalent for DOSSEG. TASM 5.0 User's Guide description: "Enables DOS segment-ordering at link time. Included for backward compatibility only."
      • .NOCREF - MASM 6.0 equivalent for .XCREF. Suppresses listing of symbols in the symbol table and browser file. If names are specified, only the given names are suppressed.
      • .NOLIST - MASM 6.0 equivalent for .XLIST. Suppresses program listing.
      • .SUBTITLE (u) - MASM 6.0 equivalent for SUBTTL. Specify subtitle for page (listing file)
      • .LISTALL - Starts listing of all statements. Equivalent to the combination of .LIST, .LISTIF, and .LISTMACROALL.
      • .LISTIF - Starts listing of statements in false conditional blocks.
      • .NOLISTIF - Suppresses listing of conditional blocks whose condition evaluates to false.
      • .LISTMACRO - Suppresses listing of macro expansions.
      • .LISTMACROALL - Starts listing of all statements in macros.
      • .NOLISTMACRO - Suppresses listing of macro expansions.
      • PROLOGUE - Instructs the assembler to call macroname to generate a user-defined prologue instead of generating the standard prologue code.
      • EPILOGUE - Instructs the assembler to call the macroname to generate a user-defined epilogue instead of the standard epilogue code when a RET instruction is encountered.
      • LANGUAGE - Specifies the default language type (C, PASCAL, FORTRAN, BASIC, SYSCALL, or STDCALL) to be used with PROC, EXTERN, and PUBLIC. This use of the OPTION directive overrides the .MODEL directive but is normally used when .MODEL is not given.
      • M510 - Sets all features to be compatible with MASM version 5.1, disabling the SCOPED argument and enabling OLDMACROS, DOTNAME, and, OLDSTRUCTS. OPTION M510 conditionally sets other arguments for the OPTION directive.
      • NOM510 - Disables M510 compatibility options
      • NOSIGNEXTEND - Overrides the default sign-extended opcodes for the AND, OR, and XOR instructions and generates the larger non-sign-extended forms of these instructions. Provided for compatibility with NEC V25 and NEC V35 controllers.
      • OFFSET - Determines the result of OFFSET operator fixups. SEGMENT sets the defaults for fixups to be segment-relative (compatible with MASM 5.1). GROUP, the default, generates fixups relative to the group (if the label is in a group). FLAT causes fixups to be relative to a flat frame. (The .386 mode must be enabled to use FLAT.)
      • OLDMACROS - Enables the version 5.1 treatment of macros.
      • NOOLDMACROS - Disables the version 5.1 treatment of macros.
      • OLDSTRUCTS - Enables compatibility with MASM 5.1 for treatment of structure members.
      • NOOLDSTRUCTS - Disables compatibility with MASM 5.1 for treatment of structure members.
      • READONLY - Enables checking for instructions that modify code segments, thereby guaranteeing that read-only code segments are not modified. Same as the /p command-line option of MASM 5.1, except that it affects only segments with at least one assembly instruction, not all segments. The argument is useful for protected mode programs, where code segments must remain read-only.
      • NOREADONLY - Disables checking for instructions that modify code segments
      • SETIF2 - If TRUE, .ERR2 statements and IF2 and ELSEIF2 conditional blocks are evaluated on every pass. If FALSE, they are not evaluated. If SETIF2 is not specified (or implied), .ERR2, IF2, and ELSEIF2 expressions cause an error. Both the /Zm command-line argument and OPTION M510 imply SETIF2:TRUE.
  • Visibility in Procedure Declarations:
    Turbo Assembler supports three visibility modes in procedure (PROC) declarations; PRIVATE, PUBLIC, and EXPORT. The visibility indicates whether the procedure is available to other modules. PUBLIC procedures are available to other modules. All procedures are PUBLIC by default. PRIVATE procedures are available only within the module in which they are declared. Code in other modules cannot call PRIVATE procedures. If the visibility is EXPORT, the linker places the procedure's name in the export table for segmented executables. EXPORT also enables PUBLIC visibility.
  • Distance in Procedure Declarations:
    In addition to the ability to specify NEAR or FAR distance in procedure (PROC) declarations, Turbo Assembler now supports the modifiers NEAR16, NEAR32, FAR16, and FAR32 when programming for the 80386, and up, and using both 16 and 32-bit segments.
  • SIZE operator in MASM mode:
    In MASM mode the size operator returns the values below for the given labels:
    
    

    Label		SIZE
    SHORT		0FF01h
    NEAR16		0FF02h
    NEAR32		0FF04h
    FAR16		0FF05h
    FAR32		0FF06h

Possible Undocumented-Feature Keywords:


• EPILOGUEDEF (u)
• PROLOGUEDEF (u)
• FLDENVD (u) - [bytepointer.com edit] DWORD override version of the FLDENV instruction (8087)
• FLDENVW (u) - [bytepointer.com edit] WORD override version of the FLDENV instruction (8087)
• FNSAVED (u) - [bytepointer.com edit] DWORD override version of the FNSAVE instruction (8087)
• FNSAVEW (u) - [bytepointer.com edit] WORD override version of the FNSAVE instruction (8087)
• FNSTENVD (u) - [bytepointer.com edit] DWORD override version of the FNSTENV instruction (8087)
• FNSTENVW (u) - [bytepointer.com edit] WORD override version of the FNSTENV instruction (8087)
• FRSTORD (u) - [bytepointer.com edit] DWORD override version of the FRSTOR instruction (8087)
• FRSTORW (u) - [bytepointer.com edit] WORD override version of the FRSTOR instruction (8087)
• FSAVED (u) - [bytepointer.com edit] DWORD override version of the FSAVE instruction (8087)
• FSAVEW (u) - [bytepointer.com edit] WORD override version of the FSAVE instruction (8087)
• FSTENVD (u) - [bytepointer.com edit] DWORD override version of the FSTENV instruction (8087)
• FSTENVW (u) - [bytepointer.com edit] WORD override version of the FSTENV instruction (8087)
• IRETDF (u) - [bytepointer.com edit] 32-bit interrupt return with no epilogue generation (i.e. LEAVE instruction) (80386)
• IRETF (u) - [bytepointer.com edit] interrupt return with no epilogue generation (i.e. LEAVE instruction) (80386)
• LOOPED (u) - [bytepointer.com edit] DWORD override version of the LOOPE instruction (80386)
• LOOPEW (u) - [bytepointer.com edit] WORD override version of the LOOPE instruction (80386)
• LOOPNED (u) - [bytepointer.com edit] DWORD override version of the LOOPNE instruction (80386)
• LOOPNEW (u) - [bytepointer.com edit] WORD override version of the LOOPNE instruction (80386)
• LOOPNZD (u) - [bytepointer.com edit] DWORD override version of the LOOPNZ instruction (80386)
• LOOPNZW (u) - [bytepointer.com edit] WORD override version of the LOOPNZ instruction (80386)
• LOOPZD (u) - [bytepointer.com edit] DWORD override version of the LOOPZ instruction (80386)
• LOOPZW (u) - [bytepointer.com edit] WORD override version of the LOOPZ instruction (80386)
• PUSHD (u) - [bytepointer.com edit] DWORD override version of the PUSH instruction (80386)
• PUSHW (u) - [bytepointer.com edit] WORD override version of the PUSH instruction (80386)

New VERSION Directive Indentifiers:


• M611 (u) - support for MASM 6.11
• T410 (u) - support for Turbo Assembler 4.1
• T450 (u) - [bytepointer.com edit] The presence of this keyword confirms that a TASM version 4.5 must have existed in some capacity, even if not released to the public. I've confirmed this VERSION id does indeed work, but what functionality it enables is a different story.
• T500 - support for [the current] Turbo Assembler 5.0

TASM 5.0 Box Images

TASM 5.0 Registration Card

TASM 5.0 Disk #1

TASM 5.0 Manuals

09/02/2002  05:00 AM               890 INSTALL.BAT
02/05/1996  04:07 PM            61,311 PATCH.EXE
04/11/1997  09:47 AM               832 README.TXT
02/05/1997  01:00 AM            48,705 TASM32.RTP
02/05/1997  01:00 AM            48,069 TD32.RTP
               5 File(s)        159,807 bytes

02/09/1997  06:00 PM               855 INSTALL.BAT
02/05/1996  09:07 AM            61,311 PATCH.EXE
02/09/1997  06:00 PM            48,705 TASM32.RTP
02/09/1997  06:00 PM            48,069 TD32.RTP
               4 File(s)        158,940 bytes

Serial No:   Tester:

• DISTRIBUTED AS PATCH (TASMPT.ZIP) including PATCH.EXE, README.TXT, TASM32.RTP, and TD32.RTP
  LAST OFFICIAL DOWNLOAD LOCATION: http://www.borland.com/devsupport/borlandcpp/patches/TASMPT.ZIP

• New Pentium MMX Directives and Version Identifier:
  
  • PMMX (u) - needed to assemble MMX instructions in this version
  • PNOMMX (u)
  • .MMX (u) - Borland commented out w/ space after period / doesn't work until 5.2b
  • .NOMMX (u) - Borland commented out w/ space after period / doesn't work until 5.2b
  • T510 (u) - VERSION directive identifier for Turbo Assembler 5.1
    [bytepointer.com edit] This is version 5.0r with a new version identifier (the latest embedded within file) that suggests we are at version 5.1. I think 5.0r is actually TASM 5.1, although I don't know of any TASM that reports itself as version 5.1 on the command-line.
• New Pentium MMX Instructions:
  
  • EMMS (u)
  • MOVD (u)
  • MOVQ (u)
  • PACKSSWB (u)
  • PACKSSDW (u)
  • PACKUSWB (u)
  • PADDB (u)
  • PADDW (u)
  • PADDD (u)
  • PADDSB (u)
  • PADDSW (u)
  • PADDUSB (u)
  • PADDUSW (u)
  • PAND (u)
  • PANDN (u)
  • PCMPEQB (u)
  • PCMPEQW (u)
  • PCMPEQD (u)
  • PCMPGTB (u)
  • PCMPGTW (u)
  • PCMPGTD (u)
  • PMADDWD (u)
  • PMULHW (u)
  • PMULLW (u)
  • POR (u)
  • PSLLW (u)
  • PSLLD (u)
  • PSLLQ (u)
  • PSRAW (u)
  • PSRAD (u)
  • PSRLW (u)
  • PSRLD (u)
  • PSRLQ (u)
  • PSUBB (u)
  • PSUBW (u)
  • PSUBD (u)
  • PSUBSB (u)
  • PSUBSW (u)
  • PSUBUSB (u)
  • PSUBUSW (u)
  • PUNPCKHBW (u)
  • PUNPCKHWD (u)
  • PUNPCKHDQ (u)
  • PUNPCKLBW (u)
  • PUNPCKLWD (u)
  • PUNPCKLDQ (u)
  • PXOR (u)
• New MMX Registers:
  
  • MM0 (u)
  • MM1 (u)
  • MM2 (u)
  • MM3 (u)
  • MM4 (u)
  • MM5 (u)
  • MM6 (u)
  • MM7 (u)

C++Builder 1.0 Standard Box

C++Builder 1.0 Professional CD and CD Case

C++Builder 1.0 Professional Splash Image

C++Builder 1.0 Professional Programmer's Guide

C++Builder 1.0 TLINK32/ILINK32 Quick Reference

C++Builder 3 Pro and Client/Server

C++Builder 3 Standard Box

C++Builder 3 Professional Splash Image

• New Pentium Pro Directives and Version Identifier:
  
  • .686 (u)
  • .686P (u)
  • .686C (u)
  • .687 (u)
  • P686 (u)
  • P686N (u)
  • P687 (u)
  • T520 (u) - VERSION directive identifier for [the current] Turbo Assembler 5.2
• New MMX Directives:
  
  • .MMX (u)
  • .NOMMX (u)
• New Pentium Instructions:
  
  • RDTSC (u)
• New Pentium MMX Instructions:
  
  • RDPMC (u)
• New Pentium Pro Instructions:
  
  • UD2 (u)
  • CMOVA (u)
  • CMOVAE (u)
  • CMOVB (u)
  • CMOVBE (u)
  • CMOVC (u)
  • CMOVE (u)
  • CMOVG (u)
  • CMOVGE (u)
  • CMOVL (u)
  • CMOVLE (u)
  • CMOVNA (u)
  • CMOVNAE (u)
  • CMOVNB (u)
  • CMOVNBE (u)
  • CMOVNC (u)
  • CMOVNE (u)
  • CMOVNG (u)
  • CMOVNGE (u)
  • CMOVNL (u)
  • CMOVNLE (u)
  • CMOVNO (u)
  • CMOVNP (u)
  • CMOVNS (u)
  • CMOVNZ (u)
  • CMOVO (u)
  • CMOVP (u)
  • CMOVPE (u)
  • CMOVPO (u)
  • CMOVS (u)
  • CMOVZ (u)
  • FCMOVB (u)
  • FCMOVE (u)
  • FCMOVBE (u)
  • FCMOVU (u)
  • FCMOVNB (u)
  • FCMOVNE (u)
  • FCMOVNBE (u)
  • FCMOVNU (u)

Inprise Logo (Courtesy archive.org)

C++Builder 4

C++Builder 4 Standard Splash Image

• New Pentium Pro Instructions:
  
  • FCOMI (u)
  • FCOMIP (u)
  • FUCOMI (u)
  • FUCOMIP (u)

• C++Builder 5 (file date 1/30/2000 10:00pm)
• C++Builder 6 (file date 1/31/2002 10:00pm)
• Turbo Delphi Explorer (file date 8/5/2006 11:41am)
• Turbo C++ Explorer (file date 9/8/2006 11:56am)

C++Builder 5 Enterprise C++Builder 6 Enterprise

Turbo C++ Explorer / 2006 Turbo Delphi Explorer / 2006

C++Builder 5 Easter Egg Images C++Builder 6 Team Employees

• support long file names for "tasm32 *"
• assembling source filename begining with 'ï'
• fix @Cpu symbol value for ".286p", ".386p", ".486p", ".586p", ".686p", "p286", "p386", "p486", "p586", "p686" directives
• fix code generate for LOOPED & LOOPEW
• enabled @@,@B,@F labels in IDEAL mode
• support 2^32 labels for conditional directives
• other bugs