Glossary
These definitions are of terms
as they are used in this list.
Some of these terms have more formal definitions which are
slightly
different.
Many of these terms are from the ANSI/ISO C Standard;
see ANSI Sec. 1.6 or ISO Sec. 3.
- aggregate
- n.
An array or structure type.
adj.
Refers to such a type.
- actual argument
- See argument.
- alias
- n.
A reference
(usually in the form of a pointer)
to an object which is also known via other references
(i.e. its own name,
or
other pointers).
vt.
To create such a reference.
- ANSI
- n.
The American National Standards Institute.
adj.
Used informally to refer to Standard C;
see question 11.1.
- argument
- n.
A value which is passed
in an argument list
during a function call
or function-like macro invocation.
Often emphasized ``actual argument.''
Compare parameter.
- argv
- n.
The traditional name for the array
(``vector'')
of command-line arguments
which is passed to main()
when a C program is invoked;
see questions
11.12b
and
20.3.
- arithmetic
- adj.
Refers to a
type or
value on which
conventional
arithmetic can be performed.
The arithmetic types in C are
the integral types (q.v.)
and the floating types
(float, double, and long double).
- ASCII
- n.,adj.
The American
Standard Code for Information Interchange,
ANSI X3.4-86.
- assignment context
- n.
An expression
context
which is recognizably the source
of an assignment
or conversion
to a destination
of known type.
The assignment contexts in C
are
initializations,
the right-hand side of assignment expressions,
casts,
return statements,
and
function
arguments
in the presence of a
prototype.
- automatic
- adj.
(Often as ``automatic duration.'')
Refers to an object which has its storage automatically allocated
on entry to
a function
(or a nested block),
and deallocated upon return from the function
(or exit from the block).
In other words,
refers to local, nonstatic variables
(as opposed to global variables,
or static variables whether inside or outside of a function).
Compare static, sense 1.
See question 1.30.
- big-endian
- adj.
Refers to storage of a multi-byte quantity
with the most-significant byte
at the lowest
address.
See also byte order.
- binary
- adj.
1.
Base two.
2.
Refers to I/O done in a byte-for-byte or bit-for-bit way,
without formatting or interpretation,
i.e. a direct copy operation
between internal memory and external storage.
3.
Refers to
a
file which is to be interpreted as a sequence of raw bytes,
in which
any byte values may appear.
Compare text.
See questions
12.38,
12.40,
and
20.5.
4.
Refers to an operator taking two operands.
Compare unary.
- bind
- vt,vi.
Informally, to ``stick to'' or ``stick together'';
usually used to indicate which operand(s) are associated with
which operator,
based on precedence rules.
- bitmask
- n.
A mask, sense 1.
- byte
- n.
A unit of storage suitable for holding one character.
Compare octet.
See question 8.10.
See ANSI Sec. 1.6
or ISO Sec. 3.4.
- byte order
- n.
The characteristic ordering of multi-byte quantities
(usually integral)
in memory,
on disk,
or in a network or other bytewise I/O stream.
The two
common
byte orders
(most-significant-first and least-significant-first)
are often called
big-endian and little-endian
(q.v.).
- canonical mode
- n.
The mode of a terminal driver
in which input is collected a line at a time,
allowing the user to correct mistakes
with the
backspace/delete/rubout or other keys.
See question 19.1.
- .c file
- n.
A source file, sense 2.
(See questions 1.7 and 10.6.)
- cast
- n.
The syntax
( type-name )
where type-name is a type name
such as int or char *
;
used to indicate an explicit conversion of a value
to another type.
vt.
To convert a value using a cast.
- conforming
- adj.
1.
Refers to an implementation
(a compiler or other language processor)
which will accept any strictly conforming (q.v.) program.
2.
Refers to a program which is acceptable to a conforming implementation.
(See ANSI Sec. 1.7 or ISO Sec. 4.)
- cpp
- n.
The traditional name for a standalone program
implementing the features of the C preprocessor.
- decay
- vi.
To undergo an implicit transformation
to
a value
of
slightly reduced type.
Informally,
arrays and functions tend to decay into pointers in C.
See questions 6.3 and 1.34.
- declaration
- n.
1.
In general,
a syntactical element
which describes the name and type
of one or more
variables, functions,
structures, unions, or enumerations.
2.
More specifically,
such a description
which refers to a variable or function
which has its definition elsewhere.
See question 1.7.
- declarator
- n.
The ``second half'' of a C declaration,
consisting of an identifier name
along with optional *, [], or () syntax
indicating
(if present)
that the identifier is
a pointer, array, function, or some combination.
See question 1.21.
- definition
- n.
1.
A declaration
of a variable or function
which allocates and optionally initializes
(in the case of a variable)
or provides the function body
(in the case of a function).
A definition in this sense is the opposite of
declaration, sense 2.
See question 1.7.
2.
A declaration of a structure, union, or enumeration type
which describes the type
(and usually assigns a tag)
without necessarily defining any variables of that type.
3.
A preprocessor #define directive.
- dereference
- vt.
To look up a value referred to.
Usually, the ``value referred to''
is the value pointed to by a pointer,
so to ``dereference a pointer''
simply means to see what it points to
(in C,
either
with the unary * operator
or the ``array subscripting'' operator []).
Occasionally,
may refer to the fetching of the value of any variable.
See also indirect.
- dope vector
- n.
An array
(or pointer-simulated array)
which consists merely of pointers to other arrays
(or other pointer-simulated arrays).
See also ragged array.
See questions 6.16
and 20.2.
- endianness
- n.
byte order
(q.v.).
- external
- n.
A function or variable which is referred to,
but not defined,
by some source file
(or object module).
Often
shows up
in the error message ``undefined external''
printed by a linker
when a definition
cannot be found.
- field
- n.
1.
Loosely,
a
member of a structure or union.
(An unambiguous term is member.)
2.
Specifically, a bitfield
(see question 2.25).
- formal parameter
- n.
See parameter.
- freestanding environment
- A C environment which does not support the C libraries;
one
intended for embedded applications and the like.
Compare hosted environment.
(See ANSI Sec. 1.7 or ISO Sec. 4.)
- FSF
- n.
The Free Software Foundation.
- FTP
- 1.
n.
The internet
File Transfer Protocol.
2.
vt.
To transfer a file by FTP.
- full expression
- The complete expression that forms an expression statement,
or one of the controlling expressions of an if,
switch, while, for, or
do/while statement,
or the expression in an initializer or a return statement.
A full expression is not part of a larger expression.
(See ANSI Sec. 3.6 or ISO Sec. 6.6.)
- function pointer
- n.
A pointer to any function type.
Compare object pointer.
- gcc
- n.
The FSF's GNU C compiler.
- GNU
- n.
The FSF's ``GNU's Not Unix!'' project.
- .h file
- n.
A header file.
- header file
- n.
A file containing declarations and certain definitions,
but not function bodies or global variable definitions,
incorporated into a translation unit during
preprocessing via the #include directive.
Compare source file.
See question 10.6.
- H&S
- The book
C: A Reference Manual,
by Samuel P. Harbison and
Guy L. Steele, Jr.
(see the Bibliography for a complete citation).
- hosted environment
- A C environment which also supports the C libraries.
Compare freestanding environment.
(See ANSI Sec. 1.7 or ISO Sec. 4.)
- idempotent
- adj.
Acting exactly once;
innocuous if re-applied.
In C,
usually refers to header files;
see questions 10.7 and 11.21.
- identifier
- n.
A name,
usually having meaning
in a particular namespace and scope.
See question 1.29.
- implementation
- n.
A compiler or other language translator,
together with its run-time libraries.
Used in constructions such as
``Whether plain char is signed or unsigned
is implementation-defined''
and
``These identifiers are reserved to the implementation.''
- implementation-defined
- adj.
Refers to behavior which is not fully specified by the Standard
but which is required to be defined,
and documented,
by any particular implementation.
Example: whether plain char is signed or unsigned.
See question 11.33.
- #include file
- n.
A header file.
- incomplete type
- n.
A type which is not completely specified,
but which may nevertheless be used in some contexts.
Examples:
dimensionless arrays;
structure or union types with tags but without member information.
(See ANSI Sec. 3.1.2.5 or ISO Sec. 6.1.2.5.)
- in-band
- adj.
Refers to a sentinel value
which is not always
unique within the set of values where it appears.
Compare out-of-band.
Example: CP/M or MS-DOS control-Z end-of-file markers.
See question 12.40.
- indirect
- vi.
To apply a level of indirection.
For example, to ``indirect on a pointer''
means
to chase
where the pointer points to
(as opposed to merely discovering the pointer's value).
See also dereference.
- int
- n.
The integral type,
usually matching a machine's natural word size,
which is most often used
(and in some cases is used by default)
to represent integers in C.
- integer
- n.
An integer of some size
(perhaps short or long),
not necessarily plain int.
- integral
- adj.
Refers to a type which can represent integers.
The integral types in C are:
char,
three sizes of int
(short, plain, and long),
signed and unsigned variants of all of these,
and enumerations.
- ISO
- The International Organization for Standardization
or
Organisation Internationale de Normalisation.
- K&R
- n.
1.
The book
The C Programming Language
(see the Bibliography for a complete citation).
2.
That book's
authors,
Brian Kernighan and Dennis Ritchie.
adj.
Refers to the early version of C described in the first edition
(``K&R1'') of the book.
- lhs
- n.
The left-hand side,
usually of an assignment,
or more generally,
of any binary operator.
- lint
- n.
A program written by Steve Johnson
as
companion to his pcc,
for performing cross-file and other error checking not normally
performed by C compilers.
The name supposedly derives from
the bits of fluff it picks from programs.
vt.
To check a program with lint.
- little-endian
- adj.
Refers to storage of a multi-byte quantity
with the least-significant byte
at the lowest
address.
See also byte order.
- lvalue
- n.
Originally,
an expression
which could appear
on the left-hand sign of an assignment operator,
hence,
something that can perhaps be assigned to.
More precisely,
something that has a location,
as opposed to a transient value.
In the assignment
a = b;
a is an lvalue, and is not fetched, but is written to.
Compare rvalue.
See also question 6.7.
See ANSI Sec. 3.2.2.1 (especially footnote 31)
or ISO Sec. 6.2.2.1.
- mask
- 1.
n.
An integer value
which is intended specifically as a pattern of 1's and 0's
with which to perform bitwise operations
(&, |, etc.).
2.
vt.
To select certain bits using a mask (sense 1) and a bitwise operator.
See question 20.7.
- member
- n.
One of the typed components
of a structure or union.
- namespace
- n.
A context within which names
(identifiers)
may be defined.
There are several namespaces in C;
for example,
an ordinary identifier can have the same name as a structure tag,
without ambiguity.
See question 1.29.
- narrow
- adj.
Refers to a type which is widened under the default argument promotions:
char, short, or float.
See questions 11.3
and 15.2.
- nonreentrant
- adj.
Refers to
a piece of code which makes use of static memory,
or works with data structures which it temporarily leaves in an
inconsistent state,
such that it can not safely be called
while another instance of itself is already active.
(That is, it can not be called from an interrupt handler,
because it might have been the code interrupted.)
- ``notreached''
- interj.
A directive
indicating to lint
or some other program checker
that control flow cannot reach a particular point,
and that certain warnings
(e.g. ``control falls off end of function without return'')
should therefore be suppressed.
See question 11.12b.
- null pointer
- n.
A distinguished pointer value
which is not the address of any object or function.
See question 5.1.
- null pointer constant
- n.
An integral constant expression with value 0
(or such an expression cast to void *),
used to request a null pointer.
See question 5.2.
- O(n)
- adj.
A notation referring to the ``order''
or computational complexity of an algorithm.
O(n) algorithms take time
roughly
proportional to the number of items operated upon.
O(n**2)
algorithms take time proportional to the square of the number of items, etc.
- object
- n.
Any piece of data that can be manipulated by a C program:
a simple variable, an array, a structure, a piece of malloc'ed memory,
etc.
See also object pointer.
- object pointer
- n.
A pointer
to any object or incomplete type.
Compare function pointer.
- octet
- n.
An 8-bit quantity.
Compare byte.
- opaque
- adj.
Refers to a data type which is intended to be abstract:
code using the type is not supposed to know how
the type
is
implemented
(whether it is a simple type or a structure,
and if
a structure,
what fields it contains).
See question 2.4.
- order of evaluation
- n.
The order in which the operations implied by an expression
are actually carried out by the processor.
Compare precedence.
See question 3.4.
- out-of-band
- adj.
Refers to a sentinel
or otherwise exceptional
value which is distinct from all normal values
which can appear in some context
(e.g. in a set of
function return values, etc.).
Compare in-band.
Example: EOF (see question 12.1).
- parameter
- n.
The identifier in a function definition,
function-like macro definition,
or function prototype declaration
which stands for the actual argument which will be passed.
Often emphasized ``formal parameter.''
Compare argument.
In the code
main()
{
f(5);
return 0;
}
f(int i)
{
}
the formal parameter of f is i
and the actual argument is 5.
In the fragment
extern int g(int apple);
int orange = 5;
g(orange);
the formal parameter of g is apple
and the actual argument is orange.
- pass by reference
- n.
An argument passing mechanism in which a function receives
a reference to the actual argument,
such that if it modifies it,
it modifies the value in the caller.
Not available in C
(see question 4.11).
- pass by value
- n.
An argument passing mechanism in which a function receives
a copy of the actual argument,
such that if it modifies it,
it modifies only its own copy
(and does not affect the value in the caller).
Always used in C.
See questions
4.8,
7.21,
and
4.11.
- pcc
- n.
Steve Johnson's Portable C Compiler,
first written for the PDP-11
(as an alternative to Dennis Ritchie's cc)
circa
1978.
pcc was retargeted to the VAX during the Unix 32V and BSD
projects
and saw very wide distribution,
and served as the base for a large number of C compilers.
As much as K&R1, it served as the de facto definition
of C for many years,
until X3J11 began its work.
(Note that the PCC mentioned in question 18.3
is probably no relation.)
- precedence
- n.
The ``strength'' of an operator,
indicating how tightly it binds to its operands during parsing,
especially as compared to other nearby operators.
Along with associativity and explicit parentheses,
precedence determines how an expression is parsed:
which operators are applied to which operands and
which subexpressions are the operands of which operators.
Precedence does not necessarily say anything about
order of evaluation (q.v.);
see question 3.4.
- preprocessor
- n.
The part of a compiler
(traditionally, a separate program; hence the name)
which handles the #include, #define, #ifdef,
and related directives,
and performs substitution of #defined macros
in the rest of the
program source.
- pointer context
- n.
An expression
context
in which it
can be recognized
that a pointer value is required.
The pointer contexts in C are:
(1)
any assignment context (q.v.)
in which the destination
(left-hand side) has pointer type;
(2)
an == or != comparison in which one side has
pointer type;
(3)
the second and third operands of the ?: operator, when one
of them is a pointer;
and
(4)
the operand of a pointer cast,
such as (char *) or (void *).
See question 5.2.
- pun
- vt.
To
contrive to
treat
an object
as if it had
a different type,
usually by using a union
or an expression of the form *(othertype *)&object.
- ragged array
- n.
An array,
usually simulated with pointers,
in which the rows are not necessarily of the same length.
See also dope vector.
See questions 6.16
and 20.2.
- reentrant
- adj.
Refers to code which can safely be called
from interrupts
or in other circumstances
in which it is possible
that another instance of the code is simultaneously active.
Reentrant code has to be very careful of the way it
manipulates data:
the data
must either all be local,
or else protected by semaphores or
the like.
- RFC
- n.
An internet
Request For Comments document,
available by ftp from ds.internic.net and many other sites.
- rhs
- n.
The right-hand side,
usually of an assignment,
or more generally,
of any binary operator.
- rvalue
- n.
Originally,
an
expression
which could appear
on the right-hand sign of an assignment operator.
More generally,
any
value which can participate in an expression or be
assigned to some other variable.
In the assignment
a = b;
b is an rvalue, and has its value fetched.
Compare lvalue.
See ANSI Sec. 3.2.2.1 (especially footnote 31)
or ISO Sec. 6.2.2.1.
(See also questions
3.16 and 4.5.)
- scope
- n.
The region over which a declaration is active.
adj.
``In scope'': Visible.
See question 1.29.
- semantics
- n.
The meaning behind a program:
the interpretation which the compiler
(or other translator)
places on the various source code constructs.
Compare syntax.
- short circuit
- v.
To prematurely terminate the evaluation of an expression
when the outcome is
determined.
The short-circuiting operators in C are &&, ||,
and ?:.
In the case of && and ||,
the second (right-hand) operand is not evaluated if the first one
determines the
outcome
(is zero in the case of &&,
or nonzero in the case of ||).
In the case of ?:, only one of the second and third
operands is evaluated,
depending on the value of the first operand.
See question 3.6.
- side effect
- n.
Something
permanent
which happens
when an expression or subexpression is evaluated,
beyond
simply yielding a value.
Typical side effects are:
modifying a variable,
printing something.
See ANSI Sec. 2.1.2.3 or ISO Sec. 5.1.2.3.
- sign preserving
- adj.
Another name for the unsigned preserving rules, q.v.
- source file
- n.
1.
Any file containing C source.
2.
More specifically,
a file with a name ending in .c,
containing function bodies and global variable definitions
(and perhaps declarations and definitions of other kinds).
Compare header file, translation unit.
See questions 1.7 and 10.6.
- Standard
- (With a capital S:)
n.
The ANSI/ISO C Standard,
ANSI X3.159-1989 or ISO/IEC 9899:1990
(see question 11.1).
adj.
Refers to something which is compatible with that Standard.
- static
- adj.
1.
(Often as ``static duration.'')
Refers to an object which persists throughout the lifetime of a program,
being allocated and initialized just once, at program startup.
Compare automatic.
See question 1.30.
2.
Local to a source file,
i.e. not of global scope.
- strictly conforming
- adj.
Refers to a program
which uses only the features described in the ANSI/ISO C Standard,
and does not depend on any
unspecified, undefined, or implementation-defined behavior.
(See ANSI Sec. 1.7 or ISO Sec. 4.)
- string
- n.
An array of char,
or a malloc'ed region,
containing a sequence of characters terminated with '\0'.
- stringize
- vt.
To convert a source token
into a string literal.
See questions
11.17
and
11.18.
- string literal
- n.
A sequence of characters between double quotes in source code.
Used to initialize an array of char,
or
to request an anonymous array
containing a constant string
(which will generally be accessed by
the pointer which the anonymous array decays to).
See question 1.32.
- syntax
- n.
The text of a program:
the
series
of tokens
in which it is expressed.
Compare semantics.
- tag
- n.
The (optional) name for a particular
structure, union, or enumeration.
See question 2.1.
- token
- n.
1.
The smallest syntactic unit generally seen by a compiler or
other translator:
a keyword, identifier, binary operator
(including multicharacter operators such as += and &&),
etc.
2.
A whitespace-separated word within a string
(see question 13.6).
- translation unit
- n.
The set of source files seen by the compiler and translated as a unit:
generally one .c file (that is, source file, sense 2),
plus all header files mentioned in #include directives.
- terminal driver
- n.
That portion of the system software
responsible for character-based input and output,
usually interactive;
originally from and to a serially-connected terminal,
now more generally any virtual terminal
such as a window or network login session.
See question 19.1.
- text
- adj.
Refers to a file or I/O mode which is intended for handling
human-readable text, specifically, printable characters
arranged into lines.
Compare binary, sense 3.
See question
12.40.
- translator
- n.
A program
(compiler, interpreter, lint, etc.)
which parses and
interprets
semantic meaning in
C syntax.
- unary
- adj.
Refers to an operator taking one operand.
Compare binary,
sense 4.
- undefined
- adj.
Refers to behavior which is not specified by the Standard,
for which an implementation
is not required to do anything reasonable.
Example: the behavior of the expression i = i++.
See questions 3.3
and 11.33.
- unroll
- vt.
To replicate the body of a loop one or more times
(while correspondingly reducing the number of iterations),
to improve efficiency
by reducing loop control overhead
(but at the expense of increased code size).
- unsigned preserving
- adj.
Refers to a set of rules,
common in pre-ANSI implementations,
for promoting
signed and unsigned types
which meet across binary operators,
and for promoting narrow unsigned types in general.
Under the unsigned preserving rules,
promotion
is always to an unsigned type.
Compare value preserving.
See question 3.19.
- unspecified
- adj.
Refers to behavior which is not fully specified by the Standard,
for which each implementation must choose some behavior,
though it need not be documented nor even consistent.
Example:
the order of evaluation of
function arguments and other subexpressions.
See question 11.33.
- value preserving
- adj.
Refers to a set of rules,
mandated by the ANSI C Standard
and also
present in some pre-ANSI implementations,
for promoting
signed and unsigned types
which meet across binary operators,
and for promoting narrow unsigned types in general.
Under the value preserving rules,
promotion is to a signed type
if it is large enough to preserve all values,
otherwise to an unsigned type.
Compare unsigned preserving.
See question 3.19.
- varargs
- adj.
1.
Refers to a function which accepts a variable number of
arguments,
e.g. printf.
(A synonym for variadic.)
2.
Refers to one of the arguments
in the variable-length part of a variable-length argument list.
- variadic
- adj.
Refers to a function which accepts a variable number of
arguments,
e.g. printf.
(A synonym for varargs, sense 1.)
- wrapper
- n.
A function
(or macro)
which is ``wrapped around'' another,
providing a bit of added functionality.
For example, a wrapper around malloc
might check malloc's return value.
- X3.159
- n.
The original ANSI C Standard,
ANSI X3.159-1989.
See question 11.1.
- X3J11
- n.
The committee charged by ANSI with the task of drafting the C Standard.
X3J11 now functions as the US Technical Advisory Group
to the ISO C standardization working group WG14.
See question 11.1.
top
about this FAQ list
about eskimo
search
feedback
copyright
Hosted by
