www.delorie.com/djgpp/doc/lexicon/   search  
DJGPP Lexicon

Please send changes or additions to DJ Delorie. Here's the source file.

There are 148 definitions in this lexicon.

a.out
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.

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

Allegro
A game programming library for djgpp, with sound, graphics, sprites, and many other functions you'll need. http://www.talula.demon.co.uk/allegro/

ar
Short for "archiver". It makes archives (*.a), usually of objects (*.o). These are the unix equivalent of libraries.

as
Short for "assembler". This is the GNU assembler, which makes COFF object files (*.o).

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

AT&T
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 usually use.

awk
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 each line.

bash
"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.

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

build
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".

cache
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 as well.

child
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 "child process".

See Also: spawn(ing)

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

COFF
Stands for Common Object File Format. This describes the internal layout of object modules and executables on some unix systems and DJGPP. http://www.delorie.com/djgpp/doc/coff/

See Also: a.out, ELF

compiler
(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

crt0.*
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.

ctrl-c
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.

cwsdpmi
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 DPMI environment

cwsparam
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!

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

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

diff
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 original file.

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

djgpp.djl
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.

djgpp.lnk
An old name for djgpp.djl. Windows didn't appreciate djgpp using the lnk suffix, so we renamed it in djgpp 2.01

DPMI
Stands for "DOS Protected Mode Interface". It is a standard way for protected mode programs to cooperate with the operating system and MS-DOS.

See Also: DPMI server, EMS, XMS

__dpmi_int
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".

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

dumpbase
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".

edebug32
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

ELF
Another object file/executable format. Use by IRIX, Solaris, and Linux. Often, people ask if djgpp will switch from COFF to elf.

emacs
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 advanced programmers.

EMS
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

emulator
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

EMX
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 utilities. ftp://ftp-os2.cdrom.com/pub/os2/emx09c/

emxaout
A program that converts 32-bit .OBJ files (microsoft format) into 32-bit .O files (djgpp format). ftp://ftp.scitechsoft.com/devel/emxaout1.zip

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.

fsdb
Full Screen DeBugger. This is an extended version of edebug32 that supports multiple windows, but is still pretty low-powered.

See Also: gdb, rhgdb

FSF
The Free Software Foundation. http://www.fsf.org/

gas
The GNU Assembler (as) is called "gas" to keep from confusing it with the standard unix assembler, also called "as".

gdb
The GNU Debugger. This is an *extremely* powerful debugger, but it's not screen-oriented like rhgdb is.

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

GNU
Stands for "GNU's Not Unix". This is a software project run by the FSF to write freely redistributable replacements for unix programs.

go32
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 build it.

go32-v2
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 allocation.

GPL
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

grep
Stands for "Global Regular Expression Print". Searches a text file for a string or pattern you give it, and prints the lines that match.

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

hbreak
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 3.1.

_header
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 insensitivity.

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.

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

heap-fix
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 the host.

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

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

interrupt
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 processed in.

ld
GNU's linker is called ld. It's short for "loader", meaning the programs that loaded all your objects into one big program.

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

LGPL
Like the GPL, but it only requires that you distibute objects for the non-LGPL parts.

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

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

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

make
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

malloc
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 exits.

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.

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

obj
The default extension for microsoft-style object files. An object file is a part of a complete program's machine code.

obj2coff
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

objdump
A GNU program that can tell you what's in different parts of an object file.

pack(ing)
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.

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

parent
A human who has a child.

parent process
See child process

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

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

povray
A Persistance Of Vision RAY tracer. This program renders really neat three-dimensional pictures from a description of the objects within it. http://www.povray.org/

process
When a program runs, the instance of that program running is a process. In Unix, you can run the same program twice, making two processes.

profile
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 is gprof.

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.

redir
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 program.

rhgdb
rhide's debugger, which is based on gdb.

rhide
Robert Hoehne's Integrated Development Environment, for djgpp. This is like Borland's IDE, but is way cooler. http://www.tu-chemnitz.de/~rho/rhide.html

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

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

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

sed
Stands for "Stream EDitor". This is a filter (reads text, prints text) that can edit the lines it sees before it prints them.

selector
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 to use.

setvbuf
A function that changes the type of buffered i/o a file uses.

shell
Any program that reads commands from the user and executes them. COMMAND.COM is a shell. bash is another shell.

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

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

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

spawn(ing)
Like the biblical meaning, this is when a parent process creates a child process. The spawn family of functions (ex: spawnvpe()) do this.

stack
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 recursion.

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 local variables.

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

See Also: crt0.*

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

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

stub
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 running.

See Also: stubedit, stubify

stubedit
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

stubify
A program that puts the stub on your program.

swap
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 to it.

See Also: ln

symify
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 debugging information.

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

thbreak
Like hbreak, but only happens once and then it's removed.

See Also: gdb

traceback
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

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

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

wmemu
William (Bill) Metzenthen's EMUlator. You need to use this one, and not the default one, if you want to debug emulated floating point instructions.

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.

wrapper
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 for you.

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.

XMS
Stands for "eXtended Memory Specification". A standard way of allocating and using memory above the 1Mb boundary.

See Also: EMS, DPMI, low memory


  webmaster   donations   bookstore     delorie software   privacy  
  Copyright 1997   by DJ Delorie     Updated Mar 1997