.TF     Target File


        .TF  [filename.ext [,format [,expression]]]

See also:

.CP   .EF   .LF   .LI   .SF   .TW  


With the .TF directive you can open a target file in any of the available formats. This target file will be filled with the generated object code of your program.

Boundary Sync:

In Version 3 of the SB-Assembler this directive will perform a boundary sync.


The .TF directive, without parameters, will close an already open target file. Nothing will happen if no target file is open at that time.
If you want to include a comment behind an empty .TF directive a semicolon should precede this comment.

If a filename does follow the .TF directive an already open target file will also be closed. Then a new target file is created with the name filename. If that file already exists its length will be reduced to zero, effectively overwriting the file without prior notice!
As usual the filename may be preceded by a drive letter and legal path name, obeying the file name rules of your operating system. The SB-Assembler will NOT provide a default extension with target files if you don't provide one. If you omit the extension .ext the created filename will simply not have an extension.

Some target file formats have only a 16 bit address range. Therefore you can not create programs that are larger than 64k bytes. This means that if you start your program at $F000 your program can't be any bigger than 4 k bytes!
There is no limit to the number of target files used during one assembly run. You can have as many target files filled with part of your program as you like. Only one of those target files will be open at any given time. Every time you open a new target file the previous one is closed.

Other target file formats allow you to create programs of up to 4G bytes, which will be sufficient for the next few years from now ;-)
The unformatted files BIN and HEX don't have an address field and can grow as large as your file system allows it.
Motorola has designed 3 different file formats, each with their own limit to file size. The address range for the S19 format is only 64k bytes and so is the maximum file size. For format S28 the maximum address range is 16M bytes (24 bits address). Finally the maximum file size for the S37 format is 4G bytes (32 bits address).
The FPC file format is standard equipped with a 32 bit address range, so that file format is automatically capable of handling file sizes of 4G bytes.
The Intel Hex file format originally has an address range of only 64k bytes. When Intel noticed that this was not enough they invented some extensions to overcome this 64k limit.
The first method of having larger file sizes was the use of segments, like in 80x86 processors. Every segment still can hold up to 64k bytes. But at every 16 byte interval you can start a new segment of 64k again. This could be quite useful for 80x86 processors, but is particularly difficult to handle for other processors because program counter and target address will be out of sync without obvious relation. The maximum target file size for segmented Intel Hex files is 1M bytes.
The second solution they came up with at Intel is somewhat easier to comprehend. This solution uses linear segments. Again every segment is still 64k bytes long. But at the end of this segment a new linear segment is started. Up to 64k segments of 64k bytes each can be used, which in fact is a 32 bit addressing range resulting in a maximum target file size of 4G bytes.
The SB-Assembler can handle linear segmented Intel Hex files. Every time a segment boundary is crossed a new segment is started automatically.

Please note that all bytes generated by the program will be lost when no target file is open yet.

Warning: If the file filename already exists its contents will be erased and overwritten without prior notice.

In Version 2 of the SB-Assembler it is also possible to send the target file to a device, instead of to a file. That way you can send your object code directly to a programmer or EPROM simulator. A device name should always end in a colon. All MS-DOS device names are allowed like PRN:, LPT1:, COM1:, NUL:. Avoid sending the object file to the screen (CON:) however, it will only cause a lot of gibberish to be displayed there.

The file format following the filename is optional. If it is not provided the default BIN format is used.

Please note: The .OR directive will close the unformatted file types BIN and plain HEX immediately because they don't support an address field. Please specify the start of the program before opening the target file if you intend to use one of these two file formats. If, for any reason, you do have to change the start address of the next code you can always use the .NO directive in stead.
With all other file formats you may change the program address as often as you like.

These are the possible file format names:

AP1Apple 1 format
BINBinary format
E52Elektor EMON52 format (not a standard format!)
HEXHexadecimal format (every byte is translated to 2 hexadecimal digits coded in ASCII)
S19Motorola S19 format (64 kb range)
S28Motorola S28 format (16 Mb range)
S37Motorola S37 format (4 Gb range)
INTIntel Hex format (No opening segment if segment 0)
INSIntel Hex format (Always opening segment included)
SIGSignetics format
TEKTektronix format
FPCFour Packed Code format

What format you can use best depends on the capabilities of your EPROM programming tools. I prefer the FPC format because it produces the most compact formatted target files. Unfortunately not many EPROM programmers support that format though.
The desired format is entered behind the filename, separated by a comma. Your choice is made by entering one of the 3 letter format names shown above.
The difference between the INT and INS formats applies only to the very first line sent to the target file. If the first address of your target file requires a segment of 0, the INT format will not include a segment definition line in your target file. This is useful for programs that don't grow larger than 64k, no segmentation is required there anyway. If you use the INS format the first line of the target file is always a segment address definition, even if it is segment 0.

The format identifier may also be followed by an expression, separated from the format by an other comma. This expression defines the maximum number of data bytes you want to have on each line in your target file. Only BIN files don't provide for this because they don't consist of lines.
Legal values for expression range from 8 to 32. Lower values will be increased to 8, higher values will be reduced to 32, without warning. If the optional expression is omitted the default line length will be 16 data bytes long.

The syntax of the .TF directive will only be checked during pass 2 of the assembling process. An existing file with the name filename will not be erased and overwritten before pass 2. So if any errors are encountered during pass 1 the old target file(s) will still exist unchanged.

All errors that occur in the parameter field of the .TF directive will result in a fatal error message to be reported. This will stop the assembly process immediately.


         .TF   C:\OBJ\TARGET.BIN     Open BIN file (BIN is default)
         .TF   C:\OBJ\TARGET         Open BIN file (no extension)
         .TF   TARGET.BIN,BIN        Open BIN file
         .TF   TARGET.TXT,AP1,8      Open Apple 1 format
         .TF   TARGET.HEX,E52        Open EMON52 file
         .TF   TARGET.HEX,HEX        Open HEX file
         .TF   TARGET.INT,INT,32     Open INT file (32 bytes/line)
         .TF   TARGET.INT,INS        Open INS file
         .TF   TARGET.MOT,S19,8      Open S19 file (8 bytes/line)
         .TF   TARGET.MOT,S28        Open S28 file
         .TF   TARGET.MOT,S37        Open S37 file
         .TF   TARGET.SIG,SIG,0      Open SIG file (8 bytes/line)
         .TF   TARGET.TEK,TEK,100    Open TEK file (32 bytes/line)
         .TF   TARGET.FPC,FPC        Open FPC file
         .TF   TARGET.MOT,INT        Confusing, but legal
         .TF   TARGET.BIN,BIN,10     Legal, but length irrelevant
         .TF                         ; Close previous target file
         .TF   COM1:,INT,32          Send object to COM1:

Note on the Apple 1 format:

Vince Briel started some sort of Apple 1 fever around the 30th anniversary of this legendarily computer. The original Apple 1 has only the cassette recorder as mass storage. However it is possible to expand the original Apple 1 with a serial interface and several replica versions are standard equipped with a similar serial interface.
All these serial interfaces have one thing in common: Everything received is literally "typed" to the Apple 1. This behaviour allows us to simply send a file to the Apple 1. And that is exactly what the Apple 1 format is meant for. Each line starts with an address, followed by a colon, which is then followed by the data bytes. Just like you would have done to manually type the code to the Apple 1.