Glossary
|
This paragraph defines the section break and format. Please do not remove. |
8087, 80287, or 80387 coprocessor Intel chips that perform high-speed floating-point and binary coded decimal number processing. Also called math coprocessors. Floating-point instructions are supported directly by the 80486 processor.
A
|
address |
The memory location of a data item or procedure. The expression can represent just the offset (in which case the default segment is assumed), or it can be in segment:offset format.
|
address constant |
In an assembly-language instruction, an immediate operand derived by applying the SEG or OFFSET operator to an identifier.
|
address range |
A range of memory bounded by two addresses.
|
addressing modes |
The various ways a memory address or device I/O address can be generated. See “far address,” “near address.”
|
aggregate types |
Data types containing more than one element, such as arrays, structures, and unions.
|
animate |
A debugging feature in which each line in a running program is highlighted as it executes. The Animate command from the CodeView debugger Run menu turns on animation.
API (application programming interface) A set of system-level routines that can be used in an application program for tasks such as basic input/output and file management. In a graphics-oriented operating environment like Microsoft Windows, high-level support for video graphics output is part of the Windows graphical API.
|
arg |
In PWB, a function modifier that introduces an argument or an editing function. The argument may be of any type and is passed to the next function as input. For example, the PWB command Arg textarg Copy passes the text argument textarg to the function Copy.
|
argument |
A value passed to a procedure or function. See “parameter.”
|
array |
An ordered set of continuous elements of the same type.
ASCII (American Standard Code for Information Interchange) A widely used coding scheme where 1-byte numeric values represent letters, numbers, symbols, and special characters. There are 256 possible codes. The first 128 codes are standardized; the remaining 128 are special characters defined by the computer manufacturer.
|
assembler |
A program that converts a text file containing mnemonically coded microprocessor instructions into the corresponding binary machine code. MASM is an assembler. See “compiler.”
|
assembly language |
A programming language in which each line of source code corresponds to a specific microprocessor instruction. Assembly language gives the programmer full access to the computer’s hardware and produces the most compact, fastest executing code. See “high-level language.”
|
assembly mode |
The mode in which the CodeView debugger displays the assembly-language equivalent of the high-level code being executed. CodeView obtains the assembly-language code by disassembling the executable file. See “source mode.”
B
|
base address |
The starting address of a stack frame. Base addresses are usually stored in the BP register.
|
base name |
The portion of the filename that precedes the extension. For example, SAMPLE is the base name of the file SAMPLE.ASM.
|
BCD (binary coded decimal) |
A way of representing decimal digits where 4 bits of 1 byte are a decimal digit, coded as the equivalent binary number.
|
binary |
Referring to the base-2 counting system, whose digits are 0 and 1.
|
binary expression |
A Boolean expression consisting of two operands joined by a binary operator and resolving to a binary number.
|
binary file |
A file that contains numbers in binary form (as opposed to ASCII characters representing the same numbers). For example, a program file is a binary file.
|
binary operator |
A Boolean operator that takes two arguments. The AND and OR operators in assembly language are examples of binary operators.
BIOS (Basic Input/Output System) The software in a computer’s ROM which forms a hardware-independent interface between the CPU and its peripherals (for example, keyboard, disk drives, video display, I/O ports).
|
bit |
Short for binary digit. The basic unit of binary counting. Logically equivalent to decimal digits, except that bits can have a value of 0 or 1, whereas decimal digits can range from 0 through 9.
|
breakpoint |
A user-defined condition that pauses program execution while debugging. CodeView can set breakpoints at a specific line of code, for a specific value of a variable, or for a combination of these two conditions.
|
buffer |
A reserved section of memory that holds data temporarily, most often during input/output
operations.
|
byte |
The smallest unit of measure for computer memory and data storage. One byte consists of 8 bits and can store one 8-bit character (a letter, number, punctuation mark, or other symbol). It can represent unsigned values from 0 to 255 or signed values between –128 and +127.
C
|
C calling convention |
The convention that follows the C standard for calling a procedure—that is, pushing arguments onto the stack from right to left (in reverse order from the way they appear in the argument list). The C calling convention permits a variable number of arguments to be passed.
|
chaining (to an interrupt) |
Installing an interrupt handler that shares control of an interrupt with other handlers. Control passes from one handler to the next until a handler breaks the chain by terminating through an IRET instruction. See “interrupt handler,” “hooking (an interrupt).”
|
character string |
See “string.”
|
clipboard |
In PWB, a section of memory that holds text deleted with the Copy, Ldelete, or Sdelete functions. Any text attached to the clipboard deletes text already there. The Paste function inserts text from the clipboard at the current cursor position.
|
.COM |
The filename extension for executable files that have a single segment containing both code and data. Tiny model produces .COM files.
|
combine type |
The segment-declaration specifier (AT, COMMON, MEMORY, PUBLIC, or STACK) which tells the linker to combine all segments of the same type. Segments without a combine type are private and are placed in separate physical segments.
|
compact |
A memory model with multiple data segments but only one code segment.
|
compiler |
A program that translates source code into machine language. Usually applied only to high-level languages such as Basic, FORTRAN, or C. See “assembler.”
|
constant |
A value that does not change during program execution. A variable, on the other hand, is a value that can—and usually does—change. See “symbolic constant.”
|
constant expression |
Any expression that evaluates to a constant. It may include integer constants, character constants, floating-point constants, or other constant expressions.
D
|
debugger |
A utility program that allows the programmer to execute a program one line at a time and view the contents of registers and memory in order to help locate the source of bugs or other problems. Examples are CodeView and Symdeb.
|
declaration |
A construct that associates the name and the attributes of a variable, function, or type. See “variable declaration.”
|
default |
A setting or value that is assumed unless specified otherwise.
|
definition |
A construct that initializes and allocates storage for a variable, or that specifies either code labels or the name, formal parameters, body, and return type of a procedure. See “type definition.”
|
description file |
A text file used as input for the NMAKE utility.
|
device driver |
A program that transforms I/O requests into the operations necessary to make a specific piece of hardware fulfill that request.
|
Dialog Command window |
The window at the bottom of the CodeView screen where dialog commands can be entered, and previously entered dialog commands can be reviewed.
|
direct memory operand |
In an assembly-language instruction, a memory operand that refers to the contents of an explicitly specified memory location.
|
directive |
An instruction that controls the assembler’s state.
|
displacement |
In an assembly-language instruction, a constant value added to an effective address. This value often specifies the starting address of a variable, such as an array or multidimensional table.
|
DLL |
See “dynamic-link library.”
|
double-click |
To rapidly press and release a mouse button twice while pointing the mouse cursor at an object on the screen.
|
double precision |
A real (floating-point) value that occupies 8 bytes of memory (MASM type REAL8). Double-precision values are accurate to 15 or 16 digits.
|
doubleword |
A 4-byte word (MASM type DWORD).
|
drag |
To move the mouse while pointing at an object and holding down one of the mouse buttons.
|
dump |
To display or print the contents of memory in a specified memory range.
|
dynamic linking |
The resolution of external references at load time or run time (rather than link time). Dynamic linking allows the called subroutines to be packaged, distributed, and maintained independently of their callers. Windows extends the dynamic-link mechanism to serve as the primary method by which all system and nonsystem services are obtained. See “linking.”
|
dynamic-link library (DLL) |
A library file that contains the executable code for a group of dynamically linked routines.
|
dynamic-link routine |
A routine in a dynamic-link library that can be linked at load time or run time.
E
|
element |
A single member variable of an array of like variables.
|
environment block |
The section of memory containing the MS-DOS environment variables.
|
errorlevel code |
See “exit code.”
|
.EXE |
The filename extension for a program that can be loaded and executed by the computer. The small, compact, medium, large, huge, and flat models generate .EXE files. See “.COM,” “tiny.”
|
exit code |
A code returned by a program to the operating system. This usually indicates whether the program ran successfully.
|
expanded memory |
Increased memory available after adding an EMS (Expanded Memory Specification) board to an 8086 or 80286 machine. Expanded memory can be simulated in software. The EMS board can increase memory from 1 megabyte to 8 megabytes by swapping segments of high-end memory into lower memory. Applications must be written to the EMS standard in order to make use of expanded memory. See “extended memory.”
|
expression |
Any valid combination of mathematical or logical variables, constants, strings, and operators that yields a single value.
|
extended memory |
Physical memory above 1 megabyte that can be addressed by 80286–80486 machines in protected mode. Adding a memory card adds extended memory. On 80386-based machines, extended memory can be made to simulate expanded memory by using a memory-management program.
|
extension |
The part of a filename (of up to three characters) that follows the period (.). An extension is not required but is usually added to differentiate similar files. For example, the source-code file MYPROG.ASM is assembled into the object file MYPROG.OBJ, which is linked to produce the executable file MYPROG.EXE.
|
external variable |
A variable declared in one module and referenced in another module.
F
|
far address |
A memory location specified with a segment value plus an offset from the start of that segment. Far addresses require 4 bytes—two for the segment and two for the offset. See “near address.”
|
field |
One of the components of a structure, union, or record variable.
|
fixup |
The linking process that supplies addresses for procedure calls and variable references.
|
flags register |
A register containing information about the status of the CPU and the results of the last arithmetic operation performed by the CPU.
|
flat |
A nonsegmented linear address space. Selectors in flat model can address the entire 4 gigabytes of addressable memory space. See “segment,” “selector.”
|
formal parameters |
The variables that receive values passed to a function when the function is called.
|
forward declaration |
A function declaration that establishes the attributes of a symbol so that it can be referenced before it is defined, or called from a different source file.
|
frame |
The segment, group, or segment register that specifies the segment portion of an address.
G
|
General-Protection (GP) fault |
An error that occurs in protected mode when a program accesses invalid memory locations or accesses valid locations in an invalid way (such as writing into ROM areas).
|
gigabyte |
1,024 megabytes, or 1,073,741,824 bytes.
|
global |
See “visibility.”
|
global constant |
A constant available throughout a module. Symbolic constants defined in the module-level code are global constants.
|
global data segment |
A data segment that is shared among all instances of a dynamic-link routine; in other words, a single segment that is accessible to all processes that call a particular dynamic-link routine.
|
global variable |
A variable that is available (visible) across multiple modules.
|
granularity |
The degree to which library procedures can be linked as individual blocks of code. In Microsoft libraries, granularity is at the object-file level. If a single object file containing three procedures is added to a library, all three procedures will be linked with the main program even if only one of them is actually called.
|
group |
A collection of individually defined segments that have the same segment base address.
H
|
handle |
An arbitrary value that an operating system supplies to a program (or vice versa) so that the program can access system resources, files, peripherals, and so forth, in a controlled fashion.
|
handler |
See “interrupt handler.”
|
hexadecimal |
The base-16 numbering system whose digits are 0 through F (the letters A through F represent the decimal numbers 10 through 15). This is often used in computer programming because it is easily converted to and from the binary (base-2) numbering system the computer itself uses.
|
high-level language |
A programming language that expresses operations as mathematical or logical relationships, which the language’s compiler then converts into machine code. This contrasts with assembly language, in which the program is written directly as a sequence of explicit microprocessor instructions. Basic, C, COBOL, and FORTRAN are examples of high-level languages. See “assembly language,” “compiler.”
|
hooking (an interrupt) |
Replacing an address in the interrupt vector table with the address of another interrupt handler. See “interrupt handler,” “interrupt vector table,” “unhooking (an interrupt).”
|
huge |
A memory model (similar to large model) with more than one code segment and more than one data segment. However, individual data items can be larger than 64K, spanning more than one segment. See “large.”
I
|
identifier |
A name that identifies a register or memory location.
|
|
|
IEEE format |
A standard created by the Institute of Electrical and Electronics Engineers for representing floating-point numbers, performing math with them, and handling underflow/overflow conditions. The 8087 family of coprocessors and the emulator package implement this format.
|
immediate expression |
An expression that evaluates to a number that can be either a component of an address or the entire address.
|
immediate operand |
In an assembly-language instruction, a constant operand that is specified at assembly time and stored in the program file as part of the instruction opcode.
|
import library |
A pseudo library that contains addresses rather than executable code. The linker reads the addresses from an import library to resolve references to external dynamic-link library routines.
|
include file |
A text file with the .INC extension whose contents are inserted into the source-code file and immediately assembled.
|
indirect memory operand |
In an assembly-language instruction, a memory operand whose value is treated as an address that points to the location of the desired data. See “pointer.”
|
instruction |
The unit of binary information that a CPU decodes and executes. In assembly language, instruction refers to the mnemonic (such as LDS or SHL) that the assembler converts into machine code.