Click above to get retro games delivered to your door ever month!

 Zinc Application Framework for DOS
------------------------------------------------------------------------------
 Blinker supports version 5.12 and later of Zinc Application Framework for
 DOS for DOS protected programs when used with the Borland C++ 5.x, Symantec
 C++ 7.x (user supported as per Zinc documentation) and Watcom C++ 10.6 and
 later 16 bit compilers.

 In the event of an error while running a ZINC program linked with the
 Blinker extender, PLEASE try linking the same program with your current
 extender or linker, if you have one, to see if the same problem occurs.
 To simplify the isolation of link time errors, remember to use the /K option
 of ZMAKE to force it to keep the temporary link script file it generated.

 Set up

 Firstly ensure that INCLUDE environment variable points to the C
 subdirectory of the Blinker installation directory, or copy the header files
 (C\*.H) to the include directory of your compiler. Also check that the PATH
 environment variable points to the BIN subdirectory of the Blinker
 installation directory.

 Before using Blinker with the Zinc ZMAKE make utility and .MAK scripts you
 will also need to copy the appropriate Blinker protected mode files for the
 compiler you are using to the compiler LIB subdirectory. The names of the
 Blinker protected mode files all finish with a 2 digit version number for
 the compiler, and this should be dropped when copying each file.
 For example, Blinker requires the files C0LPnn.OBJ and BLXBCPnn.LIB for
 Borland C/C++, where nn represents the compiler version number, from its OBJ
 and LIB subdirectories of the Blinker installation directory respectively.
 These should be copied to the Borland C/C++ LIB subdirectory while dropping
 the nn on the end of the name. E.g. for version 5.x of Borland C/C++:

 COPY C:\BLINKER\OBJ\C0LP50.OBJ C:\BORLANDC\LIB\C0LP.OBJ
 COPY C:\BLINKER\LIB\BLXBCP50.LIB C:\BORLANDC\LIB\BLXBCP.LIB

 Or for Watcom C/C++ 10.5

 COPY C:\BLINKER\LIB\BLXWCC10.LIB C:\Watcom\LIB16\BLXWCC.LIB

 ZMAKE can now be used to build the Zinc Application Framework libraries and
 any of the example programs using the target DOS16B.

 Building a Zinc Application Framework example program

 Start by building the Zinc Application Framework libraries from the SOURCE
 subdirectory of the Zinc Application Framework directory.

 CD\ZAF51\SOURCE
 ZMAKE DOS16B

 Then change to the directory containing the example program and build it
 using the same ZMAKE command and target, e.g.

 CD\ZAF51\EXAMPLE\HELLO
 ZMAKE DOS16B

 Building your own programs

 Ideally, copy the ZMAKE.MAK file from one of the Zinc Application Framework
 example programs, modify it for your program and use ZMAKE DOS16B to build
 the application.

 If you decide to create your own make files and link scripts for a Zinc
 Application Framework application, use the same compiler options as for the
 PharLap 286 extender, as documented by Zinc. Base your link script files on
 one generated and saved by ZMAKE for one of the Zinc Application Framework
 example programs by running ZMAKE with the /K (keep) option.
 Make absolutely sure you include any command line options that ZMAKE adds to
 the Blinker command line.

 ZMAKE creates MS Link, TLink or WLink format link scripts for all the sample
 programs. In order to process MS Link script files Blinker requires the
 first command line parameter to be '/qm', or the 'LINKER=MSLINK' setting in
 the BLINKER.INI file. In order to process TLink script files Blinker
 requires the first command line parameter to be '/qt', or the 'LINKER=TLINK'
 setting in the BLINKER.INI file. In order to process WLink script files
 Blinker requires the first command line parameter to be '/qw'.

 Alternatively, you can use Blinker's default script file format, known as
 free format, for clearer link script files. The format of these is
 documented in the Blinker online help and the Blinker manual, so please
 refer to those for further details.

 Simple DOS extended link script file examples for the various supported
 compilers can be found in the documentation or the online help under 'Quick
 start by compiler' under 'Quick Start'. The only additional commands
 necessary are the LIB commands for the Zinc Application Framework libraries.
 A sample LNK file for linking the Zinc Application Framework sample program
 HELLO1 compiled with Borland C++ 5.x is included in the ZAF subdirectory of
 the Blinker installation directory, and is as follows:

 #
 #  HELLO.LNK      ZAF 5.1 HELLO example link script for BC++ 5.x
 #
 file c0lp50.obj   # Blinker replacement startup for BC++ 5.x
 file hello1.o16   # OBJ file names
 out hello1        # Output file name
 map s,a           # Create a MAP file
 bli exe ext       # Create DOS extended program
 lib blxbcp50      # Blinker protected mode library for BC++ 5.x
 lib zafd16p       # ZAF libraries
 lib zafd16
 lib met_xp2d
 lib met_pp2l
 lib emu           # Borland libraries
 lib mathl
 lib cl
 codeview          # Include debugging information
 nodef             # No default libraries
 nobell            # No irritating beep

 For the other compilers, simply remove the 'file c0lp50.obj' line and
 replace the 'blxbcp50 in the 'lib blxbcp50' line with the appropriate
 library name for the compiler and version you are using, as per the Blinker
 documentation.

 Source level debugging

 To create an output file with debugging  information, set DEBUG=ON in the
 ZMAKE make file, or if you are using a Blinker link script file include the
 CODEVIEW command.

 To debug a DOS extended program you will require a protected mode debugger
 such as NuMega SoftICE/W, since the standard compiler debuggers do not
 currently support the debugging of Blinker created DOS extended programs.
 Full debugging information including source line numbers, global and local
 variables, classes and structures should be available with Symantec and
 Watcom C/C++ programs.

 Borland C/C++ uses a unique format for its symbol debugging information, so
 currently Blinker only supports source line number information and global
 variables with Borland C/C++.

 Support for full debugging information with Borland C/C++ is planned for a
 future update to Blinker.

 NuMega SoftICE/W debugger