glossary.gml

开放源码的编译器open watcom 1.6.0版的源代码

.begnote $break
.*
.note address
.ix 'address'
An address is a location in a computer's memory.
Each storage location (byte) has
.* a unique
an address by which it is referenced. A
.us pointer
is an address.
.*
.note aggregate
.ix 'aggregate'
An aggregate type is either an
.us array
or a
.us structure.
The term
.us aggregate
refers to the fact that arrays and structures are made up of other
types.
.*
.note alignment
.ix 'alignment'
On some computers, objects such as integers, pointers and
floating-point numbers may be stored only at certain addresses (for
example, only at even addresses). An attempt to reference an object
that is not properly aligned may cause the program to fail. Other
computers may not require alignment, but may suggest it in order to
increase the speed of execution of programs.
.pp
C compilers align all objects that require it, including putting
padding characters within structures and arrays, if necessary.
However, it is still possible for a program to attempt to reference an
improperly-aligned object.
.*
.************************************************************************
.*
.shade begin
..if '&target' eq 'PC' ..th ..do begin
The &wcboth. compilers align structure members by default.
A command line switch, or the
.mono pack
pragma, may be used to control this behavior. Other objects may also
be aligned by default.
.pp
See the &userguide. for default values and other details.
..do end
..if '&target' eq 'PC 370' ..th ..do begin
By default, the &wcall. compilers do not align objects.
.pp
With &wcboth., a command line switch, or the
.mono pack
pragma, may be used to force alignment of objects.
.pp
With &wlooc., a command line switch may be used to force alignment.
.pp
See the &pragma. for details.
..do end
.shade end
.*
.************************************************************************
.*
.note argument
.ix 'argument'
.ix 'parameter'
An argument to a function call is an expression whose value is
assigned to the parameter for the function. The function may modify
the parameter, but the original argument is unaffected. This method of
passing values to a function is often called
.ix 'call by value'
.us call by value.
.pp
The argument may be a pointer to an object, in which case the function
may modify the object to which the pointer points, while the argument
value (the pointer) is unaffected.
.*
.note array
.ix array
An array is a set of objects of the same type, grouped into adjacent
memory locations. References to elements of the array are made by
.ix subscript
.us subscripts
or
.ix index
.us indices.
.*
.note assignment
.ix 'assignment'
Assignment is the storing of a value into an object, which is usually
done with the
.ix 'operator' '='
.ix 'assignment operator'
.mono =
operator.
.*
.note automatic storage duration
.ix 'automatic storage duration'
An object with automatic storage duration is created when the
.us function
in which it is defined is invoked, and is destroyed when the function
returns to the caller.
.*
.note bit
.ix 'bit'
A bit is the smallest possible unit of information, representing one
of two values, 0 or 1.
If the bit is 0, it is said to be
.us off.
If the bit is 1, it is said to be
.us on.
.pp
A bit is not representable by an
.us address,
but is part of a
.us byte,
which does have an address.
.shade begin
Most processors,
.*
.************************************************************************
.*
..if '&target' eq 'PC' ..th ..do begin
including the Intel 80x86 family of processors,
..do end
..if '&target' eq 'PC 370' ..th ..do begin
including the Intel 80x86 family of processors and the IBM 370 family
of processors,
..do end
.*
.************************************************************************
.*
have 8 bits
in a byte.
.shade end
.*
.note bit-field
.ix bit-field
A bit-field is a type that contains a specified number of bits.
.*
.note block
.ix block
A block is a part of a function that begins with
.mono {
and ends with
.mono }
and contains declarations of objects and statements that perform some
action. A block is also called a
.ix 'compound statement'
.us compound statement.
.*
.note byte
.ix byte
A byte is the smallest unit of storage representable by a unique
.us address,
usually capable of holding one character of information.
.shade begin
Most processors,
.*
.************************************************************************
.*
..if '&target' eq 'PC' ..th ..do begin
including the Intel 80x86 family of processors,
..do end
..if '&target' eq 'PC 370' ..th ..do begin
including the Intel 80x86 family of processors and the IBM 370 family
of processors,
..do end
.*
.************************************************************************
.*
have 8
.us bits
in a byte.
.shade end
.*
.note cast
.ix cast
To cast an object is to explicitly convert it to another
.us type.
.*
.note character constant
.ix 'character constant'
.ix 'constant' 'character'
A character constant is usually one character (possibly a
.ix trigraphs
.us trigraph
or
.ix 'escape sequences'
.us escape sequence)
contained within single-quotes (for example,
.mono 'a', '??('
and
.monoon
'\n'
.monooff
..ct ).
.*
.************************************************************************
.*
..if '&target' eq 'PC' ..th ..do begin
.shade begin
The &wcboth. compilers allow character constants with one, two, three
or four characters.
.shade end
..do end
..el ..if '&target' eq 'PC 370' ..th ..do begin
.shade begin
The &wcall. compilers allow character constants with one, two, three
or four characters.
.shade end
..do end
.*
.************************************************************************
.*
.note comment
.ix comment
A comment is a sequence of characters, outside of a
.ix 'string literal'
.ix string
.us string literal
or
.ix 'character constant'
.ix 'constant' 'character'
.us character constant,
starting with
.mono /*
and ending with
.mono */.
The comment is only examined to find the
.mono */
that terminates it.
Hence, a comment may not contain another comment.
.*
.note compiler
.ix compiler
A compiler is a program which reads a file containing programming
language statements and translates it into instructions that the
computer can understand.
.pp
For example, a C compiler translates statements described in this book.
.*
.note compound statement
.ix 'compound statement'
A compound statement is a part of a function that begins with
.mono {
and ends with
.mono }
and contains declarations of objects and statements that perform some
action. A compound statement is also called a
.ix block
.us block.
.*
.note declaration
.ix declaration
A declaration describes the attributes of an object or function, such
as the storage duration, linkage, and type.
The space for an object is reserved when its
.us definition
is found.
The declaration of a function describes the function arguments and
type and is also called a function prototype. The declaration of a
function does not include the statements to be executed when the
function is called.
.*
.note decrement
.ix decrement
To decrement a number is to subtract (one) from it. To decrement a
pointer is to decrease its value by the size of the object to which
the pointer points.
.*
.note definition
.ix definition
A definition of an object is the same as a
.us declaration,
except that the storage for the object is reserved when its definition
is found. A function definition includes the statements to be executed
when the function is called.
.*
.note exception
.ix exception
An exception occurs when an operand to an operator has an invalid
value. Division by zero is a common exception.
.*
.note floating-point
.ix floating-point
A floating-point number is a member of a subset of the mathematical
set of real numbers, containing (possibly) a fraction and an exponent.
The floating-point
.us type
is represented by one of the keywords
.kw float
..ct ,
.kw double
or
.kw long double
..ct ..li .
.*
.note function
.ix function
A function is a collection of declarations and statements, preceded by
a declaration of the name of the function and the
.us parameters
to it, as well as a possible
.us return value.
The statements describe a series of steps to be taken after the
function is called, and before it finishes.
.*
.note header
.ix header
A header contains C source, usually function prototypes, structure and
union definitions, linkages to externally-defined objects and macro
definitions. A header is included using the
.kwpp #include
preprocessor directive.
.* A header may or may not be a separate source
.* file.
.*
.keep begin
.note identifier
.ix identifier
An identifier is a sequence of characters, starting with a letter or
underscore, and consisting of letters, digits and underscores. An
identifier is used as the name of an object, a tag, function, typedef,
label, macro or member of a structure or union.
.keep end
.*
.note implementation-defined behavior
.ix 'implementation-defined behavior'
Behavior that is implementation-defined depends on how a particular C
compiler handles a certain case. All C compilers must document their
behavior in these cases.
.*
.note incomplete type
.ix 'incomplete type'
An incomplete type is one which has been declared, but its size or
structure has not yet been stated. An example is an array of items
that was declared without specifying how many items. The
.kw void
type is also an incomplete type, but it can never be completed.
.*
.note increment
.ix increment
To increment a number is to add (one) to it. To increment a pointer is
to increase its value by the size of the object to which the pointer
points.
.*
.note index
.ix index
An index (or
.us subscript
..ct )
is a number used to reference an element of an
.us array.
It is an integral value. The first element of an array has the index
zero.
.*
.note indirection
.ix indirection
Indirection occurs when an object that is a pointer to an object is
actually used to point to it. The unary form of the
.ix 'operator' 'indirection'
.ix 'operator' 'unary *'
.ix 'operator' '*'
.ix 'indirection operator'
.ix 'unary operator' *
.mono *
operator, or the
.ix 'operator' 'arrow'
.ix 'operator' '->'
.ix 'arrow operator'
.mono ->
operator are used for indirection.
.*
.note initialization
.ix initialization
The initialization of an object is the act of giving it its first
(initial) value. This may be done by giving an initialization value
when the object is declared, or by explicitly assigning it a value.
.*
.note integer
.ix integer
An integer is a
.us type
that is a subset of the mathematical set of integers. It is
represented by the keyword
.kw int
..ct ,
and has a number of variations including
.kw signed char
..ct ,
.kw unsigned char
..ct ,
.kw short signed int
..ct ,
.kw short unsigned int
..ct ,
.kw signed int
..ct ,
.kw unsigned int
..ct ,
.kw long signed int
..ct ,
.kw long unsigned int
..ct ,
.kw long long signed int
and
.kw long long unsigned int
..ct ..li .
.*
.note integral promotion
.ix 'integral promotion'
An object or constant that is a
.kw char
..ct ,
.kw short int
..ct ,
.kw int
bit-field, or of
.kw enum
type, that is used in an expression, is promoted to an
.kw int
(if
.kw int
is large enough to contain all possible values of the smaller
type) or
.kw unsigned int
..ct ..li .
.*
.note keyword
.ix keyword
A keyword is an
.us identifier
that is reserved for use by the compiler. No object name or other use
of an identifier may use a keyword.
.*
.note label
.ix label
A label is an
.us identifier
that corresponds to a particular
.us statement
in a
.us function.
It may be used by the
.ix statement goto
.ix 'goto statement'
.kw goto
statement.
.kw default
is a special label which is used with the
.kw switch
statement.
.*
.note library function
.ix 'library function'
A library function is a function provided with the C compiler that
performs some commonly needed action. The C language standard
describes a set of functions that all C compilers must provide.