Please send changes or additions to DJ Delorie. Here's the source file.
There are 148 definitions in this lexicon.
- This is the default COFF output file name for djgpp's linker, ld. However, djgpp version 2 also creates an EXE file, whose default name
is a.exe. The -o option to gcc changes the default output name.
Also, the original Unix object format was called, for lack of imagination, the a.out format.
- Most processors deal with more than one byte at a time in memory, usually four or more bytes at a time. If a word in memory is lined up
on one of these boundaries, it can get it in one access. If not, it
needs two - one for part of it, one for the other part. When a word
is aligned, access is faster.
- A game programming library for djgpp, with sound, graphics, sprites, and many other functions you'll need.
- Short for "archiver". It makes archives (*.a), usually of objects (*.o). These are the unix equivalent of libraries.
- Short for "assembler". This is the GNU assembler, which makes COFF object files (*.o).
- The assembler converts machine-specific textual representations of each machine instruction (*.s) into binary values that the machine can
actually use (*.o). Usually, the compiler's job is to create such a
text file and let the assembler turn it into an object.
- When used in a djgpp conversation, this usually means that the AT&T assembler syntax is being used. This is also known as "motorola
format". This is the opposite of "intel format", which PC compilers
- Named after the three authers' initials, this program is a text filter - it can read lines of text and do interesting things with words on
- "Bourne Again SHell". This is a GNU replacement for /bin/sh, the original unix shell. This can replace command.com if you know what
you're doing. The DJGPP port of bash is designed to provide a
Unix-like interface for a DOS-based PC, and is recommended for DJGPP
users who are familiar with Unix.
- When your program needs to move data around, this is a big chunk of memory that is used to temporarily hold it.
See Also: transfer buffer, buffered i/o
- buffered i/o
- To save time, your program will often read or write more information at a time than you tell it. For example, if you print a thousand
characters, one at a time, it may just store them in a buffer and
print them all at once when you're done. You must use fflush() to
force the data to be written if you are printing a prompt.
- To convert one or more source files, objects, and archives into a working program. Sometimes, the results are also called a "build", as
in "last friday's build of libc".
- When you ask the computer to get something off the disk (or some other slow storage), it may remember the data, so that next time, it doesn't
have to go back to the disk to get it. The place that this data is
stored (usually in memory) is the cache. smartdrv is a cache for
disk; most high performance computers have a hardware cache for memory
- A small human.
- child process
- Programs can run other programs. For the sake of describing them, we refer to the first one (the one that causes the new program) as the
"parent process" and the second one (the new program itself) as the
See Also: spawn(ing)
- In gcc, when a function uses a register or memory location for something, it has "clobbered" that value, and gcc can't assume that it
still contains the previous value.
Also, if your program "clobbers" something, that usually implies that it shouldn't have.
- Stands for Common Object File Format. This describes the internal layout of object modules and executables on some unix systems and
See Also: a.out, ELF
- (Generally) A program that translates source code from a specific computer language into an executable program. (Specifically) A program
that translates preprocessed source code into assembly code - the second
pass of the compilation process. The specific compiler used varies
depending on the source language; for C it is 'cc1.exe'; for C++ it is
'cc1plus.exe'. Normally there is no need to invoke either of these
manually; 'gcc.exe' knows how to call them with the correct parameters.
- compiler passes
- GCC (and thus DJGPP) support many languages (C, Pascal, etc). These languages have a lot in common, as far as compiling them goes. To
reduce the size and complexity of each language's compiler, the
compilation is broken down into different parts, each handled by a
different program. When gcc runs these programs, those are the
compiler passes. The specific ones for C (for example), are the
preprocessor (for includes and defines), the C compiler itself, the
assembler, and the linker.n
- Stands for "C RunTime Zero", the first object to get linked into your programs. This handles all the messy bits of getting your program
started - environment, arguments, etc.
- Hold down the Control key and press the C key. This should interrupt any running program. Because MS-DOS treats this key special, so do
you if you want to use it for a game or something.
- Charles W Sandmann's DPMI server. Based on the old go32 programs from djgpp version 1, it is one of the few free DPMI servers in the
world, and supports DPMI 0.9. All djgpp v2 programs run only in a
- A program that lets you customize cwsdpmi's runtime defaults.
- delayed write
- If it thinks it can help performance, the operating system may decide not to write your data out to the disk right away. It will write it
out later when the disk isn't busy reading, or may reshedule the
writes to make the access more optimal. Make sure you wait for the
writes to finish before shutting off your machine!
- C++ compilers often create internal names for your functions that include information about the parameters they take (so that you can
overload functions with the same name). These "mangled" names are
hard for humans to use, so you can demangle them and get back the
function prototype they correspond to.
- A segment descriptor is a small amount of information that describes a segment's size, location, and attributes. This is normally put into a
segment register when you use it.
The term descriptor is also used to refer to any integer that refers to a resource, such as a file descriptor or shared memory descriptor.
See Also: selector, descriptor table
- descriptor table
- A list of all the usable segments and pseudo-segments (like the interrupt table) in the system. A selector is used to select one of
these descriptors when you need to use that segment.
- A program that compares two files and tells you what the differences are. The differences themselves are also called diffs. The patch
program can use these differences to update another copy of the
- A program that turns programs or objects back into source files. Often it is not possible to completely reconstruct the original code.
In addition, disassembly of most commercial and many non-commercial
products is strictly prohibited.
- This file tells the linker how to turn your object files into executable files. Mainly, it is concerned with organizing and
aligning the types of information in your program, but it also plays a
key role in setting up static C++ contructors.
- An old name for djgpp.djl. Windows didn't appreciate djgpp using the lnk suffix, so we renamed it in djgpp 2.01
- Stands for "DOS Protected Mode Interface". It is a standard way for protected mode programs to cooperate with the operating system and
See Also: DPMI server, EMS, XMS
- This function is used by DJGPP programs to call dos-type interrupts. Its use is preferred in most cases, because it initializes the stack
for you. It can sometimes take longer to call than you expect. An
online reference is at http://www.delorie.com/djgpp/doc/dpmi/
See Also: DPMI server
- DPMI server
- A program or process that listens to your program when your program needs to do something DPMI-ish. Also known as a "DPMI host".
- Converts text files from Dos TO Unix. Some djgpp programs that were ported from Unix still don't like dos-style text files, so you have to
convert them to Unix (removing carriage returns) to use them.
- When gcc dumps a report into a file or prints an error message, this is the name of the file to base all those reports and errors on.
- dword aligned
- A "dword" is a double word, or eight bytes. For fastest access, the address of a dword should be a multiple of eight (ex: 0x10018). When
it is, the dword is "dword aligned".
- The first External DEBUGger for djgpp's 32-bit programs. This is an assembler-level debugger, but it will print source lines if it can.
It's not powerful, but it was the first.
See Also: fsdb, gdb, rhgdb
- Another object file/executable format. Use by IRIX, Solaris, and Linux. Often, people ask if djgpp will switch from COFF to elf.
- Stands for Editing MACroS. This is a very popular programmer's editor, used mainly by unix programmers but now on many machines.
Emacs uses a pane-based format, has multiple modes for editing
different types of files, color syntax highlighting, automatic
indentation, and comes with its own extensible programming language
called ELisp. Emacs is highly recommended for intermediate to
- Stands for "Expanded Memory Specification". This is memory that complies with the original Lotus-Intel-Microsoft specification for
"banked" memory. This was before the 286 made it possible to access
16 Mb of memory; you do not need to enter protected mode to use it, so
many 16-bit programs prefer it.
See Also: DPMI, XMS
- Something that pretends to be or substitutes for something else. In DJGPP, the floating point processor (80387 if you have a 80386, or
80487 if you have a 486XS) may be emulated with software on machines
that don't have one in hardware.
See Also: emulator library
- emulator library
- In djgpp, this is libemu.a. If you link your program with this, your program will run on machines without a floating point processor, even
if your program needs one.
See Also: emulator, wmemu
- Eberhard Mattes eXtender for OS/2. Since EMX (which is like djgpp, but for OS/2) also runs under DOS, it and djgpp share a number of
- A program that converts 32-bit .OBJ files (microsoft format) into 32-bit .O files (djgpp format).
See Also: obj2coff
- fatal signal
- A "signal" is a message that the operating system (or other programs) sends to your program. Signals are used for exception cases as well,
like division by zero. If you don't make arrangements to deal with a
signal, your program will often be terminated when one happens. Those
signals are fatal.
- Full Screen DeBugger. This is an extended version of edebug32 that supports multiple windows, but is still pretty low-powered.
See Also: gdb, rhgdb
- The Free Software Foundation. http://www.fsf.org/
- The GNU Assembler (as) is called "gas" to keep from confusing it with the standard unix assembler, also called "as".
- The GNU Debugger. This is an *extremely* powerful debugger, but it's not screen-oriented like rhgdb is.
- An interesting term that represents the wildcard expansion process that djgpp uses to convert wildcard patterns on the command line into
lists of files that they match.
- Stands for "GNU's Not Unix". This is a software project run by the FSF to write freely redistributable replacements for unix programs.
- The original dos extender for DJGPP Version 1. It made the program "go into 32-bit mode", hence the name. In DJGPP Version 2, it is no
longer used. DPMI and the runtime library do all the work now.
Reliance on go32 was removed for various reasons, such as instability, lack of true DPMI portability, and the need to purchase Turbo-C to
- A program shipped with DJGPP Version 2 that can be renamed to "go32" if you have a makefile or something that calls go32 directly. All it
does is run the program you pass it. It also prints memory
information, so that you can see what's available for your programs.
- gp fault
- A General Protection Fault. This usually happens when you try to do something you shouldn't do, like access memory outside your
- The GNU General Public License. This requires that if you use GPL sources in any binary you distribute, you must distribute sources for
that binary also.
See Also: LGPL
- Stands for "Global Regular Expression Print". Searches a text file for a string or pattern you give it, and prints the lines that match.
- The first graphics library for djgpp was simply called "gr". This is the extended version, "grx". It is in "extended beta testing," and
has not been updated for quite some time. Unless you are particularly
attached to it, we recommend that you examine the Allegro library
for serious graphical programming.
- A command in gdb that uses hardware to stop your program at a specific spot. That spot is called a "break point". You must use
hardware, and not software, breakpoints when debugging under Windows
- Some header files from the C++ library were renamed to begin with an underscore, because they differed only in case - like string.h and
String.h, so String.h became _string.h. This is due to MS-DOS's case
- header files
- Each module of your program is made of two parts: the declarations and specifications for the interface, and the implementation, which has
the actual functions and data. The declarations go into a separate
file that other modules can share. This file is called a header file,
since it (1) contains the "top-level specification" and (2) is listed
at the top (head) of your source file.
- Your program uses a number of memory regions when it runs. The program itself (the code) is stored in the "text" region (go figure,
but it is the part the computer reads). The data is in the "data"
region. These are at the bottom of the memory space. The stack is at
the top (in unix, at least - in djgpp it's inside the data region).
When you need more memory (malloc), the operating system heaps it on
top of your existing data area. This extra memory region is thus
called the heap.
- A program used to fix a bug in an older version of the cwsdpmi DPMI host that caused it to crash when a program attempted to allocate too many
blocks of memory. The fix has been incorporated into later versions of
- A program that reads "info files". The standard format for GNU documentation (and thus djgpp) is texinfo, which can be readily
converted into many other formats. The plain-text but still hypertext
version is info, which can be read by the info program and emacs.
- info browser
- A program that can read info files.
- When a function is inlined, the compiler inserts those instructions directly into the program, rather than going through all the trouble
to call a separate function. This is much faster, but makes larger
programs and can only be used for simple functions.
- internal tables
- This is a generic term that refers to information that programs generate, use themselves, and then discard.
- This is the way the machine tells the program that something it wasn't expecting happened, like the user hitting a key or a disk write
completing. In unix and djgpp, these are often called signals
once they get into your program.
See Also: fatal signal
- interrupt handlers
- If you want to handle interrupts yourself, you can install an interrupt handler. This is a special function, usually written in
assembler, that can run in the special environment that interrupts are
- GNU's linker is called ld. It's short for "loader", meaning the programs that loaded all your objects into one big program.
- Long File Names. This term refers to the Windows 95 way of dealing with long file names (rather than dos's 8.3 limitation). The LFN
environment variable can be used to override what your programs wil
normally do (pretend to be DOS, or use Win95 long names).
- Like the GPL, but it only requires that you distibute objects for the non-LGPL parts.
- Means different things, depending on context. You link object modules together to make a program. A symbolic link is a tiny file that lets
you refer to a larger file by a different name.
- link line
- When your program is made up of many source modules, you normally compile each of them separately into objects, then link them
afterwards. The command you use to do the linking is usually called
the "link line". Normally, compiling involves the -c option, and
linking uses one or more -l options to specify libraries.
- A program that reads object files and object archives, links them together, and makes a program out of it. DJGPP's linker is called ld.
- linker passes
- Some linkers read your objects many times, in order to resolve function calls and such. DJGPP's linker (ld) passes through each
object and library only once, in the order you list them. Thus, ld is
a "one-pass" linker, and you have to be careful about the order you
list things. Also, when you're talking about compiler passes, the
linker pass is the last one.
- A unix program, recently ported to DOS, that creates hard or symbolic links. It's only useful in djgpp because it makes "stub" links, which
are tiny djgpp programs that invoke other programs but with a
different name. For example, grep, fgrep, and egrep are all the
same exact program, but they act differently based on what name you
give them. One is the real program, the other two are "symbolic
links". The ln program makes those.
- low memory
- The first 640k (or the first 1M, depending on who you talk to) of memory in your PC. Old 16-bit programs could only use low memory, and
there wasn't very much of it, so the lack of memory was often a
problem. Even in a protected mode program, you still need to copy
data to a buffer in low memory if you want to pass it to DOS.
- A program that can be taught how to make your program from its sources, so that all you have to type is "make" to build everything
that needs to be built.
See Also: build
- A function that allocates memory from the heap. This is the way you create a buffer at runtime. You must free() this memory if you want
to reuse it in your program, but all memory is freed when your program
- memory lock
- When you use virtual memory, sometimes the OS moves memory around without warning. You can lock down parts of your memory so that they
don't move, and remain in physical memory.
- memory manager
- A program that manages all the memory in your system, except for the low memory. Such a program usually provides one or more ways for
your program to talk to it, like DPMI, EMS or vcpi.
- memory-mapped devices
- A hardware device whose communication ports show up as part of your memory space, so that you can talk to it with regular C commands. The
other type of device uses the I/O instructions (like inport() and
outport()) to talk to it.
Traditionally, text video memory is mapped at physical address B8000h, and graphics memory is mapped at address A0000h. However, one of the
tricks of DPMI is that you cannot directly access this memory without
using one of several special techniques.
- A program that lists all the symbol NaMes (functions, variables, etc) in your program.
- numeric exception
- When you do something like divide by zero or add infinity, this is an exceptional case called a "numeric exception". This may cause a
fatal signal or it may just do the "Right Thing" (like 1/0 ->
- The default extension for microsoft-style object files. An object file is a part of a complete program's machine code.
- A program that converts 32-bit microsoft-style object files into djgpp-style COFF object files. Warning: Even if the conversion
works, the resulting program is likely to crash in some cases! Not
all objects do the Right Thing in a djgpp environment.
See Also: emxaout
- A GNU program that can tell you what's in different parts of an object file.
- GCC will normally make structure members aligned to improve performance. However, some file formats require that this not happen,
so you can tell gcc to pack all the members together. For example, a
structure with one character and one integer is eight bytes if you
don't pack it and five bytes if you do. GCC uses the
__attribute__((packed)) syntax to control this.
- If a program needs more memory than your computer has available, the operating system may take other parts of your program that you're not
using, and copy them out to disk in order to use that memory for other
things. It may also rearrange the physical memory it has to put
memory where you need it. The smallest unit of memory it can deal
with is a "page" of memory, or about 4096 bytes on a PC.
- A human who has a child.
- parent process
- See child process
- When you patch a tire, you put a little fix on it so that you can keep using it without getting a whole new tire. In software, a patch is a
small change in the code (source or executable) that makes the program
work better, without having to get a whole new program. The patch
program can use a diff to update a text file.
- A standard that defines the way a compatible Unix system operates. While MS-DOS can't support some of the POSIX functions, DJGPP tries to
support as many as it can.
- A Persistance Of Vision RAY tracer. This program renders really neat three-dimensional pictures from a description of the objects within
- When a program runs, the instance of that program running is a process. In Unix, you can run the same program twice, making two
- You can ask the compiler to watch your program run and tell you where all the time went (how much was spent in each function, how many times
they were each called, who they called, etc). It then summarizes the
statistics into a profile of your program. The program that does this
- protected mode
- This is when the computer is running in a mode whereby the operating system can protect its resources from the program that runs. This
allows the OS to run multiple programs at the same time, without
letting them interfere with each other.
In addition to that, protected mode is also the only way to make programs too big for low memory.
In protected mode, your program has complete and total freedom to roam around its own address space, but when it begins poking around outside
of its assigned space, it needs to use special techniques to tell the
operating system that what it's doing is okay. DOS adds additional
complications, since it is a 16-bit operating system and DJGPP
programs run as 32-bit applications. To talk to DOS, 32-bit programs
must do lots of complicated and time-consuming things (see the FAQ).
The tradeoff is that, while in protected mode, programs can run quite
a bit faster than in real mode, manage memory much more efficiently,
and the programmer can take comfort in the knowledge that a stray
pointer won't accidentally wipe out his hard drive.
- protection fault
- If you try to access something that the operating system doesn't want you to access, it stops your program instead of letting you do it.
This is a protection fault. The OS will send you a fatal signal
when it happens.
- protection violation
- Same as a protection fault, but it refers to the in appropriate action, rather than the results of that action.
- real mode
- A misnomer. It's actually unprotected mode. In this mode, the old 16-bit DOS programs run. It's also the *only* mode for old PCs (like
8086 machines). Also called "dos mode", although that's not as
accurate these days. In real mode, you can only access 1Mb of memory.
- A program that allows you to do fancy redirection. It's in djdev201.zip. With it, you can save the errors from gcc to a file.
- relocatable object file
- When you compile a source file, but before you link it, it doesn't know what it's final location will be. The assembler stores
additional information in the object to allow the linker to modify
the code in the object depending on where it winds up in the final
- rhide's debugger, which is based on gdb.
- Robert Hoehne's Integrated Development Environment, for djgpp. This is like Borland's IDE, but is way cooler.
- Rainer Schnitker's eXtender. This allows you to use gcc (either djgpp or emx) to create Windows GUI programs (32-bit, for Win95 or WinNT).
- The top of the heap is called the "break" (if you go past it, your program breaks). The brk() function sets this limit directly, and the
sbrk() function allows you to change the break by adding a
(relatively) small amount to the exsting break. For example,
sbrk(4069) increases your available memory by 4096 bytes.
- A text file that contains commands for some other program to execute. This is the Unix name for what MS-DOS calls a "batch file", but since
you can specify which program reads the file (rather than just
command.com), it can be much more powerful.
- Stands for "Stream EDitor". This is a filter (reads text, prints text) that can edit the lines it sees before it prints them.
- The value that you put in a segment register is a selector, because it selects one of the descriptors from the descriptor table for you
- A function that changes the type of buffered i/o a file uses.
- Any program that reads commands from the user and executes them. COMMAND.COM is a shell. bash is another shell.
- Each type of signal (or interrupt) has a name, all starting with SIG. SIGSEGV means a segmentation violation signal, SIGINT means an
interrupt (ctrl-c), SIGALRM is the alarm clock, etc.
- An ms-dos program that gives you a cache for your hard drives and CD-ROM. Use of a disk cache is strongly recommended when using djgpp.
- A custom utility that comes with the MVGA-S3C911 Graphics Adapter.
- source modules
- When you write a large program, it's easier to work with if you split it up into multiple source files. When you do this, you have to write
header files for them. The combination of source file and header is
a source module.
- Like the biblical meaning, this is when a parent process creates a child process. The spawn family of functions (ex: spawnvpe()) do
- A section of memory in which you can stack up data. Like a deck of cards, you always put things on the top and take them off the top.
This is used extensively for nested functions, local variables, and
- stack dump
- Since function calls use the stack, when your program crashes it can read that information in the stack to find out what functions were
running when it crashed. This is a stack dump.
In gdb a stack dump tells you what's on the top of the stack at the moment. It can also use the stack to tell you the values of
- stack frame
- That part of the stack that holds the data local to a function call.
- stack frame pointer
- The register that refers to the current stack frame>
- stack space
- The space where the stack lives. If you run out, your program crashes in such a way that you don't realize that this is the problem.
- startup code
- When MS-DOS starts your program, there is a lot to do before it actually calls the part that you wrote. Depending on the language you
wrote your program in, different things have to happen to support that
language. For example, C programs have to figure out what the
arguments to main() are.
The startup code that is part of every DJGPP program handles starting up the DPMI host, processing the command line, reading the system and
DJGPP environment, handling interrupts and exceptions, and handling
the tricky interface between real and protected mode. Many users ask
about the seemingly large size of DJGPP executables without realizing
what it is that they are getting for all that space. Also, the
startup code is a fixed size, meaning that the larger your program is,
the less proportional amount of it will be taken up by the startup
See Also: crt0.*
- This variable can be set by your program to change the amount of stack space it has. Stack space is consumed mainly by function
calls, automatic variables, and calls to alloca().
- A program that removes debugging information from your executable. This makes the program smaller, but nearly impossible to debug. You
can also give gcc the -s option to strip your program by default.
- MS-DOS only knows how to run EXEs. DJGPP produces COFF programs. The stub is a little tiny 16-bit MS-DOS program that knows how to run
COFF programs, so djgpp sticks it onto your program to get it
See Also: stubedit, stubify
- A program that modifies a number of parameters in the stub, such as the name of the DPMI server, the amount of stack space to
allocate, and the size of the transfer buffer.
See Also: stub
- A program that puts the stub on your program.
- When you are paging memory out to disk, this is swapping (compared to just rearranging memory internally).
- swap file
- A file that holds the parts of your program that don't fit into physical memory.
See Also: paging
- symbolic link
- A tiny file that represents another larger file. This allows you to have one program that can be called with different names. In unix,
this is part of the file system, and can be used for any type of file.
MS-DOS does not support symbolic links, but djgpp emulates them for
executables by using a modified stub with no COFF program attached
See Also: ln
- A program that reads a stack dump off the screen and converts all those meaningless numbers into source file names and line numbers, so
that you can see where it crashed. Use "gcc -g" to get useful
- In gcc, this is the machine that the program you are compiling will run on. In gdb, this is the program you will be debugging.
- Like hbreak, but only happens once and then it's removed.
See Also: gdb
- When your program crashes and gives you a stack dump, the data that it returns, after you run symify is a traceback. It lets you trace
back through your program to find out how you got there.
You can also ask gdb to give you a traceback when you're debugging.
- transfer buffer
- A buffer that the stub sets up in low memory for your program to use when it needs to send data to or from ms-dos.
See Also: stubedit, __dpmi_int
- Stands for "Terminate and Stay Resident". It allows a program to exit, but remain in memory, so that it can provide additional services
to other programs or deal with interrupts. Examples: virus
scanners, memory managers, disk cache programs, etc.
- uninitialised memory
- When you ask the operating system for memory with sbrk, the memory it gives you has unspecified values in it - it has not been given a
known initial value.
- unresolved externals
- When you write a program, you may call functions in other source modules or in an archive. The compiler doesn't know if those
functions exist when it compiles the source, but when the linker
tries to link your program, any references to functions that it
can't find are unresolved externals (external meaning it's not in the
same module that it was called from).
The most common (FAQ) reason for this error is that you forgot to link a library (like -lstdcxx), or you put the library before the objects
(they should be at the end of the command line).
- unroll loops
- If you have a small loop with a fixed number of iterations, the compiler may decide it's faster to just repeat the instructions that
many times instead of actually putting a loop in there.
- The reverse of dtou - converts unix files (like you'd get off the Internet) into dos text files, so that you can use your favorite dos
text editor without confusing it.
- virtual memory
- When the operating system uses paging and a swap file to let your program become bigger than the amount of physical memory you have, the
memory your program thinks is there is called virtual memory.
- William (Bill) Metzenthen's EMUlator. You need to use this one, and not the default one, if you want to debug emulated floating point
See Also: emulator library
- word aligned
- Like dword aligned but words are only four bytes, so this means that an address is a multiple of four. Aligning objects allows the CPU to
access them faster.
- A function (usually in assembler) that cleans up the environment and calls a regular function. This allows you to use regular functions in
cases where you normally wouldn't be able to. For example,
__dpmi_int is a wrapper function that calls the raw DPMI interface
- write back
- When you finally get around to writing out a delayed write in a cache, that's a write back (you're writing it back out).
- write behind
- A type of cache where the data is written to the cache and to the disk (or slower memory) at the same time.
- Stands for "eXtended Memory Specification". A standard way of allocating and using memory above the 1Mb boundary.
See Also: EMS, DPMI, low memory