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

 Glossary
------------------------------------------------------------------------------
 ASCII

 American Standard Code for Information Interchange - the almost world-wide
 standard for representing characters in the memory of a computer.

 batch file

 An ASCII file containing DOS commands which are executed by the operating
 system each time the file is called.

 BIOS

 (Basic Input Output System) The code built into a PC's system memory which
 provides hardware interface routines for programs.

 bit

 (binary digit) the smallest unit of information stored in a computer's
 memory.

 byte

 Eight bits of data. The smallest individually addressable unit of storage.

 cache

 A reserved portion of memory used to temporarily store information which is
 also stored on disk. If the information is subsequently required, it can be
 provided extremely quickly from the temporary memory store rather than from
 a slow disk access, thus improving a program's performance.

 class

 A named collection of segments which are to be associated in the .EXE file
 at link time and therefore in memory at run time. At link time, classes are
 written to the .EXE file in the order they are encountered. Within each
 class, segments are also written in the order they are encountered. Classes
 are usually compiler-specified. See also: .OBJ file, segment

 compiling

 The process of translating source code into object code. The resulting
 object files can then be linked to produce an executable program. See also
 Linking, .OBJ File, source code

 conventional memory

 The 640 Kb region of memory below one megabyte on the X86 family of
 computers which is designated for program usage.

 default library

 A library which is specified within an .OBJ file to be automatically
 processed by the linker if unresolved references still exist at the end of
 the normal link process. Typically, a default library is a compiler's
 language library containing the language's run time support.

 descriptor

 A structure containing the size, base and attributes of a protected mode
 segment.

 DOS extender

 A program which allows other programs written for X86 real mode to run in
 protected mode on 286-class machines and above. See also protected mode

 DPMI

 DOS Protected Mode Interface is the industry standard program interface
 which allows multitasking of DOS extenders, DOS extended applications and
 other protected mode control programs. This interface is similar to, but
 much more general purpose than, the VCPI interface which was one of its
 predecessors. See also VCPI

 dynamic overlaying

 At program runtime, the process of loading, executing and discarding
 overlays as they are needed, rather than according to a predefined overlay
 structure. See also overlay, static overlaying

 EMS

 see expanded memory.

 environment variables

 Operating system variables which can be used to communicate configuration
 information to programs. Environment variables are manipulated using the DOS
 SET command.

 executable file

 A file containing executable code which is the output from a successful
 link. This file may contain the complete program or there may be associated
 external overlay files which contain the remainder of the program. In all
 cases it is the file loaded and executed by the operating system.

 .EXE file

 see executable file.

 expanded memory

 Also known as LIM EMS (Lotus - Intel - Microsoft Expanded Memory
 Specification). A method of mapping memory pages in and out of the 1 Mb real
 mode address space of the Intel family of processors, thereby increasing the
 RAM storage of the computer. The memory originates on an expanded memory
 board (or a software emulator).

 extended memory

 Available on 80286 or better processors only. Memory residing at addresses
 above 1 Mb. Blinker does not support extended memory directly, but can use
 extended memory in conjunction with an XMS driver. See also XMS.

 external overlay

 A file separate from, but related to, the .EXE file, containing one or more
 overlays to be loaded and executed when required. An external overlay will
 have by default the .OVL extension, although any other extension may be
 specified in the SECTION INTO command, with the exception of .EXE. See also
 .EXE file, overlay

 external symbol

 A public symbol which is not defined within the module which references it.

 far address

 A memory address or reference which consists of both a segment and an offset
 which can access any memory location, as opposed to a near address which
 consists of only an offset portion.

 free pool

 The area of memory managed by CA-Clipper Summer '87 to store the values of
 variables used in a CA-Clipper application. This memory is also used by
 CA-Clipper for temporary buffers and work areas. The CA-Clipper function
 MEMORY(0) returns the size in kilobytes of the amount of memory available
 within the free pool. Also called CA-Clipper dynamic memory.

 group

 An addressing classification which defines to the linker a collection of
 segments which will be accessed by the same segment register. Group is a
 logical concept used only for addressing. Segments in a group do not require
 adjacent memory locations so long as they remain within a 64 Kb memory area.
 Segments from different groups can be mixed together in the same section,
 and segments from the same group can be distributed among several sections.

 incremental linking

 The process of linking only the parts of a program which have changed since
 the previous link. This process can greatly speed up the time required to
 link the program during development. See also linking

 internal overlay

 An overlay section which is part of the .EXE itself, attached to the end for
 convenience.

 .LIB file

 See library.

 library

 A file (usually with the .LIB extension) containing one or more .OBJ files
 grouped for convenience. When a library file is linked with a program, only
 those .OBJ files which are required by the program are extracted from the
 library and included in the program. See also linking, .OBJ file

 linking

 The process of combining .OBJ files, searching library files for additional
 .OBJ files, resolving references between these .OBJ files, and producing an
 executable program .EXE file. See also .EXE file, .LIB file, .OBJ file

 link script

 An ASCII file specifying all commands, object files, and libraries to be
 processed by the linker.

 load size

 The amount of memory required by DOS to load a program. This value is
 displayed by Blinker at the end of a successful link, and should not be
 confused with the amount of memory needed to execute the program.

 module

 Equivalent to an .OBJ file, usually within a .LIB file. The module name
 usually corresponds to the name of the source file from which the .OBJ was
 created. The module name is listed in the Blinker output for VERBOSE and
 BLINKER MESSAGE DUPLICATES commands as well as in the output from librarian
 utilities such as Microsoft's LIB.EXE.

 near address

 A memory address or reference consisting of a single offset word which can
 only access a memory location in the current segment, as opposed to a far
 address which contains both a segment and an offset.

 .OBJ file

 see object file.

 object file

 A file containing code produced by a language translator. The file consists
 of program code, data to be used by the program and symbolic information
 which tells the linker how to combine this file with other .OBJ files to
 produce an .EXE file. Also referred to as a module. See also .EXE file

 overlay

 A section of program code which is loaded into memory, executed a number of
 times and then discarded to make room for another section of code. The use
 of overlays enables a program to execute even though it is larger than the
 amount of memory available.

 overlay cache

 A reserved portion of memory used to temporarily store overlaid program code
 which is also stored on disk. If the overlay is subsequently required, it
 can be provided extremely quickly from the temporary memory store rather
 than from a slow disk access, thus improving a program's performance.

 overlay manager

 A section of code which manages the loading, execution and discarding of
 overlays while a program is running. This code is responsible for ensuring
 that all the required overlays of a program are in memory when they are
 needed, and for doing so with efficiency. See also overlay

 overlay pool

 The area of memory in which overlays are stored when they are executed. The
 contents of the overlay pool are controlled by the overlay manager while the
 program is executing. See also overlay manager

 opsize

 The operating size of Blinker's overlay pool. The opsize determines how many
 overlays can reside in memory at a time. When the opsize is small, the
 program will use less memory, but overlays will be swapped in and out of the
 overlay pool more frequently.

 page frame

 The page frame is a 64 Kb block of memory used to hold EMS pages as they are
 swapped in and out by programs which use EMS. It resides outside the normal
 640 Kb of conventional DOS memory but within the first 1 Mb, and is
 typically provided and managed by memory managers such as the EMM386.EXE
 device driver which comes with DOS.

 paragraph

 The segment portion of a real mode address, e.g. the paragraph of the colour
 adapter is B800h.

 profiling

 The process of gathering statistics about routines as they are executed.
 These statistics can then be analyzed to determine how to make the program
 run more efficiently.

 protected mode

 The extended addressing mode of an 80286 processor and above. 286 protected
 mode gives direct access to up to 16 Mb of real memory, and 386 protected
 mode up to 4 Gb. Segment protection and address validation are automatically
 performed by the processor when in protected mode. See also protection
 exception

 protection exception

 A protection exception occurs when a program running in protected mode
 attempts to perform an operation which it is not authorised to do. These
 operations include accessing memory beyond the end of a segment, writing to
 code segments, executing data segments and dereferencing a null or invalid
 pointer.

 public symbol

 A symbol whose relative address is designated by the compiler to be
 accessible to all modules. Public symbols are used to share procedures,
 functions and variables among different modules which make up a single
 executable.

 ram cram

 A situation in which the number of loaded device drivers or TSRs has reduced
 the available memory, resulting in a degradation of program performance.

 ram disk

 A ram disk is a disk drive which actually exists in memory but is made to
 look like an extra disk by a device driver, such as the RAMDRIVE.SYS driver
 which comes with DOS. The ram disk can be accessed and copied to and from
 like any other drive, but because the ram drive exists entirely in extended
 or expanded memory, it can be accessed extremely quickly, often hundreds of
 times faster than a real disk. The only drawback is that the entire contents
 of the ram disk is lost if the power to the PC is switched off, since the
 disk only exists in memory.

 real mode

 The native operating mode of the X86 family of computers. This mode uses
 20-bit addressing and so has a maximum address space of one megabyte. See
 also protected mode

 root

 The section of a program which always remains in memory and is never
 overlaid. DOS will always load at least this section into memory, while
 other sections, or overlays, may be loaded by the overlay manager as and
 when required. See also overlay, overlay manager

 segment

 A block of memory containing up to 64 Kb of code or data. A segment is the
 smallest indivisible unit which may be processed by the linker, and is the
 basic unit of a dynamic overlay.

 selector

 The value used to identify a segment when running in protected mode, i.e.
 that is passed to and from the protected mode memory allocation functions.

 source code

 The program code as written and entered into the computer by the programmer.
 It can be written in one of the many programming languages such as dBase,
 CA-Clipper, C, BASIC or Assembler.

 stack

 An area of memory used to store function parameters, return addresses and
 temporary data associated with an instance of a procedure or function.

 static overlaying

 The process of loading, executing and discarding overlays at program runtime
 according to a predefined overlay structure set up by the linker and
 determined by the developer in the link script file. See also dynamic
 overlaying, overlay

 swapping

 Moving elements in and out of memory. For example, Blinker moves overlays
 into the portion of memory called the overlay pool from a disk or cache
 area.

 TSR

 (Terminate and Stay Resident) A program which installs itself in memory and
 returns to DOS without freeing the memory which it occupies (staying
 resident). Generally a TSR will wait for an external event such as a
 keypress, timer tick or communications activity to 'wake up' and perform
 some function.

 UMB

 See upper memory block (UMB)

 unresolved external

 An external symbol which was referenced by one or more of the .OBJ files
 being linked, but which was not found in any of the specified .OBJ files or
 .LIB files. Unresolved externals usually indicate that one or more necessary
 .OBJ or .LIB files have been omitted from the link process. See also
 external symbol

 upper memory block (UMB)

 UMBs are blocks of memory outside the normal 640 Kb of conventional DOS
 memory but within the first 1 Mb where device drivers and TSRs such as
 network drivers can be loaded. Since they take up no conventional memory,
 this leaves the maximum amount of conventional memory free for application
 programs. UMBs are typically provided and managed by memory managers such as
 the HIMEM.SYS driver which comes with DOS.

 VCPI

 Virtual Control Program Interface is an industry standard program interface
 which allows EMS emulators and DOS extenders to coexist on an 80386 or 80486
 machine. It consists of a set of calls provided by the EMS emulator and used
 by the DOS extender to manage the system resources. See also DPMI

 XMS memory

 XMS memory is extended memory (at addresses above 1 Mb) managed by an XMS
 driver, such as HIMEM.SYS, QEMM386.SYS or 386MAX.SYS. Only available on
 80286 and better processors.