Glossary

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

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.

In an assembly-language instruction, an immediate operand derived by applying the SEG or OFFSET operator to an identifier.

A range of memory bounded by two addresses.

The various ways a memory address or device I/O address can be generated. See “far address,” “near address.”

Data types containing more than one element, such as arrays, structures, and unions.

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.

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.

A value passed to a procedure or function. See “parameter.”

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.

A program that converts a text file containing mnemonically coded microprocessor instructions into the corresponding binary machine code. MASM is an assembler. See “compiler.”

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.”

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

The starting address of a stack frame. Base addresses are usually stored in the BP register.

The portion of the filename that precedes the extension. For example, SAMPLE is the base name of the file SAMPLE.ASM.

A way of representing decimal digits where 4 bits of 1 byte are a decimal digit, coded as the equivalent binary number.

Referring to the base-2 counting system, whose digits are 0 and 1.

A Boolean expression consisting of two operands joined by a binary operator and resolving to a binary number.

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.

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).

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.

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.

A reserved section of memory that holds data temporarily, most often during input/output
operations.

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

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.

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).”

See “string.”

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.

The filename extension for executable files that have a single segment containing both code and data. Tiny model produces .COM files.

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.

A memory model with multiple data segments but only one code segment.

A program that translates source code into machine language. Usually applied only to high-level languages such as Basic, FORTRAN, or C. See “assembler.”

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.”

Any expression that evaluates to a constant. It may include integer constants, character constants, floating-point constants, or other constant expressions.

D

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.

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

A setting or value that is assumed unless specified otherwise.

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.”

A text file used as input for the NMAKE utility.

A program that transforms I/O requests into the operations necessary to make a specific piece of hardware fulfill that request.

The window at the bottom of the CodeView screen where dialog commands can be entered, and previously entered dialog commands can be reviewed.

In an assembly-language instruction, a memory operand that refers to the contents of an explicitly specified memory location.

An instruction that controls the assembler’s state.

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.

See “dynamic-link library.”

To rapidly press and release a mouse button twice while pointing the mouse cursor at an object on the screen.

A real (floating-point) value that occupies 8 bytes of memory (MASM type REAL8). Double-precision values are accurate to 15 or 16 digits.

A 4-byte word (MASM type DWORD).

To move the mouse while pointing at an object and holding down one of the mouse buttons.

To display or print the contents of memory in a specified memory range.

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.”

A library file that contains the executable code for a group of dynamically linked routines.

A routine in a dynamic-link library that can be linked at load time or run time.

E

A single member variable of an array of like variables.

The section of memory containing the MS-DOS environment variables.

See “exit code.”

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.”

A code returned by a program to the operating system. This usually indicates whether the program ran successfully.

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.”

Any valid combination of mathematical or logical variables, constants, strings, and operators that yields a single value.

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.

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.

A variable declared in one module and referenced in another module.

F

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.”

One of the components of a structure, union, or record variable.

The linking process that supplies addresses for procedure calls and variable references.

A register containing information about the status of the CPU and the results of the last arithmetic operation performed by the CPU.

A nonsegmented linear address space. Selectors in flat model can address the entire 4 gigabytes of addressable memory space. See “segment,” “selector.”

The variables that receive values passed to a function when the function is called.

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.

The segment, group, or segment register that specifies the segment portion of an address.

G

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).

1,024 megabytes, or 1,073,741,824 bytes.

See “visibility.”

A constant available throughout a module. Symbolic constants defined in the module-level code are global constants.

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.

A variable that is available (visible) across multiple modules.

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.

A collection of individually defined segments that have the same segment base address.

H

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.

See “interrupt handler.”

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.

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.”

Replacing an address in the interrupt vector table with the address of another interrupt handler. See “interrupt handler,” “interrupt vector table,” “unhooking (an interrupt).”

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

A name that identifies a register or memory location.

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.

An expression that evaluates to a number that can be either a component of an address or the entire address.

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.

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.

A text file with the .INC extension whose contents are inserted into the source-code file and immediately assembled.

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.”

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.

See “prefix.”

A signal to the processor to halt its current operation and immediately transfer control to an interrupt handler. Interrupts are triggered either by hardware, as when the keyboard detects a keypress, or by software, as when a program executes the INT instruction. See “interrupt handler.”

A routine that receives processor control when a specific interrupt occurs.

See “interrupt handler.”

An address that points to an interrupt handler.

A table maintained by the operating system. It contains addresses (vectors) of current interrupt handlers. When an interrupt occurs, the CPU branches to the address in the table that corresponds to the interrupt’s number. See “interrupt handler.”

K

A word with a special, predefined meaning for the assembler. Keywords cannot be used as identifiers.

1,024 bytes.

L

A symbol (identifier) representing the address of a code label or data objects.

The specifier that establishes the naming and calling conventions for a procedure. These are BASIC, C, FORTRAN, PASCAL, STDCALL, and SYSCALL.

A memory model with more than one code segment and more than one data segment, but with no individual data item larger than 64K (a single segment). See “huge.”

A file that contains modules of compiled code. MS-DOS programs use normal run-time libraries, from which the linker extracts modules and combines them with other object modules to create executable program files. Windows-based programs can use dynamic-link libraries (see), which the operating system loads and links to calling programs. See also “import library.”

A data structure in which each entry includes a pointer to the location of the adjoining entries.

In normal static linking, the process in which the linker resolves all external references by searching run-time and user libraries, and then computes absolute offset addresses for these references. Static linking results in a single executable file. In dynamic linking (see), the operating system, rather than the linker, provides the addresses after loading the modules into separate parts of memory.

A constant whose scope is limited to a procedure or a module.

A variable whose scope is confined to a particular unit of code, such as module-level code, or a procedure. See “module-level code.”

A symbolic name for a device that can be mapped to a physical (actual) device.

A complete program statement in source code, including the initial line of code and any extension lines.

A memory area in which a program stores code, data, or stack information. See “physical segment.”

low-level input and output routines  Run-time library routines that perform unbuffered, unformatted input/output operations.

The bit lowest in memory in a binary number.

M

The binary numbers that a microprocessor interprets as program instructions. See “instruction.”

A block of text or instructions that has been assigned an identifier. When the assembler sees this identifier in the source code, it substitutes the related text or instructions and assembles them.

The module containing the point where program execution begins (the program’s entry point). See “module.”

See “8087, 80287, or 80387 coprocessor.”

A memory model with multiple code segments but only one data segment.

1,024 kilobytes or 1,048,576 bytes.

One of the elements of a structure or union; also called a field.

A number through which a program can reference a location in memory.

A representation of where in memory the computer expects to find certain types of information.

A convention for specifying the number and types of code and data segments in a module. See “tiny,” “small,” “medium,” “compact,” “large,” “huge,” and “flat.”

An operand that specifies a memory location.

A prefix that modifies the subsequent PWB function.

A word, abbreviation, or acronym that replaces something too complex to remember or type easily. For example, ADC is the mnemonic for the 8086’s add-with-carry instruction. The assembler converts it into machine (binary) code, so it is not necessary to remember or calculate the binary form.

A discrete group of statements. Every program has at least one module (the main module). In most cases, a module is the same as a source file.

A text file containing information that the linker uses to create a Windows-based program.

Program statements within any module that are outside procedure definitions.

The bit farthest to the left in a binary number. It represents 2^(n-1), where n is the number of bits in the number.

An operating system in which two or more programs, processes, or threads can execute simultaneously.

N

The way the compiler or assembler alters the name of a routine before placing it into an object file.

Acronym for “not a number.” Math coprocessors generate NANs when the result of an operation cannot be represented in IEEE format. For example, if two numbers being multiplied have a product larger than the maximum value permitted, the coprocessor returns a NAN instead of the product.

A memory location specified by the offset from the start of the value in a segment register. A near address requires only 2 bytes. See “far address.”

See “reentrant procedure.”

The ASCII character encoded as the value 0.

A pointer to nothing, expressed as the value 0.

O

Default filename extension for an object file.

A file (normally with the extension .OBJ) produced by assembling source code. It contains relocatable machine code. The linker combines object files with run-time and library code to create an executable file.

The number of bytes from the beginning of a segment to a particular byte within that segment.

The binary number that represents a specific microprocessor instruction.

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

One or more symbols that specify how the operand or operands of an expression are manipulated.

A variable that modifies the way a program performs. Options can appear on the command line, or they can be part of an initialization file (such as TOOLS.INI). An option is sometimes called a switch.

The CodeView screen that displays program output. Choosing the Output command from the View menu or pressing F4 switches to this screen.

An error that occurs when the value assigned to a numeric variable is larger than the allowable limit for that variable’s type.

A program component loaded into memory from disk only when needed. This technique reduces the amount of free RAM needed to run the program.

P

The name given in a procedure definition to a variable that is passed to the procedure. See “argument.”

Transferring the address of an argument to a procedure. This allows the procedure to modify the argument’s value.

Transferring the value (rather than the address) of an argument to a procedure. This prevents the procedure from changing the argument’s original value.

The true memory address of a segment, referenced through a segment register.

A variable containing the address of another variable. See “indirect memory operand.”

The relative position of an operator in the hierarchy that determines the order in which expression elements are evaluated.

Having the power to take precedence over another event.

A keyword (LOCK, REP, REPE, REPNE, REPNZ, or REPZ) that modifies the behavior of an instruction. MASM 6.1 ensures the prefix is compatible with the instruction.

Data items and routines local to the module in which they are defined. They cannot be accessed outside that module. See “public.”

A hardware-supported feature of the 80286–80486 processors that allows the programmer to specify the exclusivity of a program or process. Programs running at low-numbered privilege levels can access data or resources at higher-numbered privilege levels, but the reverse is not true. This feature reduces the possibility that malfunctioning code will corrupt data or crash the operating system.

The term applied to privilege level 0. This privilege level should be used only by a protected-mode operating system. Special privileged instructions are enabled by .286P, .386P, and .486P. Privileged mode should not be confused with protected mode.

An expression that invokes a procedure and passes actual arguments (if any) to the procedure.

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

A procedure declaration that includes a list of the names and types of formal parameters following the procedure name.

Generally, any executing program or code unit. This term implies that the program or unit is one of a group of processes executing independently.

A 256-byte data structure at the base of the memory block allocated to a transient program. It contains data and addresses supplied by MS-DOS that a program can read during execution.

The 80286–80486 operating mode that permits multiple processes to run and not interfere with each other. This feature should not be confused with privileged mode.

Data items and procedures that can be accessed outside the module in which they are defined. See “private.”

Q

A user-defined type consisting of an existing MASM type (intrinsic, structure, union, or record), or a previously defined TYPEDEF type, together with its language or distance attributes.

R

The base of a number system. The default radix for MASM and CodeView is 10.

Computer memory that can be both written to and read from. RAM data is volatile; it is usually lost when the computer is turned off. Programs are loaded into and executed from RAM. See “ROM.”

The normal operating mode of the 8086 family of processors. Addresses correspond to physical (not mapped) memory locations, and there is no mechanism to keep one application from accessing or modifying the code or data of another. See “protected mode.”

A MASM variable that consists of a sequence of bit values.

A procedure that can be safely interrupted during execution and restarted from its beginning in response to a call from a preemptive process. After servicing the preemptive call, the procedure continues execution at the point at which it was interrupted.

In an assembly-language instruction, an operand that is stored in the register specified by the instruction.

The optional CodeView window in which the CPU registers and the flag register bits are displayed.

Memory locations in the processor that temporarily store data, addresses, and processor flags.

A text expression that specifies a pattern of text to be matched (as opposed to matching specific characters).

Not having an absolute address. The assembler does not know where the label, data, or code will be located in memory, so it generates a fixup record. The linker provides the address.

The value returned by a function.

Computer memory that can only be read from and cannot be modified. ROM data is permanent; it is not lost when the machine is turned off. A computer’s ROM often contains BIOS routines and parts of the operating system. See “RAM.”

A generic term for a procedure or function.

The act of establishing a link when a process is running. See “dynamic linking.”

A math or logic error that can be detected only when the program runs. Examples of run-time errors are dividing by a variable whose value is zero or calling a DLL function that doesn’t exist.

S

The range of statements over which a variable or constant can be referenced by name. See “global constant,” “global variable,” “local constant,” “local variable.”

A screen-exchange method that uses buffers to store the debugging and output screens. When you request the other screen, the two buffers are exchanged. This method is slower than flipping (the other screen-exchange method), but it works with most adapters and most types of programs.

The bars that appear at the right side and bottom of a window and some list boxes. Dragging the mouse on the scroll bars allows scrolling through the contents of a window or text box.

A section of memory, limited to 64K with 16-bit segments or 4 gigabytes with 32-bit segments, containing code or data. Also refers to the starting address of that memory area.

The mode in CodeView in which no windows are available. Input and output scroll down the screen, and the old output scrolls off the top of the screen when the screen is full. You cannot examine previous commands after they scroll off the top. This mode is required with computers that are not IBM compatible.

A value that indirectly references a segment address. A protected-mode operating system, such as Windows, assigns selector values to programs, which use them as segment addresses. If a program attempts to use an unassigned selector, it triggers a General-Protection fault (see).

A memory segment that can be accessed simultaneously by more than one process.

A method of gaining access to the operating system without leaving CodeView or losing the current debugging context. It is possible to execute MS-DOS commands, then return to the debugger.

The process of widening an integer (for example, going from a byte to a word, or a word to a doubleword) while retaining its correct value and sign.

An integer value that uses the most-significant bit to represent the value’s sign. If the bit is one, the number is negative; if zero, the number is positive. See “two’s complement,” “unsigned integer,” “MSB.”

A real (floating-point) value that occupies 4 bytes of memory. Single-precision values are accurate to six or seven decimal places.

An environment in which only one program runs at a time. MS-DOS is a single-tasking environment.

A memory model with only one code segment and only one data segment.

A text file containing symbols that define the program.

The mode in which CodeView displays the assembly-language source code that

represents the machine code currently being executed.

An area of memory in which data items are consecutively stored and removed on a last-in, first-out basis. A stack can be used to pass parameters to procedures.

The portion of a stack containing a particular procedure’s local variables and parameters.

A short routine called on entry to a function to verify that there is enough room in the program stack to allocate local variables required by the function.

Changing the stack pointers to point to another stack area.

A symbolic representation of the functions that are being executed to reach the current instruction address. As a function is executed, the function address and any function arguments are pushed on the stack. Therefore, tracing the stack shows the active functions and their arguments.

The device to which a program can send error messages. The display is normally standard error.

The device from which a program reads its input. The keyboard is normally standard input.

The device to which a program can send its output. The display is normally standard output.

A combination of labels, data declarations, directives, or instructions that the assembler can convert into machine code.

See “linking.”

The line at the bottom of the PWB or CodeView screen. The status bar displays text position, keyboard status, current context of execution, and other program information.

A calling convention that uses caller stack cleanup if the VARARG keyword is specified. Otherwise the called routine must clean up the stack.

A contiguous sequence of characters identified with a symbolic name.

A string of characters and escape sequences delimited by single quotation marks
(' ') or double quotation marks (" ").

A set of variables that may be of different types, grouped under a single name.