DJGPP Lexicon

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

webmaster	delorie software privacy
Copyright © 1997	Updated Mar 1997