apped font:
A font in which each character is defined by (mapped to) the bits of an
array.

bitwise operator:

An operator used to manipulate bits in an integer expression. Bitwise
operators in the C language are & (AND), | (inclusive OR), ^ (exclusive OR),
    (left shift), >> (right shift), and ~ (one's complement).

block:
A sequence of declarations, definitions, and statements enclosed within
curly braces ({}).

bounding rectangle:
An imaginary rectangle that defines the outer limits of a rounded shape such
as an ellipse, arc, or pie.

byte:
The unit of measure used for computer memory and data storage. One byte
contains eight bits and can store one ASCII character.

case label:
The case keyword and the constant, or constant expression, that follows it.

CGA:
IBM's Color Graphics Adapter.

character code:
A numeric code that represents a character. The default ASCII character set
used in all PCs and PS/2s comprises 256 eight-bit character codes.

character constant:
A character enclosed in single quotes, for example, 'p'. A character
constant has a type of char. See "string constant."

character set:
A set of alphabetic and numeric characters and symbols.

clipping:
The process of determining which parts of a graphics image lie within the
clipping region. Parts of the image that lie outside this region are
"clipped"; that is, they are not displayed.

clipping region:
The rectangular area of the screen where graphics display occurs.

color index:
A short integer that represents a displayable color. See "remapping" and
"color value."

color value:
A long integer representing an absolute color. See "remapping" and "color
index."

command-line argument:
A value passed to a program when the program begins execution.

conditional expression:
An expression consisting of three operands joined by the ternary (? :)
operator. Similar to an if-else construct, a conditional expression is used
to evaluate either of two expressions depending on the value of a third
expression.

constant expression:
An expression that evaluates to a constant. A constant expression may
involve integer constants, character constants, floating-point constants,
enumeration constants, type casts to integral and floating-point types, and
other constant expressions.

current color:
The color index for the color in which graphics pixels are displayed. The
current color can be examined with _getcolor or changed with _setcolor.

declaration:
A construct that associates the name and the attributes of a variable,
function, or type.

default:
A condition that is assumed by a program if not specified.

definition:
A construct that initializes and allocates storage for a variable or that
specifies the name, formal parameters, body, and return type of a function.

dimension:
The number of subscripts required to specify a single array element.

directive:
An instruction to the C preprocessor to perform an action on source-program
text before compilation.

double precision:
A real (floating-point) value that occupies eight bytes of memory. Double
precision values are accurate to 15 or 16 digits.

EGA:
Enhanced Graphics Adapter.

enumeration type:
A user-defined data type with values that range over a set of named integral
constants.

escape sequence:
A specific combination of a backslash (\) followed by a letter or
combination of digits, which represents white space and nonprinting
characters within strings and character constants.

expression:
A combination of operands and operators that yields a single value.

external variable:
A variable that is defined outside any function in a C source file and is
used in other source files in the same program.

file handle:
An integer value that is returned when a library function that performs
low-level input/output opens or creates a file. The file handle is used to
refer to that file in later operations.

file pointer:
A value that keeps track of the current position in an input or output
stream. It is updated to reflect the new position each time a read or write
operation takes place.

FILE pointer:
A pointer to a structure of type FILE that contains information about a
file. It is returned by library functions that create or open files and use
stream input/output.

fill flag:
A parameter that determines whether a shape will be drawn as a solid.

fill mask:
A group of pixels that defines the pattern used to fill a graphics shape.

fill pattern:
The design defined by the fill mask and used to fill a shape.

font:
A description of the style and shapes of the characters in a character set.

foreground color:
The color index for the color in which text is displayed. See "background
color."

format specification:
A string that specifies how the printf and scanf families of functions
interpret input and output data.

function:
A collection of declarations and statements that has a unique name and can
return a value.

function body:
A statement block containing the local variable declarations and statements
of a function.

function call:
An expression that passes control and arguments (if any) to a function.

function declaration:
A declaration that states the name, return type, and storage class of a
function that is defined explicitly elsewhere in the program.

function definition:
A definition that specifies a function's name, its formal parameters, the
declarations and statements that define what it does, and (optionally) its
return type and storage class.

function pointer:
A pointer that holds the address of a function.

function prototype:
A function declaration that includes a list of the names and types of formal
parameters in the parentheses following the function name.

global:
See "visibility."

graphics mode:
See "video mode."

header file:
An external source file that contains commonly used declarations and
definitions. The #include directive is used to insert the contents of a
header file into a C source file.

hexadecimal:
The base-16 numbering system whose digits are 0 through F. The letters A
through F represent the decimal numbers 10 through 15. It is often used in
computer programming because it is easily converted to and from binary, the
base-2 numbering system the computer itself uses.

HGC:
Hercules monochrome Graphics Card.

identifier:
A user-defined name in a C program. Identifiers name variables, functions,
macros, constants, and data types.

include file:
See "header file."

Incolor Card:
Hercules InColor Card, a 16-color version of the HGC+.

indirection:
Accessing a data object through a pointer, rather than directly by name.

initialize:
To assign a value to a variable, often at the time the variable is declared.

in-line assembler:
The part of QuickC that converts assembly-language instructions into machine
language.

in-line assembly code:
Assembly language instructions that appear within a QuickC source program.

input/output:
The processes involved in reading (input) and writing (output) data.

integer:
A whole number represented in the machine as a 16-bit two's-complement
binary number. A signed integer has a range of -32,768 to 32,767. An
unsigned integer has a range of 0 to 65,535. See "long integer."

I/O:
Abbreviation for input/output.

keyword:
A word with a special, predefined meaning for the C compiler.

label:
A unique name followed by a colon. Labels are used to denote statements to
which a goto statement can branch. See "case label."

library:
A file containing compiled modules. The linker extracts modules from the
library file and combines them with the user-created object file to form an
executable program.

lifetime:
The time, during program execution, that a variable or function exists. An
"automatic" variable has storage and a defined value only in the block where
it is defined or declared. A "static" variable exists for the duration of
the program.

line style:
An unsigned short integer (16 bits) that specifies the pattern with which
lines will be drawn. Each bit specifies whether a corresponding pixel in the
line will be displayed. The default line style is a solid line.

local:
See "visibility."

long integer:
A whole number represented inside the machine as a 32-bit two's-complement
binary number. A signed long integer has a range of -2,147,483,648 to
2,147,483,647. An unsigned long integer has a range of 0 to 4,294,967,295.
See "integer."

low-level input and output routines:
Run-time library routines that perform unbuffered, unformatted I/O
operations, for example, creat, read, write, and lseek.

lvalue:
An expression (such as a variable name) that refers to a memory location and
is required as the left-hand operand of an assignment operation, or as the
single operand of a unary operator.

machine language:
A series of binary numbers that a computer executes as program instructions.


macro:
An identifier defined in a #define preprocessor directive to represent
another series of characters.

main function:
The function with which program execution begins (the program's entry
point).

manifest constant:
See "symbolic constant."

MCGA (Multicolor Graphics Array):
The video subsystem integrated into the PS/2 Model 30. Also, Memory
Controller Gate Array, one of the components of the Model 30's video
subsystem.

member:
One of the elements of a structure or union.

member-of operator:
The dot operator (.), which is used with the name of a structure and one or
more fields to identify a structure member.

mode:
See "video mode."

monochrome display:
A computer monitor capable of showing only two colors─black and a second
color such as white, green, or amber. Some monochrome monitors can also show
the second color with higher intensity or with underlined text.

Monochrome Display Adapter (MDA):
A printed-circuit card that controls the display and can show text only at
medium resolution in one color.

newline character:
The character used to mark the end of a line in a text file, or the escape
sequence (\n) used to represent this character.

null character:
The ASCII character encoded as the value 0, represented as the escape
sequence (\0) in a source file. A null character marks the end of a string.

null pointer:
A pointer to nothing, expressed as the value 0.

one's complement:
The arithmetic operation in which all 1 bits are converted to 0 bits and
vice versa. The tilde character (~) is the one's-complement operator.

operand:
A constant or variable value that is manipulated in an expression.

operator:
One or more symbols that specify how the operand or operands of an
expression are manipulated. See "unary operator," "binary operator," and
"ternary operator."

origin:
The point on the screen at which the x and y coordinates are both equal to
0. On the physical screen, the origin is at the upper left corner.

palette:
The displayable colors for a given video mode. The CGA modes operate with a
set of predetermined palette colors. The EGA, VGA, and MCGA color modes
operate with a redefinable palette of colors.

parameter:
An identifier that receives a value passed to a function.

path:
The name that defines the location of a file or directory. A path may
include a drive name and one or more directory names.

PGA (Professional Graphics Adapter):
Another name for IBM's PGC.

physical coordinates:
The coordinate system defined by the hardware. The physical coordinate
system has the origin (0, 0) at the upper left corner of the screen. The
value of x increases from left to right, and the value of y increases from
top to bottom. See "viewport coordinates."

pixel:
A single dot on the screen. It is the smallest item that may be manipulated
with the graphics library, and it is the basic unit of the
viewport-coordinate system.

pointer:
A variable containing the address of another variable, function, or
constant.

pointer arithmetic:
The use of addition or subtraction to change a pointer's value. Pointer
arithmetic is typically used with array pointers, though it is not illegal
on other kinds of pointers.

pointer-member operator:
The -> operator, used with structure pointers to name a structure member.

pragma:
An instruction to the compiler to perform an action at compile time.

precedence:
The relative position of an operator in the hierarchy that determines the
order in which expressions are evaluated.

preprocessor:
A text processor that manipulates the contents of a C source file during the
first phase of compilation.

preprocessor directive:
See "directive."

prototype:
See "function prototype."

recursion:
The process by which a function calls itself.

register variable:
An integer variable that is placed in a machine register, which may cause
the program to be smaller and faster.

remapping:
The process of assigning new color values to color indexes. Remapping a
color index changes the screen color of any pixels that have been drawn with
that color index.

reserved word:
See "keyword."

return value:
The value that a function returns to the calling function.

run time:
The time during which a previously compiled and linked program is executing.

run-time library:
A file containing the routines needed to implement certain functions of the
Microsoft QuickC language.

scaling:
The mapping of real-window coordinates to viewport coordinates.

scope:
The parts of a program in which an item can be referenced by name. The scope
of an item may be limited to the file, function, block, or function
prototype in which it appears.

screen mode:
See "video mode."

single precision:
A real (floating-point) value that occupies four bytes of memory. Single-
precision values are accurate to seven decimal places.

sizeof operator:
A C operator that returns the amount of storage, in bytes, associated with
an identifier or a type.

source file:
A text file containing C language code.

standard error:
The device to which a program sends its error messages unless the error
output is redirected. In normal DOS operation, standard error is the
display. The predefined stream stderr is associated with standard error in
the C language.

standard input:
The device from which a program reads its input unless the input is
redirected. In normal DOS operation, standard input is the keyboard. The
predefined stream stdin is associated with standard input in the C language.

standard output:
The device to which a program sends its output unless the output is
redirected. In normal DOS operation, standard output is the display. The
predefined stream stdout is associated with standard output in the C
language.

static variable:
A variable that keeps its value even after the program exits the block in
which the variable is declared.

stream:
A sequence of bytes flowing into (input) or out of (output) a program.

stream functions:
Run-time library functions that treat data files and data items as "streams"
of individual characters.

string:
An array of characters, terminated by a null character (\0).

string constant:
A string of characters and escape sequences enclosed in double quotes ("").
Every string constant is an array of elements of type char. See "character
constant."

structure:
A set of elements, which may be of different types, grouped under a single
name.

structure member:
One of the elements of a structure.

structure pointer:
A pointer to a structure. Structure pointers identify structure members by
specifying the name of the structure, the pointer-member operator (->), and
the member name.

symbolic constant:
An identifier defined in a #define preprocessor directive to represent a
constant value.

tag:
The name assigned to a structure, union, or enumeration type.

ternary operator:
An operator used in ternary (three-part) expressions. C has one ternary
operator, the conditional operator (? :).

text:
Ordinary, readable characters, including the uppercase and lowercase letters
of the alphabet, the numerals 0-9, and punctuation marks.

text file:
A file of ASCII characters that you can read with the TYPE command or a word
processor.

text format:
A method of disk storage in which all data are converted to ASCII format.

text mode:
See "video mode."

text window:
A window defined in row and column coordinates where text output to the
screen will be displayed. Text printed beyond the edge of the text window is
not visible. The default text window is the whole screen.

two's complement:
A kind of base-2 notation used to represent positive and negative numbers in
which negative values are formed by complementing all bits and adding 1 to
the results.

type:
A description of a set of values. For example, the type char comprises the
256 values in the ASCII character set.

type cast:
An operation in which a value of one type is converted to a value of a
different type.

type checking:
An operation in which the compiler verifies that the operands of an operator
are valid, or that the actual arguments in a function call are of the same
types as the corresponding formal parameters in the function definition and
function prototype.

type declaration:
A declaration that defines the name and members of a structure or union
type, or the name and enumeration set of an enumeration type.

typedef declaration:
A declaration that defines a shorter or more meaningful name for an existing
C data type or for a user-defined data type. Names defined in a typedef
declaration are often referred to as "typedefs."

typeface:
The style of displayed text.

type name:
The name of a data type. See "type."

type qualifier:
The keywords short, long, signed, and unsigned, which modify a basic data
type.

type size:
A measure of the screen area occupied by individual characters in a font,
typically specified in pixels.

unary expression:
An expression consisting of a single operand preceded or followed by a unary
operator.

unary operator:
An operator that takes a single operand. Unary operators in the C language
are the complement operators (- ~ !), indirection operator (*), increment
(++) and decrement (- -) operators, address-of operator (&), and sizeof
operator. The unary plus (+) operator is legal but has no effect.

union:
A set of values of different types that occupy the same storage space.

vector-mapped font:
A font in which each character is defined in terms of lines and arcs.

VGA (Video Graphics Array):
    Many users refer to the video subsystem integrated into the PS/2 Models 50,
60, and 80, as well as the IBM PS/2 Display Adapter, as the "VGA."

video adapter:
A printed-circuit card that generates video output. Well-known IBM PC video
adapters include the MDA, CGA, HGC, EGA, MCGA, and VGA Adapters.

video mode:
An integer that specifies the resolution and other characteristics of video
output. QuickC supports 17 different video modes, although some of them are
available only with certain video adapters.

viewport:
A clipping region in which the origin (0, 0) may be redefined. The initial
origin of a viewport is the upper left corner.

viewport coordinates:
The integer coordinate system defined by the programmer for a specific
viewport. By default, the viewport-coordinate system has the origin (0, 0)
at the upper left corner of the viewport, but this may be changed by a call
to _setvieworg.

visibility:
The parts of the program in which a particular variable or function can be
referenced by name. An item has global visibility if it is visible in all
source files constituting the program and local visibility if its use is
restricted.

white-space character:
A space, tab, line-feed, carriage-return, form-feed, vertical-tab, or
newline character.

window:
An imaginary rectangle on the screen where output takes place. See "text
window" and "window coordinates."

window coordinates:
The coordinate system defined by the programmer.