This Glossary gives terms used throughout Micro Focus COBOL. Individual
books may have their own glossaries giving more specialized terms.
The section headed "!" contains entries beginning with digits,
punctuation marks, and other special characters. However, file-name extensions,
although shown with their preceding periods (for example, .int), appear
under their initial letters.
- 16-bit environment
- An operating system that uses 16-bit segmented addressing. Examples
are DOS, Windows, and OS/2 V1.x, running on the Intel 80x86 family of
processors. See also 32-bit environment.
- 32-bit environment
- An operating system that uses 32-bit flat addressing. Examples are
UNIX and OS/2 V2.x. See also 16-bit environment.
- Abstract Class
- A class which does not act as a creator of instance objects. Abstract
classes implement behavior for their subclasses.
- Adis
- The run-time support module that executes the code generated from the
Enhanced ACCEPT/DISPLAY syntax available in this COBOL system. See also
Enhanced ACCEPT/DISPLAY.
- Animator
- A tool that enables a program to run totally under user control. The
source text of the program is displayed and the user can single step individual
lines of COBOL, or execute predetermined parts at full speed.
- Animator machine
- The machine on which Animator runs in cooperative animation.
- Animator session
- The session in which Animator runs in cross-session animation.
- ANSI'74, ANSI'85
- Abbreviations referring to the American National Standards Institute
(ANSI) standards covering the COBOL language. ANSI'74 is the American National
Standard X3.23-1974, and ANSI'85 is the ANS X3.23-1985.
- API
- Abbreviation for Applications Programming Interface, a set of
routines that can be called from a program to provide a set of related
functions.
- application
- A set of programs and subprograms which are invoked from a single
command.
- ASCII
-
Abbreviation for American Standard Code for Information Interchange,
the code used for storing text in microcomputers. Each character is stored in
one byte. There are two forms: standard and extended. In the standard form,
seven bits are used, and 128 different characters are represented. This COBOL
system can use the extended form, in which all eight bits are used and 256
different characters are represented, if the computer system supports it.
- Attributes
- The data encapsulated by an object. The only data which should be
declared as part of an object's attributes is the data required to describe the
object's state at any particular time.
For example, the attributes of a circle are its radius and the
coordinates of its center. The actual code for implementing circle objects
might require other data items for calculations, but these would not be
considered part of the attributes for that object.
- Base
- The root class of the Object COBOL Class Library. All other Object
COBOL programs supplied with this system inherit their fundamental behavior
from Base.
- base-name
- The main part of a file-name, that is, the name excluding the path,
extension and separators such as "/" and ".".
- bound
- The limits of a table or array. The BOUND directive determines if
compiled code will allow bounds to be exceeded.
- breakpoint
- A point in a program where execution will pause when you are
animating it; you set breakpoints using Animator commands.
- build
- The process of combining application programs and Run-time System
programs to create an executable module. See also Run-time System.
- CallBack
- An object of class CallBack stores a reference to an object and the
name of a method implemented by that object. When the CallBack object is sent
the "invoke" message, it executes the named method in the object it
has stored.
One use of CallBack objects is to handle GUI event processing. For
example, the Phonebook GUIController has an Add method for adding new records.
A CallBack to this method in GUIController is attached to the pushbutton object
for Add, and whenever the pushbutton is clicked it invokes this CallBack.
- .cfg file
- Configuration file.
- Checker
- The part of this COBOL system that checks the syntax of your COBOL
source program and produces intermediate code. See also intermediate
code.
- child
- A run unit created by another run unit.
- Class
- An Object COBOL program which contains the code and data descriptions
for a class object and its instance objects. It is also known as the class
program.
A class consists of nested COBOL programs, which correspond to class
object and instance object methods. Each class starts with an identifier naming
the class and the class from which it inherits. When a class is loaded at
run-time, the OO run-time system creates the class object.
- Class Object
- An object which is a template for the creation of instance objects of
the same type. For example, the the OrderedCollection class object creates
instances of OrderedCollection.
The class object itself does not have the same behaviour and methods
as the instance objects which it creates. By analogy, a biscuit cutter is a
template for creating biscuits; however, you can't eat a biscuit cutter and you
can't stamp a biscuit from another biscuit.
In Object COBOL, all the methods and data for a class object and the
instance objects which it creates are represented by a class program.
- Class Library
- The set of classes supplied with Object COBOL. The root class of the
Class Library, Base, implements basic behaviour for all classes, and provides a
superclass for your own classes.
There are also classes to implement collections, exception handlers,
CallBacks, and GUI interfaces.
- Class Program
- See Class.
- cob
- Command that converts your source code into executable code. It can
compile COBOL, C, or assembler sources, generate native code, and link and
build executable files.
- COBPATH
- An environment variable that contains a list of the paths of the
COBOL system directories. Each path is separated from the next by a colon (:).
- Compiler
- The part of this COBOL system that checks the syntax of your COBOL
source program and produces intermediate code.
- copyfile
- A file containing text, which the Compiler inserts into the main body
of a COBOL program when it processes a COPY statement in that program.
- cooperative animation
- Animation in which Animator runs on one machine and the user program
on another.
- coru
- A set of run units consisting of a parent run unit and all the run
units created from it.
- cross-session animation
- Animation in which Animator runs in one session and the user program
in another.
- current directory
- The directory that the operating system, when looking for a file,
will search first if no path is specified.
- current statement
- The statement currently being executed in Animator or, if none is
currently being executed, the statement to be executed next.
- data compression
- A process to compress the data in a sequential or indexed file. See
also key compression.
- decorations
- Attributes that a window can have: title bar, system menu, menu bar,
minimize and maximize buttons, horizontal and vertical scroll bars.
- default action
- The action that will be performed when Enter is pressed or a
confirmation choice is selected. If you double-click on a selection, the item
is selected and the default action is performed on it.
- directives
- Keywords used to control compilation, animation, and generation.
- directives file
- An ASCII text file containing one or more directives on one or more
lines.
- Dynamic Binding
- The object which will receive a message is unknown when an Object
COBOL program is compiled. The Object COBOL system determines the receiver at
run-time.
- dynamically assigned file
- A file whose name is specified to the COBOL program via a data item
referenced in the ASSIGN clause of the SELECT statement. See also externally
assigned file.
- Encapsulation
- You can only access or manipulate the an object's data through the
methods it provides. To invoke a particular method, you send the object a
message. The object's data is said to be encapsulated.
- Enhanced ACCEPT/DISPLAY
- The ACCEPT and DISPLAY syntax available with this system has been
extended beyond the ANSI standard to allow sophisticated handling of the screen
and keyboard.
Such ACCEPT and DISPLAY syntax is referred to as enhanced or
extended, and is defined in the chapter Screen Handling in the
Language Reference. See also Adis.
- event
- Something done by a user, such as pressing a key, to which Panels
Version 2 or Dialog System responds by executing a specified piece of code.
- executable file
- A file created by the link process, which can be invoked from the
command line or dynamically called from another program.
- Extended ACCEPT/DISPLAY
- See Enhanced ACCEPT/DISPLAY.
- extension
- The part of a file-name that follows the period (.).
- external file
- A file that is EXTERNAL as defined by the ANSI'85 standard. It can be
accessed by any program running in the run unit.
Do not confuse external files with externally assigned files.
- externally assigned file
- A file whose name is specified to the COBOL program via a mechanism
outside the program – such as an operating system command – rather
than in the ASSIGN clause of the SELECT statement. See also dynamically
assigned file.
- field
- An area on a screen defined to display or accept an elementary data
item. The term is sometimes used to refer to the elementary data item.
- Framework
- A protocol used by several different types of object co-operating to
implement a particular function. An individual class or instance object has a
public interface which describes the way you communicate with that object. A
framework describes the way in which different types of object interact
together.
For example, the public interface to an OrderedCollection describes
how you can add, retrieve and remove elements. The Collection framework
describes how OrderedCollections (and other types of collection) communicate
with the objects they are storing as elements.
- .gnt code
- Generated code.
- generated code
- The native code produced by the Generator by optimizing intermediate
code. See also Generator.
- Generator
- The part of this COBOL system that converts intermediate code to
native code (also called generated code). See also generated code.
- global configuration file
- A file containing configuration details which affect all users of the
COBOL system in the installation. The configuration details are concatenated
with those from the local configuration file. See also local configuration
file.
- .gnt file
- A file created by the Compiler from an intermediate code
(.int) file and containing optimized native code.
- high level menu
- See command interface menu.
- hotspot
- An area on the screen which you select, using the Tab key, in
order to select a software function.
- .idy file
- A file created when the source file is syntax-checked and the ANIM
directive is used. It has a file extension of .idy, and contains the
information necessary for Animator to display source code during program
debugging.
- includefile
- A file containing text, which the Compiler inserts into the main body
of a COBOL program when it processes an INCLUDE statement in that program. See
also copyfile.
- information line
- In character mode, same as status line. See status line.
- instance
- A call of a recursive routine.
- .int code
- Intermediate code.
- intermediate code
- Code produced when the source program is syntax-checked. An object
code file is produced by generating machine code from the intermediate code.
See also Checker.
- .int file
- A file created when the source file is syntax-checked, containing
intermediate code.
- Instance
- See Instance Object.
- Instance object
- A single occurrence of an object of a particular class. Instance
objects are created by sending an appropriate message (usually "new")
to a class object. For example, to create a window for display on the desktop,
you send the "new" message to the Window class object.
The methods and data for instance objects are defined in the object
program, which is nested within the class program. The object program starts
with the header object. and finishes with end object.
- Intrinsic Class
- A class corresponding to a COBOL intrinsic data type. These classes
are used as templates so that you can send messages to COBOL intrinsic data
using the invoke ... as... construct. For more information, see the chapter
Intrinsic Frameworks.
- Inheritance
- A mechanism for reusing code, by which each class inherits the
methods (and optionally the data) of its superclass. By identifying where
different types of objects have common functionality, you can implement the
common methods for that functionality in a single class and inherit it in any
number of subclasses.
Each class inherits all the methods of its superclass, so a class
ultimately inherits all methods all the way up to the root class (Base). A
class object inherits the class methods of its superclass, and an instance
object inherits the instance methods of its superclass.
In this Object COBOL implementation, a class has only one immediate
superclass. The superclass is named in the inherits clause of the class-id
paragraph of the class which implements the class.
- ISAM file
- A term occasionally used as a synonym for "indexed sequential
file". It is derived from "Indexed Sequential Access Method", a
mechanism used for handling indexed sequential files on UNIX and on some IBM
mainframes.
- K
- Abbreviation for kilobyte, a measure of size of computer storage,
equal to 1024 bytes.
- key compression
- A process to compress the keys in an indexed file. See also data
compression.
- library
- A file with a file extension of .lbr containing a set of other
files or programs. The library file can be opened by the COBOL system or a user
application to make those files or programs accessible.
- linking support
- A set of run-time system routines and run-time support modules that
you link with your programs (using the cob command) to create stand-alone
executable files.
- local configuration file
- A file containing configuration details which affect the individual
user. The configuration details are concatenated with those from the global
configuration file. See also global configuration file.
- low-level menu
- A menu specific to a function or facility that is part of that
facility and enables the user to enter options and make selections. This menu
cannot usually be modified by the user.
- machine code
- See Native Code.
- main program
- The first program in an application. This program receives control
when the application is invoked.
- Mb
- Abbreviation for megabyte, a measure of size of computer storage,
equal to 1024 kilobytes.
- MCS
- The COBOL communications module. This is implemented in this COBOL
system in a way that enables two COBOL programs operating on separate
workstations on the same network to send messages to each other.
- Memory leak
- Memory no longer needed, but not deallocated by the OO system. An
application should finalize an object when it is no longer required. When an
application no longer has a handle to an object which still exists, the object
is effectively unreachable, and can no longer be finalized. This is a memory
leak.
- Message
- Invokes a method when sent to an object. The method invoked matches
the message sent. The text of the message is known as the method selector.
The invoke verb enables you to send messages. For example:
INVOKE anOrange "peel" returning
segments
The method selector "peel" invokes the peel method in
anOrange. Data is returned from the method in data item segments.
- Message Binding
- Ensuring that each message is delivered to the right object. Binding
can be dynamic or static. In a statically bound object-oriented programming
system (OOPS), the receiver of a message is determined at compile-time. In a
dynamically bound OOPS, the receiver of a message is determined at run-time.
This release of Object COBOL supports dynamic binding only.
- Metaclass
- Enables the creation of class objects. All class objects are
instances of the metaclass object. In Object COBOL, the metaclass is Behavior,
which is part of the Class Library.
- Method
- Code manipulating or interrogating the data within an object. In
Object COBOL, each method is coded as a nested program within a class.
- Motif
- An environment using a graphical user interface, which runs under
UNIX.
- multi-program source
- A source file containing more than one independent program. Each
program must have a PROGRAM-ID clause and be terminated by an END PROGRAM
header. When the source is compiled, the file-names used for all but the first
program will be derived from the first eight characters of the program-ID.
- native code
- The code that the microprocessor understands directly without the
need for an interpreter. Also known as native machine code. It will only run on
machines containing the appropriate microprocessor.
- Native Code Generator
- See Generator.
- NCG
- See Native Code Generator.
- Object
- An encapsulation of data and methods. The only way to access an
object's data is by sending it messages. You can also think of an object as
intelligent data, which includes implementations for the operations (methods)
appropriate to itself.
There are two types of object: classes and instances. A class object
is created when you register a class; an instance is created whenever you send
an appropriate message to the class object which defines that instance. The
Object COBOL run-time system allocates each object its own data area in memory.
There can be many instance objects of the same type within a run-unit, but
there can only be one class object of each type.
- Object COBOL Run-time System
- Supports features of object oriented programming not covered by the
standard COBOL run-time system (for example, object creation and destruction).
- Object Handle
- An ID or reference by which you can access a particular object. Every
object is assigned a handle when it gets created at run-time.
You always give the object handle when you send a message; the OO
RTS uses the handle to find the object which should receive the message. You
store object handles in data items of type object reference.
- Object Reference
- A COBOL data item, declared as
object reference which can hold an object
handle.
- on-disk document
- An ASCII text file that gives information that is not in the printed
books.
- on-disk supplement
- an on-disk document that is the main documentation for a feature, and
is equivalent to a chapter, or supplementary to a chapter, in a printed manual.
- On-line Help
- A set of screens of information that you can display while working.
Each screen briefly lists and explains the functions available on the menu
currently displayed.
- OO RTS
- See Object COBOL Run-time System.
- On-line Reference
- A database of formatted information that you can display on the
screen while working; it is an electronic book, structured in a more advanced
way than a printed book.
- parent
- A run unit that has created another run unit or a window that has
opened another window.
- PATH
- An environment variable that is a list (with entries separated by
semicolons) of directories that are searched when a program is invoked. It
should include the path where the driver programs are installed.
- pathname
- The part of a file-name up to and including the last "/"
character.
- PERFORM range
- The PERFORM range is the lines of code encompassed by a single
PERFORM statement.
- Persistence
- The ability of the Object COBOL run-time system to remember the state
of all objects in the system between runs. It does this by storing all objects
in an indexed file.
Persistence is an Early Release feature of Object COBOL.
- Polymorphism
- The method invoked by a particular message depends on the object
which receives it. For example, you could implement several different classes
of bank account object (checking, savings, high rate). All bank account objects
would respond to the message"printStatement". However, each different
type of account would implement "printStatement" differently, in a
way appropriate to itself – savings accounts show interest paid, but
checking accounts don't.
Polymorphism enables you to send the same message
("printStatement") to any type of account object and get appropriate
results.
- release notes
- A standard set of on-disk documents containing administrative
technical information.
- RTS
- See Run-time System.
- RTE
- See Run-time Environment.
- Run-time Environment
- An environment for running COBOL programs. It is based on the shared
run-time system, and runs .int and .gnt files.
- Run-time System
- The support modules needed by a COBOL program to enable it to run. It
provides an interface between the program and the operating system.
- run unit
- A run unit is a main program, as invoked from the command line, plus
any subprograms that it calls, directly or through other subprograms called by
it. A run unit is an independent entity that can be executed without
communicating with any other run unit.
- sample programs
- The programs supplied with the COBOL system as examples to
demonstrate use of the system. Some are referred to by tutorials in the
documentation.
- source code
- The COBOL code that makes up the program. This can consist of one or
more text files.
- status line
- A line displayed on most character menus that indicates the menu name
and settings of various options. It is normally the fourth line up from the
bottom of the screen, above two menu lines and a message line.
- stride
- The length of a single element in a table or array.
- Subclass
- A class descended from another one, inheriting its methods and data.
In the Class Library supplied with Object COBOL all class are ultimately
subclasses of Base.
- Superclass
- The parent of a class. Every class has a single superclass
immediately above it in the inheritance hierarchy, with the exception of those
at the top of the hierarchy. In the supplied Class Library there is only one
root class, Base, from which all other classes are descended.
- system attributes
- Screen attributes used by COBOL Toolbox for determining the color of
its different components.
- tag
- A position marker in a file used by the COBOL Editor.
Or
A position marker within a program under investigation
using CSI or Animator Version 2.
Or
A text
marker in a configuration file; it shows the start of the part of the file from
which the application using the Application Configuration System is requesting
information.
- terminfo
- A UNIX system database that hold information on the characteristics
of terminals.
- text file
- A file containing ASCII text created by any standard editor. Such
text files can contain, for example, COBOL source code or Compiler directives.
COBOL programs can read or write such files by specifying ORGANIZATION LINE
SEQUENTIAL.
- user machine
- The machine on which the user program runs in cooperative animation.
- user program
- An application program. A term used especially when discussing the
Animator, to refer to the program being tested as distinct from the COBOL
system.
- user session
- The session in which the user program runs in cross-session
animation.
- wildcard
- A character that can be used in a file-name in certain contexts; any
character is considered to match the wildcard character, so that all files
whose names match the rest of the string will be selected.