top/contents search


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.

n. An array or structure type. adj. Refers to such a type.
actual argument
See argument.
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.
n. The American National Standards Institute. adj. Used informally to refer to Standard C; see question 11.1.
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.
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.
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).
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.
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.
adj. Refers to storage of a multi-byte quantity with the most-significant byte at the lowest address. See also byte order.
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.
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.
n. A mask, sense 1.
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.)
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.
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.)
n. The traditional name for a standalone program implementing the features of the C preprocessor.
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.
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.
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.
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.
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.
n. byte order (q.v.).
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.
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.)
n. The Free Software Foundation.
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.
n. The FSF's GNU C compiler.
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.
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.)
adj. Acting exactly once; innocuous if re-applied. In C, usually refers to header files; see questions 10.7 and 11.21.
n. A name, usually having meaning in a particular namespace and scope. See question 1.29.
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.''
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. or ISO Sec.
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.
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.
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.
n. An integer of some size (perhaps short or long), not necessarily plain int.
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.
The International Organization for Standardization or Organisation Internationale de Normalisation.
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.
n. The left-hand side, usually of an assignment, or more generally, of any binary operator.
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.
adj. Refers to storage of a multi-byte quantity with the least-significant byte at the lowest address. See also byte order.
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. (especially footnote 31) or ISO Sec.
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.
n. One of the typed components of a structure or union.
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.
adj. Refers to a type which is widened under the default argument promotions: char, short, or float. See questions 11.3 and 15.2.
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.)
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.
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.
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.
n. An 8-bit quantity. Compare byte.
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.
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).
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
		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;
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.
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.)
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.
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.
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.
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.
n. An internet Request For Comments document, available by ftp from and many other sites.
n. The right-hand side, usually of an assignment, or more generally, of any binary operator.
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. (especially footnote 31) or ISO Sec. (See also questions 3.16 and 4.5.)
n. The region over which a declaration is active. adj. ``In scope'': Visible. See question 1.29.
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. or ISO Sec.
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.
(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.
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.)
n. An array of char, or a malloc'ed region, containing a sequence of characters terminated with '\0'.
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.
n. The text of a program: the series of tokens in which it is expressed. Compare semantics.
n. The (optional) name for a particular structure, union, or enumeration. See question 2.1.
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.
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.
n. A program (compiler, interpreter, lint, etc.) which parses and interprets semantic meaning in C syntax.
adj. Refers to an operator taking one operand. Compare binary, sense 4.
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.
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.
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.
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.
adj. Refers to a function which accepts a variable number of arguments, e.g. printf. (A synonym for varargs, sense 1.)
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.
n. The original ANSI C Standard, ANSI X3.159-1989. See question 11.1.
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.


contents search
about this FAQ list   about eskimo   search   feedback   copyright

Hosted by Eskimo North