@comment *********************************************************************
@comment ** A. Glossary of Terms                                            **
@comment *********************************************************************
@newappendix{Glossary of Terms}
@table @asis
@item @itemdfn{Alphabetic Data Item}
A data item whose @code{PICTURE} clause allows it to contain only upper- and/or lower-case letters.  @xref{PICTURE}.

@item @itemdfn{Alphanumeric Data Item}
A data item whose @code{PICTURE} clause allows it to contain absolutely any character whatsoever.  @xref{PICTURE}.  Group items (@pxref{Structured Data}) are also implicitly considered to be alphanumeric data items.

@item @itemdfn{Alphanumeric Literal}
A string of characters enclosed within a pair of quotation marks (@samp{"}) or apostrophes (@samp{'}).  @xref{Alphanumeric Literals}.

@item @itemdfn{Called Program}
Another way to refer to a subprogram.  Note that a called program may also be a calling program.

@item @itemdfn{Calling Program}
A program that executes a subprogram.  Note that a calling program may also be a called program.

@item @itemdfn{Collating Sequence}
The sequence in which the characters that are acceptable to a computer are ordered for purposes of all types of sorting, merging, comparing, and processing.  GnuCOBOL programs may utilize standard character-set collating sequences (such as that defined by the ASCII or EBCDIC character sets) or programmer-defined custom sequences as specified in the OBJECT-COMPUTER paragraph (section 4.1.2) and defined in the SPECIAL-NAMES paragraph (section 4.1.4).

@item @itemdfn{Compilation Group}
The collection of all compilation units being compiled by a single execution of the GnuCOBOL compiler.

@item @itemdfn{Compilation Unit}
A single source file being compiled by the GnuCOBOL compiler.  A compilation unit may contain one or more programs.

@item @itemdfn{Control Break}
An event that is triggered when a control field on an RWCS-generated report changes value.  It is these events that trigger the generation of control heading and control footing groups.

@item @itemdfn{Control Field}
A field of data being presented within a detail group; as the various detail groups that comprise the report are presented, they are presumed to appear in sorted sequence of the control fields contained within them.  As an example, a department-by-department sales report for a chain of stores would probably be sorted by store number and -- within like store numbers -- be further sorted by department number.  The store number will undoubtedly serve as a control field for the report, allowing control heading groups to be presented before each sequence of detail groups for the same store and control footing groups to be presented after each such sequence.

@item @itemdfn{Control Footing}
A report group that appears immediately after one or more detail groups of an RWCS-generated report.  Such are produced automatically as a result of a control break.  This type of group typically serves as a summary of the detail group(s) that precede it, as might be the case on a sales report for a chain of stores, where the detail groups documenting sales for each department (one department per detail group) from the same store might be followed by a control footing that provides a summation of the department-by-department sales for that store.

@item @itemdfn{Control Heading}
A report group that appears immediately before one or more detail groups of an RWCS-generated report.  Such are produced automatically as a result of a control break.  This type of group typically serves as an introduction to the detail group(s) that follow, as might be the case on a sales report for a chain of stores, where the detail groups documenting sales for each department (one department per detail group) from the same store might be preceded by a control heading that states the full name and location of the store.

@item @itemdfn{Control Hierarchy}
The natural hierarchy of control breaks within a RWCS-controlled report based upon the manner in which the data the report is being generated from is sorted.

@item @itemdfn{Copybook}
A segment of program code that may be utilized by multiple programs simply by having that program use the @code{COPY} statement to import that code into the program.  Although similar to the ``include'' facility present in many other programming languages, the COBOL copybook mechanism is actually considerably more powerful.  @xref{Copybooks}, for a general discussion.  @xref{COPY}, for the specifics of the @code{COPY} statement.

@item @itemdfn{Data Item}
A contiguous area of storage within the memory space of a program that may be referenced, by name, in a COBOL program.  Other programming languages use the term variable, property or attribute to describe the same concept.  @xref{Structured Data}.

@item @itemdfn{Detail Group}
A report group that contains the detailed data being presented for the report.

@item @itemdfn{Detail Report}
An RWCS-generated report to which at least one type of detail group is presented.

@item @itemdfn{Division}
A collection of zero, one, or more sections of paragraphs, called the division body, that are formed and combined in accordance with a specific set of rules.  Each division consists of the division header and the related division body.  There are four divisions in a GnuCOBOL program: Identification, Environment, Data, and Procedure (coded in that sequence).  @xref{Program Structure}.

@item @itemdfn{Dynamic Subprogram}
A subprogram whose executable object code is contained in a different executable file as its calling program.  Dynamic subprograms are therefore loaded into memory as needed.

@item @itemdfn{Elementary Item}
A data item that isn't itself comprised of other data items.  @xref{Structured Data}.

@item @itemdfn{Entry-point}
A spot in the procedure division where a program may begin execution when it is executed from the operating system, invoked as a user-defined function or called by another program.

Every program has at least one entry-point --- known as the primary entry-point --- which corresponds to the first executable statement in the procedure division following the declaratives area, if any.

Additional entry-points may be defined via the @statementref{ENTRY}.

@item @itemdfn{Entry-point Name}
Every entry-point has a name.  That name must be unique for all programs that comprise an executable program.  Entry-point names are defined using a subroutine's @code{PROGRAM-ID} paragraph, a user-defined function's @code{FUNCTION-ID} paragraph or via @syntaxref{ENTRY} statements coded in a subprogram's procedure division.

@item @itemdfn{Executable File}
The GnuCOBOL compiler can create operating-system appropriate files that may be executed directly from the operating system environment.  On Windows systems, these will be @file{.exe} files whereas on UNIX systems they will have no specific extensions.  The compiler's
@switchidx{-x} is used to create executable files.  Only main programs should be compiled in this manner.

@item @itemdfn{Execution Thread}
The complete set of executable code that is run during the execution of a program.  This includes the main program as well as all executed subprograms, including those that are both dynamically and statically loaded.

@item @itemdfn{Figurative Constants}
GnuCOBOL, like other COBOL implementations, supports a number of reserved words that may be used to represent a specific literal value.  These are known as figurative constants.  @xref{Figurative Constants}, for more information.

@item @itemdfn{Fixed Format Mode}
A mode of the GnuCOBOL compiler's operation where source statements are constrained to meeting the pre-2002 standard of limiting COBOL statements to 80 columns, with various columns having limitations as to what sort of COBOL syntax could be specified in them.  @xref{Format of Program Source Lines}, for more information.

@item @itemdfn{Free Format Mode}
A mode of the GnuCOBOL compiler's operation where source statements are allowed to be as long as 255 characters, with no restrictions or requirements as to in which columns various syntax elements must appear.  @xref{Format of Program Source Lines}, for more information.

@item @itemdfn{Group Item}
A hierarchical data structure where the group item --- itself a data item --- actually consists of two or more other contiguously allocated data items.  For example, @code{Employee-Name} could be a 35-character data item consisting of a 20-character @code{Last-Name} data item followed by a 14-character @code{First-Name} and a 1-character @code{Middle-Initial}.  @xref{Structured Data}.

@item @itemdfn{Hexadecimal Alphanumeric Literal}
These are alphanumeric literals whose character sequence is specified by hexadecimal value.  These literals are formed by a quote- or apostrophe-delimited sequence of an even number of hexadecimal digits (upper- or lower-case), prefixed with the letter @samp{X} (also upper- or lower-case).  For example, the character string ``@code{Demo}'' could be specified as the hexadecimal alphanumeric literal @code{X'44656D6F'}, assuming the ASCII character set.  @xref{Alphanumeric Literals}.

@item @itemdfn{Hexadecimal Numeric Literal}
A numeric literal whose value is specified by hexadecimal value.  These literals are formed by a quote- or apostrophe-delimited sequence of from 1 to 16 hexadecimal digits (upper- or lower-case), prefixed with the letter @samp{H} (also upper- or lower-case).  For example, the number 123456 could be specified as the hexadecimal numeric literal @code{H'01E240'}.  @xref{Numeric Literals}.

@item @itemdfn{Identifiers}
These are data items a COBOL program will be working with.  The vast majority of identifiers are defined by the user (programmer) while a few are pre-defined by the GnuCOBOL compiler.  Identifiers pre-defined by the compiler are referred to as special registers.  Other programming languages generally refer to identifiers as ``variables''.

@item @itemdfn{Imperative Statement}
@anchor{Imperative Statement}Either a statement that begins with a non decision-making verb and specifies an unconditional action to be taken or a conditional verb such as @code{IF} or @code{EVALUATE}, delimited by its explicit scope terminator (such as @code{END-IF} or @code{END-EVALUATE}).  An imperative statement can consist of a sequence of imperative statements.

@item @itemdfn{Intrinsic Function}
A built-in routine that accepts arguments and returns a value; syntactically, these may be used most places where GnuCOBOL identifiers are valid.  @xref{List of Intrinsic Functions}, for documentation on all the GnuCOBOL intrinsic functions.

@item @itemdfn{Level Number}
A 1- or 2-digit number that indicates the hierarchical position of a data item in a group item or the special properties of a data description entry.

Level numbers in the range 1 through 49 indicate the position of a data item in the hierarchical structure of a logical record.   Level numbers in the range 1 through 9 can be written either as a single digit or as a zero followed by the significant digit.

Level numbers 66, 77, 78 and 88 identify special properties of a data description entry.

@item @itemdfn{Literal}
A generic term used for a constant value coded in a program that may be either a numeric literal or an alphanumeric literal.

@item @itemdfn{Main program}
A program that is executed directly from an operating system or shell event.  Main programs are not executed from other programs (i.e. they are not called programs).

@item @itemdfn{National Character set}
A character set that supports symbols using other than the traditional Roman alphabet symbols used by the ASCII character set.  Typically, such a character set uses a UTF-16 (i.e. 16 bits-per-character) encoding of the Unicode character set.

Support for national character sets in GnuCOBOL is currently only partially implemented, and the compile- and run-time effect of using the @code{N} symbol in a @syntaxref{PICTURE} clause to define a field as containing national characters is the same as if @code{X(2)} had been coded, with the additional effect that such a field will qualify as a @code{NATIONAL} or @code{NATIONAL-EDITED} field on an @syntaxref{INITIALIZE} statement.

@item @itemdfn{Numeric Data Item}
A data item whose @code{PICTURE} clause allows it to contain only the numeric digit characters @code{0}-@code{9} (signed or unsigned), or a data item whose @code{PICTURE}/@code{USAGE} combination allow it to contain actual binary numbers in integer, fixed-point, floating-point or packed-decimal format.  Numeric data items are the only ones that may be used as table subscripts or as source arguments on arithmetic statements.  @syntaxref{PICTURE}, or @syntaxref{USAGE}.

@item @itemdfn{Numeric Edited Data Item}
An otherwise numeric data item whose @syntaxref{PICTURE} clause also contains any of the editing symbols @samp{$}, @samp{*}, @samp{+}, @samp{,}, @samp{-}, @samp{.}, @samp{/}, @samp{0} (zero), @samp{B}, @samp{CR}, @samp{DB} or @samp{Z}.  Numeric edited data items are not eligible to serve as table subscripts or source arguments on arithmetic statements.

@item @itemdfn{Numeric Literal}
A numeric constant.  @xref{Numeric Literals}.

@item @itemdfn{Page Footing}
A report group that appears at the bottom of every page of an RWCS-generated report.  Information typically found within such a report group might be:

@itemize @bullet
@item
The date the report was generated
@item
The current page number of the report
@end itemize

@item @itemdfn{Page Heading}
A report group that appears at the top of every page of an RWCS-generated report. Information typically found within such a report group might be:

@itemize @bullet
@item
A title for the report
@item
The date the report was generated
@item
The current page number of the report
@item
Column headings describing the fields within the detail group(s)
@end itemize

@item @itemdfn{Primary Entry-Point}
See entry-point.

@item @itemdfn{Procedure}
All executable code statements within a single procedure division paragraph or section.

@item @itemdfn{Procedure name}
A programmer-defined section or paragraph name in the procedure division assigned to a procedure.  Procedure names serve as a means by which a statement may refer to the statements that follow the procedure name.

@item @itemdfn{Program}
A GnuCOBOL main program or subprogram.

@item @itemdfn{Qualification}
The process of establishing a unique reference to a data item whose name is duplicated in a program.  This takes the form of using the duplicated data name and the name of any of its parent data items, connected by @code{OF} or @code{IN} such that the combination of those two data names is unique within the program.

@item @itemdfn{Record}
A group item that is not part of a higher-level group item.  @xref{Data Definition Principles}.  An elementary item with a level number of 01 can also be referred to as a record if its definition occurs in the file section, provided that its definition does not include the @code{CONSTANT} attribute.  @xref{FILE-SECTION-Data-Item}.

@item @itemdfn{Report Footing}
A report group that occurs only once in an RWCS-generated report --- as the very last presented report group of the report.  These typically serve as a visual indication that the report is finished.

@item @itemdfn{Report Group}
One or more consecutive lines on a report that serve a common informational purpose or function.  For example, lines of text that are displayed at the top or bottom of every printed page of a report.

@item @itemdfn{Report Heading}
A report group that occurs only once in an RWCS-generated report --- as the very first presented report group of the report.  These typically serve as an introduction to the report.

@item @itemdfn{Reserved Word}
A word coded in a GnuCOBOL program without any quote or apostrophe characters around it (which would have transformed that sequence of characters into a literal string) which has a very specific meaning to the compiler.  @xref{Language Reserved Words}, for a general discussion of the concept.  Appendix C for a complete list of GnuCOBOL reserved words.

@item @itemdfn{Sentence}
An arbitrarily long sequence of statements terminated by a period.

@item @itemdfn{Special Registers}
Special data items that are automatically defined for your use by the GnuCOBOL compiler.  @xref{Special Registers}, for a complete list.

@item @itemdfn{Statement}
A single executable COBOL instruction.  All statements start with a verb (@code{DISPLAY}, @code{IF}, @code{MOVE}, ...) which is followed by the operands and additional syntax elements that describe the actions to be performed.

@item @itemdfn{Static Subprogram}
A subprogram whose executable object code is part of the same executable file as its calling program.  Static subprograms are therefore loaded into memory at the same time as their caller.

@item @itemdfn{Subprogram}
A program invoked directly by another program in such a manner that it may return control back to the other program, directly back to the point where the subprogram was invoked.

@item @itemdfn{Subroutine}
A subprogram executed from another via a GnuCOBOL @syntaxref{CALL} statement (or the equivalent in whatever programming language that other program was written in).

@item @itemdfn{Summary Report}
An RWCS-generated report to which no detail groups are presented.

@item @itemdfn{User-Defined Function}
A subprogram written in GnuCOBOL that is executed in a syntactically-similar manner to that by which the various built-in intrinsic functions are executed.

@item @itemdfn{User-Defined Names}
Either the name of an identifier or a procedure in the program.  GnuCOBOL limits user-defined names to a maximum of 31 characters taken from the set of numeric digits, upper- and lower-case letters, hyphens and underscores.  A user-defined name may neither begin nor end with a hyphen or underscore.  User-defined names used as file names may additionally not begin with a digit although - unlike many other programming languages - user-defined names used as identifiers or procedure names may.

@item @itemdfn{Verb}
The first reserved word of a COBOL statement.

@item @itemdfn{Zero-Delimited Alphanumeric Literals}
An alphanumeric literal prefixed with an upper- or lower-case @samp{Z} character --- for example, @code{Z'ABC'}.  These literals are one character longer than the value within apostrophes or quotes would make them appear.  The extra character (the last character) will be a null character (comprised entirely of zero bits).  These literals are ideal when defining or assigning values to alphanumeric data items that will be passed as arguments to a C subroutine.  @xref{Alphanumeric Literals}.
@end table
@iftex
@sp 3
@center ------------------------------------------------------------
@center End of Appendix A --- Glossary of Terms
@end iftex
