- P
-
- pack
- To store data in a compact form in such a way that the
original form can be recovered.
- pad
- To fill unused positions in a field with data, usually
0's, 1's, or blanks.
- page
- (1) In a virtual storage system, a fixed-length block
that has a virtual address and is transferred as a unit
between real storage and auxiliary storage. I. A.
(2) A defined unit of space on a storage medium. (3) In
the VisualAge C++ IDE workbook, the displayed information
about an object relevant to a specific task, such as
debugging. Each page is an instance of a page
description. The workbook offers predefined pages and the
option of user-defined pages. A page is composed of one
or more panes. See pane, page description, workbook.
- page description
- In the VisualAge C++ IDE, the definition of the views
that appear on a page, how the views are laid out, the
filter applied to each pane, the links between the panes,
the style of the links, and the objects that can be
viewed. Every page is an instance of a page description
defined in the IDE.
- pane
- A portion of a window used to present information. In the
VisualAge C++ IDE, a workbook page consists of one or
more panes. Each pane has a title bar and menus. Panes
can be linked so that an object can flow from one pane to
another. See floating
pane, link.
- pane filter
- See filter.
- parameter
- (1) In the C and C++ languages, an object declared as
part of a function declaration or definition that
acquires a value on entry to the function, or an
identifier following the macro name in a function-like
macro definition. X/Open. (2) Data passed
between programs or procedures. IBM.
- parameter declaration
- A description of a value that a function receives. A
parameter declaration determines the storage class and
the data type of the value.
- parent class
- See base class.
- parent node
- In a tree structure, a node to which one or more other
nodes are subordinate. See child
node, root.
- parent process
- (1) The program that originates the creation of other
processes by means of spawn or exec function calls. (2) A
process that creates other processes.
- parent window
- A window that provides its child windows with information
on how and where to draw themselves. The parent window
defines the relationship that the child windows have with
other windows in the system. See child window, owner window.
- part
- In VisualAge C++, a self-contained object with a
standardized public interface, which consists of a set of
external features that allow the part to interact with
other parts. Parts are encapsulations of C++ classes used
specifically for visual programming or database access.
See visual part, nonvisual part, subpart.
- part interface
- A set of external features that allows a part to interact
with other parts. A part's interface is composed of three
characteristics: attributes, actions, and events. CB.
See action, attribute, event, part.
- Part Interface Editor
- An editor used to create and modify attributes, actions,
and events, which together make up the interface of a
part. CB.
- parts palette
- A GUI control that offers a collection of visual and
nonvisual parts that can be used in building
applications. Developers can add parts to the palette for
use in defining applications or other parts. See visual part, nonvisual part, part.
- path name
- (1) A string that is used to identify a file. It has an
optional beginning slash, followed by zero or more file
names separated by slashes. If the path name refers to a
directory, it may also have one or more trailing slashes.
Multiple successive slashes are considered to be the same
as one slash. A path name that begins with two successive
slashes may be interpreted in an implementation-dependent
manner, although more than two leading slashes will be
treated as a single slash. (2) A file name specifying all
directories leading to the file.
- pattern
- (1) A sequence of characters used either with regular
expression notation or for path name expansion, as a
means of selecting various character strings or path
names, respectively. The syntaxes of the two patterns are
similar, but not identical. X/Open. (2) A
recognizable shape, form, or configuration. IBM. (3)
In computer graphics, a combination of toned and untoned
picture elements (pels) that make up an image. (4) A
regular expression that defines a search pattern. (5) In
AIX graphics, a 16x16, 32x32, or 64x64 array of bits
defining the texturing of polygons on the system display.
IBM.
- pause
- To temporarily halt the medium. The halted visual should
remain displayed but no audio should be played.
- pel
- See pixel.
- persistent codestore
- See codestore.
- pipe
- To direct data so that the output from one process
becomes the input to another process. The standard output
of one command can be connected to the standard input of
another with the pipe operator (|). Two commands
connected in this way constitute a pipeline. IBM.
- pixel
- Picture element. The smallest area of a display screen
capable of being addressed and switched between visible
and invisible states.
- pointer
- A variable that holds the address of a data object or
function.
- pointer class
- A class that implements pointers.
- pointer to member
- An operator used to access the address of nonstatic
members of a class.
- point size
- The size of a typeface, measured in points. The size
refers to the height of the letters. There are 72 points
in an inch. See typeface.
- polymorphic function
- A function that can be applied to objects of more than
one data type. C++ implements polymorphic functions in
two ways:
- Overloaded functions (calls are resolved at
compile time)
- Virtual functions (calls are resolved at run
time)
- polymorphism
- The technique of taking an abstract view of an object or
function and using any concrete objects or arguments that
are derived from this abstract view.
- port
- (1) To adapt an application for use with another
operating system. Contrast with migrate. (2) To adapt an
application for use with a different compiler system or
class library.
- portability
- The ability of a programming language to compile
successfully on different operating systems without
requiring changes to the source code.
- portable
character set
- The set of characters specified in POSIX 1003.2, section
2.4. See character set,
Portable
Operating System Interface.
- Portable
Operating System Interface (POSIX)
- (1) A set of operating system portable interface
standards defined by the Institute of Electrical and
Electronic Engineers (IEEE). Now an ISO/IEC international
standard (ISO/IEC 9945). (2) An IEEE 1003.1 standard that
defines the language interface between application
programs and the UNIX operating system.
- positioning property
- The property of an element that is used to position the
element in a collection. For example, the value of a key
may be used as the positioning property.
- POSIX
- See Portable
Operating System Interface.
- pragma
- A preprocessor directive that is not specified by the
ANSI standard. Pragmas often control actions of the
compiler and linker. A pragma always begins with a number
sign (#).
- precedence
- The priority system for grouping different types of
operators with their operands.
- precondition
- A condition that a function requires to be true when it
is called.
- predefined function
- See built-in
function.
- predefined macro
- A frequently used routine provided by an application or
language for the programmer. See macro.
- predicate function
- A function that returns an IBoolean value of true
or false. (IBoolean is an integer-represented
Boolean type.)
- preemptive
multitasking
- The operating system's ability to interrupt a thread at
almost any time and assign the processor to a waiting
thread. Multiple applications can thus run
simultaneously, and a single application cannot
monopolize all of the system's resources. See multitasking.
- preparation
- Any activity that the source performs before rendering
the data. For example, the drag item may require that the
source create a secondary thread where the source
rendering takes place. The system remains responsive to
users so that they can do other tasks.
- preprocessor
- A phase of the compiler that examines the source program
for preprocessor statements, which are then executed,
resulting in the alteration of the source program.
- preprocessor directive
- In C and C++, a statement that begins with the number
sign (#) and contains instructions that the preprocessor
interprets.
- preroll
- To prepare a device to begin a playback or recording
function with minimal delay.
- primary expression
- A literal, name, or name qualified by the scope
resolution operator (::).
- primary part
- In a composite part, the representation of the part's
base class on the free-form surface, added when you first
create the composite. For example, the primary part of an
IFrameWindow-based composite is the IFrameWindow* part
instance.
- primary source file
- A source file defined for a build in the configuration
file. Each primary source file is processed only once
during a compilation. See source
file, included
source file.
- primary thread
- The first thread created when a process is initialized.
See thread.
- primitive
- See graphic
primitive.
- primitive attribute
- A specifiable characteristic of a graphic primitive. See graphic attributes.
- priority queue
- A queue that has a priority assigned to its elements.
When accessing elements, the element with the highest
priority is removed first. A priority queue has a
largest-in, first-out behavior. See queue.
- private
- Pertaining to a class member that is accessible only to
member functions and friends of that class. Contrast with
protected, public.
- process
- (1) A collection of code, data, and other system
resources, including at least one thread of execution,
that performs a data processing task. (2) A running
application, its address space, and its resources. (3) An
instance of a running program. A Win32 process owns a
4-GB address space containing the code and data for an
application's executable file; it does not execute
anything. It also owns certain resources, such as files,
dynamic memory allocations, and threads. (4) A program
running under the OS/2 operating system, along with the
resources associated with it (memory, threads, file
system resources, and so on).
- profiling
- The process of generating a statistical analysis of a
program that shows processor time and the percentage of
program execution time used by each procedure in the
program.
- program
- (1) One or more files containing a set of instructions
conforming to a particular programming language syntax.
(2) A self-contained, executable module. Multiple copies
of the same program can be run in different processes.
- program group
- In Windows NT, a window displaying a group of programs.
- program heap
- See free store.
- project
- (1) A container that groups related objects (tasks). (2)
The complete set of data objects (called project parts)
and actions needed to build a single target, such as a
dynamic link library or executable file. (3) In VisualAge
C++, the programming unit controlled by a single
configuration file. A project is composed of a
configuration file, one or more source files, and a
codestore.
- project-scoped action
- An action that applies to a project as a whole, or to a
project's specially designated parts. Specially
designated project parts are the project's makefile and
target. An example of a project-scoped action is
debugging, which is invoked on the project's target.
- promote [a feature]
- In visual programming, make a feature of a subpart
available to be used for making connections. CB.
See subpart.
- property function
- A function that is used to determine whether the element
it is applied to has a given property or characteristic.
A property function can be used, for example, to remove
all elements with a given property.
- protected
- Pertaining to a class member that is only accessible to
member functions and friends of that class, or to member
functions and friends of classes derived from that class.
Contrast with private, public.
- prototype
- A function declaration or definition that includes both
the return type of the function and the types of its
arguments. See function
prototype.
-
- public
- Pertaining to a class member that is accessible to all
functions. Contrast with private,
protected.
- pure virtual function
- A virtual function that has a function initializer of the
form = 0;
-
