m204wiki - User contributions [en]

LoadCommandInfo (XmlDoc subroutine)

2020-05-20T17:36:56Z

Dme: /* Syntax terms */

{{Template:XmlDoc:LoadCommandInfo subtitle}}
This page is [[under construction]].
==Syntax==
{{Template:XmlDoc:LoadCommandInfo syntax}}
===Syntax terms===
<table class="syntaxTable">
<tr><th>doc</th>
<td>XmlDoc object</td></tr>
<tr><th>string</th>
<td>Command selection pattern, case ignored (i.e., converted to upper case). This argument is optional and defaults to the null string, which is the same as an asterisk (<code>*</code>. Leading and trailing blanks are ignored.</td></tr>
</table>

==Usage notes==
==Examples==
==See also==
{{Template:XmlDoc:LoadCommandInfo footer}}

List of Model 204 parameters

2020-05-13T16:07:44Z

Dme:

Parameters are variables that control or describe <var class="product">Model 204</var>. They can be set to different values to tailor <var class="product">Model 204</var> operation to the requirements of an installation
or user.

Each parameter is described on its own page; links to those pages are included in the table below (click on the parameter name).

For a description of Model 204 parameters and parameter types and how to use them, see the [[Overview_of_Model_204_parameters|parameter overview]].

One of the key bits of information about a parameter is, "when can it be assigned a new value", or reset, since this is often done using the <var>[[RESET command|RESET]]</var> command. This information is provided for each parameter below.

The value of one or more individual parameters can be displayed with the <var>[[VIEW command|VIEW]]</var> command. <var>VIEW</var> also provides special forms which allow display of a class of parameters.

The table contains an entry for every Model 204 parameter. Some are associated with specific products and may be unavailable at sites not authorized for those products. Other parameters, while available, don't really do anything unless a site is authorized for specific products.

See the [[#Sirius parameters|"Sirius parameters"]] footnote below, which describes the availability of parameters marked with (S).

==List of parameters==
{{Template:List of Model 204 parameters}}

==Footnotes==
===Obsolete parameters===
The (obs) symbol indicates parameters that were operative in earlier versions of <var class="product">Model 204</var> but are no longer operative. In order to support compatibility with earlier versions, an obsolete parameter:
<ul>
<li>Can still be referenced in a <var>VIEW</var> command, but its viewed value should be ignored. </li>

<li>Can be set or reset, but the value will not change, and a warning message is issued indicating this. Hence, an obsolete parameter is, in effect, viewable only. </li>
</ul>
Further information about the specific obsolescence for a parameter is contained on the parameter's description page, which is accessed from its link in the table above.

===Sirius parameters===
The (S) symbol is shown at the end of the description of each parameter that was provided in the <var class="product">[[Sirius Mods]]</var>. These parameters are unavailable to you if both of these are true:
<ul>
<li>You are using a version of <var class="product">Model 204</var> prior to version 7.5. </li>

<li>You do not have the <var class="product">Sirius Mods</var> included in your <var class="product">Model 204</var> load module. </li>
</ul>

FOPT parameter

2020-04-25T14:32:22Z

Dme: /* Description */

{{Template:FOPT parameter subtitle}}
==Summary==
<dl>
<dt>Default value
<dd>0
<dt>Parameter type
<dd>File
<dt>Where set
<dd>During file creation or reset by file manager
<dt>Related products
<dd>All
<dt>Introduced
<dd><var class="product">Model 204 V2.1</var> or earlier
</dl>

==Description==
The following table lists the valid settings for file options (<var>FOPT</var>), which can be summed:
<table>
<tr class="head"><th>Setting</th><th>Meaning</th></tr>
<tr><th align="right"><var>X'80'</var></th>
<td>Prohibits statement numbers in procedures.</td></tr>

<tr><th align="right"><var>X'40'</var></th>
<td>Prohibits statement labels in procedures. </td></tr>

<tr><th align="right"><var>X'10'</var></th>
<td>Enables the date/time stamp feature.
Note: This option can be set only after the [[Adding_a_date-time_stamp_field|date/time stamp field]] has been defined in the file. You cannot set X'10' when you [[CREATE command: File|create]] the file, because the date/time stamp field has not yet been created. 
The X'02' and X'10' options are mutually exclusive.</td></tr>

<tr><th align="right"><var>X'08'</var></th>
<td>(Obsolete) Indicates append-first mode in an RDFS file. Without the X'08' option, an RDFS file is in reuse-first mode. The <var>FILEORG</var> parameter contains option 4.</td></tr>

<tr><th align="right"><var>X'02'</var></th>
<td>Disables [[Record_level_locking_and_concurrency_control#Lock_pending_updates|lock pending updates]] — <var class="product">Model 204</var> automatically disables transaction backout by turning on the X'08' bit of the <var>[[FRCVOPT parameter|FRCVOPT]]</var> parameter. The X'02' bit of the <var>FOPT</var> parameter and the X'08' bit of the <var>FRCVOPT</var> parameter for a file must be turned off to activate the transaction backout facility.
The <var>FOPT</var> X'02' and X'10' options are mutually exclusive.</td></tr>

<tr><th align="right"><var> X'01'</var></th>
<td>Permits only the file manager to define new [[Field names|field names]], not other users.</td></tr>

<tr><th align="right"><var> X'00'</var></th>
<td>Allows labels and statement numbers in the same file.
Enables the Lock Pending Updates feature, which is required for [[Transaction_back_out|transaction backout (TBO)]].
Disables the date/time stamp feature (DTS).
</td></tr>
</table>

==Usage notes==
<ul>
<li>Options X'80' and X'40' can be used to avoid the mixture of statement numbers and labels in procedures on old files and/or to ensure that any procedure development on new files uses statement labels exclusively.</li>

<li>A file manager can set the <var>FOPT</var> file options during file creation or via the <var>[[RESET_command|RESET]]</var> command. Note that the options are file-specific. Thus, if a procedure from one file includes a procedure from another file, the use of labels or numbers within each procedure is governed by the <var>FOPT</var> option assigned to the file where they reside.

The enforcement of these options occurs at compile time and is in effect only for procedures compiled from a <var class="product">Model 204</var> file. These options are not enforced if a procedure is compiled as a temporary procedure.
Note: When a file is opened, bits that are not currently defined for <var>FOPT</var> are reset. This bit resetting is designed to permit the possible use of these bits by features to be introduced in future <var class="product">Model 204</var> releases. You cannot use the <var>RESET</var> command to set bits that are currently undefined.</li>

<li>If an application makes use of any of the undefined bits of the <var>FOPT</var> parameter, it can produce unexpected results.</li>
</ul>

[[Category:CREATE parameters]]
[[Category:File parameters]]
[[Category:Parameters]]

Field design

2020-04-24T16:22:25Z

Dme: /* BLOB and CLOB compatibility with other attributes */

==Overview==

The field structures in <var class="product">Model 204</var> are at the heart of providing applications which perform the functions that you require in the most efficient manner possible.

This page discusses exactly how the data structures should be defined.

==Designing records, field groups, and fields==

When setting up a <var class="product">Model 204</var> file, you must first decide what fields the records will contain. A record in a personnel file, for instance, might contain a social security number field, a last name field, a spouse's name field, and so on. 

===Variable record formats===

The record in <var class="product">Model 204</var> is a very loose concept. Physically, it is simply a collection of fields (data items).

Any field in the [[#Table A (File architecture) Internal File Dictionary|Table A dictionary]] can appear in any record in the file. It is quite possible that you create a file with many different logical record types with only a few (or even none) appearing in all of the records.

Thus, each record is not required to have a value for every field; so that record lengths are variable, and it can be argued that the entire concept of a record "format" does not apply to Model 204 files. If an employee's address is unknown or doesn't exist in a particular logical record, for example, the address field will be left out of the record altogether. The exception to this is [[#Preallocated fields (OCCURS attribute)|preallocated fields]]. If they are are defined for a file, space is reserved in each record for all such fields, even if they would never exist for that logical record. 

===Multiply occurring fields===

Most types of fields can be multiply occurring, that is, have more than one value per record. For example, the <code>CHILD</code> field can appear no times, once, or several times in one record. 

==Field descriptions and attributes==

When you describe a field in a <var class="product">Model 204</var> file with the <var>[[DEFINE FIELD command|DEFINE FIELD]]</var> or <var>[[REDEFINE command|REDEFINE FIELD]]</var> command, you specify a field description that consists of the field name followed by a list of field attributes. These attributes determine how a field can be accessed and how it is stored internally. This section describes the attributes supported for <var class="product">Model 204</var> fields. 

Within a record, there is usually no restriction on the number of different fields that can have the same attribute (the exception being the key fields for Sorted and Hash Key files). For example, several fields within the same record can have ORD CHAR indices built for them.

Attribute assignments

The attribute assignments apply whether the field was defined separately or as part of a [[Field group (File architecture)|field group]].

If you do not assign a particular attribute to a field, the default attribute is assigned. For example, if you do not assign the <var>KEY</var> attribute to a field definition, the field is assigned <var>NON-KEY</var>.

If a required attribute is not assigned a value, the default value is used. For example, if you define a CONCATENATION-OF field, which requires the SEPARATOR attribute, and you do not enter the SEPARATOR attribute, the default value of X'00' is used as the SEPARATOR value.

Multiply occurring fields

For most field attributes there is almost no restriction on the number of times a particular field can occur within a record. This makes file/record design very flexible. If you have a record which has child details as repeating fields or groups, for example, any number can be supported. 

Singly occurring fields

There are a few attributes which require a field to have no more than one occurrence per record:
<ul>
<li>NUMERIC RANGE
<li>Sort key fields
<li>Hash key fields
</ul>

Others require a field to have no more than one occurrence per record or field group (depending on the context in which they are defined):
<ul>
<li>AT-MOST-ONE
<li>EXACTLY-ONE
</ul>

==Indexing fields==
Model 204 files can become quite large, and so it is almost always preferable to directly access the record or records which have particular characteristics. As part of your design process, you should have identified which field(s) are likely to be used for direct retrieval of sets of records.

For example, if you have a personnel file, you are likely to have a unique identifier for each employee, and it is also likely that you will often want to process only the record or records with that ID.

Where retrievals are attempted against non indexed fields, a search of Table B must be done, and the danger of request cancellation because [[MBSCAN parameter|MBSCAN]] is exceeded exists.

Model 204 supports a few different ways to implement these direct searches, and the recommended default choice for indexing is the ORDERED attribute.

===ORDERED and NON-ORDERED attributes===

Fields used in retrieval specifications should normally be defined as ORDERED (unless one of the other indexing methods, described below) is chosen. NON-ORDERED, the default, means that all retrieval requests need to scan the records directly in Table B to find the selected records.

For the architectural approach to the implementation of the ordered index, refer to [[Table D (File architecture)#Understanding the Ordered Index|understanding the Ordered Index]].

====Choosing an order type====

An ORDERED field can have an index with either CHARACTER or NUMERIC ordering. This is called its order type. The field's order type and updating characteristics are declared with the DEFINE command. You can specify only one order type for a field. ORDERED NUMERIC fields contain numeric values stored as standardized floating-point numbers in one section of the index and non-numeric values in EBCDIC order in another section. 

=====ORDERED CHARACTER fields=====

ORDERED CHARACTER fields use the standard EBCDIC collating sequence. If a field is ORDERED CHARACTER, all values of the field are stored in the Ordered Index in EBCDIC collating sequence order.

=====ORDERED NUMERIC fields=====

A string field value is considered NUMERIC if it consists of digits, with one optional decimal point, and an optional plus or minus sign at the beginning of the string. The value of the number cannot be greater than 10 to the power 75 or less than 10 to the power -75. 

If an ORDERED NUMERIC field is also FLOAT, exponential format is allowed. Values for BINARY, FLOAT (8), and FLOAT (16) fields are rounded to 15 significant digits. Values for FLOAT (4) fields are rounded to 6 significant digits. 

An invalid value is stored as an unconverted string. 

In ORDERED NUMERIC fields, leading zeros are ignored. For example, 001 and 1 are considered equivalent and are maintained in the ORDERED NUMERIC portion of the B-Tree as the same value. For fields that require a meaningful leading zero (such as zip code), use ORDERED CHARACTER.

Values of an ORDERED NUMERIC field that do not satisfy the definition of NUMERIC are stored in a separate section of the Ordered Index and processed in EBCDIC order. During FOR EACH VALUE and FOR EACH RECORD IN ORDER BY FIELD processing of an ORDERED NUMERIC field, these values are processed after the valid NUMERIC values unless you restrict the range of values. 

=====Default order types=====

If a field is defined as ORDERED without specifying which type of ordering to create, a default order type is used. The default depends on whether the field is STRING, BINARY, or FLOAT:
<table>
<tr class="head">
<th>For...</th><th>The default order type is...</th>
</tr>

<tr>
<td>STRING</td><td>ORDERED CHARACTER</td>
</tr>

<tr>
<td>BINARY or FLOAT</td><td>ORDERED NUMERIC </td>
</tr>
</table>

====ORDERED field definition====

The ORDERED attribute has options that allow you to determine the type of ordering the Ordered Index is to have, as well as some of the characteristics of the Ordered Index tree as it expands or is rebuilt. These options are described in the discussions of order type and Ordered Index tree structure that follow.

=====Defining ORDERED field attributes=====

The [[DEFINE command]] is used to specify a field's attributes. The format of the DEFINE command with the ORDERED attribute options is:

=====Syntax=====
DEFINE FIELD fieldname WITH ORDERED
[CHARACTER | NUMERIC][SPLITPCT s] [IMMED i]
[LRESERVE <var class="term">r</var>] [NRESERVE n]


Note: The default designation for a field is <var>NON-ORDERED</var>. Ordered Index tree parameters do not apply for a <var>NON-ORDERED</var> field. 

<var>CHARACTER</var> and <var>NUMERIC</var> order types are described above.

<var>SPLITPCT</var>, <var>IMMED</var>, <var>LRESERVE</var>, and <var>NRESERVE</var> parameters are described in [[Table D (File architecture)#Ordered Index spacing parameters|Ordered Index spacing parameters]]. 

=====Redefining ORDERED fields=====

To change the type of ordering of an ORDERED field, use the [[REDEFINE command]] followed by the new ordering type, thereby deleting the old type. To change the spacing characteristics, specify the current parameter (LRESERVE, NRESERVE, SPLITPCT, or IMMED) with a new value. This takes effect only for fields added after the change.

====Choosing between ORDERED and NUMERIC RANGE====

The ORDERED attribute has several advantages over the NUMERIC RANGE attribute, and as such should be the normal choice. Specifically: 
<ul>
<li>Ordered Index allows for multiple occurrences of the same numeric field in a record. The NUMERIC RANGE attribute issues an error message whenever an attempt is made to store more than one occurrence of the same NUMERIC RANGE field in the same record.</li>

<li>Cost of updating an ORDERED field is lower than that of a NUMERIC RANGE field. The NUMERIC RANGE field requires multiple attributes to be maintained to describe the characteristic of a number. The cost of an update to the Ordered Index is always proportional to the depth of the tree.</li>

<li>In most cases, especially with large numbers, the Ordered Index uses less space to maintain the index information.</li>

<li>Ordered Index allows for more accurate range requests, with numbers representable by IBM double-word floating-point numbers. </li>
</ul>

=====Range retrievals=====

Although range retrievals are usually faster for ORDERED fields than for NUMERIC RANGE fields, the size of the range interval and the density of the distribution of values over that range are the principal determining factors.

In the past, NUMERIC RANGE retrievals have been faster for very large ranges with densely distributed data values. 

=====CHUNK attribute=====
However, as of Model 204 version 7.5, you can improve the efficiency of data range retrieval on <var>ORDERED NUMERIC</var> fields by defining the fields with the <var>[[DEFINE FIELD command#CHUNK attribute|CHUNK]]</var> attribute.

The <var>CHUNK</var> attribute defines a subrange ("OI chunk") of the Ordered Index data range, so the desired data can be found with fewer scans of the Ordered Index entries.

<var>CHUNK</var> fields are automatic fields and therefore require that FILEORG X'100' be set for the file.

The <var>CHUNK</var> attribute is followed by a number, defining the size of the OI chunk, and then FOR <var class="term">chunkTargetFieldName</var>, where <var class="term">chunkTargetFieldName</var> is the existing <var>ORDERED NUMERIC</var> field from which you want to retrieve data in OI chunks.

So, to illustrate:
DEFINE FIELD YYYYMMDD WITH ORDERED NUMERIC
DEFINE FIELD YYYYMM WITH ORDERED NUMERIC INVISIBLE CHUNK 100 FOR YYYYMMDD


A <var>CHUNK</var> field is automatically maintained based on updates to the target (FOR) field (here, YYYYMMDD). The stored value is the value of the target field rounded down to the CHUNK size. So, for example, if you stored a value of 20121225 into YYYYMMDD, the underlying code would automatically store the value 20121200 into YYYYMM. Similarly, if you stored 20121203 into YYYYMMDD, a 20121200 value would also be stored into YYYYMM.


When doing a range find, Model 204 decomposes the find into range finds based on the <var>CHUNK</var> field and the target field.
So, for example, a find for values between 20121211 and 20130205 would be decomposed into a find for:

<ul>
<li>YYYYMMDD between 20121211 and 20121299 (ignoring for the moment issues with non-integer values and demonstrating that <var>CHUNK</var> doesn't really know or care if the field is a date)</li>

<li>OR YYYYMM between 20130100 and 20130100 (or more precisely, exactly equal to 20130100)</li>

<li>OR YYYYMMDD between 20130200 and 20130205</li>
</ul>

This reduces the number of scanned ordered index entries by a factor of 2.
Results would often be much better than that. For example, it probably would not be atypical for a date range to land on month boundaries, resulting in improvements closer to a factor of 30. And, as the range got bigger and bigger, more and more of the range processing would occur on the CHUNK field, with additional improvement in processing.


=====Multiple CHUNK fields=====

To get even better performance, you could define multiple <var>CHUNK</var> fields for a target field:

DEFINE FIELD YYYYMMDD WITH ORDERED NUMERIC
DEFINE FIELD YYYYMMD WITH INVISIBLE ORDERED NUMERIC CHUNK 10 FOR YYYYMMDD
DEFINE FIELD YYYYMM WITH INVISIBLE ORDERED NUMERIC CHUNK 100 FOR YYYYMMDD
DEFINE FIELD YYYY WITH INVISIBLE ORDERED NUMERIC CHUNK 10000 FOR YYYYMMDD


The OI chunk size for a <var>CHUNK</var> field must be a greater-than-1 integral multiple of all smaller OI chunk sizes for the same target field. For example, specifying "7" as the first <var>CHUNK</var> size in the above example would be invalid because 100 is not an integral multiple of 7.

Note that you could reference the <var>CHUNK</var> fields directly in non-updating statements, as shown in this example:

fd to %recset
yyyy eq %year
end find


In any case, the number and size of the <var>CHUNK</var> fields allows you to trade off the overhead of doing updates against the efficiency of doing range finds. 

====Choosing between ORDERED and FRV====

The ORDERED attribute is usually a better alternative to the FRV attribute. Although FRV fields with small numbers of values might perform faster in value loop processing, they lose this advantage if the found values are required to be in order, and as the number of values increase. FRV ordered retrievals require additional sorting. For retrievals in ascending or descending order, ORDERED fields are more efficient. For (presumably rare) right-adjusted character strings in order, ORDERED fields require additional sorting.

=====Compatibility of ORDERED with other field attributes=====

Use the following guidelines when specifying the ORDERED attribute:
<ul>
<li>A field cannot be both ORDERED and FRV.</li>
<li>A field cannot be both ORDERED NUMERIC and NUMERIC RANGE.</li>
<li>A field can be both KEY and ORDERED (but serves little or no purpose).</li>
<li>A field can be both INVISIBLE and ORDERED.</li>
<li>A field can be both DEFERRABLE and ORDERED. If the field is DEFERRABLE, the index updates can be written out to a (see [[#DEFERRABLE and NON-DEFERRABLE attributes|DEFERRABLE and NON-DEFERRABLE attributes]] for details). </li>
<li>UNIQUE field must be ORDERED. </li>
<li>Hash and sort key fields and record security fields can be ORDERED.</li>
<li>Fields which are defined as KEY can be converted to ORD with no code changes required (as direct retrievals will work with either type of ORD field).</li>
</ul>

For an architectural view of the ordered index, see [[#Table D (File architecture) Ordered Index|the Ordered Index]].

===KEY and NON-KEY attributes===

The KEY and NON-KEY attributes govern whether to create a hash index for a field or not. If KEY is specified, an index is created for the field. Retrieval commands will access the index for that field. If NON-KEY is specified, every record in the table is examined. The NON-KEY attribute is a default field description. This section provides information about space and performance for each of these attributes.

=====KEY attribute=====

When storing fields that have the KEY attribute, <var class="product">Model 204</var> makes special entries in the hash index. During retrieval, <var class="product">Model 204</var> goes directly to the appropriate index entry to find which records satisfy the selection criteria, without searching through other records in the file. This makes retrieval based on KEY fields extremely fast. 

However, these index entries must be updated, when User Language statements or Host Language Interface functions add, change, or delete fields. Processing might take slightly longer for KEY fields than for NON-KEY fields. In addition, the space occupied by the index entries can be considerable, especially in large files and in fields that take on many values. 

=====NON-KEY attribute=====

No index entries are maintained in Tables C and D for NON-KEY fields. When a retrieval is performed based on the value of NON-KEY fields, the data in Table B must be searched directly. The direct search can have a significantly adverse effect on performance, if a large number of records must be searched. 

However, the cost of the direct search can be greatly reduced in some cases where both KEY and NON-KEY fields are specified in the retrieval conditions. <var class="product">Model 204</var> reduces the number of records to be searched directly by performing the indexed selection first. Records that are definitely eliminated, based on the KEY conditions, are not searched directly. 

=====Choosing between KEY and NON-KEY=====

Keep the following guidelines in mind when deciding to designate a field as KEY or NON-KEY:
<ul>
<li>If space is not an overriding consideration, designate fields that are used frequently for retrievals of equality as KEY.</li>

<li>If a field is updated frequently and only occasionally used for retrieval, define it as NON-KEY.</li>

<li>If a field is used frequently for retrievals and updated frequently, the choice is less obvious. If you reserve sufficient space in Tables C and D for adding inversion entries, the field initially can be defined as NON-KEY and changed later with the <var>REDEFINE</var> command. </li>
</ul>

===FOR EACH VALUE (FRV) and NON-FRV attributes===

The FRV attribute is useful when creating fields used in value loop processing. If the FRV attribute is not specified when a field is defined, the NON-FRV attribute is assumed. If this attribute is set, the field is usually assigned the KEY attribute as well. 

====Table space for FRV fields====

Every value of an FRV field is automatically encoded in Table A, whether or not the value is stored in Table B (that is, INVISIBLE). In addition to more Table A space, FRV fields require slightly more Table C and Table D space than ordinary key fields. Because of these additional space requirements, the FRV attribute is most frequently defined for fields in which the number of different values does not exceed approximately 200.

====Using the FRV attribute====

The FRV attribute behaves in a special way when combined with the BINARY attribute. This is discussed in [[#BINARY attribute|BINARY attribute]].

Fields cannot be defined with the FRV attribute in [[Field attributes#File model feature|First-Normal Form (1NF)]] files. 

====FRV attribute, FRV User Language statement====

=====Value loops=====

User Language provides a special construction called a value loop that executes a set of statements once for each different value of an indicated field. The loop is initiated by the FOR EACH VALUE statement; the field must have the FRV or ORDERED attribute. The FOR EACH VALUE statement has Host Language equivalents in IFFDV and IFGETV. A value loop is illustrated in the following example:

Example
EACH.STATE:
FOR EACH VALUE OF STATE
GET.RECS:
FIND ALL RECORDS FOR WHICH
STATE = VALUE IN EACH.STATE
END FIND
TOT.RECS:
COUNT RECORDS IN GET.RECS
PRINT.CT:
PRINT VALUE IN EACH.STATE -
WITH COUNT IN TOT.RECS AT COLUMN 20
END FOR


On the first pass through the loop, a value of STATE, such as DELAWARE, is selected. The last statement prints DELAWARE and the number of records with the field-name-equals-value pair: STATE = DELAWARE. On the next pass, another value is chosen, such as IOWA, and so on until all values of the STATE field have been processed exactly once.

=====Using the IN ORDER option=====

The IN ORDER option of the FOR EACH VALUE statement specifies that the values of an FRV KEY field be presented in an ordered sequence-ascending, descending, numerical, right adjusted. This option improves performance by avoiding Online sorts of a large number of records, because only the values are sorted instead of a large found set of records. 

=====Value loop processing for ORDERED fields=====

You can also use value loop processing on fields with the ORDERED attribute. When the FOR EACH VALUE statement with the IN ORDER option is used for NON-FRV, ORDERED fields, ORDERED retrievals can be significantly faster than FRV ordered retrievals. See [[#ORDERED and NON-ORDERED attributes|ORDERED and NON-ORDERED attributes]] for a description of the ORDERED attribute. 

Value loop processing can be made more flexible and efficient by using [[Is_Like_pattern_matching#Pattern matching|pattern matching]].

===NUMERIC RANGE and NON-RANGE attributes===

Prior to the introduction of ORDered NUMeric fields, Model 204 permitted range retrieval (a field value numerically equal to, less than, greater than, or between certain values) with the NUMERIC RANGE attribute. This attribute indexes the component parts of a numeric value and then joins them, to provide rapid numeric range retrievals without a direct search of the records.

If the NUMERIC RANGE attribute is not specified when a field is defined, the NON-RANGE attribute is assumed. 

It is recommended that, for any new fields being defined,the ORDERED NUMERIC attribute is used in preference to NUMERIC RANGE.

The NUMERIC RANGE attribute cannot be set where the product ([[ASTRPPG parameter|ASTRPPG]] * [[ATRPG parameter|ATRPG]]) is greater than 4000 (available in <var>[[FILEORG parameter|FILEORG]]</var> X'100' files).

====NUMERIC RANGE retrieval specifications====

The following retrieval specifications, with their symbolic operator equivalents in parentheses, can be used:
fieldname IS value
fieldname IS EQ (=) value
fieldname IS LESS THAN (LT or <) value
fieldname IS GREATER THAN (GT or >) value
fieldname IS BETWEEN (GT or >) value AND (LT or <) value
fieldname IS GREATER THAN (GT or >) value AND LESS THAN (LT or <) value
fieldname IS LESS THAN (LT or <) value AND GREATER THAN (GT or >) value


====Examples====

The following examples show numeric retrieval specifications:
ALL:
FIND ALL RECORDS FOR WHICH AMOUNT IS 53.00
DATE IS BETWEEN 050500 AND 050532
END FIND


These specifications retrieve records for which AMOUNT has a value of 53.00 (or 53 or 053, and so on) and DATE has a value in May 2005.

====NUMERIC RANGE retrieval fields====

The values of NUMERIC RANGE retrieval fields can be either positive or negative numbers that have as many as ten digits on either side of the decimal point (20 digits maximum). When such fields are stored, <var class="product">Model 204</var> makes many entries in Tables C and D as well as some special entries in the field name (attribute) section of [[Table A (File architecture)|Table A]]. These entries are quite complex, and NUMERIC RANGE retrieval fields require both more storage space and more time to store and update than do KEY fields. 

In deciding whether to define a field as NUMERIC RANGE or NON-RANGE (and NON-ORDERED), use the same choice criteria described in [[#KEY and NON-KEY attributes|KEY and NON-KEY attributes]], keeping in mind the additional overhead caused by the extra index entries for RANGE fields.

====Interpreting nonnumeric values====

If a NUMERIC RANGE field is stored with a value that <var class="product">Model 204</var> cannot interpret as a number, the system stores a special index entry for the record. The field name of this special entry consists of the NUMERIC RANGE retrieval field name with ++ appended. The entry has a value of NON NUMERICAL. Thus, the following User Language retrieval retrieves all records with nonnumerical values of AGE:
ALL:
FIND ALL RECORDS FOR WHICH
AGE++ = NON NUMERICAL
END FIND


This can be useful in locating bad input data.

====Compatibility with other attributes====

You can specify as many NUMERIC RANGE retrieval fields in each record as you need. However, a particular NUMERIC RANGE retrieval field cannot be multiply occurring within any one record.

You cannot specify the NUMERIC RANGE attribute in the following circumstances:
<ul>
<li>With any field defined as FLOAT</li>
<li>For any field in a 1NF file</li>
</ul>

For a table showing invalid attribute combinations, see the <var>[[DEFINE FIELD command|DEFINE FIELD]]</var> command. If you are defining field attributes with FILEMGMT, you will not be allowed to specify conflicting attributes.

== Data typing ==

The following attributes are described individually in the next sections. They represent the way the field is physically stored. Only one of these can be assigned to any field.
<ul>
<li>STRING</li>
<li>BINARY</li>
<li>BLOB, CLOB, MINLOBE</li>
<li>FLOAT</li>
<li>DATETIME</li>
<li>UTF-8 or UTF-16</li>
<li>VISIBLE, INVISIBLE</li>
</ul>

===STRING attribute===

STRING is the default attribute for all fields. If your data is character or alphanumeric, such as names and addresses, specify a data type of STRING. STRING fields are also useful if you plan to store mixed data types in an image. 

The length of a STRING field is limited to 255 bytes, because the first byte of a STRING data field is a count byte-that is, a byte that contains the length of the rest of the string. 

===BINARY attribute===

Fields whose values are numeric integers can alternatively be compressed and stored as 4-byte binary numbers with the BINARY attribute. Specifying BINARY saves Table B space if the average value of the field is from 4-9 digits long.
Acceptable BINARY values

To be compressed successfully, the value must be1-9 digits long and can contain a minus sign. It cannot contain a plus sign, a decimal point, or leading zeros. If the value cannot be compressed, <var class="product">Model 204</var> refers to the CODED/NON-CODED field attribute (which the BINARY attribute usually overrides) to decide how to store the value. 
BINARY and FRV fields

The BINARY attribute overrides the FRV attribute, except for values that cannot be compressed. If the field cannot be compressed, it will be stored in Table A in either the FEW-VALUED or MANY-VALUED pages depending on the field definition. For instance, AGE has been defined with the BINARY and FRV attributes and takes on the values:
23, 04, -34578, 935., 20,
+8754, and TWO


The statement FOR EACH VALUE OF AGE retrieves only the values:
04, 935., +8754 and TWO


If BINARY is not specified when a field is defined, the STRING attribute is assumed.
BINARY fields and NUMERIC VALIDATION files

If a BINARY field is defined in a NUMERIC VALIDATION file model file ([[FILEMODL parameter|FILEMODL]] = X'01'), <var class="product">Model 204</var> provides numeric data type validation. If you try to store non-numeric or other non-conforming (that is, non-compressible) data in a BINARY field in a NUMERIC VALIDATION file, <var class="product">Model 204</var> cancels the request with the following message:
M204.2123: VALUE SPECIFIED VIOLATES BINARY DATA TYPE VALIDATION IN RECORD <var class="term">recno</var>, FIELD IGNORED: <var class="term">fieldname</var> = <var class="term">value</var>


<div id="BLOB attribute"></div>
<div id="CLOB attribute"></div>
<div id="MINLOBE attribute"></div>
===BLOB, CLOB, and MINLOBE attributes===


The <var>BLOB</var> and <var>CLOB</var> attributes describe [[Record (File architecture)#Large objects|Large Object data]] that can be used to store long strings in the database, for example, long XML strings. This means that <var class="product">Model 204</var> User Language threads can exchange Large Object data with a partner process by way of the Universal Buffer and/or the [[MQ/204]] Interface. The Universal Buffer is a one-per-user, temporary storage area that, like the [[MQ/204 data conversion and handling#Data handling|MQ buffer]], automatically expands to accommodate its data contents.
<ul>
<li>With the Universal Buffer, Large Object data can be sent and received using SOUL <var>READ IMAGE</var> and <var>WRITE IMAGE</var> statements, or <var>[[Program Communication facilities#.24SOCKET function|$SOCKET]]</var> <var>READ</var> and <var>WRITE</var> calls.</li>

<li>With the MQ/204 Interface, Large Object data can be sent and received by <var>MQPUT</var> and <var>MQGET</var> statements, stored and retrieved from the database with SOUL <var>STORE</var>, <var>ADD</var>, and assignment statements using the <var>BUFFER</var> reserved area name.</li>
</ul>

Note: Files created in V6R1 and later are not compatible with earlier versions of <var class="product">Model 204</var>, because of Large Object support and the concomitant changes to the FPL page.

====Introducing Large Object field types====

The Large Object field types includes the following Character Large Object (CLOB) and Binary Large Object (BLOB) attributes. 
<ul>
<li>CLOBs are character strings. </li>
<li>BLOBs are binary strings. No translation is performed when the object is sent or received.</li>
</ul>

Note: Because Large Object fields require that Table E be present in a file, you cannot simply add a Large Object field to an existing file created in a pre-6.1 version of Model 204. You would need to rebuild the existing file by downloading the data and procedures; recreate the file to establish Table E; define the Large Object fields to incorporate; and load the data.

====Limitations of Large Object support====
<ul>
<li>Currently there is a limit of 2,147,483,647 bytes (or two gigabytes) of data per Large Object.</li>

<li>For CLOBs the translation of ASCII to EBCDIC and back is handled by the design of your application.</li>

<li>For BLOBs no translation is performed.</li>

<li>The User Language INSERT statement is not supported.</li>
</ul>

====Handling Large Object data====

The <var>BLOB</var> and <var>CLOB</var> attributes are supported as follows:
<ul>
<li>You can create, open, and recover a file with a <var>BLOB</var> or <var>CLOB</var> attribute. The Large Object field can be multiply occurring. </li>

<li>The <var>DELETE fieldname</var> statement supports Large Object data. This statement frees the Table B and Table E data.</li>

<li>You can store and add a Large Object data to the file you have created from the Universal Buffer, BUFFER. Using an assignment statement you can transfer Large Object data from a field into the Universal Buffer.</li>

<li>You can set the number of Table E pages during file creation with <code>[[ESIZE parameter|ESIZE]]=n</code>.</li>

<li>You can view the <var>EHIGHPG</var> parameter to determine the highest number of Table E pages in use.</li>

<li>You can modify the size of Table E with an <var>INCREASE</var> or <var>DECREASE</var> command.</li>

<li>The <code>DELETE FIELD fieldname</code> command supports the Large Object field type, so you can delete a Large Object field name. However, the space in Table B and Table E is not automatically available for reuse. </li>

<li>The [[$LobLen]](lob-field-name) function is available for your use.</li>

<li>[[Dictionary/204 overview|Dictionary/204]] and the Cross-Reference facility support Large Object field types.</li>

<li>NULL Large Object data is supported.</li>

<li>Transaction back out is supported for Large Object field types.</li>

<li>Field-level security is supported.</li>
<li>A string field cannot be converted to a CLOB via PAI unload followed by FLOD/FILELOAD.
<ul>
<li>The new CLOB field must be populated, from the STRING field, using a SOUL program and the universal buffer.</li>
<li>Or, if using Fast/Unload, a STRING field can be converted to a CLOB during UAI/LAI. See [[Fast/Unload_BLOB/CLOB_processing_considerations#NEW_statement_option_for_Lobs|NEW statement option for Lobs]] for more details.</li>
</ul>
</li>
</ul>

====BLOB and CLOB compatibility with other attributes====

See the [[Field attribute combinations]] page for the attributes that are not allowed with <var>BLOB</var> or <var>CLOB</var>. Use of conflicting attributes produces the following message:
M204.0411: Conflicting attributes: ([BLOB | CLOB]) and <var class="term">attribute2</var>


====Using the MINLOBE (MLBE) attribute====
Note: The <var>MINLOBE</var> attribute is available as of Model 204 version 7.5.

The <var>MINLOBE</var> attribute defines the minimum size of a <var>BLOB</var> or <var>CLOB</var> field value that will be stored in Table E.

You can use the <var>MINLOBE</var> attribute only with a BINARY LARGE OBJECT (BLOB) or a CHARACTER LARGE OBJECT (CLOB) field in a <var>[[FILEORG parameter|FILEORG]]</var> X'100' file. The <var>MINLOBE</var> attribute cannot be paired with the <var>OCCURS</var> attribute. You can redefine the <var>MINLOBE</var> attribute value.

Syntax
MINLOBE nnn


The default and smallest value for <var>MINLOBE</var> is 0, which means that all values of the field are stored in Table E. The maximum value of <var>MINLOBE</var> is 200.

If a field has a <var>MINLOBE</var> attribute greater than 0:
<ul>
<li>And the value of the field is not longer than <var>MINLOBE</var>, then the value is stored in Table B or Table X, instead of Table E.</li>

<li>The SOUL <var>CHANGE</var> statement is not allowed, and the following error is displayed:
M204.2869 Change refused: MINLOBE > 0 for File filename field fieldname

Any <var>CHARACTER LARGE OBJECT</var> or <var>BINARY LARGE OBJECT</var> field that does not use the <var>CHANGE</var> statement benefits from setting <code>MINLOBE 200</code>.
</li>

<li>The <var>[[Large Object field processing for non-FILEORG X'100' files#Adding Large Object fields|RESERVE]]</var> clause is ignored on the SOUL <var>ADD</var> statement.</li>
</ul>

====Storing and updating LOBs====

All large object data (LOBs) in a <var>FILEORG</var> X'100' file are chained. There are four bytes per Table E page overhead for chained LOBs. The pages used by a chained LOB are not contiguous.

Handling LOBs in <var>FILEORG</var> X'100' files also has the following effects:
<ul>
<li>The <var>RESERVE</var> clause is ignored in a LOB field <var>ADD</var> statement processing, as well as the <var>STORE RECORD</var> statement processing of fieldname=value pairs.

Consequently, the <var>CHANGE</var> statement does not fail because of insufficient reserved space. If the <var>CHANGE</var> statement requires that a LOB field be extended, it is.
</li>

<li>The value of the <var>[[EHIGHPG parameter|EHIGHPG]]</var> parameter is always one less than the high water mark of the number of pages used to hold LOBs. (Unless none were ever added, in which case it is zero, not -1).</li>

<li>The value of the <var>[[EPGSUSED parameter|EPGSUSED]]</var> parameter is always the number of pages currently being used to hold LOBs.</li>

<li>The <var>[[COMPACTE command|COMPACTE]]</var> command does not process <var>FILEORG</var> X'100' files, just as it does not process a file created in V6R1 or earlier. Thus, issuing a <var>COMPACTE</var> command for a <var>FILEORG</var> X'100' file produces an error message.</li>

<li>The <var>[[TABLEE command|TABLEE]]</var> command effectively does a <code>[[VIEW command|VIEW]] ESIZE EHIGHPG EPGSUSED</code> for a <var>FILEORG</var> X'100' file. Consequently there are no <var>TABLEE</var> overhead pages in a <var>FILEORG</var> X'100' file.</li>
</ul>

===FLOAT attribute===

Any field whose values are always, or almost always, numeric might be more efficiently stored in a floating-point representation than in character form. Using FLOAT can also reduce the time spent in data type conversions for fields used frequently in User Language or Host Language Interface computations. 

Very large or very small numbers, or numbers with many significant digits, occupy considerably less space in floating-point form. 

Floating-point fields are fully supported by User Language, the Host Language Interface, and the File Load utility. For more information about storing values in floating-point fields, see the SOUL [[Floating point conversion, rounding, and precision rules]].

Note
If FLOAT is not specified when a field is defined, the STRING attribute is assumed.

====Defining floating point fields====

Field values are stored in floating-point by specifying the FLOAT attribute in the DEFINE FIELD command and supplying a LENGTH of 4, 8, or 16. The length supplied determines the precision of the floating-point field being defined. For example, to define a long precision field, specify:
Syntax
DEFINE FIELD <var class="term">fieldname</var> WITH FLOAT LEN 8


You can define three types of floating point fields through the FLOAT and LENGTH attributes.:
<table>
<tr class="head">
<th>Type of floating-point field</th>
<th>Occupies</th>
<th>Holds a maximum of</th>
<th>Model 204 maintains a maximum precision of</th>
</tr>

<tr>
<td>Short precision</td>
<td>4 bytes</td>
<td> 6 significant digits</td>
<td> </td>
</tr>

<tr>
<td>Long precision</td>
<td>8 bytes</td>
<td>15 significant digits </td>
<td>15 significant digits</td>
</tr>

<tr>
<td>Extended precision</td>
<td>16 bytes </td>
<td>31 significant digits</td>
<td>15 significant digits </td>
</tr>
</table>

====Acceptable values====

The floating-point data type uses IBM hardware's floating-point representation.

A value of negative zero (X'800...0') cannot be stored in a preallocated FLOAT field. 

====FLOAT with NUMERIC VALIDATION files====

If you define a FLOAT field in a NUMERIC VALIDATION file model file ([[FILEMODL parameter|FILEMODL]]=X'01'), <var class="product">Model 204</var> provides numeric data type validation. Trying to store non-conforming data in a FLOAT field in a NUMERIC VALIDATION file causes <var class="product">Model 204</var> to cancel the request with the following message:
M204.2124: VALUE SPECIFIED VIOLATES FLOAT DATA TYPE VALIDATION IN RECORD recno, FIELD IGNORED: fieldname = value


====Compatibility with other attributes====

STRING, BINARY, NUMERIC RANGE, and INVISIBLE cannot be specified for a FLOAT field. 

===Storing invalid numeric data: FLOAT or ORDERED NUMERIC===

The valid range of floating point numbers is:
1E-74 through 7.2370E+75


Model 204 enforces storage rules for floating point numbers outside the valid range:
<ul>
<li>If 7.2371E75 is stored in a FLOAT field, the value is treated as an invalid floating point number and is stored as a data string '7.2371E75'.</li>

<li>1E-75 is treated as an invalid floating point number and stored as a data string '1E-75'.</li>
</ul>

If an invalid value is stored for a field with the ORDERED NUMERIC attributes, the value stored in the Ordered Index is the data string. That data string is stored on the Invalid Numeric Data portion of the Ordered Index. This changes the output order of these values when the ordering is done against the Ordered Index, for example, when using the User Language IN ORDER BY or FOR EACH VALUE clauses.

===DATETIME (DT) attribute===

The DATETIME attributes specifies the format of the stored data in Table B, not its function. The other date/time attributes are automatically updated fields generated at the time of record or field group creation or update. A non-automatic field can have a DATETIME format, but all the automatic date/time fields are stored in DATETIME format. The DATETIME attribute requires at least eight significant digits. 

Once you define a DATETIME value for a field, you cannot redefine the DATETIME value.

===UTF-8 and UTF-16 attributes===
Note:
The <var>UTF-8</var> and <var>UTF-16</var> attributes are available as of Model 204 version 7.5.

The <var>UTF-8</var> (or <var>UTF8</var>) attribute indicates that data is stored in [http://en.wikipedia.org/wiki/UTF-8 UTF-8] format and is treated as [[Unicode|unicode]] data inside SOUL programs. You can define a <var>UTF-8</var> field as follows:
DEFINE FIELD UTFDATA WITH [UTF-8 | UTF8]

DEFINE FIELD UTFBLOB WITH BLOB [UTF-8 | UTF8]

The <var>UTF-8</var> attribute is a constraint that rejects UTF-8 encoding of Unicode characters outside the Basic Multilingual Plane (BMP).

<var>UTF-8</var> is the only field constraint that is valid for <var>CLOB</var> or <var>BLOB</var> fields.


The <var>UTF-16</var> (or <var>UTF16</var>) attribute indicates that data is stored in [http://en.wikipedia.org/wiki/UTF-16 UTF-16] format and is treated as [[Unicode|unicode]] data inside SOUL programs. You can define a <var>UTF-16</var> field as follows:
DEFINE FIELD UTFDATA WITH [UTF-16 | UTF16]

DEFINE FIELD UTFBLOB WITH BLOB [UTF-16 | UTF16]


====Usage notes====
<ul>
<li>Since UTF-8 or UTF-16 fields behave like unicode variables in SOUL requests, printing fields with unicode characters that cannot be converted to displayable EBCDIC results in those characters being [http://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Character_reference_overview character-entity encoded], just as they are encoded when printing unicode variables. This is also true when printing is done via a <var>[[Basic SOUL statements and commands#PRINT_ALL_INFORMATION_.28or_PAI.29_statement|PAI]]</var> statement. For example, a UTF-8 field containing the unicode value of "I like apple π" would be printed as "I like apple &#x03C0;". The ampersand symbol (<tt>&</tt>) is always encoded as &amp; when printed.</li>

<li>Just as with unicode variables, assigning an EBCDIC value to a unicode field results in the EBCDIC value being converted to unicode and then to UTF-8 or UTF-16 for storage. Simlarly, assigning a UTF-8 or UTF16 field to an EBCDIC variable results in the UTF-8 or UTF-16 value being converted to unicode and then translated to EBCDIC. In either EBCDIC to unicode or unicode to EBCDIC translation, errors result in request cancellation.

<li>Unless the preponderance of data stored in UTF-8 or UTF-16 fields has unicode values greater than U+07FF (most likely if most of the data contains Asian language characters), UTF-8 is a better choice for storing unicode data, since UTF-16 requires two bytes for every unicode character while UTF-8 only requires one byte for many common characters and only two bytes for unicode characters up to U+07FF.</li>

<li>UTF-8 and UTF-16 fields can be LOB fields or they can be STRING fields (stored in table B).</li>

<li>If a UTF-8 or UTF-16 field is defined as an OCCURS field, the length indicates the length in bytes, not the length in characters. Since UTF-8 encoding can use anywhere from one to three bytes to represent a single unicode character in the [http://en.wikipedia.org/wiki/Unicode_plane#Basic_Multilingual_Plane BMP], the only unicode characters supported by SOUL, it can be tricky using UTF-8 fields as OCCURS fields since setting the defined length requires an educated guess about the types of unicode characters that will be store in the field or (probably) oversizing a UTF-8 field to three bytes per character. In the latter case, it would make much more sense to define such a field as UTF-16 as that requires exactly two bytes for each character.</li>
</ul>

====Usage notes on mapping====
<ul>
<li>Characters outside the BMP are extremely unlikely in business applications.</li>
<li>An EBCDIC blank (X'40') is a valid UTF-8 character.</li>
<li>All numerics (X'F0' through X'F9') are UTF-8 characters for mapping characters outside the BMP. Lowercase characters generally fall into the continuation byte range and uppercase characters fall into the sequence start range. Because of this, a short, mixed case sequence, such as Tom or Bo, might slip by UFT-8 validation. However, most attempts to store EBCDIC tests into a UFT-8 field will fail, and therefore catch application errors.</li>
</ul>

====Creating UTF-8 data====
You can create <var>UTF-8</var> data using the SOUL function <var>[[$Ascii]]</var>, because 7-bit ASCII is a subset of UTF-8. For example:
ADD UTFFIELD=$ascii(?Hello?)


===VISIBLE and INVISIBLE attributes===

In general, you want to be able to retrieve, and then display or print fields, or use the field values in a report. These are fields that you want defined as VISIBLE.

If, however, you have a field that is used only to retrieve records, and space is a consideration, you might want to define the field as INVISIBLE.
Note:
If the INVISIBLE attribute is not specified when the field is defined, the VISIBLE attribute is assumed. 
Using the VISIBLE attribute

Once an application retrieves a record with a User Language FIND statement or a Host Language IFFIND call, it generally processes one or more fields in User Language PRINT, NOTE, or SORT statements, arithmetic expressions, or Host Language IFGET calls. For example:
CHECK.SALARY:
IF SALARY GT 1000*AGE
THEN PRINT NAME
END IF


A field referred to by the PRINT statement must have the VISIBLE attribute in its field description. This means that the field-name-equals-value pair is actually stored in the logical record in Table B.
Using the INVISIBLE attribute

A field that has the INVISIBLE attribute, on the other hand, takes up no storage space in Table B and cannot be printed, noted, or sorted. These fields can be added, deleted, or changed in the logical record.
In a library catalog file, for example, each record can have an AUTHOR field that contains the author's full name. In addition, there can be a LAST NAME field that contains only the author's last name. This creates a convenient index to the catalog and relieves the user of the burden of knowing the entire name when making retrieval requests. Because the author's last name already is part of the (VISIBLE) AUTHOR field, some space can be saved in Table B by selecting the INVISIBLE attribute for LAST NAME.

Reorganizing INVISIBLE fields

Because INVISIBLE fields are not stored in Table B, they require special care if the file is ever reorganized. When designing a file, be sure to take reorganization requirements for these fields into consideration. See the File reorganization and table compaction page, [[File reorganization and table compaction#Reorganizing INVISIBLE fields|Reorganizing INVISIBLE fields]] section, for more information. 

Maintaining INVISIBLE fields

INVISIBLE fields must also have the KEY, NUMERIC RANGE, or ORDERED attribute, and they are normally used only to retrieve records. 

The User Language FILE RECORDS statement and the Host Language Interface IFFILE function can be used to rapidly add an INVISIBLE KEY field name = value pair to an entire set of records. For example:
ALL.RECS: FIND ALL RECORDS FOR WHICH
NAME = SMITH OR SMYTHE OR SMYTH
END FIND
FILE: FILE RECORDS IN ALL.RECS UNDER HOMONYM = SMYTH


<var class="product">Model 204</var> makes entries in Tables C and D to allow retrievals with the specification HOMONYM = SMYTH but does not change Table B. For further information about adding, changing, or deleting INVISIBLE fields, see the SOUL description of the <var>[[Field attributes#INVISIBLE attribute|INVISIBLE]]</var> attribute.
Table B considerations

The values of VISIBLE fields can be stored in the logical record in Table B in one of four formats depending upon the selection of STRING/BINARY, CODED/NON-CODED, or FLOAT field attributes. The choice affects space requirements and, except for a slight increase in the time required for updates and some types of retrievals (see [[#CODED and NON-CODED attributes|CODED and NON-CODED attributes]]), is transparent to the user. 

The values of fields that have the INVISIBLE attribute are not stored in Table B, and physical storage attributes cannot be specified in their descriptions. 
Using INVISIBLE fields in 1NF files

The First-Normal form relational model cannot be enforced for INVISIBLE fields. However, INVISIBLE fields are useful within <var class="product">Model 204</var> for list processing and to support SQL multicolumn keys (see the <var class="product">Model 204</var> SQL Server User's Guide for more information). Therefore, the INVISIBLE field attribute is allowed, but INVISIBLE fields are not mapped to SQL-accessible columns, and there are other limitations with SQL DML operations against INVISIBLE fields, as described in the SQL Server User's Guide. The following rules and restrictions apply to INVISIBLE fields in 1NF files:

<ul>
<li>Because the INVISIBLE and AT-MOST-ONE attribute are incompatible, INVISIBLE fields must be defined as REPEATABLE.</li>

<li>You cannot REDEFINE a field as INVISIBLE within a 1NF file; the INVISIBLE and REPEATABLE attributes can be specified only with a DEFINE command. In the case of a record security key field, use the INITIALIZE command to specify the field as INVISIBLE and REPEATABLE.</li>

<li>INVISIBLE fields in 1NF files must also be ORDERED or KEY (NUMERIC RANGE is not legal in a 1NF file and results in an error message). </li>
</ul>

Compatibility with other attributes

The INVISIBLE attribute cannot be specified for a field defined with the FLOAT or AT-MOST-ONE attributes.

==Data content==

In addition to the data type (above), there are additional attributes which further control how the data is stored and manipulated:
<ul>
<li>CODED, NON-CODED </li>
<li>OCCURS</li>
<li>LENGTH</li>
<li>PAD</li>
<li>FEW-VALUED, MANY-VALUED </li>
<li>UPDATE IN PLACE, UPDATE AT END</li>
<li>DEFAULT-VALUE</li>
<li>STORE-DEFAULT, STORE-NULL</li>
<li>AT-MOST-ONE, REPEATABLE and EXACTLY-ONE</li>
<li>DEFERRABLE/NON-DEFERRABLE</li>
</ul>

===CODED and NON-CODED attributes===

The CODED and NON-CODED attributes let you choose between saving disk space (with CODED) or speeding up update and retrieval time (with NON-CODED). This section discusses how these attributes work.
Note:
If the CODED attribute is not specified when a field is defined, the NON-CODED attribute is assumed.
NON-CODED attribute

If a field is designated NON-CODED without an OCCURS clause (see the following discussion), its value is stored in Table B as a simple character string that has an additional byte to indicate its length. 

NON-CODED is the best choice for any field whose values have an average length of 1-3 bytes whether or not they are compressible numbers.
CODED attribute

Choose the CODED option to save Table B space where the values of the field are not suitable for BINARY compression and where their average length is four or more characters.

When a value that has the CODED attribute is defined, the character string is stored in Table A-the internal file dictionary-and a 4-byte value code pointing to that character string is stored in the logical record in Table B. Space is saved when there are several records that contain the same value. The string is stored only once in Table A, and only the 4-byte code is stored in each of the several records in Table B.

Choosing CODED vs. NON-CODED

The coding and decoding of these value codes takes time, which can slow down updates and retrievals. If speed is important and if disk space is relatively plentiful, do not choose the CODED attribute.

If disk space is somewhat tight, choose the CODED attribute for fields where the values are long and where there are a small number of values relative to the number of records in the file. A STATE field is a prime example.

A more precise rule governing the choice of the CODED attribute is difficult to arrive at since first it must be determined (based on the number and length of the field values, and on the number of records) if any disk space is actually saved by the CODED attribute. Then, any space saved must be weighed against the extra time taken by CODED retrievals. And the relative importance of disk space and time are likely to vary with the application as well as with the installation.

The formulas in [[File size calculation in detail]] show more explicitly the effects of the CODED field attribute on Table A and B size.

Field value encoding is entirely transparent to the user. Data is returned exactly as it was entered. Codes are system-generated, internal codes that have no meaning to a user. 


<div id="Preallocated fields"></div><div id="OCCURS attribute"></div>

===Preallocated fields (OCCURS attribute)===

Any VISIBLE field can be a preallocated field. However, a VISIBLE field that appears a fixed number of times in most of the records in a file, with fairly uniform lengths for the values, is most suited for preallocation in Table B. Preallocated fields, if selected appropriately, require less Table B space than other fields and can be updated and retrieved slightly faster. 

Preallocation means that space is reserved in each new record added to a file. As occurrences of preallocated fields are stored in a record, they are placed in the reserved space. Space is used even for occurrences that have not been stored, whereas non-preallocated fields use no space for missing occurrences. Preallocation also imposes restrictions on the number and length of values that can be stored in a record. A field is preallocated if its description includes an OCCURS clause. 

[[File size calculation in detail]] provides specific rules for the amount of space used by preallocated and non-preallocated fields. Use these rules to determine whether or not to preallocate a particular field. 
Using an OCCURS clause

A field is preallocated if its description includes an OCCURS clause. The OCCURS clause indicates the number of occurrences of the field that are preallocated or reserved in each Table B record. From 1 to 255 occurrences can be specified. Any number of values, up to the specified limit, <var class="term">n</var>, can be stored in the record.

Only as many occurrences as have been stored can be retrieved. Space allocated for unstored values is wasted. 

If OCCURS is not included in a field description, the field still can occur more than once in a record. Space for the occurrences is not preallocated. There is no limit to the number of values that can be stored for a non-preallocated field.
Restrictions for preallocated fields

The OCCURS option can be specified only for fields that can be preallocated with a fixed length in Table B. This includes only fields that are defined as CODED, BINARY, or LENGTH <var class="term">m</var> (see [[#LENGTH and PAD clauses|LENGTH and PAD clauses]]). If a field is defined as BINARY but does not contain an OCCURS clause, values that cannot be compressed to a binary representation still can be stored in the field. If a field is defined as both BINARY and OCCURS, only compressible values can be stored in it. 

<var class="product">Model 204</var> does not allow incompressible values to be stored in such fields. To avoid such compression problems, include CODED with BINARY and OCCURS in the field description. 
Displaying the set of preallocated fields

The <var>[[DISPLAY RECORD command|DISPLAY RECORD]]</var> command will show all of the preallocated fields in a file. This information is stored on a page in [[Table D (File architecture)|Table D]] where it is used to create the preallocated field space at the beginning of a record when it is initially stored. 
Note:
Because <var class="product">Model 204</var> cannot distinguish values padded with X'00' from zero-length values explicitly stored in the file, <var class="product">Model 204</var> does not allow zero-length values to be explicitly stored in preallocated fields. 


OCCURS cannot be specified on a field group field.

===LENGTH and PAD clauses===
Using the LENGTH clause

Use the LENGTH clause to specify the length of FLOAT fields, as well as NON-CODED preallocated (OCCURS) string fields. 
LENGTH must be specified for NON-CODED preallocated string fields: the LENGTH must be included in the description of a NON-CODED preallocated string field to set the maximum length of the field. The length must be in the range 1 through 255. The specified length is preallocated for the number of occurrence specified by the OCCURS clause. 

LENGTH with FLOAT fields: LENGTH is required with FLOAT to indicate the precision of the floating-point field being defined. The LENGTH options in this instance are 4, 8, or 16. (See [[#FLOAT attribute|FLOAT attribute]].)
Specifying the LENGTH clause: The LENGTH clause limits the length of values that can be stored in the field. <var class="product">Model 204</var> does not store values that are longer than the specified length. The LENGTH clause does not impose any minimum length. Values that are shorter than the specified length are padded with the PAD character to the maximum length as they are stored in Table B and are returned to their original length as they are retrieved. See the description of padding in [[#LENGTH and PAD clauses|LENGTH and PAD clauses]]. 

Field occurrences that have been preallocated but not stored contain zero-length values. 

Using the PAD clause

You can include a PAD clause in a field description to select the character that is used to pad field values that are shorter than the length specified in the LENGTH clause (see [[#LENGTH and PAD clauses|LENGTH and PAD clauses]]) for the field. If no PAD character is specified in a field description, the default character, X'00', is used.

Padding characters are invisible to the user and are not included in a retrieved value. Make sure that the padding character does not appear as part of a field value. If it does, incorrect results can occur.

===FEW-VALUED and MANY-VALUED attributes===

If a field that has the CODED or FRV attribute is expected to take on fewer than about 50 different values, choose the FEW-VALUED attribute. Otherwise, define the field as MANY-VALUED. 

This option determines whether the value string is stored in the FEW-VALUED or MANY-VALUED section of Table A, and is invalid for fields that are neither CODED nor FRV. Keep the number of values stored in the FEW-VALUED section small to ensure that this section is kept in core during retrieval and update operations. This practice reduces the number of disk accesses and increases retrieval speed. 
Note:
If the FEW-VALUED attribute is not specified when a field is defined, the MANY-VALUED attribute is assumed.

===UPDATE IN PLACE (UP) and UPDATE AT END (UE) attributes===

<var class="product">Model 204</var> provides the following field attributes that control the way that the value of a field occurrence is changed in Table B:
<table>
<tr class="head">
<th>
If this attribute is specified...</th>
<th>Then a change in the value of a field
occurrence...</th>
</tr>

<tr>
<td>UPDATE IN PLACE </td>
<td>

Does not change its position relative to other occurrences of the same field in Table B.

This attribute is the default.
</td>
</tr>

<tr>
<td>UPDATE AT END</td>
<td>Is accomplished by deleting the existing occurrence and adding a new one following the others. </td>
</tr>
</table>
Choosing an update option

Specify either of these options as part of a field description. The UPDATE AT END approach can be useful in certain data aging applications: for example, in applications in which the first occurrence of a field represents the oldest update to the file, and the last occurrence is the most recent update. UPDATE IN PLACE generally is more efficient.

The choice of update option determines the position of a field occurrence within a record only in relation to other occurrences of the same field. The ordering of different fields within a record is determined by a variety of factors, of which the update method is only one. The order of fields within a record normally is not under the control of the file manager.

SOUL update statements other than <var>CHANGE</var> are not affected by the choice of an update option. The <var>ADD</var> and <var>STORE</var> statements always cause values to be added as the last occurrences in a record. The <var>DELETE</var> statement always removes the deleted value while maintaining the relative ordering of the remaining occurrences. 

Compatibility with other attributes

The values of fields that have the <var>INVISIBLE</var> attribute are not stored in Table B, and <var>UPDATE IN PLACE</var> or <var>UPDATE AT END</var> cannot be specified in their descriptions. 

===DEFAULT-VALUE (DV) attribute===
<var>DEFAULT-VALUE</var> specifies the value of the field if the value was not explicitly added in the <var>STORE RECORD</var>, <var>ADD FIELDGROUP</var>, or <var>INSERT FIELDGROUP</var> initial data block.

A field defined with a <var>DEFAULT-VALUE</var> (<var>DV</var>) attribute value:
<ul>
<li>Must also be defined with the <var>EXACTLY-ONE</var> or the <var>AT-MOST-ONE</var> attribute. </li>

<li>Must be contained in a file that has the <var>[[FILEORG parameter|FILEORG]]</var> parameter X'100' bit set. </li>
</ul>

The <var>DEFAULT-VALUE</var> attribute is available as of Model 204 version 7.5. For more information about <var>DEFAULT-VALUE</var> fields that are members of a field group, see [[Processing multiply occurring fields and field groups#Handling references to missing occurrences|Handling references to missing occurrences]]. 

The value of the <var>STORE-DEFAULT</var> attribute determines whether the <var>DEFAULT-VALUE</var> is physically stored on the record or if it is just used as the default value when the field is missing:
<table class="thJustBold">
<tr class="head"><th>STORE-DEFAULT value</th><th>Effect on record storage</th></tr>

<tr><th>ALL</th><td>Always store the <var>DEFAULT-VALUE</var> on the record.</td></tr>
<tr><th>NONE</th><td>Never store the <var>DEFAULT-VALUE</var> on the record.</td></tr>
<tr><th>LITERAL</th><td>Store the <var>DEFAULT-VALUE</var> if it was literally entered on the store statement (not entered as a variable).</td></tr>
</table>

<var>STORE-NULL</var> has the same options as <var>STORE-DEFAULT</var>, but they are applied to storing nulls:

<table class="thJustBold">
<tr class="head"><th>STORE-NULL value</th><th>Effect on null storage</th></tr>

<tr><th>ALL</th><td>Always store a null value on the record.</td></tr>
<tr><th>NONE</th><td>Never store a null value on the record.</td></tr>
<tr><th>LITERAL</th><td>Store the null value if it was literally entered on the Store statement (not entered as a variable).</td></tr>
</table>

Note: Neither <var>STORE-NULL NONE</var> nor <var>STORE-NULL LIT</var> is allowed with <var>DEFAULT-VALUE</var>.

The <var>DEFAULT-VALUE</var> attribute allows values as long as 31 bytes. An attempt to use more results in:
M204.2851: DEFAULT-VALUE VALUE
'1234567890123456789012345678901234567890' TOO BIG, MUST BE <32 BYTES

Note: The minimum length of a <var>DEFAULT-VALUE</var> value is 1 byte. A null string value is not allowed. 

The value of <var>DEFAULT-VALUE</var> is not constrained by attributes such as <var>LEQ</var>, <var>LLE</var>, and <var>LGE</var>.
For example, the entire default value is returned for a field that has been added, even if it exceeds the <var>LEQ</var> setting.


===STORE-DEFAULT (SD) and STORE-NULL (SN) attributes===
The <var>STORE-DEFAULT</var> and <var>STORE-NULL</var> attributes specify whether to physically store the default value and the null value, respectively, for the field in each record. These attributes are available as of Model 204 version 7.5.

You can redefine the <var>STORE-DEFAULT</var> and/or <var>STORE-NULL</var> attribute values.

Note: A field with the <var>STORE-DEFAULT</var> attribute must also have the <var>DEFAULT-VALUE</var> attribute.

The <var>STORE-DEFAULT</var> and <var>STORE-NULL</var> attributes offer these options:
<ul>
<li><var>LITERAL</var> (the default)</li>
<li><var>NONE</var></li>
<li><var>ALL</var></li>
</ul>

====STORE-DEFAULT example====

The following example shows the effect of <var>DEFAULT-VALUE</var> on fields defined with the different <var>STORE-DEFAULT</var> types (<var>ALL</var>, <var>NONE</var>, and <var>LITERAL</var>).
Field <code>NAME_SD_NONE</code> is defined with the <var>STORE-DEFAULT</var> option <var>NONE</var>, field <code>NAME_SD_LIT</code> with the option <var>LITERAL</var>, and field <code>NAME_SD_ALL</code> with the option <var>ALL</var>. The <var>DEFAULT-VALUE</var> for all of the fields is <code>NONAME</code>. 

In this example, the fields belong to a field group, but the <var>STORE-DEFAULT</var> (and <var>STORE-NULL</var>) attribute can also be assigned to a field that is not part of a field group. The only requirement is that the field cannot be defined as <var>REPEATABLE</var>; that is, it must be <var>AT-MOST-ONE</var> or <var>EXACTLY-ONE</var>.
DEFINE FIELDGROUP X
DEFINE FIELD NAME_SD_NONE WITH FIELDGROUP X AND ORD AT-MOST-ONE -
STORE-DEFAULT NONE DEFAULT-VALUE 'NONAME'

DEFINE FIELD NAME_SD_LIT WITH FIELDGROUP X AND ORD AT-MOST-ONE -
STORE-DEFAULT LITERAL DEFAULT-VALUE 'NONAME'

DEFINE FIELD NAME_SD_ALL WITH FIELDGROUP X AND ORD AT-MOST-ONE -
STORE-DEFAULT ALL DEFAULT-VALUE 'NONAME'


There are basically two ways to store a field in a record: 
<ul>
<li>Using a literal:
STORE RECORD
FIELD.A = 'ABC'
END STORE
</li>

<li>Using a variable:
%X = 'ABC'
STORE RECORD
FIELD.A = %X
END STORE
</li>
</ul>

Additionally, a field might simply be missing (in the following example, the record has a <code>FIELD.B</code>, but <code>FIELD.A</code> is missing):
STORE RECORD
FIELD.B = 'XXX'
END STORE


The <var>STORE-DEFAULT</var> options determine how the field will be physically stored if the <var>DEFAULT-VALUE</var> is stored in the field. 

This example shows what is physically stored in the record when the <var>DEFAULT-VALUE</var> is stored for each of the fields defined above for <code>FIELDGROUP X</code>. The <var>DEFAULT-VALUE</var> defined for each is <code>NONAME</code>. First, the actual <var>DEFAULT-VALUE</var> of <code>NONAME</code> is added by using a variable, then by using the literal <code>'NONAME'</code>. Then a field group occurrence is added where the field is missing. 
ADD.X: SUBROUTINE
IN FILEX FOR RECORD NUMBER %CURREC
* add first field group occurrence using the variable %NAME:
%NAME='NONAME'
ADD FIELDGROUP X
NAME_SD_NONE = %NAME
NAME_SD_LIT = %NAME
NAME_SD_ALL = %NAME
END ADD
* add second field group occurrence using the literal 'NONAME':
ADD FIELDGROUP X
NAME_SD_NONE = 'NONAME'
NAME_SD_LIT = 'NONAME'
NAME_SD_ALL = 'NONAME'
END ADD
* add third occurrence of the field group with all values missing:
ADD FIELDGROUP X
* none of these fields added to this occurrence
END ADD
END FOR


A subsequent <var>PAI</var> of the field group shows what is physically stored on the record: 
<table>
<tr class="head">
<th>The field defined with... </th>
<th>is...</th>
</tr>

<tr>
<td>STORE-DEFAULT NONE </td>
<td>Never stored on the record. </td>
</tr>

<tr>
<td>STORE-DEFAULT ALL </td>
<td>Always stored on the record. </td>
</tr>

<tr>
<td nowrap>STORE-DEFAULT LITERAL </td>
<td>Not stored in the first occurrence, because a %variable was used. It was stored in the second occurrence, because the field was added using a literal string.</td>
</tr>
</table>

The <var>PAI</var> output: 
\X = 1
NAME_SD_ALL = NONAME
/X = 1
\X = 2
NAME_SD_LIT = NONAME
NAME_SD_ALL = NONAME
/X = 2
\X = 3
/X = 3

<blockquote class="note">
Note:
When the record above is printed (using the following):
FR
PRINT '# NAME_SD_NONE: NAME_SD_LIT: NAME_SD_ALL:'
FEO:
FEO FIELDGROUP X
PRINT OCCURRENCE IN FEO AND NAME_SD_NONE AND -
NAME_SD_LIT AT 16 AND NAME_SD_ALL AT 30
END FOR
END FOR


The <var>DEFAULT-VALUE</var> is printed whether the field is physically stored on the record or not.

# NAME_SD_NONE: NAME_SD_LIT: NAME_SD_ALL:
1 NONAME NONAME NONAME
2 NONAME NONAME NONAME
3 NONAME NONAME NONAME

Note: The same behavior occurs whether the field is <var>AT-MOST-ONE</var>, as in this example, or <var>EXACTLY-ONE</var>. However, within fieldgroup context, a <var>PAI</var> of an <var>EXACTLY-ONE</var> field always shows a value. The actual physical storage on the record is the same for both attributes. 
</blockquote>

====STORE-NULL example====

The options on the <var>STORE-NULL</var> attribute react similarly to those of <var>STORE-DEFAULT</var>. When the fields are defined as follows:
DEFINE FIELDGROUP X
DEFINE FIELD NAME_SN_NONE WITH FIELDGROUP X AND ORD AT-MOST-ONE -
STORE-NULL NONE
DEFINE FIELD NAME_SN_LIT WITH FIELDGROUP X AND ORD AT-MOST-ONE -
STORE-NULL LITERAL
DEFINE FIELD NAME_SN_ALL WITH FIELDGROUP X AND ORD AT-MOST-ONE -
STORE-NULL ALL


And the code used to store the field groups is:
IN FILEX [[Record loops#FOR RECORD NUMBER processing|FRN]] %CURREC
* add first occurrence using the variable %NAME:
%NAME=''
ADD FIELDGROUP X
NAME_SN_NONE = %NAME
NAME_SN_LIT = %NAME
NAME_SN_ALL = %NAME
END ADD
* add second occurrence using the literal '':
ADD FIELDGROUP X
NAME_SN_NONE = ''
NAME_SN_LIT = ''
NAME_SN_ALL = ''
END ADD
* add third occurrence with missing values:
ADD FIELDGROUP X
END ADD
END FOR


The resulting <var>PAI</var> is:
\X = 1
NAME_SN_ALL =
/X = 1
\X = 2
NAME_SN_LIT =
NAME_SN_ALL =
/X = 2
\X = 3
/X = 3


And this request: 
BEGIN
FR
PRINT '# NAME_SN_NONE: NAME_SN_LIT: NAME_SN_ALL:'
FEO:
FEO FIELDGROUP X
PRINT OCCURRENCE IN FEO AND -
NAME_SN_NONE AND NAME_SN_LIT AT 18 -
AND NAME_SN_ALL AT 32
END FOR
END FOR
END


Results in nulls displayed for each field:
# NAME_SN_NONE: NAME_SN_LIT: NAME_SN_ALL:
1
2
3


===AT-MOST-ONE, REPEATABLE, and EXACTLY-ONE attributes===

You can use the AT-MOST-ONE, REPEATABLE, and EXACTLY-ONE attributes, which are mutually exclusive, to define an individual field or a field that is part of a field group definition. 
Note: The EXACTLY-ONE attribute is available as of Model 204 version 7.5.

====Using the AT-MOST-ONE attribute====

The AT-MOST-ONE attribute allows you to ensure that there is only one occurrence of a field in any record, without preallocating space for the field. 

In addition, the AT-MOST-ONE attribute is required for fields in First-Normal Form (1NF) files. AT-MOST-ONE and REPEATABLE fields in 1NF files are discussed in this section.
Note:
In non-1NF files, if the AT-MOST-ONE attribute is not specified when a field is defined, the REPEATABLE attribute is assumed. 

If a field is defined with the AT-MOST-ONE attribute, <var class="product">Model 204</var> prevents multiple occurrences of that field in any given record. The AT-MOST-ONE attribute is useful if, for example, you know that there will be one variable-length field per record, or if you have a field that is often left blank but does not have more than one value per record (such as SPOUSE NAME). 

Unlike fields with the OCCURS attribute, AT-MOST-ONE fields are not specifically preallocated. The AT-MOST-ONE attribute lets you store these kinds of records without wasting the space required by OCCURS.
Using the REPEATABLE attribute

If a field is not defined as AT-MOST-ONE, then it is REPEATABLE. Fields with the REPEATABLE attribute can accept multiple occurrences of the field in the record. Unlike the OCCURS attribute, REPEATABLE does not preallocate fields, nor does REPEATABLE let you specify the number of occurrences of the field.

====Using the EXACTLY-ONE (EXONE) attribute====

As the name suggests an EXACTLY-ONE attribute in a field definition means that the field always has exactly one occurrence in its record or field group context after the initial data block for the record or field group (STORE RECORD, ADD FIELDGROUP, or INSERT FIELDGROUP). If no explicit value is stored for the field, its value has either the DEFAULT-VALUE for the field or the null string (''), if no DEFAULT-VALUE was specified for the field.

You cannot add, insert, or delete an EXACTLY-ONE field, although you can change an EXACTLY-ONE field. 

The EXACTLY-ONE attribute that also has the DEFAULT-VALUE attribute will conflict with the STORE-NULL NONE attribute.

The EXACTLY-ONE attribute is also not allowed with the STORE-NULL LITERAL attribute.

====EXACTLY-ONE fields with a field group====

The <var>EXACTLY-ONE</var> attribute for a field within a field group means that the field can occur only once inside a single field group occurrence. However, since field groups can occur multiple times in a field group record, an <var>EXACTLY-ONE</var> field inside a field group can occur multiple times inside a field group record. 

For more information about <var>EXACTLY-ONE</var> fields in a field group, see [[Processing multiply occurring fields and field groups#Updating fields in a field group|Updating fields in a field group]]. 

====Defaults for AT-MOST-ONE, REPEATABLE and EXACTLY- ONE fields====

REPEATABLE is the default except for 1NF files, where AT-MOST-ONE is required on all fields, except INVISIBLE. See [[#VISIBLE and INVISIBLE attributes|VISIBLE and INVISIBLE attributes]] for information. 

The AT-MOST-ONE attribute is required on all fields in a 1NF file because multiply occurring fields violate relational First-Normal Form. The one exception to this rule is for INVISIBLE/REPEATABLE fields in 1NF files. See [[#AT-MOST-ONE in First Normal Form .281NF.29 files|AT-MOST-ONE in First Normal Form files]] for more information.

The EXACTLY-ONE attribute is the default frequency of occurrence for a field defined within a field group.

====Enforcing AT-MOST-ONE constraints====

<var class="product">Model 204</var> ensures that AT-MOST-ONE field constraints are not violated for the following User Language requests and the Host Language and FLOD counterparts: 
<ul>
<li>ADD</li>
<li>INSERT</li>
<li>STORE RECORD</li>
</ul>

Before the indexes are updated and a new field is added or inserted into the <var class="product">Model 204</var> record, all existing fields in the record are checked to ensure that the new field does not create a second occurrence: 

<ul>
<li>If a new field violates the AT-MOST-ONE rules, and there is no ON FCC unit, the request is canceled with the following error message:
M204.2119: AT-MOST-ONE CONSTRAINT VIOLATION IN RECORD <var class="term">recordnumber</var>,
FIELD IGNORED: <var class="term">fieldname</var>=<var class="term">value</var>
</li>

<li><var class="product">Model 204</var> validates a field if you REDEFINE it to be AT-MOST-ONE.</li>

<li>If a violation occurs and there is an ON FCC unit, <var class="product">Model 204</var> processes the ON unit. </li>
</ul>

In the Host Language Interface, the 202 return code is passed back to <var class="product">Model 204</var>; in FLOD, the file is marked logically inconsistent. However, <var class="product">Model 204</var> does not cancel the request in either case. 

====AT-MOST-ONE and transaction back out files====

Transaction back out must be active for files when defining AT-MOST-ONE fields. If you try to define an AT-MOST-ONE field in a non-TBO file, the DEFINE fails and you receive an error message. 

Once the field is defined, you can turn Transaction back out off in non-1NF files. However, <var class="product">Model 204</var> customer support strongly recommends that you keep Transaction back out set in files containing fields that can cause constraint conflicts (currently AT-MOST-ONE and UNIQUE). If you turn Transaction back out off in a file with an AT-MOST-ONE or UNIQUE field, <var class="product">Model 204</var> sends you a warning message and a "Do You Really Want To?" prompt.

====Using FLOD or FILELOAD with AT-MOST-ONE fields====

When you use FLOD or FILELOAD to load or modify records that have AT-MOST-ONE fields, <var class="product">Model 204</var> ensures that the new or modified records do not violate AT-MOST-ONE constraints. <var class="product">Model 204</var> detects and reports all violations of AT-MOST-ONE in one pass of the input data. If <var class="product">Model 204</var> finds any fields that violate the constraints, the following occurs:
<ol>
<li>The error is reported and the new or duplicate field is rejected.</li>

<li>FLOD continues processing the input data.</li>

<li>At the end of the run, the file is marked "logically inconsistent;" that is, the FISTAT parameter is set to X'40'. See [[File integrity and recovery#Logically inconsistent files|Logically inconsistent files]] for more information.</li>

<li>The following error message is issued for each violation:
M204.2119: AT-MOST-ONE CONSTRAINT VIOLATION IN RECORD <var class="term">recordnumber</var>,
FIELD IGNORED: <var class="term">fieldname</var>=<var class="term">value</var>
</li>
</ol>

====AT-MOST-ONE in First Normal Form (1NF) files====
Using OCCURS 1 in 1NF files: For 1NF files, where AT-MOST-ONE is required, use OCCURS 1 to save processing time if you are storing a large number of records in which the field is always exactly the same length (such as a Social Security Number). 

INVISIBLE fields in 1NF files: The First-Normal form relational model cannot be enforced for INVISIBLE fields. However, they are useful within <var class="product">Model 204</var> for list processing and to support SQL multicolumn keys. (See the <var class="product">Model 204</var> SQL Server User's Guide for more information.) Therefore, the INVISIBLE field attribute is allowed, but INVISIBLE fields are not mapped to SQL-accessible columns. The following rules and restrictions apply to INVISIBLE fields in 1NF files:

<ul>
<li>Because the INVISIBLE and AT-MOST-ONE attributes are incompatible, INVISIBLE fields must be defined as REPEATABLE.</li>

<li>You cannot REDEFINE a field as INVISIBLE within a 1NF file; you can specify the INVISIBLE and REPEATABLE attributes only with a DEFINE command. In the case of a record security key field, specify the field as INVISIBLE and REPEATABLE using the INITIALIZE command.</li>

<li>INVISIBLE fields in 1NF files must also be ORDERED or KEY. NUMERIC RANGE is not legal in a 1NF file and results in an error message)</li>
</ul>

====Defining AT-MOST-ONE and REPEATABLE fields in non-1NF files====

You can DEFINE or REDEFINE a field to be AT-MOST-ONE in any non-1NF <var class="product">Model 204</var> file created after Release 9.0. 

When redefining a field to AT-MOST-ONE that does not currently have the OCCCURS 1 attribute, <var class="product">Model 204</var> scans Table B to verify that no multiple occurrences of the field exist in any record. If any field violates the AT-MOST-ONE constraints, the REDEFINE fails and the following error message is displayed for each violation:
M204.2122: AT-MOST-ONE CONSTRAINT VIOLATION FOR FIELD fieldname IN RECORD recordnumber


====Using the AT-MOST-ONE or the OCCURS 1 attribute====

Although both the AT-MOST-ONE and OCCURS 1 attributes prevent more than one occurrence of a field in a record, they achieve their goal in different ways. For non-1NF files, use either the AT-MOST-ONE or the OCCURS 1 attribute. Using both causes redundant processing. Understanding the advantages of each should help you decide which attribute you want to use. 

AT-MOST-ONE attribute:

<ul>
<li>Does not preallocate the field. Therefore, if the field values between records are of very different lengths or if you do not know the length of the longest record, use AT-MOST-ONE.</li>

<li>Allows you to correct violations before the record is stored with the ON FCC unit. If you do not use an ON FCC unit, then a constraint violation cancels the request. Therefore, if it is important to allow users to correct violations, or it is important that the request not be canceled, use AT-MOST-ONE.</li>
</ul>

OCCURS 1 attribute:
<ul>
<li>Preallocates space for the field in every record. If you are storing a large number of records and the length of the value is generally the same, pre-allocating the field with OCCURS 1 can save you processing time. </li>

<li>Cancels the request when a violation occurs. With OCCURS 1, you cannot use an ON FCC unit to correct violations. </li>
</ul>

====Compatibility with other field attributes====

AT-MOST-ONE is not compatible with the following field attributes:
<ul>
<li>INVISIBLE</li>
<li>OCCURS greater than 1</li>
<li>REPEATABLE

REPEATABLE is compatible with all field attributes except AT-MOST-ONE.
</li>
</ul>

===Coordinating AT-MOST-ONE and UNIQUE attributes===

Both AT-MOST-ONE and UNIQUE are examples of field-level constraints. Although the function of the UNIQUE and AT-MOST-ONE attributes appear similar, their actual operations differ:

<table>
<tr class="head">
<th>This attribute</th>
<th>Affects...</th>
</tr>

<tr>
<td>UNIQUE</td>
<td>Value of the field</td>
</tr>

<tr>
<td>AT-MOST-ONE</td>
<td>Number of fields per record</td>
</tr>
</table>

For example, if a Social Security field within an EMPLOYEE file is both UNIQUE and AT-MOST-ONE:
<table>
<tr class="head">
<th>This attribute</th>
<th>Ensures that...</th>
</tr>

<tr>
<td>UNIQUE</td>
<td>Social security number for every employee is different.</td>
</tr>

<tr>
<td>AT-MOST-ONE</td>
<td>Each employee has only one social security number. </td>
</tr>
</table>

Coordinating the use of the AT-MOST-ONE and the UNIQUE attributes increases the integrity and accuracy of your records.

===DEFERRABLE and NON-DEFERRABLE attributes===

The DEFERRABLE and NON-DEFERRABLE attributes let you specify whether the updates to the index (Tables C and D) for a KEY ORDERED field can be deferred; that is, stored or updated at a later time.

The DEFERRABLE attribute is recommended and is the default.
Note:
If the NON-DEFERRABLE attribute is not specified when a field is defined, the DEFERRABLE attribute is assumed.

====Choosing between DEFERRABLE and NON-DEFERRABLE====

Under normal circumstances, the storing and updating of records in the <var class="product">Model 204</var> file is done all at once. That is, Tables B, C, D, E, and X are changed simultaneously. When there is a high volume of updates (for example, a Batch2 process adding large numbers of records), efficiency and space reductions can be gained by deferring the updates to Tables C and D.

Under some circumstances, it might be necessary to override this deferral of updates to the index for particular fields. For instance, consider a situation in which new records are added Online to a personnel file. You might be willing to wait a day for the ability to retrieve the new records. The updates to Tables C and D are deferred until a batch processing window (and the application of deferred updates does require exclusive access to the file), when they are done in a batch run. However, when adding new records, you want to ensure that a record containing a duplicate Social Security number (for example) is not added to the file. 

You can define the Social Security number field as NON-DEFFERABLE and write a procedure to retrieve any records already in the file that have the new Social Security number and display an error message if one is found. If updates to the index on this field have been deferred, you would not find a duplicate added earlier in the same day. By selecting the NON-DEFERRABLE attribute for the Social Security number field, you can ensure that Tables C and D are updated immediately. 
Note:
To provide immediate updating in BATCH204 runs, special action must be taken. See "Overriding deferred updates" for more information.

You can also detect duplicate Social Security numbers by defining the field with the UNIQUE and ORDERED attributes. See [[#UNIQUE and NON-UNIQUE attributes|UNIQUE and NON-UNIQUE attributes]].

====Compatibility with other attributes====

The DEFERRABLE/NON-DEFERRABLE attribute is invalid for a field that has these attributes: BLOB, CLOB, NON-KEY, NON-ORDERED, and NON-RANGE. 

For a table showing invalid attribute combinations, see the [[DEFINE FIELD command]]. If you are defining field attributes with FILEMGMT, you will not be allowed to specify conflicting attributes. 

<div id="Field Constraints">

==Field and content constraints==
You can set up constraints to prevent "invalid" updates to the file. The updates might be invalid because to permit them would violate rules about the field (a second occurrence to an AT-MOST-ONE field, for example). Or you can set up "content" constraints to prevent values outside of those permitted to be stored.

In addition, you can use the [[#LEVEL attribute|LEVEL attribute]] to prevent use of a field by unauthorized users.

===Field constraints===

====ON FIELD CONSTRAINT CONFLICT (ON FCC) unit====

To help control processing with UNIQUE and AT-MOST-ONE fields, use the User Language ON FCC unit. ON FCC is invoked whenever a field-level constraint conflict, such as an attempt to add a second occurrence of an AT-MOST-ONE field.

An ON FCC unit is used with a number of $functions that can help you determine exactly where the field constraint conflict has occurred. The $UPDSTAT function is discussed below. Refer to the SOUL wiki pages for information on [[Subroutines#ON_units_2|other $functions for ON FCC.]]

$UPDSTAT function

The $UPDSTAT function is used in conjunction with the ON FIELD CONSTRAINT CONFLICT unit and field attributes which have field-level constraints of UNIQUE and AT-MOST-ONE. You <var class="term">must</var> use $UPDSTAT in the ON FCC unit when writing procedures for files that have (or might have in the future) more than one type of field-level constraint defined.

If $UPDSTAT is invoked from an ON FCC unit following the detection of a field-level constraint conflict, it returns a numeric value denoting the type of conflict that has occurred:

<table>
<tr class="head">
<th>Value</th>
<th>Meaning </th>
</tr>

<tr>
<td align="right">0 </td>
<td>No violation occurred</td>
</tr>

<tr>
<td align="right">1 </td>
<td>Uniqueness violation occurred</td>
</tr>

<tr>
<td align="right">2 </td>
<td>AT-MOST-ONE violation occurred </td>
</tr>
</table>

The $UPDSTAT function takes no arguments. 

See information about the [[#AT-MOST-ONE.2C_REPEATABLE.2C_and_EXACTLY-ONE_attributes|AT-MOST-ONE and REPEATABLE attributes]].
UNIQUE and ORDERED fields

Because <var class="product">Model 204</var> uses the Ordered Index to process UNIQUE values, fields defined as UNIQUE must also be defined as ORDERED. For more information about the Ordered Index see [[#ORDERED and NON-ORDERED attributes|ORDERED and NON-ORDERED attributes]].

====UNIQUE and NON-UNIQUE attributes====

Defining a field with the UNIQUE attribute allows <var class="product">Model 204</var> to ensure that a given field name = value pair occurs only once in a file. A Social Security number field is one example that might benefit from having the UNIQUE attribute. The UNIQUE attribute specifies that there can be only one occurrence of a field in the file. Multiple occurrences are not allowed.

When storing a field specified as UNIQUE, <var class="product">Model 204</var> first queries the Ordered Index, looking for an identical field-name-equals-value pair. If it finds an identical value, <var class="product">Model 204</var> issues an error message and does not perform the update. This is true both within a record for multiply occurring fields and between records.

If there is not a uniqueness conflict, that is, if the field-name-equals-value pair being stored is unique, <var class="product">Model 204</var> completes the update.

Note
If the UNIQUE attribute is not specified when a field is defined, the NON-UNIQUE attribute is assumed. 

Unique values in multiply occurring fields

In a multiply-occurring field, <var class="product">Model 204</var> ensures that each occurrence of the field is unique. 
Deleting UNIQUE fields

Because UNIQUE values use the Ordered Index, do not use the DELETE ALL RECORDS statement for deleting records. Use DELETE RECORD instead.
Compatibility with other attributes

A field can only be specified as UNIQUE with the following restrictions:
<ul>
<li>UNIQUE fields must be specified as ORDERED.</li>
<li>UNIQUE fields cannot be specified as DEFERRABLE.</li>
<li>UNIQUE fields cannot be defined in non-TBO (Transaction back out) files. </li>
</ul>

If you attempt to define a UNIQUE key under any of these circumstances, you receive an error message and the field is not defined.

===Content constraints===

====Setting a pattern for a field value: the LIKE attribute====
The LIKE attribute is available as of Model 204 release 7.5.

Setting a field pattern lets you specify a pattern that a field value must conform to, otherwise it cannot be stored. The patterns you can specify are the <var class="product">Model 204</var> <var>[[Is_Like_pattern_matching#Pattern_matching|LIKE]]</var> patterns.
For example:
IN FILE PITCHERS DEFINE FIELD G WITH LIKE '@@@####'


This example specifies that field G must start with three alphabetic characters followed by four numeric characters. An attempt to store a field value that does not conform to the field's pattern results in request cancellation.

You can limit a field value to a list of values. For, example, if a field must have a value of 'M' or 'F' you could code:
IN FILE PITCHERS DEFINE FIELD SEX WITH LIKE 'M,F'


And if you want a BALL field to have a value 'SPLITTER', 'CURVE', 'KNUCKLE', or 'CHANGE UP' you could code:
IN FILE PITCHERS DEFINE FIELD BALL WITH LIKE -
'SPLITTER,CURVE,KNUCKLE,CHANGE UP'


The maximum pattern length is 47 characters. The maximum default value length is 31 characters.

As with the IS LIKE operator in SOUL, the patterns are always applied to numbers after conversion to a string.

You cannot use the <var>LIKE</var> attribute to define an automatic field.

====Range constraints====
Range constraints are available as of Model 204 version 7.5.

You can set range constraints on fields using the range attributes. Each set of range attributes is comprised of three or four attributes that you can use to establish a range for field length values, integer values, float values, or date/time stamp values. The types of range attributes are mutually exclusive. For example, you cannot define a field with the LENGTH-GE and INTEGER-LE attributes. 

The range constraints are self-editing. If you define a field with LENGTH LE 6 and LENGTH GE 8, the definition is rejected and an error message is issued.

When a range constraint is redefined, it replaces the existing field constraint.
Note: The range constraints do not have to match the data type of the stored field. That is, you can have a date/time constraint for a STRING field or an integer constraint for a FLOAT field, and so on.

=====Defining fields with length constraints=====
<table>
<tr class="head">
<th>Length constraint attributes </th>
<th>
Range</th>
</tr>

<tr>
<td>LENGTH-EQ </td>
<td>Number from 0 to 255 that indicates the required length of a field</td>
</tr>

<tr>
<td>LENGTH-GE </td>
<td>Number from 0 to 255 that indicates the minimum length of a field</td>
</tr>

<tr>
<td>LENGTH-LE </td>
<td>Number from 0 to 255 that indicates the maximum length of a field</td>
</tr>
</table>

The following field definitions illustrate using the length constraint attributes, LENGTH-EQ, LENGTH-GE, and LENGTH-LE, with each other and/or with other attributes.
IN FILE REDSOX DEFINE FIELD A WITH LENGTH-EQ 8 BINARY OCCURS 1

IN FILE REDSOX DEFINE FIELD B WITH LENGTH-GE 4 FLOAT LEN 8

IN FILE REDSOX DEFINE FIELD C WITH LENGTH-LE 10

IN FILE REDSOX DEFINE FIELD D WITH LENGTH-LE 10 LENGTH-GE 3

IN FILE REDSOX DEFINE FIELD E WITH LENGTH-LE 6 LENGTH-GE 6 BINARY

IN FILE REDSOX DEFINE FIELD F WITH LENGTH-LE 255 LENGTH-GE 0

IN FILE REDSOX DEFINE FIELD COLOR WITH EXACTLY-ONE

Note: The length constraints apply to the string representation of non-string types as they would be stored in the database. This means that the length of a FLOAT field with value 34.000 would be 2 because after being stored in the database it will return 34 on a retrieval.

=====LENGTH-EQ (LEQ) attribute=====

The LENGTH-EQ attribute is followed by a number from 0 to 255 that indicates the required length of a field.

The LENGTH-EQ attribute is not allowed for automatic fields.

=====LENGTH-GE (LGE) attribute=====

The LENGTH-GE attribute is followed by a number from 0 to 255 that indicates the minimum length of a field.

The LENGTH-GE attribute is not allowed for automatic fields. You can pair the LGE attribute with the LLE attribute, creating a length range. However, if the range is not valid or overlaps, an error message is invoked.

=====LENGTH-LE (LLE) attribute=====

The LENGTH-LE attribute is followed by a number from 0 to 255 that indicates the maximum length of a field.

The LENGTH-LE attribute is not allowed for automatic fields. You can pair the LLE attribute with the LGE attribute, creating a length range. However, if the range is not valid or overlaps, an error message is invoked.

=====Setting an integer value constraint=====

For Integer values you can define a field with:
<table>
<tr class="head">
<th>Integer attribute </th>
<th>Specifies that the integer value must be...</th>
</tr>

<tr>
<td>INTEGER-GE </td>
<td>Greater than or equal to the value that follows</td>
</tr>

<tr>
<td>INTEGER-GT </td>
<td>Greater than the value that follows</td>
</tr>

<tr>
<td>INTEGER-LE </td>
<td>Less than or equal to the value that follows</td>
</tr>

<tr>
<td>INTEGER-LT</td>
<td>Less than the value that follows</td>
</tr>
</table>

The value stored for a field must be an integer with a value that satisfies the constraint. For example:
DEFINE FIELD NCHILDREN WITH INTEGER-LE 100


The NCHILDREN field can have an integer value of less than or equal to 100.
Note: An integer constraint will not accept a value that would be stored with a decimal place. If you have an integer constraint INTEGER-GE 10 and try to store value 10.0, it will fail because 10.0 is not an integer.

=====INTEGER-GE (INTGE), INTEGER-GT (INTGT), INTEGER-LE (INTLE) and INTEGER-LT (INTLT) attributes=====

The integer range attributes (INTGE, INTGT, INTLE, and INTLT) establish a range of acceptable integer values for a field. These attributes can be defined singly or as a pair on the field. The integer range attributes If a record is added with an integer value that is not within the range, the record is rejected.

If you specify another type of range attribute on the same field, such as DATETIME-LE or FLOAT-GE, an error message is invoked. 

=====Setting a float value constraint=====

For float values you can define a field with:
<table>
<tr class="head">
<th>Float attribute </th>
<th>Specifies that the float value must be...</th>
</tr>

<tr>
<td>FLOAT-GE </td>
<td>Greater than or equal to the value that follows</td>
</tr>

<tr>
<td>FLOAT-GT </td>
<td>Greater than the value that follows</td>
</tr>

<tr>
<td>FLOAT-LE </td>
<td>Less than or equal to the value that follows</td>
</tr>

<tr>
<td>FLOAT-LT</td>
<td>Less than the value that follows</td>
</tr>
</table>

The value stored for a field must be a floating point value that satisfies the constraint. For example:
DEFINE FIELD WEIGHT WITH FLOAT-GT 10.5


The WEIGHT field must have a float value greater than 10.5. 

=====FLOAT-GE (FLTGE), FLOAT-GT (FLTGT), FLOAT-LE (FLTLE) and FLOAT-LT (FLTLT) attributes=====

The float range attributes (FLTGE, FLTGT, FLTLE, and FLTLT) establish a range of acceptable float values for a field. These attributes can be defined singly or as a pair on the field. If a record is added with a float value that is not within the range, the record is rejected.

If you specify another type of range attribute on the same field, such as DATETIME-LE or INTEGER-GE, an error message is invoked. 

=====Setting a date/time value constraint=====

For date/time values you can define a field with:
<table>
<tr class="head">
<th>Date/time attribute </th>
<th>Specifies that the date/time value must be...</th>
</tr>

<tr>
<td>DATETIME-GE </td>
<td>Later than or the same as the date/time value that follows</td>
</tr>

<tr>
<td>DATETIME-GT </td>
<td>Later than the date/time value that follows</td>
</tr>

<tr>
<td>DATETIME-LE </td>
<td>Earlier or equal to the date/time value that follows</td>
</tr>

<tr>
<td>DATETIME-LT </td>
<td>Earlier than the value that follows</td>
</tr>
</table>

The value stored for field must be a date/time value that satisfies the constraint. For example:
DEFINE FIELD BIRTHDATE WITH DATETIME-GE 18900101 DATETIME-LT 20100101

The BIRTHDATE field is required to have a date/time value greater than or equal to January 1, 1890 and less than January 1, 2010. As with any other date/time values, the values can be extended with HH, HHMM, HHMMSS, HHMMSSX, HHMMSSXX, and so on.

=====DATETIME-GE (DTGE), DATETIME-GT (DTGT), DATETIME-LE (DTLE), and DATETIME-LT (DTLT) attributes=====

The date/time range attributes-DTGE, DTGT, DTLE, DTLT-establish a range of acceptable dates for the value of the field. If a record is added with a date that is not within the range, the record is rejected. You can specify a single date/time range attribute or a pair of them on a field. 

If you specify another type of range attribute on the same field, such as FLOAT-LE or INTEGER-GE, an error message is invoked. 

The value stored for a field must be a date/time with a value that has the proper relationship to the following value. For example:
DEFINE FIELD BIRTHDATE WITH DATETIME-GE 18900101 DATETIME-LT 20100101


The BIRTHDATE field is required to have a date/time value greater than or equal to January 1, 1890 and less than January 1, 2010. As with any other date/time values, the values can be extended with HH, HHMM, HHMMSS, HHMMSSX, HHMMSSXX, and so on.

==Concatenated fields==
Note: The concatenated fields feature is available as of Model 204 version 7.5.

Fields listed after <var>CONCATENATION OF</var>:
<ul>
<li>Must be either AT-MOST-ONE, EXACTLY-ONE, or OCCURS 1 (any mixture of these field types is allowed)
<li>Must all be in the same field group, or must all not be in any field group
<li>Cannot have the <var>FIELDGROUP *</var>, <var>BLOB</var>, nor <var>CLOB</var> attribute
<li>Cannot have any of the [[#Range constraints|range attributes]]
</ul>


The following syntax is used to define a concatenated field with a separator and an escape character:

Syntax
DEFINE FIELD fieldname WITH CONCATENATION-OF -
field1 WITH field2 [WITH field3 [WITH field4 -
[AND . . .]]] -
[SEPARATOR (char | X'hex' | NONE)] -
[ESCAPE (char | X'hex' | CANCEL)]
[OtherAttributes . . .]


The SEPARATOR character appears between the field values that comprise the concatenated field. Up to eight fields can be defined for a concatenated field. 

Concatenated fields could be longer than 255 bytes after adding separator and escape characters; in this case, the request is cancelled.

Concatenated fields have the following field attribute support.
<table>
<tr class="head">
<th>Concatenated field attributes </th>
<th>Purpose</th>
</tr>

<tr>
<td>CONCATENATION-OF (CAT) </td>
<td>List the fields that make up that concatenated field</td>
</tr>

<tr>
<td>ESCAPE (ESC) </td>
<td>Specifies a character that is used to escape separator characters that occur in a field that requires a terminating separator character</td>
</tr>

<tr>
<td>SEPARATOR (SEP) </td>
<td>Specifies the character that terminates fields that do not have a fixed length and are not the last field in the concatenation</td>
</tr>
</table>

If a required attribute is not assigned a value, the default value is used. For example, if you define a CONCATENATION-OF field, which requires the SEPARATOR attribute, and you do not enter the SEPARATOR attribute, the default value of X'00' is used as the SEPARATOR value.
See the "Record retrievals" topic for more information on record retrieval of concatenated fields, including the use of [[Record_retrievals#EQ_WITH_retrieval_condition_for_concatenated_fields|EQ WITH]].

===CONCATENATION-OF (CAT) attribute===

The CONCATENATION-OF (CAT) attribute is followed by a list of fields that make up that concatenated field. At least two are required and up to eight are allowed. The field names must be separated by the word WITH and subsequent field attributes must be separated from the list by the word <var>AND</var> or by a comma. Each field specified in the list of concatenated fields must have the <var>EXACTLY-ONE</var>, <var>AT-MOST-ONE</var>, or <var>OCCURS 1</var> attribute specified.
If a field to be concatenated is an <var>OCCURS 1</var> field, define its LENGTH attribute as the total of the longest possible concatenation (including separators) to avoid a "too long" result.

If LENGTH is less than 255, a "too long" result produces message M204.0738.
If LENGTH is 255, a "too long" result produces M204.2872, which cancels the request.

===ESCAPE (ESC) attribute===

The ESC attribute is followed by one of the following:
<ul>
<li>A single character in C'<var class="term">char</var>' or X'<var class="term">hex</var>' format that specifies the character used to escape separator characters that occur in a field requiring a terminating separator character. In addition to escaping the separator character, the escape character can also escape itself.</li>

<li>CANCEL, which means that an attempt to store a separator character in a field that requires a terminating separator results in request cancellation.</li>
</ul>

The default ESCAPE character is X'01'. 

Once you define an ESCAPE value for a field, you cannot redefine the ESCAPE value.

The ESCAPE character cannot match the SEPARATOR character. The ESCAPE character is always displayed on DISPLAY FIELD output.

The ESCAPE attribute is not allowed on a field definition, if the SEPARATOR NONE attribute is specified.

Using the ESCAPE attribute

The ESC character is inserted into a concatenated field when the real data being added to the database contains the SEPARATOR or the ESCAPE character itself. When reading in stored values, programs use the ESC character to differentiate between those special characters and normal data that happens to include those special characters. When the processing encounters the ESCAPE character in a concatenated field, it knows that the next character is real data.
Note: The ESCAPE character applies to all fields except the last field in the concatenation. The programmer is expected to know how many components comprise the concatenation and therefore, special characters occurring in the last component must be real data.

Consider the following field definitions:
DEFINE FIELD A_CONCAT_TEST1 WITH AT-MOST-ONE
DEFINE FIELD A_CONCAT_TEST2 WITH AT-MOST-ONE
DEFINE FIELD A_CONCAT_TEST3 WITH CONCATENATION-OF -
A_CONCAT_TEST1 WITH -
A_CONCAT_TEST2 AND -
SEPARATOR C'+' -
ESCAPE C'/'


If this request follows:
BEGIN
IN POLICIES STORE RECORD
A_CONCAT_TEST1 = 1ST+VALUE+
A_CONCAT_TEST2 = 2ND+VALUE+
END STORE
FRN $CURREC
NP
PAI
END FOR
END


The result is:
A_CONCAT_TEST1 = 1ST+VALUE+
A_CONCAT_TEST2 = 2ND+VALUE+
A_CONCAT_TEST3 = 1ST/+VALUE/++2ND+VALUE+


The plus signs in the stored records are intentionally part of the data. For the concatenated field <var class="product">Model 204</var> stores the escape character preceding the plus signs in the data for all but the last field in the concatenation. This assumes that the programmer knows how many fields there are in the concatenation and therefore knows that any separator characters in the last field are data fields.

In storing the escape character immediately before any plus signs that are part of the data proper, <var class="product">Model 204</var> tells the programmer that they are to be read as data. If there were any escape characters in the data proper, <var class="product">Model 204</var> puts an escape character before the data proper version as in the following example:
BEGIN
IN POLICIES STORE RECORD
A_CONCAT_TEST1 = 1ST/VALUE+
A_CONCAT_TEST2 = 2ND+VALUE+
END STORE
FRN $CURREC
NP
PAI
END FOR
END


This is the output:
A_CONCAT_TEST1 = 1ST/VALUE+
A_CONCAT_TEST2 = 2ND+VALUE+
A_CONCAT_TEST3 = 1ST//VALUE/++2ND+VALUE+


If you do not want the separator or the escape character in the concatenated field, you can enforce this by assigning the value <code>CANCEL</code> as the escape character as follows:
DEFINE FIELD A_CONCAT_TEST1 WITH CONCATENATION-OF -
A_CONCAT_TEST1 WITH -
A_CONCAT_TEST2 AND -
SEPARATOR C'+' -
ESCAPE CANCEL


In which case, the concatenation is ignored, and the Store Record results in the following:
A_CONCAT_TEST1 = 1ST/VALUE+
A_CONCAT_TEST2 = 2ND+VALUE+

Note: There are no error messages associated with this condition.

If you specify the ESCAPE CANCEL attribute for a field and the SEPARATOR character for that field is in one of the field values for the concatenated string, the update is cancelled. For an example, see [[Record retrievals#Limitations when using ESCAPE CANCEL|Limitations when using ESCAPE CANCEL]].

===SEPARATOR (SEP) attribute===

The SEP attribute is followed by one of the following options:
<ul>
<li>A single character in C'<var class="term">char</var>' or an X'<var class="term">hex</var>' format that specifies the character that terminates fields that do not have a fixed length and are not the last field in the concatenation. The separator character is always used between field values, regardless of any length constraints on the component fields.</li>

<li>The NONE option that means the fields in the concatenation are concatenated end to end with no separator character and regardless of their length.</li>
</ul>

If you define a field with the SEP attribute, you must supply a value. Otherwise, the following error is issued:
DEFINE MAKE_MODEL WITH CONCATENATION-OF MAKE WITH MODEL -
AND ORD SEP ESC CANCEL
*** 1 M204.0405: INVALID DEFINE OPTION: SEP ESC


If you define a field without the SEP attribute, it defaults to X'00', as shown in the following code:
DEFINE MAKE_MODEL WITH CONCATENATION-OF MAKE WITH MODEL AND ORD ESC CANCEL

D FIELD (ABBREV) MAKE_MODEL
MAKE_MODEL
(DEF NFRV NKEY NCOD STR NNR VIS UP ORD CHAR LRES 15 -
NRES 15 SPLT 50 IMM 1 NUNIQ ONE CAT MAKE WITH MODEL AND -
SEP X'00' ESC CANCEL)


Once you define a SEPARATOR value for a field, you cannot redefine the SEPARATOR value.

The SEPARATOR character cannot match the ESCAPE character. The SEPARATOR character is always displayed on DISPLAY FIELD output.

If the SEPARATOR NONE attribute is specified on a field definition, the ESCAPE attribute is not allowed. See [[Record retrievals#Limitations when using SEPARATOR NONE|Limitations when using SEPARATOR NONE]] on the "Record retrievals" page. 

===Defining concatenated fields===

Using the attributes described in the preceding subsections, you can define these concatenated fields: 
IN FILE REDSOX DEFINE FIELD COLMOD WITH CONCATENATION-OF COLOR -
WITH MODEL AND SEP C'-' ESC C'+'

IN FILE REDSOX DEFINE FIELD MODCOL WITH CONCATENATION-OF MODEL -
WITH COLOR AND SEP C'$' ESC C'*'

IN FILE REDSOX DEFINE FIELD MODCOLI WITH CONCATENATION-OF MODEL -
WITH COLOR AND SEP X'40' ESC C'*' INVISIBLE ORDERED

IN FILE REDSOX DEFINE FIELD MCY WITH CONCATENATION-OF MODEL -
WITH COLOR WITH YEAR AND SEP X'40' ESC C'*' INVISIBLE ORDERED

IN FILE REDSOX DEFINE FIELD COLCNT WITH CONCATENATION-OF COLOR -
WITH COUNTRY AND SEP X'40' ESC C'*' INVISIBLE ORDERED

IN FILE REDSOX DEFINE FIELD CNTYR WITH CONCATENATION-OF YEAR -
WITH COUNTRY AND SEP X'40' ESC C'*' INVISIBLE ORDERED


===Defining concatenated fields in a field group context===
IN FILE REDSOX DEFINE FIELD BATTERS

IN FILE REDSOX DEFINE FIELDGROUP STARTERS

IN FILE REDSOX DEFINE FIELD NTRIP WITH CTO STARTERS AND EXACTLY-ONE

IN FILE REDSOX DEFINE FIELD A WITH AT-MOST-ONE FIELDGROUP STARTERS AND-
ORDERED CHARACTER

IN FILE REDSOX DEFINE FIELD B WITH AT-MOST-ONE FIELDGROUP STARTERS AND -
KEY

IN FILE REDSOX DEFINE FIELD C WITH AT-MOST-ONE FIELDGROUP STARTERS AND
ORDERED NUMERIC

IN FILE REDSOX DEFINE FIELD AB WITH FIELDGROUP STARTERS AND -
CONCATENATION-OF A WITH B AND SEP C'/'

IN FILE REDSOX DEFINE FIELD ABO WITH FIELDGROUP STARTERS AND -
CONCATENATION-OF B WITH A AND SEP C'+' ORDERED

IN FILE REDSOX DEFINE FIELD ABI WITH CONCATENATION-OF B WITH A AND -
SEP C'+' ORDERED INVISIBLE

<blockquote class="note">
Note: A field in a concatenated field value does not have a terminating separator set only if it is:
<ul>
<li>Last field in the concatenation, or</li>
<li>Fixed length (LENGTH-EQ set) and the default value has the same length as LENGTH-EQ.</li>
</ul></blockquote>

==Automatic fields==
Note: Automatic fields are available as of Model 204 version 7.5, and they require the <var>[[FILEORG parameter|FILEORG]]</var> X'100' setting.

<var class="product">Model 204</var> lets you define a field whose value is automatically maintained. For example, a field might count occurrences of another field so that every store or delete of the field occurrence changes the count in the automatic field. An automatic field is defined with one of the following attributes: 
<ul>
<li>CHUNK</li>
<li>COUNT-OCCURRENCES-OF</li>
<li>CREATE-TIME</li>
<li>CREATE-TIMEUTC</li>
<li>CREATE-USER</li>
<li>UPDATE-TIME</li>
<li>UPDATE-TIMEUTC</li>
<li>UPDATE-USER</li>
</ul>

The value of an automatic field is updated at the start of a transaction by <var class="product">Model 204</var>, and you cannot set it explicitly by a program. Any valid update causes the appropriate time and user stamps to be updated. For example, <code>DELETE FOO(8)</code>, when there are no occurrences of <code>FOO</code> in the record.

Once you define an automatic value for a field, you cannot redefine the automatic value.

SOUL <var>Add</var>, <var>Insert</var>, <var>Delete</var>, and <var>Store Record</var> statements are rejected with a compile error if they reference an automatic field:

M204.2862: ATTEMPT TO UPDATE AUTOMATIC FIELD fieldname


If a field name variable (<var>FNV</var>) used on an update statement resolves to an automatic field, the request is cancelled with the following error:

M204.2863: ATTEMPT TO DO updateOperation FOR AUTOMATIC FIELD: fieldname

On an update statement in group context, the [[M204.2863]] error is also issued if the field being updated is discovered to be an automatic field in one of the group's files at evaluation time.

===Automatic field context===

Automatic fields can operate in a record or field group context. For example, with the following set of fields:

...
DEFINE FIELDGROUP ADDRESS
...
DEFINE FIELD RECORD.UPDT.TIME (DATETIME UPDT-TIME)
DEFINE FIELD ADDRESS.LINE.1 (SN NONE FG ADDRESS)
...
DEFINE FIELD ADDRESS.UPDT.TIME (DATETIME FG ADDRESS AND UPDT-TIME)
...
<ul>
<li>Any update to any field in a record will automatically update <code>RECORD.UPDT.TIME</code>. </li>

<li>Any update to any field in an occurrence of the <code>ADDRESS</code> field group will cause the <code>ADDRESS.UPDT.TIME</code> for that occurrence to be updated. (And, of course, the record level <code>RECORD.UPDT.TIME</code> as well.) </li>
</ul>

===Rules for the definition of automatic fields===

====CHUNK attribute====

Fields defined with the CHUNK field attribute cannot be redefined or deleted.

====COUNT-OCCURRENCES-OF (CTO) attribute====

The COUNT-OCCURRENCES-OF (CTO) attribute is not allowed for fields defined as REPEATABLE.

Because one of the major advantages of CTO fields is to avoid unnecessary record scans, it is highly recommended that the field be preallocated. Otherwise the field is stored and updated in Table B in the normal way.

See [[#cto|CTO fields]] for details on its use.

====CREATE* and UPDATE* attributes====

The CREATE-TIME, CREATE-TIMEUTC, CREATE-USER, UPDATE-TIME, UPDATE-TIMEUTC, and UPDATE-USER automatic fields capture the add/update user/time as of the start of the transaction. Any of these attributes can be added to empty or non-empty fields (using a <var>REDEFINE</var> command). The value is maintained by <var class="product">Model 204</var> processing, so you cannot change the value.

These automatic attributes cannot be defined as REPEATABLE (the default is AT-MOST-ONE).

See [[#Tracking updates using automatic fields|Tracking updates using automatic fields]] for details on their use.

===Displaying automatic fields===

You can specify the AT-MOST-ONE or EXACTLY-ONE attribute for an automatic field. These attributes affect the order in which the fields are displayed on a PAI statement. EXACTLY-ONE fields are displayed in the order they were defined, whereas AT-MOST-ONE fields are displayed in the order they are stored in Table B. 

Currently Table B stores the following automatic fields in the order shown:
<ol>
<li>UPDATE-TIME</li>
<li>UPDATE-USER</li>
<li>CREATE-TIME</li>
<li>CREATE-USER</li>
</ol>

<div id="Counting occurrences of a field"></div>
===CTO fields: counting occurrences of a field===


To create an automatic count field you use the COUNT-OCCURRENCES-OF (CTO) keyword on a field definition, followed by the name of the field or field group for which the count is automatically maintained. For example, if you have field group DRUG you could define an automatic count field as follows:
DEFINE FIELDGROUP DRUG
DEFINE FIELD DRUGCT WITH COUNT-OCCURRENCES-OF DRUG


You cannot define a CTO field in a file that has had records already added to it.

You could also make the automatic count field a binary field:
DEFINE FIELD DRUGCT WITH CTO DRUG AND BINARY OCCURS 1
DEFINE FIELD DRUGCT WITH COUNT-OCCURRENCES-OF DRUG AND -
BINARY

Note: AND is a separator between a field or field group name and other field attributes.

An automatic count field can also be an OCCURS 1 field:
DEFINE FIELD DRUGCT WITH COUNT-OCCURRENCES-OF DRUG AND BINARY OCCURS 1


An automatic count field could even be ORDERED, KEY or NUMERIC RANGE:
DEFINE FIELD DRUGCT WITH CTO DRUG AND BINARY OCCURS 1 ORDERED NUMERIC


You can find all records with N occurrences of field group DRUG. Or, you can find those that have more or less than some number of occurrences.
Limitations on COUNT-OCCURRENCES-OF (CTO) fields

Fields defined with the CTO attribute cannot also have the UPDATE AT END attribute. You cannot define a CTO field that counts occurrences of UPDATE AT END fields.

You cannot use a CTO field to count occurrences of OCCURS fields, even though the OCCURS count is greater than 1.

Also, you cannot define a CTO field in a file that has had records already added to it.

There is a maximum of one CTO field per field or field group.
Retrieving the value of a CTO field

You can retrieve values of CTO fields via the field name (as with any VISIBLE field), as in:
PRINT DRUGCT


or
%DRUGCT = DRUGCT


====Automatic optimization with COUNT OCCURRENCES OF fields====

The use of CTO fields automatically optimizes many of the record scan processes:
<ul>
<li>[[Processing multiply occurring fields and field groups#FOR EACH OCCURRENCE OF loops|FOR EACH OCCURRENCE OF]] loops.

If a CTO field exists for the field or field group that is being looped over via an FEO or FAO statement, the value of that field limits the number of times the loop is processed, which reduces the need to scan to the end of record for every FEO or FAO statement. Note that when a record is updated or might be updated mid-loop, <var class="product">Model 204</var> normal concerns about subscript handling in these statements need to be considered.</li>

<li>FOR FIELDGROUP clause

Before processing a FOR FIELDGROUP loop, <var class="product">Model 204</var> checks whether the requested occurrence is in the record based on the CTO field. If the User Language request is for occurrence 3, but the CTO field indicates only two occurrences in the record, <var class="product">Model 204</var> stops processing the FOR loop.
</li>

<li>Field extraction

Before extracting a field <var class="product">Model 204</var> checks whether the requested occurrence is in the record based on the CTO field. If the User Language request is occurrence 3, but the CTO field indicates only two occurrences in the record, <var class="product">Model 204</var> sets the result to null (or NOT PRESENT). 

Note that in the case of the subscripted field optimization:

FOR %I FROM 1 TO %N
%FOO = FOOFIELD(%N)
END FOR


<var class="product">Model 204</var> checks only the number of occurrences on the first iteration of the loop.</li>
</ul>


In all cases, the greatest benefit from the CTO field optimization is when a record contains no occurrences of the requested field or field group. <var class="product">Model 204</var> immediately determines that no occurrence is on the record and stops scanning the record.

====Defining an efficient CTO field====

The counter fields are always physically present in the record. Using a DEFAULT-VALUE of zero for such a field defeats its purpose as you need to scan the entire record to determine whether to use the default value. When you issue a STORE RECORD statement, all CTO fields are stored as 0 in the record. For non-OCCURS, fields are always the first variable length fields in the record.

<var class="product">Model 204</var> customer support recommends that you define a CTO field as BINARY OCCURS 1, as these require only four bytes per record, whereas the minimum length of a variable length field is four bytes (for a compressed 0) and will be at least five for any non-zero value. A CTO field inside a field group cannot be an OCCURS field. 

The absolute maximum value for CTO fields is currently X'3FFFFFFF' or 1,073,741,823 since BINARY fields use the high order two bits to distinguish values from coded values. 

You cannot update CTO fields; attempts are caught at compile-time for explicit file-context references and at run-time for group-context and field-name variables. 

CTO fields can even be in field groups and zeros are stored for CTO fields when the ADD FIELDGROUP or INSERT FIELDGROUP statement is processed.

====Displaying CTO fields====

By default, the PRINT ALL INFORMATION (PAI), AUDIT ALL INFORMATION (AAI), PRINT ALL FIELD GROUP INFORMATION (PAFGI), and AUDIT ALL FIELDGROUP INFORMATION (AAFGI) statements do not display CTO (counter fields). When you are using PAI [INTO] to reorganize your files or to copy records, the automatic fields are likely to cause problems.

Under other circumstances you can use the argument to indicate that you do want automatic fields to be printed by these statements.

===Tracking updates using automatic fields===

Versions 7.5 and higher of <var class="product">Model 204</var> can track the date/time when a record was created or updated, and what user ID created or updated it.
This tracking can be accomplished by using one of the following field tracking attributes: 
<table>
<tr class="head">
<th>Tracking attribute </th>
<th>Abbreviation</th>
<th>Tracks the...</th>
</tr>

<tr>
<td>CREATE-TIME </td>
<td>CRTM</td>
<td>Moment the record was created using machine time</td>
</tr>

<tr>
<td>CREATE-TIMEUTC </td>
<td>CRTMU</td>
<td>Moment the record was created using Coordinated Universal Time</td>
</tr>

<tr>
<td>CREATE-USER </td>
<td>CRUS</td>
<td>User ID that created the record</td>
</tr>

<tr>
<td>UPDATE-TIME </td>
<td>UPTM</td>
<td>Moment the record was updated using machine time</td>
</tr>

<tr>
<td>UPDATE-TIMEUTC </td>
<td>UPTMU</td>
<td>Moment the record was updated using Coordinated Universal Time</td>
</tr>

<tr>
<td>UPDATE-USER </td>
<td>UPUS</td>
<td>User ID that updated the record</td>
</tr>
</table>

All of the automatic fields that contain date/time information also have the DATETIME attribute. 

You cannot update tracking fields with SOUL.

A record or field group can contain only a single field of each update tracing type (CREATE-USER, UPDATE-USER, CREATE-TIME, UPDATE-TIME). An attempt to create a second invokes an error message.

You can define update tracking fields (CREATE-TIME, UPDATE-TIME, CREATE-USER, UPDATE-USER) in an already populated file, even an update tracking field for the main records or a field group that already has occurrences. You can also define a DEFAULT-VALUE field, which defaults to a null string. This lets you define such fields with or without a reorganization.
Tracking fields for records

The file itself can have a single field defined for each of the tracking fields.

An attempt to define a second field of the same type on the file results in an error message, for example:
DEFINE FIELD RECORD.CREATE.TIME WITH CREATE-TIME
DEFINE FIELD RECORD.CREATE-TIME2 WITH CREATE-TIME

*** M204.2866: FILE ALREADY HAS A CREATE-TIME FIELD


The <var>UPDATE</var> tracking fields for the records are updated when any field in the record changes and the create tracking fields are added to the record when it is initially stored. 

====Tracking fields for field groups====

Automatic tracking fields can also provide a date/time and user stamp of the creator and last update of each occurrence of a field group.

If an <var>UPDATE-TIME</var> tracking field is defined as a part of field group <code>X</code> as shown below, then each occurrence of that field group will contain the tracking field:
DEFINE FIELD MY_UPDATE_TIME WITH FIELDGROUP X AND ORD NUM UPDATE-TIME


====DATETIME (DT) field values====

This section explains the format and other considerations for fields with the <var>DATETIME</var> attribute, whether they are automatic update tracking fields or not.

A <var>DATETIME</var> value is a date of the format:

YYYYMMDDHHMISSXXXXXX

Of such a 20-digit value:
<ul>
<li>The date portion (<code>YYYYMMDD</code>) is required; therefore the minimum length is 8 digits. It must specify a valid date. </li>

<li>The time portion (up to 12 digits) is optional; any of the leading portion (hours, minutes, seconds, and decimal fraction-of-seconds) can be specified. It must specify a valid time: if <code>HH</code>, <code>MI</code>, or <code>SS</code> is specified, they must each be two digits. Additionally, up to 6 decimal fraction-of-seconds digits may be specified (that is, up to 1 microsecond). </li>
</ul>

====Setting a date/time field====

The <var>DATETIME</var> field attribute indicates the format of the data stored in Table B.

Once you define a field as <var>DATETIME</var>, you assign a string to it in <code>YYYYMMDDHHMMSSXXXXXX</code> format:
IN FILE FOO DEFINE FIELD WHEN WITH DATETIME
...
BEGIN
IN FILE FOO STORE RECORD
WHEN = '2010070413470643516378'
END STORE
END


If you attempt to store the field with invalid data such as <code>WHEN = '72'</code>, the request is cancelled and you receive an error:
*** 1 CANCELLING REQUEST: M204.2865: ATTEMPT TO ADD INVALID DATETIME VALUE: WHEN = 72


As most timestamps do not require microseconds, you can specify 10ths, 100ths, 1,000ths, 10,000ths and 100,000ths of a second. The value is simply padded on the right with zeros. For date/time field <code>WHEN</code>, the following are all equivalent:
ADD WHEN = '20090704134706000000'
ADD WHEN = '2009070413470600000'
ADD WHEN = '200907041347060000'
ADD WHEN = '20090704134706000'
ADD WHEN = '2009070413470600'
ADD WHEN = '200907041347060'
ADD WHEN = '20090704134706'


In addition, you can leave off seconds, minutes or hours so the following are all equivalent:
ADD WHEN = '20090704000000'
ADD WHEN = '200907040000'
ADD WHEN = '2009070400'
ADD WHEN = '20090704'


which are also, of course, equivalent to
ADD WHEN = '20090704000000000000'


====Storing dates or date/times efficiently====

<var>DATETIME</var> fields use seven bytes to store their value (plus four bytes overhead, if the field is not preallocated). A binary representation is used to store the 20-character full date format so that it can be held in seven bytes. 

The shortest valid format for a field with the <var>DATETIME</var> attribute is <code>YYYYMMDD</code>. If the values you are storing are simple dates, they can be stored in four bytes as binary values, three fewer bytes per value than a date/time field. However, for anything with a time in it (even just hours), a <var>DATETIME</var> field takes less space than the alternative field types (<var>FLOAT</var> or <var>STRING</var>).

====Automatic validation of date/times====

In addition to the compact storage of date/time stamps, <var>DATETIME</var> fields also provide automatic validation of the values you attempt to store in them — you cannot store numbers into them that are not valid dates. For example, you cannot store <code>'9999111'</code> into a <var>DATETIME</var> field, nor can you store <code>'20070931'</code> (because September does not have 31 days), nor can you store <code>'20070229'</code> (because 2007 is not a leap year, so February only has 28 days).

Additional <var>DATETIME</var>-formatted fields also provide for [[Field design#Setting a date/time value constraint|field content validation]] for date/time fields. 

Note: It is possible to set a <var>DEFAULT-VALUE</var> for a <var>DATETIME</var> field to an invalid date/time value, such as a hyphen <code>_</code>. That value will not be stored in the database, but it would be the value returned for a reference to a missing <var>EXACTLY-ONE</var> <var>DATETIME</var> field value.

The value returned for <var>DATETIME</var> fields is always in this format:
YYYYMMDDHHMMSSXXXXXX


If you are interested in only part of the time stamp, you can use either of these: 
<ul>
<li>The <var>$Substr</var> function, to get the part you want. </li>

<li>A %variable, specified to be the length of the part of the time stamp you are interested in.

So, to use <code>%when</code> to hold a date/time in <code>YYYYMMDDHHMMSS</code> format: 
%when is string len 14
...
%when= WHEN
</li>
</ul>

<var>DATETIME</var> values can be indexed as <var>ORDERED CHARACTER</var> or <var>ORDERED NUMERIC</var>. If indexed as <var>ORDERED NUMERIC</var>, only the first 15 digits (<code>YYYYMMDDHHMMSSX</code>) are indexed. If <var>ORDERED CHARACTER</var>, it is indexed as the string representation of the date/time value in the full <code>YYYYMMDDHHMMSSXXXXXX</code> format.
Note: Making <var>DATETIME</var> fields <var>KEY</var> fields is not allowed.

====Automatic update tracking field considerations====

=====Automatic DATETIME field values=====

Automatic <var>DATETIME</var> fields are set to the date/time of the start of the update processing, so all records, fields, and field groups updated by a single update transaction get the same time stamp. Furthermore, the code that starts an update unit ensures that the date/time stamp of each update unit is unique.

The <code>M204.0173</code> and <code>M204.0172</code> messages include the time of the update as follows:
M204.0173: START OF UPDATE 12 AT 10:11:00.51


and:
M204.0172: END OF UPDATE 12 AT 10:11:00.56


=====Defining various UPDATE-USER fields=====

To indicate whether an update tracking field applies to a record or field group, specify or do not specify the containing field group on the field definition. For example:
DEFINE FIELD WHO WITH UPDATE-USER


The <code>WHO</code> field contains the user ID of the last user that updated anything in the record. The following example illustrates defining an <var>UPDATE-USER</var> field in a field group:
DEFINE FIELD DR.WHO WITH UPDATE-USER FIELDGROUP DR


The <code>DR.WHO</code> field contains the user ID of the last user that updated an occurrence of field group <code>DR</code>.

=====Defining various UPDATE-TIME fields=====

You can specify an update tracking field as <code>FIELDGROUP *</code>, which means that all field groups and the primary record all use the same update tracking field. For example:
DEFINE FIELD WHEN WITH UPDATE-TIME FIELDGROUP *


The <code>WHEN</code> field is placed in the primary record and each field group to track the last update time. If a file has a <code>FIELDGROUP *</code> update tracking field, and a field group or record has a different comparable updating tracking field, the field group or the record-specific tracking field applies to the field. For example:
DEFINE FIELD WHEN WITH UPDATE-TIME FIELDGROUP *

DEFINE FIELD MAIN.WHEN WITH UPDATE-TIME OCCURS 1

DEFINE FIELD FOO.WHEN WITH UPDATE-TIME FIELDGROUP FOO

<ul>
<li>The field <code>WHEN</code> would be updated for changes to any field group occurrences in field groups that do not have their own <var>UPDATE-TIME</var> field defined.</li>

<li>The field <code>MAIN.WHEN</code> would be set for any update to any field in the record.</li>

<li>The field <code>FOO.WHEN</code> would be set in field group <code>FOO</code> for any update to a field group occurrence.</li>
</ul>

The <var>UPDATE-TIME</var> field in a field group that has a nested field group will be updated when the nested field group is updated, even though no fields in the containing field group were updated.

===System-wide approach to adding a date-time stamp field to your files===

You can establish a single date-time stamp field with the <var>[[DTSFN parameter|DTSFN]]</var> parameter. The <var>DTSFN</var> field is used in all files in your Online that have the X'10' bit set in their <var>[[FOPT parameter|FOPT]]</var> parameter. The date-time stamp feature puts a date-time stamp on each record that was updated in a transaction. You can then use the data in the <var>DTSFN</var> field in a user-written application to find and process all the rows of data that were changed.

An application that processes these records can track the <var class="term">date-time stamp</var> field values that have been processed to date, or it might take another action, including updating the date-time stamp field.

To install and use this functionality, see [[Setting up the date-time stamp field]]. Once installed, the date-time stamp feature works only in files created in V6R1 or later. See also [[Adding a date-time stamp field]].

Note: There is no support in [[PQO|PQO/204]] for the date-time stamp feature.

====Difference between the system wide date-time stamp field and an UPDATE-TIME field====

Besides the obvious difference that the date-time stamp field will (and must) have the same name in every file in which it is used, the following are the notable differences between the two approaches:
<ul>
<li>The <var>UPDATE-TIME</var> attribute can be set to track updates to physical field groups, as well as at the record level. </li>

<li>The <var>UPDATE-TIME</var> captures the time at the start of an update unit. The date-time stamp field captures the time at the commit point. </li>

<li>The date-time stamp field updates can be [[Adding a date-time stamp field#Suspending date-time stamp updates|temporarily suspended]]. </li>
</ul>

== Assigning fields to field groups ==

===FIELDGROUP attribute===

No default, can be abbreviated as <var>FG</var>. <var>FIELDGROUP</var> is available as of Model 204 version 7.5.

The <var>FIELDGROUP</var> attribute specifies the name of the field group that the defined field is associated with (contained in). Once you define a <var>FIELDGROUP</var> value for a field, you cannot redefine the <var>FIELDGROUP</var> value.

The <var>FIELDGROUP</var> attribute cannot refer to a field group name that has not yet been defined to the file. The <var>[[DEFINE FIELDGROUP command|DEFINE FIELDGROUP]]</var> command must occur before the <var>[[DEFINE FIELD command|DEFINE FIELD]]</var> command.

===Syntax===
FIELDGROUP [fieldgroupname | *]


The <var>FIELDGROUP</var> attribute does not allow:
<ul>
<li>Record security </li>
<li>Use for <var>SORT</var> or <var>HASH</var> file </li>
<li>1NF file model </li>
</ul>

The <var>FIELDGROUP</var> attribute can be used with the <var>STORE-NULL LITERAL</var> attribute.

===Using FIELDGROUP * ===

The <var>FIELDGROUP *</var> attribute means that the field will be included into all field groups. The <var>EXACTLY-ONE</var> attribute conflicts with the <var>FIELDGROUP *</var> attribute.

<div id="Defining a LEVEL clause"></div>
==LEVEL attribute - prevent unauthorized field usage==
To secure a field against unauthorized access, include a LEVEL clause in the field's description. [[Model 204 security features#Field-level security|Field-level security]] discusses field-level security and describes the types of field access: SELECT, READ, UPDATE, and ADD.

Field-level security has a negligible impact on both performance and storage usage.

==Field naming==
The rules for field and field group naming are contained in [[Field names]].

[[Category:Model 204 files]]

Field attributes

2020-04-24T16:16:21Z

Dme: /* BINARY-LARGE-OBJECT and CHARACTER-LARGE-OBJECT attributes */

==File model feature==

The file manager defines fields and assigns attributes to each field, as described in [[Defining fields manually]]. The field attributes listed on this page are of interest to the application developer.

You can enforce file-wide constraints on files and fields with two <var class="product">Model 204</var> file models:
<table>
<tr class="head">
<th>File model </th>
<th>Action...</th>
</tr>

<tr>
<td>Numeric Validation </td>
<td>Causes <var class="product">Model 204</var> to perform numeric data type validation on fields defined as FLOAT or BINARY.</td>
</tr>

<tr>
<td>1NF (First-Normal Form) </td>
<td>Ensures that the data within a file conforms to the rules for First-Normal Form.</td>
</tr>
</table>

Use the [[FILEMODL parameter]] to set a file model when creating a file. 

==Field attribute descriptions==

===AT-MOST-ONE and REPEATABLE attributes===

If a field is defined as having the AT-MOST-ONE attribute, <var class="product">Model 204</var> prevents multiple occurrences of that field in any given record. However, unlike fields with the OCCURS attribute, AT-MOST-ONE fields are not specifically preallocated. 

If a field is not defined as AT-MOST-ONE, then it is REPEATABLE.

REPEATABLE is the default except for First-Normal Form files, where AT-MOST-ONE is required on all fields. 

===AT-MOST-ONE versus UNIQUE attributes===

Although the names of the UNIQUE and AT-MOST-ONE attributes sound similar, they have very different meanings: 
<ul>
<li>UNIQUE affects the value of the field</li>

<li>AT-MOST-ONE affects the number of field occurrences per record
</li>
</ul>

For example, if a Social Security field within an EMPLOYEE file is both UNIQUE and AT-MOST-ONE; the UNIQUE attribute ensures that the social security number for every employee is different, and AT-MOST-ONE ensures that each employee has only one social security number. 

Both AT-MOST-ONE and UNIQUE are examples of "field level constraints."

===BINARY-LARGE-OBJECT and CHARACTER-LARGE-OBJECT attributes===

If a field is defined with the BINARY-LARGE-OBJECT or CHARACTER-LARGE-OBJECT attribute, only the OCCURS and [[MINLOBE attribute|MINLOBE]] attributes can also be assigned to the field.

====Handling NULL support for Large Object data====

NULL support for Large object data is handled like the NULL support for string data. If you change Large Object data to null using:
<ul>
<li>Single quotation marks (' '), Table B stores the null and Table E deletes the former value.</li>

<li>A trailing an equal sign (= ), the former value is deleted from both Table B and Table E.</li>

<li>A source that is zero (0), the former value is deleted from both Table B and Table E.
</li>
</ul>

===DEFAULT-VALUE attribute===
The <var>DEFAULT-VALUE</var> attribute specifies the value to use for the field if the record is created and no value has been assigned to the field. The value of the <var>STORE-DEFAULT</var> attribute determines whether the <var>DEFAULT-VALUE</var> value is physically stored on the record or if it is just used as the default value when the field is missing. For more information about <var>DEFAULT VALUE</var>, see the field-design description in [[Field design#DEFAULT-VALUE (DV) attribute|DEFAULT-VALUE (DV) attribute]].

===FLOAT attribute===

The <var>FLOAT</var> attribute is typically used if the field stores data in floating point representation. For detailed information about the handling of data for fields defined with the <var>FLOAT</var> attribute, see the file management description of the [[Field design#FLOAT attribute|FLOAT attribute]].

===FOR EACH VALUE attribute===

The FOR EACH VALUE attribute maintains a list of all the unique values created for a field. This list can be accessed by using a value loop statement, such as, FOR EACH VALUE, FOR k VALUES, or FIND ALL VALUES. 

===INVISIBLE attribute===

The INVISIBLE attribute is required if the field is to be used in FILE RECORDS statements. It also can be used for other fields that have the KEY, NUMERIC RANGE, or ORDERED attribute. Such fields can be used for retrievals but cannot be used where the VISIBLE attribute is required.

An INVISIBLE field cannot be used in an arithmetic expression, as a key in a SORT statement, or in the AUDIT, COUNT OCCURRENCES, DELETE EACH, NOTE, PRINT, SET HEADER, and SET TRAILER statements. An INVISIBLE field also cannot be used in any form of the CHANGE or DELETE statement that is not followed by a fieldname = value pair.

See [[Field design#VISIBLE and INVISIBLE attributes|VISIBLE and INVISIBLE attributes]] for further details and also for information about the use of INVISIBLE fields in 1NF (First-Normal Form) files. 

===KEY attribute===

The KEY attribute specifies that if the field is to be used in FIND statement conditions of the form: 
fieldname = value


the Table C index is searched, rather than the data in Table B. Thus, the selection of records based on KEY fields is substantially more efficient than selection based on NON-KEY fields.

In addition, either the KEY attribute or the ORDERED attribute is required if the field is to be used in FILE RECORDS statements. 

===LENGTH attribute===

The LENGTH attribute specifies the preallocated length of a field occurrence in a record. See the discussion on preallocated fields in [[Data maintenance#Storing values in preallocated fields|Storing values in preallocated fields]]. 

===NON-DEFERRABLE attribute===

The NON-DEFERRABLE attribute causes a KEY, NUMERIC RANGE, or ORDERED retrieval field's index entries to be created immediately when the file is open in deferred update mode. All index entries are created immediately when a file is not in deferred update mode. The field cannot be located until its index entry has been created. 

===NUMERIC RANGE attribute===

The NUMERIC RANGE attribute specifies that if the field is used in a retrieval statement that performs a numeric retrieval, the Table C index is searched, rather than the data in Table B. Numeric retrievals based on fields with the NUMERIC RANGE attribute are more efficient than numeric retrievals based on NON-RANGE fields. A NUMERIC RANGE field cannot be multiply occurring. 

===OCCURS attribute===

The OCCURS attribute specifies the number of occurrences of a multiply occurring field that are preallocated in a record. See the discussion on preallocated fields in [[Data maintenance#Storing values in preallocated fields|Storing values in preallocated fields]]. 

===ORDERED attribute===

The ORDERED attribute specifies that the Ordered Index can be searched rather than the data in Table B for most types of retrieval. Thus, the selection of records based on ORDERED fields is substantially more efficient than selection based on NON-ORDERED fields.

A field with the ORDERED attribute also produces other efficiencies in User Language. For example, when the IN ORDER option is used on a FOR EACH RECORD statement, an internal sort is not required if the field is ORDERED.

The ORDERED attribute also allows a field to be used with any value loop statement, such as, FIND ALL VALUES, FOR EACH VALUE, and FOR k VALUES. In addition, either the ORDERED attribute or the KEY attribute is required if a field is to be used in FILE RECORDS statements.

===STORE-DEFAULT attribute===
See [[#DEFAULT-VALUE attribute|DEFAULT-VALUE attribute]], above.

===UNIQUE attribute===

The UNIQUE attribute automatically enforces a uniqueness constraint on fields; it ensures that a given field name = value pair occurs only in one record in a file. 

===VISIBLE attribute===

The VISIBLE attribute is required if the field is to be used in NOTE, PRINT, or SORT statements, or in an arithmetic expression. 

===UPDATE attribute===

The UPDATE attribute indicates the type of update method that is used when a field is changed. 

<ul>
<li>If UPDATE IN PLACE is specified, changing the value of a field occurrence does not change its position relative to other occurrences of the same field. The file manager usually specifies UPDATE IN PLACE.</li>

<li>If UPDATE AT END is specified, a change in the value of a field occurrence is accomplished by deleting the existing occurrence and adding a new one following the others.
</li>
</ul>

Refer to [[Processing multiply occurring fields and field groups#UPDATE field attribute|UPDATE field attribute]] for detailed information on the handling of updates based on the type of update method specified. 

[[Category:SOUL]]

Field attributes

2020-04-24T16:15:27Z

Dme: /* BINARY-LARGE-OBJECT and CHARACTER-LARGE-OBJECT attributes */

==File model feature==

The file manager defines fields and assigns attributes to each field, as described in [[Defining fields manually]]. The field attributes listed on this page are of interest to the application developer.

You can enforce file-wide constraints on files and fields with two <var class="product">Model 204</var> file models:
<table>
<tr class="head">
<th>File model </th>
<th>Action...</th>
</tr>

<tr>
<td>Numeric Validation </td>
<td>Causes <var class="product">Model 204</var> to perform numeric data type validation on fields defined as FLOAT or BINARY.</td>
</tr>

<tr>
<td>1NF (First-Normal Form) </td>
<td>Ensures that the data within a file conforms to the rules for First-Normal Form.</td>
</tr>
</table>

Use the [[FILEMODL parameter]] to set a file model when creating a file. 

==Field attribute descriptions==

===AT-MOST-ONE and REPEATABLE attributes===

If a field is defined as having the AT-MOST-ONE attribute, <var class="product">Model 204</var> prevents multiple occurrences of that field in any given record. However, unlike fields with the OCCURS attribute, AT-MOST-ONE fields are not specifically preallocated. 

If a field is not defined as AT-MOST-ONE, then it is REPEATABLE.

REPEATABLE is the default except for First-Normal Form files, where AT-MOST-ONE is required on all fields. 

===AT-MOST-ONE versus UNIQUE attributes===

Although the names of the UNIQUE and AT-MOST-ONE attributes sound similar, they have very different meanings: 
<ul>
<li>UNIQUE affects the value of the field</li>

<li>AT-MOST-ONE affects the number of field occurrences per record
</li>
</ul>

For example, if a Social Security field within an EMPLOYEE file is both UNIQUE and AT-MOST-ONE; the UNIQUE attribute ensures that the social security number for every employee is different, and AT-MOST-ONE ensures that each employee has only one social security number. 

Both AT-MOST-ONE and UNIQUE are examples of "field level constraints."

===BINARY-LARGE-OBJECT and CHARACTER-LARGE-OBJECT attributes===

If a field is defined with the BINARY-LARGE-OBJECT or CHARACTER-LARGE-OBJECT attribute, only the OCCURS and [[MINLOBE]] attributes can also be assigned to the field.

====Handling NULL support for Large Object data====

NULL support for Large object data is handled like the NULL support for string data. If you change Large Object data to null using:
<ul>
<li>Single quotation marks (' '), Table B stores the null and Table E deletes the former value.</li>

<li>A trailing an equal sign (= ), the former value is deleted from both Table B and Table E.</li>

<li>A source that is zero (0), the former value is deleted from both Table B and Table E.
</li>
</ul>

===DEFAULT-VALUE attribute===
The <var>DEFAULT-VALUE</var> attribute specifies the value to use for the field if the record is created and no value has been assigned to the field. The value of the <var>STORE-DEFAULT</var> attribute determines whether the <var>DEFAULT-VALUE</var> value is physically stored on the record or if it is just used as the default value when the field is missing. For more information about <var>DEFAULT VALUE</var>, see the field-design description in [[Field design#DEFAULT-VALUE (DV) attribute|DEFAULT-VALUE (DV) attribute]].

===FLOAT attribute===

The <var>FLOAT</var> attribute is typically used if the field stores data in floating point representation. For detailed information about the handling of data for fields defined with the <var>FLOAT</var> attribute, see the file management description of the [[Field design#FLOAT attribute|FLOAT attribute]].

===FOR EACH VALUE attribute===

The FOR EACH VALUE attribute maintains a list of all the unique values created for a field. This list can be accessed by using a value loop statement, such as, FOR EACH VALUE, FOR k VALUES, or FIND ALL VALUES. 

===INVISIBLE attribute===

The INVISIBLE attribute is required if the field is to be used in FILE RECORDS statements. It also can be used for other fields that have the KEY, NUMERIC RANGE, or ORDERED attribute. Such fields can be used for retrievals but cannot be used where the VISIBLE attribute is required.

An INVISIBLE field cannot be used in an arithmetic expression, as a key in a SORT statement, or in the AUDIT, COUNT OCCURRENCES, DELETE EACH, NOTE, PRINT, SET HEADER, and SET TRAILER statements. An INVISIBLE field also cannot be used in any form of the CHANGE or DELETE statement that is not followed by a fieldname = value pair.

See [[Field design#VISIBLE and INVISIBLE attributes|VISIBLE and INVISIBLE attributes]] for further details and also for information about the use of INVISIBLE fields in 1NF (First-Normal Form) files. 

===KEY attribute===

The KEY attribute specifies that if the field is to be used in FIND statement conditions of the form: 
fieldname = value


the Table C index is searched, rather than the data in Table B. Thus, the selection of records based on KEY fields is substantially more efficient than selection based on NON-KEY fields.

In addition, either the KEY attribute or the ORDERED attribute is required if the field is to be used in FILE RECORDS statements. 

===LENGTH attribute===

The LENGTH attribute specifies the preallocated length of a field occurrence in a record. See the discussion on preallocated fields in [[Data maintenance#Storing values in preallocated fields|Storing values in preallocated fields]]. 

===NON-DEFERRABLE attribute===

The NON-DEFERRABLE attribute causes a KEY, NUMERIC RANGE, or ORDERED retrieval field's index entries to be created immediately when the file is open in deferred update mode. All index entries are created immediately when a file is not in deferred update mode. The field cannot be located until its index entry has been created. 

===NUMERIC RANGE attribute===

The NUMERIC RANGE attribute specifies that if the field is used in a retrieval statement that performs a numeric retrieval, the Table C index is searched, rather than the data in Table B. Numeric retrievals based on fields with the NUMERIC RANGE attribute are more efficient than numeric retrievals based on NON-RANGE fields. A NUMERIC RANGE field cannot be multiply occurring. 

===OCCURS attribute===

The OCCURS attribute specifies the number of occurrences of a multiply occurring field that are preallocated in a record. See the discussion on preallocated fields in [[Data maintenance#Storing values in preallocated fields|Storing values in preallocated fields]]. 

===ORDERED attribute===

The ORDERED attribute specifies that the Ordered Index can be searched rather than the data in Table B for most types of retrieval. Thus, the selection of records based on ORDERED fields is substantially more efficient than selection based on NON-ORDERED fields.

A field with the ORDERED attribute also produces other efficiencies in User Language. For example, when the IN ORDER option is used on a FOR EACH RECORD statement, an internal sort is not required if the field is ORDERED.

The ORDERED attribute also allows a field to be used with any value loop statement, such as, FIND ALL VALUES, FOR EACH VALUE, and FOR k VALUES. In addition, either the ORDERED attribute or the KEY attribute is required if a field is to be used in FILE RECORDS statements.

===STORE-DEFAULT attribute===
See [[#DEFAULT-VALUE attribute|DEFAULT-VALUE attribute]], above.

===UNIQUE attribute===

The UNIQUE attribute automatically enforces a uniqueness constraint on fields; it ensures that a given field name = value pair occurs only in one record in a file. 

===VISIBLE attribute===

The VISIBLE attribute is required if the field is to be used in NOTE, PRINT, or SORT statements, or in an arithmetic expression. 

===UPDATE attribute===

The UPDATE attribute indicates the type of update method that is used when a field is changed. 

<ul>
<li>If UPDATE IN PLACE is specified, changing the value of a field occurrence does not change its position relative to other occurrences of the same field. The file manager usually specifies UPDATE IN PLACE.</li>

<li>If UPDATE AT END is specified, a change in the value of a field occurrence is accomplished by deleting the existing occurrence and adding a new one following the others.
</li>
</ul>

Refer to [[Processing multiply occurring fields and field groups#UPDATE field attribute|UPDATE field attribute]] for detailed information on the handling of updates based on the type of update method specified. 

[[Category:SOUL]]

List of Model 204 messages

2020-04-15T14:21:43Z

Dme:

__TOC__

==M204. messages==
{{Template:List of M204. messages}}

==MSIR. messages==
{{Template:List of MSIR. messages}}

==M204xxIF. and M204XDM. messages==
See [[M204xxIF. and M204XDM. messages]].

==See also==
<ul>
<li>[[Messages in order by return code]]
</ul>

[[Category:Messages]]

M204wiki main page

2020-04-14T15:25:15Z

Dme: /* Messages */

Welcome to M204wiki, the platform for Rocket Software Model 204 technical documentation. Here you can find product information, installation and reference documentation, and release notes.

M204wiki contains the current version of Model 204 documentation, with release-specific features noted in the text. In some cases, documentation is provided in [[Model 204 documentation|PDF format]].

In addition to plentiful page links, [[Searching M204wiki|M204wiki searching features]] help you quickly locate the information you need.

__TOC__

==Model 204==
<dl>
<dt>Installation
<dd>[[Model 204 installation]]

<dt>Introductions to core Model 204 areas
<dd>[[SOUL|SOUL/User Language]]
 [[File management overview|File management]]
 [[File architecture overview|File architecture]]
 [[Model 204 configurations and operating environments|System management]]

<dt>Commands
<dd>[[List of Model 204 commands]]

<dt>Parameters
<dd>[[List of Model 204 parameters]]

<dt>Security
<dd>[[Model 204 security features]]
 [[Storing security information (CCASTAT)#Overview|Storing security information (CCASTAT)]]
 [[:Category:Security interfaces|Security interfaces]]
 [[Janus Network Security]]

<dt>PDF manuals
<dd>[[Model 204 documentation|Model 204 documentation conversion]]
</dl>

==$Functions==
[[SOUL $functions#Summary of standard functions|SOUL $functions]]

==Messages==
<div id="messages"></div>
<ul>
<li>[[List of Model 204 messages|Model 204 messages]]</li>
<li>[[:Category:Fast/Unload messages|Fast/Unload messages]] </li>
<li>[[:Category:SirAud messages|SirAud messages]] </li>
<li>[[:Category:SirTune data collector messages|SirTune data collector messages]] </li>
<li>[[:Category:RockZap messages|RockZap messages]] </li>
<li>[[Dictionary/204 messages]] </li>
<li>[[SoftSpy messages]] </li>
<li>[[Connect* messages]] </li>
</ul>
Also see the [[:Category:Messages|Messages category]]

==Tools==
<ul>
<li>[[Debugger]] and [[Introduction to SoftSpy|SoftSpy]] </li>
<li>[[SirAud]] - Audit trail analysis</li>
<li>[[SirFact]] - SOUL dump analysis</li>
<li>[[SirLib]] - SOUL code management</li>
<li>[[SirMon]] - Model 204 performance monitor</li>
<li>[[SirPro]] - SOUL programmers' interface</li>
<li>[[SirScan]] - Real-time Model 204 journal queries</li>
<li>[[SirTune]] - SOUL tuning</li>
<li>[[SoulEdit]] - Advanced SOUL-based editor</li>
<li>[[RKWeb]] - Browser-based access to [[RKTools]] members</li>
<li>[[RKTools installation]]</li>
</ul>

==Release notes==
<dl>
<dt>Model 204
<dd>[[Release notes for Model 204 version 7.8|Release notes for Model 204 V7.8 (Beta)]]
<dd>[[Release notes for Model 204 version 7.7|Release notes for Model 204 V7.7]]
<dd>[[Release notes for Model 204 version 7.6|Release notes for Model 204 V7.6]]
<dd>[[Release notes for Model 204 version 7.5|Release notes for Model 204 V7.5]]
<dd>[[Media:M204_ReleaseNotes_V74.pdf|Release notes for Model 204 V7.4 (PDF)]]
<dd>[[Media:M204_ReleaseNotes_V71.pdf|Release notes for Model 204 V7.1 (PDF)]]

<dt>SoftSpy
<dd>[[Release notes for SoftSpy V7.6]]
<dd>[[Release notes for SoftSpy V7.5]]

<dt id="rktools_notes">SOUL tools
<dd>[[Release notes for RKTools V7.7]]
<dd>[[Release notes for RKTools V7.5]]

<dt id="Sirius_Mods_release_notes">Sirius Mods
<dd>[[Release notes for Sirius Mods V8.1]]
 [[Release notes for Sirius Mods V8.0]]
 [[Release notes for Sirius Mods V7.9]]
 [[Release notes for Sirius Mods V7.8]]

<dt id="funRel">Fast/Unload</dt>
Note: Fast/Unload is integrated with the Model 204 load module starting with [[Release notes for Model 204 version 7.7#funldIntegrat|Model 204 V7.7]] 
<dd>[[Release notes for Fast/Unload V4.7]]
 [[Release notes for Fast/Unload V4.6]]
 [[Media:Funrel44New.pdf|Release notes for Fast/Unload V4.4 (PDF)]]
</dl>

==Overviews and tutorials==
<dl>
<dt>Overviews of core Model 204 areas
<dd>[[Introduction to User Language]]
 [[File management overview]]
 [[File architecture overview]]
<dt>OO structures and concepts
<dd>[[Getting started with OOP for User Language programmers]]
 [[Longstrings]]
 [[$lists]]
 [[Sessions]]
 [[Sdaemons]]
 [[Regex processing]]
 [[XML processing in Janus SOAP]]
 [[Unicode]]
</dl>

==Contribute to M204wiki==
Anyone who works with [[Model 204]] is encouraged to contribute to M204wiki, either by providing new content or correcting or improving content. Before you can edit content you must [[M204wiki:Get M204wiki User ID|obtain an M204wiki User ID]].

==Download a local copy of M204wiki==
You can [[M204wiki:Database download|download your own copy of M204wiki]].

List of Model 204 messages

2020-04-14T15:23:20Z

Dme: /* M204xxIF. and M204XDM. messages */

Category:Messages

2020-04-14T15:22:21Z

Dme: Blanked the page

Category:Sirius messages

2020-04-14T15:22:04Z

Dme:

These are the numbered messages produced by all Sirius Software products.

==PDF of category pages==
You can [{{fullurl:{{FULLPAGENAMEE}}|action=pdfbook}} use this link] to create a PDF file that contains all the pages in this category. If this category contains a "Subcategories" section, the PDF will also contain a linked list of the pages that belong to each subcategory listed in the "Subcategories" section.

Note: The resulting PDF is not optimized for online use. All blue links except for those in the table of contents (TOC) take you outside of the PDF (typically to http://m204wiki.rocketsoftware.com), so you must rely on the PDF bookmarks and TOC for online navigation. Hovering your mouse over a link will reveal its destination. 
[[Category:Messages]]

Messages in order by return code

2020-04-14T15:20:02Z

Dme: /* Return code 104 */

==List of messages, in order by return code==
<blockquote type="note">Note: "Variable" or "placeholder" text not displayed.</blockquote>

===Return code 0===
 [[M204.0003]]<nowiki> ANALYZE done</nowiki>
 [[M204.0004]]<nowiki> ANALYZE work file opened</nowiki>
 [[M204.0005]]<nowiki> ANALYZE fieldname = </nowiki>
 [[M204.0017]]<nowiki> New Table D pages used = </nowiki>
 [[M204.0018]]<nowiki> set to stop, remaining users = </nowiki>
 [[M204.0020]]<nowiki> </nowiki>
 [[M204.0028]]<nowiki> session ended</nowiki>
 [[M204.0031]]<nowiki> Storage acquired for buffer(s) = bytes</nowiki>
 [[M204.0060]]<nowiki> Model 204 initialization. Version = </nowiki>
 [[M204.0061]]<nowiki> SMF system ID = , job name = , step name = , job step = , JES ID = </nowiki>
 [[M204.0062]]<nowiki> Execute parameters: </nowiki>
 [[M204.0066]]<nowiki> Minimum required for this user is </nowiki>
 [[M204.0067]]<nowiki> Fixed for this user is </nowiki>
 [[M204.0075]]<nowiki> Initialization completed. Buffers = </nowiki>
 [[M204.0079]]<nowiki> Input buffer high watermark - </nowiki>
 [[M204.0082]]<nowiki> Timeleft = </nowiki>
 [[M204.0085]]<nowiki> Password checking for CMS is turned on</nowiki>
 [[M204.0086]]<nowiki> Password checking for CMS will be bypassed</nowiki>
 [[M204.0090]]<nowiki> Dynamic storage acquired during initialization = , after initialization = </nowiki>
 [[M204.0091]]<nowiki> PST starting </nowiki>
 [[M204.0092]]<nowiki> PST stopping </nowiki>
 [[M204.0096]]<nowiki> Member removed from parallel stream </nowiki>
 [[M204.0098]]<nowiki> Minimum SERVSIZE for these tables: BTB=; ATB=; NSA=</nowiki>
 [[M204.0099]]<nowiki> Minimum SERVSIZE for these tables: BTB=; ATB=; NSA=</nowiki>
 [[M204.0101]]<nowiki> Allocated global variables will be cleared</nowiki>
 [[M204.0102]]<nowiki> LITBL reset clears stacked arguments</nowiki>
 [[M204.0118]]<nowiki> Eof for CCARF stream after seq# of </nowiki>
 [[M204.0131]]<nowiki> </nowiki>
 [[M204.0132]]<nowiki> Checkpoint in progress, please wait</nowiki>
 [[M204.0139]]<nowiki> EOF assumed in first pass of stream after seq# of </nowiki>
 [[M204.0143]]<nowiki> No files changed after last checkpoint, RESTART bypassed</nowiki>
 [[M204.0148]]<nowiki> The following files will be rolled back:</nowiki>
 [[M204.0149]]<nowiki> </nowiki>
 [[M204.0154]]<nowiki> RESTART job </nowiki>
 [[M204.0155]]<nowiki> Rerun job </nowiki>
 [[M204.0157]]<nowiki> Rolled back to transaction checkpoint </nowiki>
 [[M204.0158]]<nowiki> End of roll back</nowiki>
 [[M204.0163]]<nowiki> SERVSIZE increased to </nowiki>
 [[M204.0170]]<nowiki> No files need to be rolled forward</nowiki>
 [[M204.0171]]<nowiki> A discontinuity was detected for file in update </nowiki>
 [[M204.0172]]<nowiki> End of update at ::.</nowiki>
 [[M204.0173]]<nowiki> Start of update at ::.</nowiki>
 [[M204.0179]]<nowiki> Table B search implied for field = in </nowiki>
 [[M204.0204]]<nowiki> Parameter obsolete and not reset</nowiki>
 [[M204.0207]]<nowiki> VTAM NTO interface restarted</nowiki>
 [[M204.0223]]<nowiki> Statement label multiply defined</nowiki>
 [[M204.0278]]<nowiki> APSY: "" = ""</nowiki>
 [[M204.0283]]<nowiki> VTAM 3270 interface restarted</nowiki>
 [[M204.0292]]<nowiki> Error, running with "" = ""</nowiki>
 [[M204.0303]]<nowiki> User bumped or interrupted with an urgent message, process terminated</nowiki>
 [[M204.0339]]<nowiki> CCASTAT dataset missing</nowiki>
 [[M204.0341]]<nowiki> Unable to open CCASTAT</nowiki>
 [[M204.0342]]<nowiki> CTTC: </nowiki>
 [[M204.0344]]<nowiki> Disk version of CCASTAT changed by job </nowiki>
 [[M204.0345]]<nowiki> CCASTAT updated</nowiki>
 [[M204.0347]]<nowiki> Password</nowiki>
 [[M204.0350]]<nowiki> New password accepted</nowiki>
 [[M204.0352]]<nowiki> IODEV=, Ok </nowiki>
 [[M204.0353]]<nowiki> </nowiki>
 [[M204.0354]]<nowiki> All users are logged out</nowiki>
 [[M204.0358]]<nowiki> Password changed</nowiki>
 [[M204.0362]]<nowiki> </nowiki>
 [[M204.0367]]<nowiki> Enter table key or return</nowiki>
 [[M204.0374]]<nowiki> </nowiki>
 [[M204.0376]]<nowiki> Parameters accepted</nowiki>
 [[M204.0379]]<nowiki> Enter terminal list, all, none, add, del, or return</nowiki>
 [[M204.0391]]<nowiki> SNAPID = </nowiki>
 [[M204.0422]]<nowiki> Redefinition successfully undone for </nowiki>
 [[M204.0424]]<nowiki> At record </nowiki>
 [[M204.0430]]<nowiki> Subsystem started</nowiki>
 [[M204.0431]]<nowiki> Subsystem stopped</nowiki>
 [[M204.0434]]<nowiki> set to </nowiki>
 [[M204.0435]]<nowiki> Waiting for a buffer</nowiki>
 [[M204.0440]]<nowiki> disk update </nowiki>
 [[M204.0467]]<nowiki> Subsystem initialization procedure: </nowiki>
 [[M204.0468]]<nowiki> Compilation not saved - </nowiki>
 [[M204.0474]]<nowiki> Disconnected from </nowiki>
 [[M204.0477]]<nowiki> was restored</nowiki>
 [[M204.0478]]<nowiki> RACF message display limit reached; not all messages are displayed</nowiki>
 [[M204.0479]]<nowiki> Process group not found: </nowiki>
 [[M204.0480]]<nowiki> Invalid backpage request: </nowiki>
 [[M204.0481]]<nowiki> Procedure in could not be made resident; increase RESPAGE or RESSIZE</nowiki>
 [[M204.0490]]<nowiki> File was restored</nowiki>
 [[M204.0497]]<nowiki> SNAPID = </nowiki>
 [[M204.0500]]<nowiki> : restoring from DUMP of </nowiki>
 [[M204.0509]]<nowiki> No action taken by FREE command; not allocated</nowiki>
 [[M204.0510]]<nowiki> FREE command successful; freed</nowiki>
 [[M204.0513]]<nowiki> </nowiki>
 [[M204.0526]]<nowiki> Editing into </nowiki>
 [[M204.0542]]<nowiki> Edit complete - </nowiki>
 [[M204.0569]]<nowiki> File , Find: Table B records to be searched = </nowiki>
 [[M204.0581]]<nowiki> Waiting for share access to file </nowiki>
 [[M204.0582]]<nowiki> Access to file prevented by: </nowiki>
 [[M204.0583]]<nowiki> Waiting for exclusive access to file </nowiki>
 [[M204.0588]]<nowiki> </nowiki>
 [[M204.0590]]<nowiki> Share-dasd enqueueing inactivated, FPL of file is on a read-only device</nowiki>
 [[M204.0604]]<nowiki> Closing default, user must establish new default</nowiki>
 [[M204.0608]]<nowiki> File closed: </nowiki>
 [[M204.0615]]<nowiki> is being recovered</nowiki>
 [[M204.0619]]<nowiki> Group file opened: </nowiki>
 [[M204.0620]]<nowiki> opened </nowiki>
 [[M204.0621]]<nowiki> to </nowiki>
 [[M204.0622]]<nowiki> Update of was update by </nowiki>
 [[M204.0623]]<nowiki> may be logically inconsistent</nowiki>
 [[M204.0624]]<nowiki> is in deferred update mode</nowiki>
 [[M204.0625]]<nowiki> is full</nowiki>
 [[M204.0626]]<nowiki> is physically inconsistent</nowiki>
 [[M204.0627]]<nowiki> is not initialized</nowiki>
 [[M204.0628]]<nowiki> File message not printed - insufficient storage</nowiki>
 [[M204.0638]]<nowiki> Number of slots = </nowiki>
 [[M204.0639]]<nowiki> Slots used = </nowiki>
 [[M204.0640]]<nowiki> Percentage of Table C used = </nowiki>
 [[M204.0641]]<nowiki> has never been used</nowiki>
 [[M204.0656]]<nowiki> Updates deferred to </nowiki>
 [[M204.0683]]<nowiki> FLOD </nowiki>
 [[M204.0685]]<nowiki> Editing into </nowiki>
 [[M204.0688]]<nowiki> Input record number </nowiki>
 [[M204.0689]]<nowiki> File record number </nowiki>
 [[M204.0694]]<nowiki> FLOD finished -- pass count satisfied</nowiki>
 [[M204.0697]]<nowiki> FLOD finished -- STOP statement</nowiki>
 [[M204.0698]]<nowiki> FLOD finished -- end of input</nowiki>
 [[M204.0699]]<nowiki> Begin first Z step</nowiki>
 [[M204.0700]]<nowiki> End first Z step</nowiki>
 [[M204.0701]]<nowiki> Begin second Z step</nowiki>
 [[M204.0702]]<nowiki> End second Z step</nowiki>
 [[M204.0703]]<nowiki> FLOD finished -- record count satisfied</nowiki>
 [[M204.0705]]<nowiki> Error in record </nowiki>
 [[M204.0709]]<nowiki> Closing VTAM interface</nowiki>
 [[M204.0763]]<nowiki> Begin initialization: </nowiki>
 [[M204.0764]]<nowiki> End initialization: </nowiki>
 [[M204.0765]]<nowiki> Enter sort, hash, or record security key</nowiki>
 [[M204.0782]]<nowiki> Begin creation: </nowiki>
 [[M204.0787]]<nowiki> Reading file parameters</nowiki>
 [[M204.0794]]<nowiki> End file creation: </nowiki>
 [[M204.0807]]<nowiki> Table increased by pages</nowiki>
 [[M204.0809]]<nowiki> </nowiki>
 [[M204.0811]]<nowiki> File datasets increased</nowiki>
 [[M204.0817]]<nowiki> Table decreased by pages</nowiki>
 [[M204.0821]]<nowiki> Group file closed: </nowiki>
 [[M204.0825]]<nowiki> Reading group parameters</nowiki>
 [[M204.0828]]<nowiki> Temp group created: </nowiki>
 [[M204.0830]]<nowiki> Perm group created: </nowiki>
 [[M204.0837]]<nowiki> VTAM interface is closing</nowiki>
 [[M204.0843]]<nowiki> </nowiki>
 [[M204.0844]]<nowiki> Recovery is now complete</nowiki>
 [[M204.0848]]<nowiki> Perm group deleted: </nowiki>
 [[M204.0851]]<nowiki> Temp group deleted: </nowiki>
 [[M204.0855]]<nowiki> CCAGRP is being recovered and can't be displayed</nowiki>
 [[M204.0858]]<nowiki> Group </nowiki>
 [[M204.0859]]<nowiki> Perm groups are not available during recovery</nowiki>
 [[M204.0862]]<nowiki> Opening file: </nowiki>
 [[M204.0865]]<nowiki> IFSORT</nowiki>
 [[M204.0866]]<nowiki> IFSRTC</nowiki>
 [[M204.0867]]<nowiki> IFSRTE</nowiki>
 [[M204.0869]]<nowiki> CCAGRP security transformed</nowiki>
 [[M204.0871]]<nowiki> IFSTRT (IFAM/II) </nowiki>
 [[M204.0872]]<nowiki> IFOPEN</nowiki>
 [[M204.0873]]<nowiki> IFCLOSE</nowiki>
 [[M204.0874]]<nowiki> IFFINDC/IFFNDXC/IFFACC</nowiki>
 [[M204.0876]]<nowiki> IFFINDE</nowiki>
 [[M204.0877]]<nowiki> IFFNDXE</nowiki>
 [[M204.0878]]<nowiki> IFFIND/IFFNDX</nowiki>
 [[M204.0880]]<nowiki> IFFIND COMPLETE</nowiki>
 [[M204.0881]]<nowiki> IFCOUNT = </nowiki>
 [[M204.0882]]<nowiki> IFGETC/IFMOREC/IFPUTC</nowiki>
 [[M204.0883]]<nowiki> IFCTOC</nowiki>
 [[M204.0884]]<nowiki> IFGETE/IFGETXE</nowiki>
 [[M204.0885]]<nowiki> IFMOREE/IFMORXE</nowiki>
 [[M204.0886]]<nowiki> IFMORE/IFMOREX</nowiki>
 [[M204.0887]]<nowiki> IFGET(X)</nowiki>
 [[M204.0888]]<nowiki> IFCTOE</nowiki>
 [[M204.0889]]<nowiki> IFFLUSH</nowiki>
 [[M204.0891]]<nowiki> IFLIST</nowiki>
 [[M204.0892]]<nowiki> IFPROL</nowiki>
 [[M204.0893]]<nowiki> IFRRFL</nowiki>
 [[M204.0894]]<nowiki> IFRPRM</nowiki>
 [[M204.0895]]<nowiki> IFEPRM</nowiki>
 [[M204.0898]]<nowiki> IFDISP</nowiki>
 [[M204.0899]]<nowiki> IFFNSH</nowiki>
 [[M204.0900]]<nowiki> IFLOG</nowiki>
 [[M204.0901]]<nowiki> IFPOINT</nowiki>
 [[M204.0902]]<nowiki> IFCTO</nowiki>
 [[M204.0913]]<nowiki> IFFIND errors</nowiki>
 [[M204.0914]]<nowiki> End IFFIND</nowiki>
 [[M204.0924]]<nowiki> IFINIT</nowiki>
 [[M204.0927]]<nowiki> IFDFLD</nowiki>
 [[M204.0929]]<nowiki> IFRFLD/IFNFLD/IFDELF</nowiki>
 [[M204.0932]]<nowiki> IFBREC</nowiki>
 [[M204.0935]]<nowiki> IFDREC</nowiki>
 [[M204.0936]]<nowiki> IFPUTE</nowiki>
 [[M204.0937]]<nowiki> IFPUT</nowiki>
 [[M204.0940]]<nowiki> IFDSET</nowiki>
 [[M204.0941]]<nowiki> IFDVAL</nowiki>
 [[M204.0942]]<nowiki> IFFILE</nowiki>
 [[M204.0954]]<nowiki> IFAM2 initialized, threads = </nowiki>
 [[M204.0957]]<nowiki> IFAM batch job died, thread released for </nowiki>
 [[M204.0958]]<nowiki> Forced logout of IFAM thread for job </nowiki>
 [[M204.0961]]<nowiki> Unable to force signon checkpoint for job </nowiki>
 [[M204.0962]]<nowiki> Sign on, job name = </nowiki>
 [[M204.0963]]<nowiki> Sign off, job name = </nowiki>
 [[M204.0964]]<nowiki> Unable to force signoff checkpoint for job </nowiki>
 [[M204.0965]]<nowiki> Thread logout - IFFNSH or IFDTHRD (IFAM2)</nowiki>
 [[M204.0966]]<nowiki> IFAM2 termination. </nowiki>
 [[M204.0968]]<nowiki> IFCHKPT -- checkpoint request</nowiki>
 [[M204.0969]]<nowiki> IFCHKPT -- checkpoint waiting</nowiki>
 [[M204.0970]]<nowiki> IFCHKPC</nowiki>
 [[M204.0971]]<nowiki> M204 is not in full operation yet, call rejected for: </nowiki>
 [[M204.0993]]<nowiki> , float transform completed</nowiki>
 [[M204.0994]]<nowiki> IFAM4 initialized, threads = </nowiki>
 [[M204.0995]]<nowiki> IFAM4 termination requested by monitor</nowiki>
 [[M204.1002]]<nowiki> Thread logout - IFFNSH or IFDTHRD (IFAM4)</nowiki>
 [[M204.1003]]<nowiki> IFAM4 termination. </nowiki>
 [[M204.1028]]<nowiki> Please logout and hang up</nowiki>
 [[M204.1043]]<nowiki> System shutdown in progress; please disconnect</nowiki>
 [[M204.1051]]<nowiki> The answer is </nowiki>
 [[M204.1052]]<nowiki> LOUTPB to </nowiki>
 [[M204.1053]]<nowiki> Buffer usage statistics for VTAMNAME </nowiki>
 [[M204.1055]]<nowiki> Number of input buffer waits - </nowiki>
 [[M204.1056]]<nowiki> Number of write waits - </nowiki>
 [[M204.1057]]<nowiki> out of input buffers are active</nowiki>
 [[M204.1058]]<nowiki> out of output buffers are active</nowiki>
 [[M204.1059]]<nowiki> Number of terminals in output buffer wait queue is </nowiki>
 [[M204.1072]]<nowiki> Model 204 termination begun</nowiki>
 [[M204.1073]]<nowiki> Online Model 204 termination begun</nowiki>
 [[M204.1074]]<nowiki> CCATEMP pages used = out of </nowiki>
 [[M204.1075]]<nowiki> Termination complete: return code = </nowiki>
 [[M204.1076]]<nowiki> Do you really want to </nowiki>
 [[M204.1083]]<nowiki> Duplicate itemid: </nowiki>
 [[M204.1094]]<nowiki> tracing is </nowiki>
 [[M204.1096]]<nowiki> There were no updates for backout to process</nowiki>
 [[M204.1099]]<nowiki> Transaction has been backed out</nowiki>
 [[M204.1102]]<nowiki> Discarding response from -- rplseqno=, sevcbsqn=, rh=, hsid=</nowiki>
 [[M204.1103]]<nowiki> IFFTCNE</nowiki>
 [[M204.1104]]<nowiki> IFUPDNE</nowiki>
 [[M204.1119]]<nowiki> Reading parameters</nowiki>
 [[M204.1124]]<nowiki> Bump of scheduled by for user(s)</nowiki>
 [[M204.1136]]<nowiki> Define procedure </nowiki>
 [[M204.1144]]<nowiki> Define procedure </nowiki>
 [[M204.1145]]<nowiki> </nowiki>
 [[M204.1146]]<nowiki> Procedure definition ended</nowiki>
 [[M204.1147]]<nowiki> End procedure</nowiki>
 [[M204.1149]]<nowiki> has been set to its value: </nowiki>
 [[M204.1152]]<nowiki> Change </nowiki>
 [[M204.1168]]<nowiki> Include </nowiki>
 [[M204.1190]]<nowiki> MAXBUF set to same value as MINBUF = </nowiki>
 [[M204.1193]]<nowiki> Unable to run subsystem error procedure</nowiki>
 [[M204.1200]]<nowiki> Roll transaction for the following files:</nowiki>
 [[M204.1203]]<nowiki> was last updated on </nowiki>
 [[M204.1214]]<nowiki> </nowiki>
 [[M204.1216]]<nowiki> Record locking conflict</nowiki>
 [[M204.1217]]<nowiki> IFBOUT</nowiki>
 [[M204.1218]]<nowiki> IFCMMT</nowiki>
 [[M204.1223]]<nowiki> Enq .. waiting for </nowiki>
 [[M204.1237]]<nowiki> did not fit in preferred overflow area</nowiki>
 [[M204.1238]]<nowiki> of was last required on </nowiki>
 [[M204.1247]]<nowiki> Procedure in made resident</nowiki>
 [[M204.1248]]<nowiki> Looking for close </nowiki>
 [[M204.1255]]<nowiki> , procedure , cmmtrl substitution completed</nowiki>
 [[M204.1288]]<nowiki> CMS interface version = </nowiki>
 [[M204.1296]]<nowiki> Data conversion error for field record number in </nowiki>
 [[M204.1304]]<nowiki> IFERLC</nowiki>
 [[M204.1314]]<nowiki> IFEFCC</nowiki>
 [[M204.1319]]<nowiki> EOF assumed for </nowiki>
 [[M204.1320]]<nowiki> Offload complete for member of ring stream </nowiki>
 [[M204.1326]]<nowiki> Page trace - </nowiki>
 [[M204.1327]]<nowiki> Number of U DD lines output = </nowiki>
 [[M204.1338]]<nowiki> No On Attention unit</nowiki>
 [[M204.1339]]<nowiki> , procedure transform completed</nowiki>
 [[M204.1343]]<nowiki> IFFWOL</nowiki>
 [[M204.1344]]<nowiki> IFFWOLC</nowiki>
 [[M204.1345]]<nowiki> IFFWOLE</nowiki>
 [[M204.1350]]<nowiki> Parallel stream member record is of length </nowiki>
 [[M204.1360]]<nowiki> NOTERM too large; actual number of threads in use is </nowiki>
 [[M204.1364]]<nowiki> Retryable STXIT AB trapped </nowiki>
 [[M204.1381]]<nowiki> </nowiki>
 [[M204.1382]]<nowiki> CHUNK size used: flags=x"", low=, high=</nowiki>
 [[M204.1392]]<nowiki> Soft restart of user due to </nowiki>
 [[M204.1397]]<nowiki> A CHUNK field was defined, may no longer be opened with M204 releases prior to V7R5</nowiki>
 [[M204.1398]]<nowiki> Commit of transaction not confirmed on remote node </nowiki>
 [[M204.1401]]<nowiki> Forced logout due to bump</nowiki>
 [[M204.1422]]<nowiki> Forced logout due to inactive thread timeout</nowiki>
 [[M204.1423]]<nowiki> Hardware error, re-enter</nowiki>
 [[M204.1437]]<nowiki> REGENERATE is now complete</nowiki>
 [[M204.1453]]<nowiki> RESTART recovery is running</nowiki>
 [[M204.1469]]<nowiki> </nowiki>
 [[M204.1481]]<nowiki> The scope option should not be specified and will be discontinued in the future</nowiki>
 [[M204.1500]]<nowiki> </nowiki>
 [[M204.1503]]<nowiki> No external authorizer is running</nowiki>
 [[M204.1504]]<nowiki> interface is disabled</nowiki>
 [[M204.1523]]<nowiki> Eof reached in first pass of stream after seq# of </nowiki>
 [[M204.1548]]<nowiki> IFFDV</nowiki>
 [[M204.1549]]<nowiki> IFFDVC</nowiki>
 [[M204.1550]]<nowiki> IFFDVE</nowiki>
 [[M204.1551]]<nowiki> IFGETV</nowiki>
 [[M204.1552]]<nowiki> IFGTVC</nowiki>
 [[M204.1553]]<nowiki> IFGTVE</nowiki>
 [[M204.1554]]<nowiki> IFSRTV</nowiki>
 [[M204.1555]]<nowiki> IFSTVC</nowiki>
 [[M204.1556]]<nowiki> IFSTVE</nowiki>
 [[M204.1558]]<nowiki> IFDEQ</nowiki>
 [[M204.1561]]<nowiki> IFDALL</nowiki>
 [[M204.1562]]<nowiki> IFDEQL</nowiki>
 [[M204.1563]]<nowiki> IFENQ</nowiki>
 [[M204.1564]]<nowiki> IFENQL</nowiki>
 [[M204.1565]]<nowiki> IFFLS</nowiki>
 [[M204.1570]]<nowiki> </nowiki>
 [[M204.1571]]<nowiki> </nowiki>
 [[M204.1574]]<nowiki> End of file in file </nowiki>
 [[M204.1575]]<nowiki> Record not found in file </nowiki>
 [[M204.1591]]<nowiki> IFUTBL</nowiki>
 [[M204.1697]]<nowiki> First step in reorganizing the ordered index has completed</nowiki>
 [[M204.1708]]<nowiki> REGENERATE did not perform restore</nowiki>
 [[M204.1719]]<nowiki> IFSKEY</nowiki>
 [[M204.1720]]<nowiki> IFSKYC</nowiki>
 [[M204.1721]]<nowiki> IFSKYE</nowiki>
 [[M204.1759]]<nowiki> already being DUMPed</nowiki>
 [[M204.1760]]<nowiki> : beginning at </nowiki>
 [[M204.1761]]<nowiki> : completed at </nowiki>
 [[M204.1783]]<nowiki> is now an alias of </nowiki>
 [[M204.1800]]<nowiki> Shadow group has been opened for scattered group at client node </nowiki>
 [[M204.1802]]<nowiki> Transaction has been backed out on remote node </nowiki>
 [[M204.1814]]<nowiki> Proc located in file </nowiki>
 [[M204.1825]]<nowiki> informational message - see messages manual</nowiki>
 [[M204.1826]]<nowiki> Member of parallel stream has records</nowiki>
 [[M204.1830]]<nowiki> Opening offload member of stream</nowiki>
 [[M204.1833]]<nowiki> The total number of property entries is </nowiki>
 [[M204.1834]]<nowiki> primary property entries have overflow</nowiki>
 [[M204.1835]]<nowiki> SCOPE=SYSTEM is assumed for </nowiki>
 [[M204.1840]]<nowiki> All members of ring stream are full. Waiting for available member</nowiki>
 [[M204.1845]]<nowiki> of concatenated stream failed</nowiki>
 [[M204.1846]]<nowiki> Member of stream now active </nowiki>
 [[M204.1852]]<nowiki> End of data on input, COPY command </nowiki>
 [[M204.1858]]<nowiki> COPY command completed</nowiki>
 [[M204.1859]]<nowiki> blocks have been copied to output stream/dataset</nowiki>
 [[M204.1871]]<nowiki> The percentage of property entries with overflow is </nowiki>
 [[M204.1872]]<nowiki> is on a read-only device</nowiki>
 [[M204.1874]]<nowiki> The number of pages with spills is </nowiki>
 [[M204.1877]]<nowiki> started</nowiki>
 [[M204.1878]]<nowiki> stopped</nowiki>
 [[M204.1889]]<nowiki> </nowiki>
 [[M204.1890]]<nowiki> Number of write buffer waits - </nowiki>
 [[M204.1891]]<nowiki> Write buffer high watermark - </nowiki>
 [[M204.1892]]<nowiki> Number of CLSDST waits - </nowiki>
 [[M204.1893]]<nowiki> Number of RESPONSE waits - </nowiki>
 [[M204.1894]]<nowiki> Parallel stream member record contains x'' in position </nowiki>
 [[M204.1895]]<nowiki> Number of OPNDST waits - </nowiki>
 [[M204.1896]]<nowiki> Number of storage short retries - </nowiki>
 [[M204.1897]]<nowiki> Link opened</nowiki>
 [[M204.1898]]<nowiki> Link closed</nowiki>
 [[M204.1914]]<nowiki> Opening remote file at </nowiki>
 [[M204.1917]]<nowiki> Group open warning: optional file at not open(ed) and marked unavailable</nowiki>
 [[M204.1918]]<nowiki> Group open warning: local files cannot be optional. OPTIONAL ignored for: </nowiki>
 [[M204.1922]]<nowiki> CFRJRNL set to 0 because CFRLOOK=0</nowiki>
 [[M204.1923]]<nowiki> CFRLOOK set to 0, statistics not being collected</nowiki>
 [[M204.1929]]<nowiki> Number of users = , number of compactions = </nowiki>
 [[M204.1930]]<nowiki> Current # bytes = , HWM # bytes = </nowiki>
 [[M204.1931]]<nowiki> Current # headers = , HWM headers = </nowiki>
 [[M204.1932]]<nowiki> Required LRETBL = </nowiki>
 [[M204.1934]]<nowiki> has field-level constraints defined </nowiki>
 [[M204.1938]]<nowiki> Request for space in Table E extends beyond EHIGHPG, bit map pages are scanned for freespace</nowiki>
 [[M204.1939]]<nowiki> Number of blocks written = </nowiki>
 [[M204.1942]]<nowiki> Subsystem started without in-core procedure dictionary</nowiki>
 [[M204.1960]]<nowiki> interface initialized</nowiki>
 [[M204.1968]]<nowiki> Process timed out waiting for completion of </nowiki>
 [[M204.1969]]<nowiki> Remote file at </nowiki>
 [[M204.1981]]<nowiki> Length attribute ignored for output parameter</nowiki>
 [[M204.1985]]<nowiki> Multiple itemids specified: using </nowiki>
 [[M204.1992]]<nowiki> Recovery: processing roll forward block# </nowiki>
 [[M204.1994]]<nowiki> Commit of transaction completed on node </nowiki>
 [[M204.1998]]<nowiki> IFD2SNCC</nowiki>
 [[M204.2002]]<nowiki> IFD2PLME</nowiki>
 [[M204.2015]]<nowiki> IFDSOPEN</nowiki>
 [[M204.2016]]<nowiki> IFDSREOP</nowiki>
 [[M204.2017]]<nowiki> IFGETAPG</nowiki>
 [[M204.2018]]<nowiki> IFGETFPL</nowiki>
 [[M204.2019]]<nowiki> IFGETRD</nowiki>
 [[M204.2027]]<nowiki> Rejecting ATTACH - SENSE DATA = </nowiki>
 [[M204.2028]]<nowiki> Unable to send reject-attach due to local resource shortage</nowiki>
 [[M204.2037]]<nowiki> IFFTCH</nowiki>
 [[M204.2038]]<nowiki> IFFTCHC</nowiki>
 [[M204.2039]]<nowiki> IFFTCHE</nowiki>
 [[M204.2040]]<nowiki> IFFCHBC</nowiki>
 [[M204.2041]]<nowiki> IFFCHBE</nowiki>
 [[M204.2042]]<nowiki> IFOCUR</nowiki>
 [[M204.2043]]<nowiki> IFOCURC</nowiki>
 [[M204.2044]]<nowiki> IFOCURE</nowiki>
 [[M204.2045]]<nowiki> IFCMTR</nowiki>
 [[M204.2050]]<nowiki> COMMAND USE= PRIVILEGE=</nowiki>
 [[M204.2053]]<nowiki> Redundant file contexts</nowiki>
 [[M204.2055]]<nowiki> IFRELR</nowiki>
 [[M204.2056]]<nowiki> IFRELA</nowiki>
 [[M204.2058]]<nowiki> ZZZZCCATEMP: pg: what: who: </nowiki>
 [[M204.2066]]<nowiki> Multi-tasking requires KOMMOPT=1, NMPSUBS set to 0</nowiki>
 [[M204.2067]]<nowiki> IFCLST</nowiki>
 [[M204.2068]]<nowiki> IFPROLS</nowiki>
 [[M204.2069]]<nowiki> IFRRFLS</nowiki>
 [[M204.2072]]<nowiki> IFDECL</nowiki>
 [[M204.2073]]<nowiki> Latest successful checkpoint completed at: </nowiki>
 [[M204.2074]]<nowiki> checkpoints have since timed out</nowiki>
 [[M204.2075]]<nowiki> records currently in active CHKPOINT stream</nowiki>
 [[M204.2076]]<nowiki> checkpoints currently in CHKPOINT stream</nowiki>
 [[M204.2077]]<nowiki> users currently inhibiting checkpoints</nowiki>
 [[M204.2078]]<nowiki> Users currently inhibiting checkpoints are:</nowiki>
 [[M204.2079]]<nowiki> MINBUF reset to NLRUQ * ((NSERVS + NSUBTKS) * MAXOBUF + 15) = * (( + ) * + 15) = </nowiki>
 [[M204.2080]]<nowiki> Bug .. DBCFMOD flag was off</nowiki>
 [[M204.2081]]<nowiki> IFSTOR</nowiki>
 [[M204.2082]]<nowiki> IFSTORC</nowiki>
 [[M204.2083]]<nowiki> IFSTORE</nowiki>
 [[M204.2085]]<nowiki> IFUPDT</nowiki>
 [[M204.2086]]<nowiki> IFUPDTC</nowiki>
 [[M204.2087]]<nowiki> IFUPDTE</nowiki>
 [[M204.2091]]<nowiki> IFFRN</nowiki>
 [[M204.2092]]<nowiki> IFFRNC</nowiki>
 [[M204.2093]]<nowiki> IFFRNE</nowiki>
 [[M204.2095]]<nowiki> IFRNUM</nowiki>
 [[M204.2096]]<nowiki> IFOCC</nowiki>
 [[M204.2097]]<nowiki> IFOCCC</nowiki>
 [[M204.2098]]<nowiki> IFOCCE</nowiki>
 [[M204.2099]]<nowiki> FRCVOPT forced to 'no transaction backout'</nowiki>
 [[M204.2115]]<nowiki> Data received while waiting for CEB response- rh=, ru=</nowiki>
 [[M204.2133]]<nowiki> IFCCUR</nowiki>
 [[M204.2134]]<nowiki> IFFAC</nowiki>
 [[M204.2136]]<nowiki> IFFACE</nowiki>
 [[M204.2138]]<nowiki> End of input stream, level = </nowiki>
 [[M204.2144]]<nowiki> diagnostic DUMP of MRFT</nowiki>
 [[M204.2145]]<nowiki> </nowiki>
 [[M204.2150]]<nowiki> Start subroutine</nowiki>
 [[M204.2151]]<nowiki> End subroutine</nowiki>
 [[M204.2152]]<nowiki> Statement turned off parallel</nowiki>
 [[M204.2154]]<nowiki> Subsystem is not active</nowiki>
 [[M204.2157]]<nowiki> M204XSVC version = </nowiki>
 [[M204.2166]]<nowiki> Offload stopped for ring stream due to run termination</nowiki>
 [[M204.2252]]<nowiki> IFLCKREL</nowiki>
 [[M204.2256]]<nowiki> IFLCKGET</nowiki>
 [[M204.2259]]<nowiki> 'no transaction backout' forces 'roll forward all the way'</nowiki>
 [[M204.2260]]<nowiki> Connection with , - source was </nowiki>
 [[M204.2285]]<nowiki> Warning: 'Datalen' omitted</nowiki>
 [[M204.2288]]<nowiki> TCP/IP cleanup has closed socket for user </nowiki>
 [[M204.2293]]<nowiki> Socket call failed due to macro, X15=x''</nowiki>
 [[M204.2307]]<nowiki> IFBOUTP</nowiki>
 [[M204.2317]]<nowiki> Recalling migrated dataset </nowiki>
 [[M204.2328]]<nowiki> </nowiki>
 [[M204.2330]]<nowiki> Subsystem start in progress</nowiki>
 [[M204.2335]]<nowiki> Shadow group created: </nowiki>
 [[M204.2336]]<nowiki> Shadow group deleted: </nowiki>
 [[M204.2351]]<nowiki> TCP/IP interface '' has been created</nowiki>
 [[M204.2367]]<nowiki> file = , procedure = , line = </nowiki>
 [[M204.2368]]<nowiki> Included from </nowiki>
 [[M204.2372]]<nowiki> STOPU requires that "on" or "off" be specified as last argument</nowiki>
 [[M204.2373]]<nowiki> STOPU will not stop the userid issuing the STOPU command</nowiki>
 [[M204.2374]]<nowiki> User scheduled for stop</nowiki>
 [[M204.2375]]<nowiki> System manager has stopped you; answering "yes" to the following message will have no effect until the system manager turns stop off</nowiki>
 [[M204.2376]]<nowiki> Specified user not logged on: </nowiki>
 [[M204.2377]]<nowiki> Key too long, sort key has been truncated to 760 bytes</nowiki>
 [[M204.2385]]<nowiki> Recall failed for dataset return code </nowiki>
 [[M204.2388]]<nowiki> Procedure in is no longer resident</nowiki>
 [[M204.2396]]<nowiki> With result longer than 255 bytes was truncated</nowiki>
 [[M204.2404]]<nowiki> Soft restart of user secondary to Horizon PST restart</nowiki>
 [[M204.2415]]<nowiki> REGENERATE backed out uncommited transactions for due to roll forward discontinuity</nowiki>
 [[M204.2418]]<nowiki> File disabled for remote open</nowiki>
 [[M204.2419]]<nowiki> Communications error: disabled</nowiki>
 [[M204.2420]]<nowiki> User scheduled for start</nowiki>
 [[M204.2421]]<nowiki> File regenerated over missing journals</nowiki>
 [[M204.2425]]<nowiki> Record: transformed to: in </nowiki>
 [[M204.2426]]<nowiki> DK file= page= dbcd= buf= from=,</nowiki>
 [[M204.2427]]<nowiki> DKBM trace: file= page= caller=,</nowiki>
 [[M204.2428]]<nowiki> CCAPRQ dataset too small</nowiki>
 [[M204.2431]]<nowiki> CCAPRQ open failed</nowiki>
 [[M204.2432]]<nowiki> Print request queued for , lines</nowiki>
 [[M204.2437]]<nowiki> Print queue definitions busy, try later</nowiki>
 [[M204.2439]]<nowiki> Previous options reset by "like" clause</nowiki>
 [[M204.2440]]<nowiki> Unrecognized define print queue option: ""</nowiki>
 [[M204.2441]]<nowiki> Maximum forms name length is four</nowiki>
 [[M204.2443]]<nowiki> Target of like clause, "", not found</nowiki>
 [[M204.2444]]<nowiki> Gmt time service not supported in this environment</nowiki>
 [[M204.2445]]<nowiki> Omnireplicator </nowiki>
 [[M204.2449]]<nowiki> procedure = , line = </nowiki>
 [[M204.2451]]<nowiki> Bad mapping of SQL column . to M204 field (datatype mismatch)</nowiki>
 [[M204.2452]]<nowiki> Index for field cannot be used in SQL query processing</nowiki>
 [[M204.2453]]<nowiki> SQL request may trigger Table B search in file and the whole file may be locked</nowiki>
 [[M204.2457]]<nowiki> TIME > 18325 specified - TIMESTOP will be ignored</nowiki>
 [[M204.2458]]<nowiki> Trace table allocated,size = x"" bytes</nowiki>
 [[M204.2459]]<nowiki> Trace output will go to </nowiki>
 [[M204.2463]]<nowiki> Command is an alias of , resetting it also</nowiki>
 [[M204.2464]]<nowiki> Warning - RCL received out of sequence request</nowiki>
 [[M204.2472]]<nowiki> was last updated in the future and has failed the future date check; current date: - date of file: </nowiki>
 [[M204.2480]]<nowiki> MODENAME unspecified by and will default</nowiki>
 [[M204.2486]]<nowiki> : Table D full. Page allocated from Table D reserve area</nowiki>
 [[M204.2493]]<nowiki> Variable too small for Initial value</nowiki>
 [[M204.2499]]<nowiki> Data conversion error for value set in </nowiki>
 [[M204.2504]]<nowiki> user= comp_code= rsn_code= qm= q=</nowiki>
 [[M204.2505]]<nowiki> MQOPEN ext_qm= ext_q=</nowiki>
 [[M204.2506]]<nowiki> user= comp_code= rsn_code= qm= ext_qm= task=</nowiki>
 [[M204.2507]]<nowiki> </nowiki>
 [[M204.2508]]<nowiki> </nowiki>
 [[M204.2509]]<nowiki> </nowiki>
 [[M204.2511]]<nowiki> </nowiki>
 [[M204.2512]]<nowiki> Roll back will use the following dataset: </nowiki>
 [[M204.2519]]<nowiki> User request interrupted by EOJ </nowiki>
 [[M204.2531]]<nowiki> MQ/204 EVAL debug: </nowiki>
 [[M204.2532]]<nowiki> MQ/204 EVAL debug end</nowiki>
 [[M204.2546]]<nowiki> Soft restart of user due to bump while in extended quiesce</nowiki>
 [[M204.2547]]<nowiki> ENQCTL proceeding with jobname=</nowiki>
 [[M204.2548]]<nowiki> ENQCTL proceeding with jobname=</nowiki>
 [[M204.2554]]<nowiki> PROTOCOL=PRX1 is obsolete: defaulting to PROTOCOL=IP</nowiki>
 [[M204.2555]]<nowiki> ECF subtask type= ECTASK= TCB= initialized</nowiki>
 [[M204.2557]]<nowiki> </nowiki>
 [[M204.2558]]<nowiki> ECF </nowiki>
 [[M204.2559]]<nowiki> can be reset only on user 0 or the first IODEV=7 line: this value is ignored</nowiki>
 [[M204.2560]]<nowiki> ECF subtask ECTASK= TCB= (module=) due to </nowiki>
 [[M204.2561]]<nowiki> ECF module= completion= reason= return= ECTASK= TCB=</nowiki>
 [[M204.2562]]<nowiki> ECF module= ddName= addr= length= EPA= </nowiki>
 [[M204.2564]]<nowiki> has already been recovered using this CCARF</nowiki>
 [[M204.2566]]<nowiki> LINK=, LOCALID=, PGROUP=, PROCESS=, RMTID=</nowiki>
 [[M204.2567]]<nowiki> Regs= </nowiki>
 [[M204.2568]]<nowiki> Entry , PDRT , 2nd PDRT </nowiki>
 [[M204.2569]]<nowiki> Seslock already </nowiki>
 [[M204.2570]]<nowiki> TCP/IP cleanup deferred for socket user - </nowiki>
 [[M204.2571]]<nowiki> TCP/IP cleanup deferred for socket user - local sessterm has been previously scheduled</nowiki>
 [[M204.2572]]<nowiki> TCP/IP cleanup failed for socket user - session block could not be located</nowiki>
 [[M204.2573]]<nowiki> user= comp_code= rsn_code= qm= q= ext_qm= ext_q= local dynamic queue </nowiki>
 [[M204.2576]]<nowiki> RENAMEd from to </nowiki>
 [[M204.2578]]<nowiki> Socket link closing</nowiki>
 [[M204.2579]]<nowiki> Socket link closed</nowiki>
 [[M204.2587]]<nowiki> Socket was set in the exception FDS for but there is no session block currently associated with this socket</nowiki>
 [[M204.2588]]<nowiki> Socket was set in the read FDS for but there is no session block currently associated with this socket</nowiki>
 [[M204.2589]]<nowiki> Socket was set in the write FDS for but there is no session block currently associated with this socket</nowiki>
 [[M204.2590]]<nowiki> SESD for socket link unexpectedly deallocated before socket data could be read</nowiki>
 [[M204.2591]]<nowiki> SESD for socket link unexpectedly deallocated after socket data was read</nowiki>
 [[M204.2592]]<nowiki> Passive socket for link has been closed</nowiki>
 [[M204.2594]]<nowiki> Socket received a zero-length record from remote port </nowiki>
 [[M204.2595]]<nowiki> Passive socket for link has been closed temporarily due to local resource shortage</nowiki>
 [[M204.2596]]<nowiki> Passive socket for link has been reopened: local resource shortage abated</nowiki>
 [[M204.2598]]<nowiki> Socket moved to deferred clnup queue for link </nowiki>
 [[M204.2602]]<nowiki> Late data received after timeout or bump -- rh=, ru=</nowiki>
 [[M204.2603]]<nowiki> Socket accept request for link could not be accommodated: no session block available</nowiki>
 [[M204.2610]]<nowiki> </nowiki>
 [[M204.2611]]<nowiki> CHECKPOINT command successful</nowiki>
 [[M204.2613]]<nowiki> </nowiki>
 [[M204.2614]]<nowiki> Extended quiesce in progress - updating suspended, please wait</nowiki>
 [[M204.2615]]<nowiki> </nowiki>
 [[M204.2622]]<nowiki> HWM CCATEMP pages used in = , max available = </nowiki>
 [[M204.2627]]<nowiki> Fast recovery: beginning journal block </nowiki>
 [[M204.2628]]<nowiki> </nowiki>
 [[M204.2632]]<nowiki> LQTBL set to max of 16383 for non-UL threads</nowiki>
 [[M204.2633]]<nowiki> new password</nowiki>
 [[M204.2634]]<nowiki> Your password will expire in </nowiki>
 [[M204.2635]]<nowiki> There have been unsuccessful login attempts</nowiki>
 [[M204.2636]]<nowiki> User deleted from password table: </nowiki>
 [[M204.2638]]<nowiki> Discrepancy: current vs expected journal block </nowiki>
 [[M204.2644]]<nowiki> Data set used by CCASTAT DD statement currently in use</nowiki>
 [[M204.2646]]<nowiki> 'KEEPDEFS' specified and no field definitions present, 'KEEPDEFS' ignored</nowiki>
 [[M204.2649]]<nowiki> CCASTAT is currently in use</nowiki>
 [[M204.2652]]<nowiki> </nowiki>
 [[M204.2657]]<nowiki> Subsystem resumed</nowiki>
 [[M204.2659]]<nowiki> set to suspend, remaining users = </nowiki>
 [[M204.2661]]<nowiki> Subsystem suspended</nowiki>
 [[M204.2665]]<nowiki> refreshed in subsystem </nowiki>
 [[M204.2666]]<nowiki> replaced in </nowiki>
 [[M204.2667]]<nowiki> EXCPVR not supported under 64 bit; EXCP will be substituted</nowiki>
 [[M204.2684]]<nowiki> Checkpoint configuration conflict - </nowiki>
 [[M204.2685]]<nowiki> CHKPNTS is open so CPMAX set to 1</nowiki>
 [[M204.2686]]<nowiki> Checkpoint processing will use both CHKPOINT and CHKPNTS</nowiki>
 [[M204.2687]]<nowiki> Sub-transaction checkpoint postponed by user user no on file </nowiki>
 [[M204.2692]]<nowiki> is highest number of CHKP records</nowiki>
 [[M204.2697]]<nowiki> Start of sub-trans CHKP at: , </nowiki>
 [[M204.2698]]<nowiki> End of sub-trans CHKP at: , </nowiki>
 [[M204.2701]]<nowiki> </nowiki>
 [[M204.2708]]<nowiki> No files updated by transaction after subtran chkp</nowiki>
 [[M204.2709]]<nowiki> *LOOK CORE x'' x'' </nowiki>
 [[M204.2712]]<nowiki> </nowiki>
 [[M204.2716]]<nowiki> Free space is empty</nowiki>
 [[M204.2722]]<nowiki> Group closed: </nowiki>
 [[M204.2724]]<nowiki> Parameter "DELETE" is indicated for with no LPU feature enabled and not a single user run. An exclusive file enqueue will be required.</nowiki>
 [[M204.2736]]<nowiki> FOPT=x'10' turned off: date time stamp field undefined</nowiki>
 [[M204.2749]]<nowiki> number of basic records processed: </nowiki>
 [[M204.2750]]<nowiki> number of extension records before compaction: </nowiki>
 [[M204.2751]]<nowiki> number of extension records after compaction: </nowiki>
 [[M204.2752]]<nowiki> number of not processed (locked) records: </nowiki>
 [[M204.2753]]<nowiki> number of free pages used: </nowiki>
 [[M204.2754]]<nowiki> number of deleted logically-deleted records: </nowiki>
 [[M204.2756]]<nowiki> NUMBUFG reset to NLRUQG * ((NSERVS + NSUBTKS) * MAXOBUF + 15) = * (( + ) * + 15) = </nowiki>
 [[M204.2761]]<nowiki> detected - backout will follow</nowiki>
 [[M204.2763]]<nowiki> Table total number of pages processed: </nowiki>
 [[M204.2764]]<nowiki> Table # of pages added to the reuse queue: </nowiki>
 [[M204.2765]]<nowiki> Table reuse queue length before rebuild: </nowiki>
 [[M204.2766]]<nowiki> Table # of pages that were on the reuse queue: </nowiki>
 [[M204.2767]]<nowiki> Table reuse queue length after rebuild: </nowiki>
 [[M204.2768]]<nowiki> has no Table X pages</nowiki>
 [[M204.2769]]<nowiki> has no TABLEX pages in use</nowiki>
 [[M204.2777]]<nowiki> parameter reset to larger = </nowiki>
 [[M204.2784]]<nowiki> Ignoring commands, until Begin found</nowiki>
 [[M204.2785]]<nowiki> Rewind invalid with stream configuration</nowiki>
 [[M204.2786]]<nowiki> CPQZSECS timer refreshed - expires in seconds</nowiki>
 [[M204.2788]]<nowiki> Ignoring commands, until Begin found</nowiki>
 [[M204.2790]]<nowiki> Initial clause references uninitialized variable: </nowiki>
 [[M204.2791]]<nowiki> Initial clause ignored, Initial specified in previous Common declaration</nowiki>
 [[M204.2794]]<nowiki> Journal block discrepancy. Expected block number is , current block number is </nowiki>
 [[M204.2804]]<nowiki> >><<</nowiki>
 [[M204.2805]]<nowiki> </nowiki>
 [[M204.2806]]<nowiki> </nowiki>
 [[M204.2807]]<nowiki> (file = , procedure = , line = )</nowiki>
 [[M204.2811]]<nowiki> number of moved objects: </nowiki>
 [[M204.2812]]<nowiki> number of moved pages: </nowiki>
 [[M204.2813]]<nowiki> number of record locking conflicts: </nowiki>
 [[M204.2814]]<nowiki> number of multisegment objects: </nowiki>
 [[M204.2815]]<nowiki> total number of gaps: </nowiki>
 [[M204.2816]]<nowiki> total gap size: </nowiki>
 [[M204.2817]]<nowiki> segment: number of gaps: total gap size: </nowiki>
 [[M204.2825]]<nowiki> COMPACTB and COMPACTE may not be run at the same time</nowiki>
 [[M204.2829]]<nowiki> Reorganize to improve efficiency for Table E allocation</nowiki>
 [[M204.2832]]<nowiki> USE PROC active for procedure</nowiki>
 [[M204.2834]]<nowiki> Address lookup failed for </nowiki>
 [[M204.2835]]<nowiki> Table increased by pages automatically</nowiki>
 [[M204.2836]]<nowiki> Value of parameter invalid - reset to </nowiki>
 [[M204.2864]]<nowiki> Full search of ordered index performed for field: </nowiki>
 [[M204.2879]]<nowiki> Remote ID mode </nowiki>
 [[M204.2888]]<nowiki> Link flags locks held remote partner </nowiki>
 [[M204.2889]]<nowiki> User no session abandoned for link </nowiki>
 [[M204.2890]]<nowiki> Link closed normally; it can be re-opened</nowiki>
 [[M204.2891]]<nowiki> Link subtask waiting on ECB RPL </nowiki>
 [[M204.2892]]<nowiki> SQEDS in chain last one is </nowiki>
 [[M204.2896]]<nowiki> Link has replaced link </nowiki>
 [[M204.2897]]<nowiki> now uses link </nowiki>
 [[M204.2902]]<nowiki> ECTG supported; XMEMOPT reset from x'' to x''</nowiki>
 [[M204.2905]]<nowiki> IBM system interface macro warning, return code = , reason code = </nowiki>
 [[M204.2907]]<nowiki> Link rejected accept: sockaddr is </nowiki>
 [[M204.2915]]<nowiki> IGNORE specified for file </nowiki>
 [[M204.2919]]<nowiki> HWM MBYTES ATB storage allocated = </nowiki>
 [[M204.2924]]<nowiki> SERVNSSZ/SERVNSA reset: server swap inactive (NUSERS=NSERVS)</nowiki>
 [[M204.2925]]<nowiki> HWM MBytes storage allocated with 1 MB pages = </nowiki>
 [[M204.2926]]<nowiki> 1 MB page feature is not available. Parameter ZPAGEOPT is reset to zero.</nowiki>
 [[M204.2927]]<nowiki> </nowiki>
 [[M204.2928]]<nowiki> Maximum socket used on TCP/IP link was </nowiki>
 [[M204.2930]]<nowiki> Unable to allocate storage object for </nowiki>
 [[M204.2931]]<nowiki> Operating system does not support </nowiki>
 [[M204.2939]]<nowiki> has been set to its value: </nowiki>
 [[M204.2946]]<nowiki> Error(s) encountered, command not performed</nowiki>
 [[M204.2947]]<nowiki> Module address length protected successfully</nowiki>
 [[M204.2951]]<nowiki> is obsolete</nowiki>
 [[M204.2952]]<nowiki> Auto-defining IODEV 25 (FUSI) threads</nowiki>
 [[M204.2953]]<nowiki> File zHPF capabilities Supported: </nowiki>
 [[M204.2954]]<nowiki> Feature not supported</nowiki>
 [[M204.2956]]<nowiki> File is in-memory file</nowiki>
 [[M204.2957]]<nowiki> Error opening stream for Janus Web port </nowiki>
 [[M204.2960]]<nowiki> Initialized interface for </nowiki>
 [[M204.2963]]<nowiki> PGM=FUNLOAD user zero parameters:</nowiki>
 [[M204.2966]]<nowiki> line , procedure in file </nowiki>
 [[M204.2967]]<nowiki> line of command level program</nowiki>
 [[M204.2968]]<nowiki> : no debug info</nowiki>
 [[M204.2970]]<nowiki> Maximum call stack limit () reached</nowiki>
 [[M204.2972]]<nowiki> Warning SIRTERM X'02' bit not set - WSF Query not supported</nowiki>
 [[M204.2975]]<nowiki> connection to host port number using Janus 2PC port </nowiki>
 [[M204.2977]]<nowiki> Global transaction error: </nowiki>
 [[USER.0001]]<nowiki> DUMMY MESSAGE</nowiki>
 [[MSIR.0031]]<nowiki> Port already stopped</nowiki>
 [[MSIR.0032]]<nowiki> Port already started</nowiki>
 [[MSIR.0033]]<nowiki> Port already draining</nowiki>
 [[MSIR.0034]]<nowiki> Port already forcing</nowiki>
 [[MSIR.0035]]<nowiki> Port drain requested</nowiki>
 [[MSIR.0036]]<nowiki> Port force requested</nowiki>
 [[MSIR.0037]]<nowiki> Port deleted</nowiki>
 [[MSIR.0038]]<nowiki> Port not started</nowiki>
 [[MSIR.0039]]<nowiki> Port started</nowiki>
 [[MSIR.0050]]<nowiki> Invalid LOGIN record received from </nowiki>
 [[MSIR.0053]]<nowiki> Invalid buffer type received from </nowiki>
 [[MSIR.0056]]<nowiki> Invalid buffer header received from </nowiki>
 [[MSIR.0057]]<nowiki> Unexpected EOM received from </nowiki>
 [[MSIR.0060]]<nowiki> SDAEMON is an obsolete command</nowiki>
 [[MSIR.0068]]<nowiki> Running $COMM request for USER </nowiki>
 [[MSIR.0077]]<nowiki> Host name resolved to </nowiki>
 [[MSIR.0078]]<nowiki> Sirius functions are expired</nowiki>
 [[MSIR.0079]]<nowiki> Sirius functions not authorized for CPU </nowiki>
 [[MSIR.0083]]<nowiki> tables for USER </nowiki>
 [[MSIR.0100]]<nowiki> Starting SQL connection for USER </nowiki>
 [[MSIR.0101]]<nowiki> SQL connection closed by initiating user</nowiki>
 [[MSIR.0105]]<nowiki> Port defined</nowiki>
 [[MSIR.0114]]<nowiki> for port from </nowiki>
 [[MSIR.0115]]<nowiki> Starting outgoing site manager for port , remote server </nowiki>
 [[MSIR.0116]]<nowiki> Starting incoming site manager for port , remote server </nowiki>
 [[MSIR.0122]]<nowiki> is expired</nowiki>
 [[MSIR.0123]]<nowiki> not authorized for CPU </nowiki>
 [[MSIR.0124]]<nowiki> </nowiki>
 [[MSIR.0128]]<nowiki> RESTART functionality being provided by SIRTUNE</nowiki>
 [[MSIR.0133]]<nowiki> Restart utility is started</nowiki>
 [[MSIR.0146]]<nowiki> added to port </nowiki>
 [[MSIR.0147]]<nowiki> Can't delete remote server from port , a connection is active</nowiki>
 [[MSIR.0148]]<nowiki> deleted from port </nowiki>
 [[MSIR.0149]]<nowiki> SYBMSG(20149,14,1) </nowiki>
 [[MSIR.0150]]<nowiki> SYBMSG(4002,14,1) Login failed.</nowiki>
 [[MSIR.0151]]<nowiki> SYBMSG(20151,14,1) TDS version invalid.</nowiki>
 [[MSIR.0152]]<nowiki> SYBMSG(20152,14,1) Language request invalid on RPCONLY port.</nowiki>
 [[MSIR.0153]]<nowiki> SYBMSG(20153,15,1) Invalid RPC parameter datatype received.</nowiki>
 [[MSIR.0154]]<nowiki> SYBMSG(20154,15,1) Length of variables and RPC parameters exceeds RBSIZE</nowiki>
 [[MSIR.0155]]<nowiki> SYBMSG(20155,15,1) Invalid stream received.</nowiki>
 [[MSIR.0156]]<nowiki> SYBMSG(20156,15,1) Unable to open server </nowiki>
 [[MSIR.0157]]<nowiki> SYBMSG(20157,15,1) Invalid statement ''.</nowiki>
 [[MSIR.0158]]<nowiki> SYBMSG(131,15,1) The size () given to the parameter '' exceeds the maximum (255).</nowiki>
 [[MSIR.0159]]<nowiki> SYBMSG(20159,15,1) '' statement invalid after EXEC statement.</nowiki>
 [[MSIR.0160]]<nowiki> SYBMSG(103,15,1) The identifier that starts with '' is too long.</nowiki>
 [[MSIR.0161]]<nowiki> SYBMSG(20161,15,1) Unsupported syntax near ''.</nowiki>
 [[MSIR.0162]]<nowiki> SYBMSG(20162,15,1) Unclosed quote before character string ''.</nowiki>
 [[MSIR.0163]]<nowiki> SYBMSG(2715,16,1) Parameter '' has an invalid datatype.</nowiki>
 [[MSIR.0164]]<nowiki> SYBMSG(102,15,1) Incorrect syntax near ''.</nowiki>
 [[MSIR.0165]]<nowiki> SYBMSG(134,15,1) The variable name '' has already been declared.</nowiki>
 [[MSIR.0166]]<nowiki> SYBMSG(156,15,1) Incorrect syntax near the keyword ''.</nowiki>
 [[MSIR.0167]]<nowiki> SYBMSG(137,15,1) Must declare variable ''.</nowiki>
 [[MSIR.0168]]<nowiki> SYBMSG(20168,15,1) Unable to store value '' into variable of type .</nowiki>
 [[MSIR.0169]]<nowiki> SYBMSG(20169,15,1) Implicit conversion from datatype '' to '' is not allowed.</nowiki>
 [[MSIR.0170]]<nowiki> SYBMSG(20170,15,1) Unsupported datatype ''.</nowiki>
 [[MSIR.0171]]<nowiki> SYBMSG(179,15,1) Can't use OUTPUT option when passing a constant to a stored procedure.</nowiki>
 [[MSIR.0172]]<nowiki> SYBMSG(119,15,1) Must pass parameter number and subsequent parameters as '@name = value'.</nowiki>
 [[MSIR.0182]]<nowiki> Message from server - Msg , Level , State :</nowiki>
 [[MSIR.0183]]<nowiki> Message from server - Msg , Level , State :</nowiki>
 [[MSIR.0184]]<nowiki> Message from server - Server '', Procedure '', Line :</nowiki>
 [[MSIR.0185]]<nowiki> Message from server - </nowiki>
 [[MSIR.0193]]<nowiki> Port reloaded</nowiki>
 [[MSIR.0200]]<nowiki> Sirius Fast/Backup Restore is using full I/O</nowiki>
 [[MSIR.0218]]<nowiki> SYBMSG(20218,14,1) Error in Model 204 processing - see audit trail</nowiki>
 [[MSIR.0220]]<nowiki> not supported by Fast/Reload, program being passed to standard </nowiki>
 [[MSIR.0221]]<nowiki> FILELOAD Compiler , program being passed to standard </nowiki>
 [[MSIR.0229]]<nowiki> Field causing error = </nowiki>
 [[MSIR.0247]]<nowiki> </nowiki>
 [[MSIR.0250]]<nowiki> SDAEMON started by USER </nowiki>
 [[MSIR.0261]]<nowiki> Establishing client connection to port , remote server </nowiki>
 [[MSIR.0268]]<nowiki> </nowiki>
 [[MSIR.0276]]<nowiki> defined</nowiki>
 [[MSIR.0277]]<nowiki> deleted</nowiki>
 [[MSIR.0292]]<nowiki> JANUS added to port </nowiki>
 [[MSIR.0293]]<nowiki> JANUS (S) for port pre-empted</nowiki>
 [[MSIR.0300]]<nowiki> Using full track I/O</nowiki>
 [[MSIR.0301]]<nowiki> Using disk buffer monitor</nowiki>
 [[MSIR.0302]]<nowiki> Unable to continue because FTONLY specified</nowiki>
 [[MSIR.0303]]<nowiki> SORT/HASH key out of order</nowiki>
 [[MSIR.0304]]<nowiki> Switching to disk buffer monitor</nowiki>
 [[MSIR.0305]]<nowiki> Can't add to end of file</nowiki>
 [[MSIR.0306]]<nowiki> SORT/HASH key can't be appended to file</nowiki>
 [[MSIR.0325]]<nowiki> $ - no arguments specified</nowiki>
 [[MSIR.0326]]<nowiki> $ - argument = ''</nowiki>
 [[MSIR.0329]]<nowiki> After SIRFIELD, fieldname is no longer produced by PAI because related fieldname now is</nowiki>
 [[MSIR.0330]]<nowiki> After SIRFIELD, alias of field is no longer produced by PAI because related fieldname now is</nowiki>
 [[MSIR.0331]]<nowiki> After SIRFIELD, fieldname is no longer produced by PAI because alias of related field now is</nowiki>
 [[MSIR.0337]]<nowiki> After SIRFIELD, alias of field is no longer produced by PAI because alias of related field now is</nowiki>
 [[MSIR.0338]]<nowiki> After SIRFIELD, alias of field is no longer produced by PAI because now is</nowiki>
 [[MSIR.0339]]<nowiki> After SIRFIELD, fieldname is no longer produced by PAI because alias now is</nowiki>
 [[MSIR.0340]]<nowiki> Warning: has SIRFIELD SET attributes PAI and REFERENCE WARN</nowiki>
 [[MSIR.0345]]<nowiki> referenced in and WARN set by SIRFIELD command</nowiki>
 [[MSIR.0359]]<nowiki> WEB status </nowiki>
 [[MSIR.0361]]<nowiki> Processing request </nowiki>
 [[MSIR.0363]]<nowiki> </nowiki>
 [[MSIR.0365]]<nowiki> Transferring connection to user </nowiki>
 [[MSIR.0366]]<nowiki> Connection received from user </nowiki>
 [[MSIR.0369]]<nowiki> Connection transferred to user </nowiki>
 [[MSIR.0388]]<nowiki> Password for private key for port </nowiki>
 [[MSIR.0390]]<nowiki> JANUS WEB ALLOW USER/USGROUP not recommended for non-SSL port </nowiki>
 [[MSIR.0391]]<nowiki> It will result in unencrypted passwords being sent over the network</nowiki>
 [[MSIR.0393]]<nowiki> Relative CENTSPAN value in SIRFIELD FORMAT command converted to </nowiki>
 [[MSIR.0399]]<nowiki> Warning: update to FLOAT date field which is unnormalized number will be rejected</nowiki>
 [[MSIR.0401]]<nowiki> CENTSPAN remains at previous value set in SIRFIELD FORMAT command: </nowiki>
 [[MSIR.0411]]<nowiki> File must be reloaded with the LAI NOFDEF option or using a load module with the Sir2000 Field Miggration Facility</nowiki>
 [[MSIR.0415]]<nowiki> Target file has SIRFIELD definitions, program being passed to standard </nowiki>
 [[MSIR.0424]]<nowiki> Both ERROR formats * in SIRFIELD RELATE command</nowiki>
 [[MSIR.0427]]<nowiki> *==</nowiki>
 [[MSIR.0428]]<nowiki> *==</nowiki>
 [[MSIR.0429]]<nowiki> *==</nowiki>
 [[MSIR.0432]]<nowiki> Terminating session because WEBSDMAX exceeded</nowiki>
 [[MSIR.0434]]<nowiki> Warning: value matches WARN format in record = </nowiki>
 [[MSIR.0435]]<nowiki> Warning: value of for field matches WARN format in record , input record number </nowiki>
 [[MSIR.0438]]<nowiki> Warning: value of for field matches WARN format</nowiki>
 [[MSIR.0447]]<nowiki> </nowiki>
 [[MSIR.0448]]<nowiki> Warning: OPTION BAVAIL ignored</nowiki>
 [[MSIR.0452]]<nowiki> First deleted occurrence of : record , input record </nowiki>
 [[MSIR.0459]]<nowiki> procedure set to </nowiki>
 [[MSIR.0460]]<nowiki> procedure not set</nowiki>
 [[MSIR.0465]]<nowiki> Autodetected TCPTYPE=</nowiki>
 [[MSIR.0469]]<nowiki> connection to host port number using Janus CLSOCK port , user socket number </nowiki>
 [[MSIR.0470]]<nowiki> SYBMSG(20470,15,1) Can't start new thread, MAXCURS exceeded</nowiki>
 [[MSIR.0471]]<nowiki> SYBMSG(20471,15,1) Can't start new thread, no SDAEMON' available</nowiki>
 [[MSIR.0472]]<nowiki> SYBMSG(20472,15,1) Invalid request format</nowiki>
 [[MSIR.0473]]<nowiki> SYBMSG(20473,15,1) Unsupported token </nowiki>
 [[MSIR.0474]]<nowiki> SYBMSG(20474,15,1) Mix of and not suported in a single request</nowiki>
 [[MSIR.0475]]<nowiki> SYBMSG(20475,15,1) Attempt to declare cursor with in-use name</nowiki>
 [[MSIR.0476]]<nowiki> SYBMSG(20476,15,1) Reference to non-existent cursor</nowiki>
 [[MSIR.0477]]<nowiki> Starting cursor thread for user for IP address </nowiki>
 [[MSIR.0494]]<nowiki> Assert info: </nowiki>
 [[MSIR.0528]]<nowiki> Starting SirFact server for user </nowiki>
 [[MSIR.0529]]<nowiki> Taking SirFact dump to proc in </nowiki>
 [[MSIR.0530]]<nowiki> SirFact dump completed</nowiki>
 [[MSIR.0550]]<nowiki> SirSafe rules do not allow current security environment ( )</nowiki>
 [[MSIR.0551]]<nowiki> SirSafe is for current CCASTAT</nowiki>
 [[MSIR.0552]]<nowiki> SirSafe: external authorization not active</nowiki>
 [[MSIR.0553]]<nowiki> (,) to tried by SirSafe</nowiki>
 [[MSIR.0554]]<nowiki> SirSafe disallowed password access</nowiki>
 [[MSIR.0557]]<nowiki> SirSafe approved password access</nowiki>
 [[MSIR.0578]]<nowiki> Public login</nowiki>
 [[MSIR.0594]]<nowiki> SIRFACT SNAP issued by user ()</nowiki>
 [[MSIR.0597]]<nowiki> SirSafe: (,) checking R/W to on </nowiki>
 [[MSIR.0598]]<nowiki> SirSafe: R/W access </nowiki>
 [[MSIR.0599]]<nowiki> SirSafe read-only file checking is </nowiki>
 [[MSIR.0607]]<nowiki> Waiting for JAN(US)DEB(UG) request</nowiki>
 [[MSIR.0608]]<nowiki> Issuing CMD ''</nowiki>
 [[MSIR.0609]]<nowiki> Sending response with WEB status </nowiki>
 [[MSIR.0610]]<nowiki> Debugging from </nowiki>
 [[MSIR.0611]]<nowiki> JAN(US)DEB(UG) finished</nowiki>
 [[MSIR.0612]]<nowiki> Issuing command ''</nowiki>
 [[MSIR.0613]]<nowiki> Looking for exception handler</nowiki>
 [[MSIR.0614]]<nowiki> Running exception handler</nowiki>
 [[MSIR.0637]]<nowiki> Warning: certificate expires in days</nowiki>
 [[MSIR.0642]]<nowiki> Added CA '' from file , proc to port </nowiki>
 [[MSIR.0644]]<nowiki> CA from file , proc deleted from port </nowiki>
 [[MSIR.0657]]<nowiki> User pressed EXITKEY button - session terminating</nowiki>
 [[MSIR.0659]]<nowiki> Non-logged-in SDAEMON terminating</nowiki>
 [[MSIR.0661]]<nowiki> Snap taken, user bumped by BUMPSNAP command</nowiki>
 [[MSIR.0662]]<nowiki> </nowiki>
 [[MSIR.0663]]<nowiki> </nowiki>
 [[MSIR.0664]]<nowiki> </nowiki>
 [[MSIR.0665]]<nowiki> </nowiki>
 [[MSIR.0678]]<nowiki> </nowiki>
 [[MSIR.0687]]<nowiki> SirSafe enhanced shared DASD not active, run SirEnq on ()</nowiki>
 [[MSIR.0688]]<nowiki> SirSafe enhanced shared DASD active on ()</nowiki>
 [[MSIR.0689]]<nowiki> SirSafe Shared DASD visible system: </nowiki>
 [[MSIR.0690]]<nowiki> Janus Web content compressed by percent from to bytes</nowiki>
 [[MSIR.0693]]<nowiki> Error may be due to limited XPath support in Janus SOAP ()</nowiki>
 [[MSIR.0703]]<nowiki> Subsystem resumed</nowiki>
 [[MSIR.0704]]<nowiki> Subsystem quiesced</nowiki>
 [[MSIR.0708]]<nowiki> : </nowiki>
 [[MSIR.0709]]<nowiki> </nowiki>
 [[MSIR.0710]]<nowiki> XML doc parse error: near or before position </nowiki>
 [[MSIR.0711]]<nowiki> </nowiki>
 [[MSIR.0712]]<nowiki> : </nowiki>
 [[MSIR.0762]]<nowiki> Sending K bytes for port to </nowiki>
 [[MSIR.0763]]<nowiki> Sent K bytes for port to in seconds (K/sec)</nowiki>
 [[MSIR.0819]]<nowiki> Session for owner - </nowiki>
 [[MSIR.0878]]<nowiki> Starting daemon for user </nowiki>
 [[MSIR.0879]]<nowiki> Error processing XML Schema document(s): </nowiki>
 [[MSIR.0880]]<nowiki> Error validating XML document instance: </nowiki>
 [[MSIR.0884]]<nowiki> : objects/VTBL/STBL - //, count/pages swapped /</nowiki>
 [[MSIR.0890]]<nowiki> request made by </nowiki>
 [[MSIR.0891]]<nowiki> request completed, RC = </nowiki>
 [[MSIR.0893]]<nowiki> Doing a cancel of Fast/Unload request -- </nowiki>
 [[MSIR.0898]]<nowiki> Attempt to re-use keep-alive connection failed -- connection was lost</nowiki>
 [[MSIR.0911]]<nowiki> SIRTUNE - Initialization complete</nowiki>
 [[MSIR.0912]]<nowiki> SIRTUNE - Already running under SIRTUNE task</nowiki>
 [[MSIR.0913]]<nowiki> Debugger </nowiki>
 [[MSIR.0915]]<nowiki> Debugging is on: client is port , sessionID: </nowiki>
 [[MSIR.0920]]<nowiki> Debugger client has requested: </nowiki>
 [[MSIR.0921]]<nowiki> Debugger worker was posted, state: </nowiki>
 [[MSIR.0922]]<nowiki> Debugger worker posts debuggee: </nowiki>
 [[MSIR.0923]]<nowiki> Debugger breakpoint set at quad: </nowiki>
 [[MSIR.0925]]<nowiki> </nowiki>
 [[MSIR.0926]]<nowiki> Connection to debugger from </nowiki>
 [[MSIR.0928]]<nowiki> Debugging session begins, external user number: internal user number: </nowiki>
 [[MSIR.0930]]<nowiki> Debugger worker freed for user: </nowiki>
 [[MSIR.0931]]<nowiki> Debugger worker draining for user: </nowiki>
 [[MSIR.0932]]<nowiki> Debugger worker drained for user: at </nowiki>
 [[MSIR.0933]]<nowiki> Janus/Tn3270 Debugger status: =</nowiki>
 [[MSIR.0934]]<nowiki> Debugger: skipping procedure: </nowiki>
 [[MSIR.0935]]<nowiki> Debug: suspend session while debugging</nowiki>
 [[MSIR.0936]]<nowiki> Debug: suspend session while skipping</nowiki>
 [[MSIR.0937]]<nowiki> Debug: resume session while debugging</nowiki>
 [[MSIR.0938]]<nowiki> Debug: resume session while skipping</nowiki>
 [[MSIR.0940]]<nowiki> Bumping asynchronous daemon (user ) for object discard</nowiki>
 [[MSIR.0942]]<nowiki> Debugger port defaulted to </nowiki>
 [[MSIR.0943]]<nowiki> Request cancel performed from debugger</nowiki>
 [[MSIR.0948]]<nowiki> </nowiki>
 [[MSIR.0955]]<nowiki> Debugging suspended</nowiki>
 [[MSIR.0956]]<nowiki> Debugging resumed</nowiki>
 [[MSIR.0957]]<nowiki> Debug: suspend late session</nowiki>
 [[MSIR.0958]]<nowiki> Debug: resume late session</nowiki>
 [[MSIR.0960]]<nowiki> Debugger refreshing audit trail on client</nowiki>
 [[MSIR.0961]]<nowiki> Debugger terminated run until/white list</nowiki>
 [[MSIR.0962]]<nowiki> Debugger source preview: </nowiki>
 [[MSIR.0965]]<nowiki> </nowiki>
 [[MSIR.0969]]<nowiki> Warning: fields in first occurrence of fieldgroup , in last occurrence, recnum , unloaded file recnum </nowiki>
 [[MSIR.0995]]<nowiki> () Garbage collection completed in ms realtime with ms CPU time. Discarded / objects.</nowiki>
 [[MSIR.0999]]<nowiki> Exclude of lines from debugger started at include level </nowiki>
 [[MSIR.1000]]<nowiki> Exclude of lines from debugger ended: total lines were excluded</nowiki>
 [[MSIR.1002]]<nowiki> More than blocks defined</nowiki>
 [[MSIR.1003]]<nowiki> Debugger Exclude block(s) defined</nowiki>
 [[MSIR.1004]]<nowiki> Lines - excluded from the debugger</nowiki>
 [[MSIR.1005]]<nowiki> Quads - excluded from the debugger</nowiki>
 [[MSIR.1006]]<nowiki> Include of lines started within exclude block at include level </nowiki>
 [[MSIR.1007]]<nowiki> Include of lines within exclude block ended</nowiki>
 [[MSIR.1008]]<nowiki> !debugger include must be inside exclude block</nowiki>
 [[MSIR.1010]]<nowiki> Proc excluded by the debugger</nowiki>
 [[MSIR.1011]]<nowiki> Proc included by the debugger</nowiki>
 [[MSIR.1012]]<nowiki> Routine/Method excluded by the debugger</nowiki>
 [[MSIR.1013]]<nowiki> Routine/Method included by the debugger</nowiki>
 [[MSIR.1014]]<nowiki> Debugger: compiling routine/method: </nowiki>
 [[MSIR.1019]]<nowiki> Debugger: ='', hex=X''</nowiki>
 [[MSIR.1020]]<nowiki> Debugger: =X''</nowiki>
 [[MSIR.1021]]<nowiki> Debugger: Set target is type: </nowiki>
 [[MSIR.1022]]<nowiki> Debugger: Unicode data: hex=X''</nowiki>
 [[MSIR.1023]]<nowiki> Debugger: commandString=''</nowiki>
 [[MSIR.1024]]<nowiki> CLIENTCOMMAND ignored: not debugging</nowiki>
 [[MSIR.1026]]<nowiki> Debugger: sending CLIENTCOMMAND=''</nowiki>
 [[MSIR.1028]]<nowiki> Debugger: procedure will be debugged</nowiki>
 [[MSIR.1035]]<nowiki> Debugger: addWatch ''</nowiki>
 [[MSIR.1036]]<nowiki> Recompiling because of FACTDEB X'01'</nowiki>
 [[MSIR.1037]]<nowiki> Fast/Reload </nowiki>
 [[MSIR.1038]]<nowiki> Time: seconds to process </nowiki>
 [[MSIR.1039]]<nowiki> Debugger: PAI mode set on SORT</nowiki>
 [[MSIR.1040]]<nowiki> Debugger: '' matches pattern ''</nowiki>
 [[MSIR.1041]]<nowiki> Debugger: matching '' against ''</nowiki>
 [[MSIR.1042]]<nowiki> Delaying user for MAXAUSER</nowiki>
 [[MSIR.1050]]<nowiki> Session object has direct or indirect reference to locked record(s)</nowiki>
 [[MSIR.1054]]<nowiki> Debugger daemon limit hit, daemon not debugged</nowiki>
 [[MSIR.1055]]<nowiki> record locking conflict with user () for file , record number </nowiki>
 [[MSIR.1056]]<nowiki> lock was obtained by user at </nowiki>
 [[MSIR.1057]]<nowiki> </nowiki>
 [[MSIR.1059]]<nowiki> SNAPLIMD table </nowiki>
 [[MSIR.1061]]<nowiki> bug: //</nowiki>
 [[MSIR.1062]]<nowiki> In lieu of snap: </nowiki>
 [[MSIR.1066]]<nowiki> Debugger: white list scan</nowiki>
 [[MSIR.1067]]<nowiki> Debugger: black list scan</nowiki>
 [[MSIR.1068]]<nowiki> FACTDEB set to 0 because </nowiki>
 [[MSIR.1069]]<nowiki> Debugger: proc= old-level= new-level= </nowiki>
 [[MSIR.1070]]<nowiki> Port draining because of accept error</nowiki>
 [[MSIR.1076]]<nowiki> Debugger: RUNUNTIL continued into DAEMON</nowiki>
 [[MSIR.1077]]<nowiki> Begin debug session, user , client: ()</nowiki>
 [[MSIR.1078]]<nowiki> End debug session, user </nowiki>
 [[MSIR.1080]]<nowiki> Connection upgraded to Web Socket protocol</nowiki>
 [[MSIR.1083]]<nowiki> </nowiki>
 [[MSIR.1084]]<nowiki> </nowiki>
 [[MSIR.1085]]<nowiki> </nowiki>
 [[MSIR.1086]]<nowiki> </nowiki>
 [[MSIR.1087]]<nowiki> </nowiki>
 [[MSIR.1088]]<nowiki> </nowiki>
 [[MSIR.1089]]<nowiki> </nowiki>
 [[MSIR.1090]]<nowiki> </nowiki>
 [[MSIR.1091]]<nowiki> </nowiki>
 [[MSIR.1092]]<nowiki> </nowiki>
 [[MSIR.1093]]<nowiki> </nowiki>
 [[MSIR.1094]]<nowiki> </nowiki>
 [[MSIR.1095]]<nowiki> </nowiki>
 [[MSIR.1096]]<nowiki> </nowiki>
 [[MSIR.1097]]<nowiki> </nowiki>
 [[MSIR.1098]]<nowiki> </nowiki>
 [[MSIR.1099]]<nowiki> </nowiki>
 [[MSIR.1100]]<nowiki> </nowiki>
 [[MSIR.1101]]<nowiki> </nowiki>
 [[MSIR.1102]]<nowiki> </nowiki>
 [[MSIR.1103]]<nowiki> </nowiki>
 [[MSIR.1104]]<nowiki> </nowiki>
 [[MSIR.1105]]<nowiki> </nowiki>
 [[MSIR.1106]]<nowiki> </nowiki>
 [[MSIR.1107]]<nowiki> </nowiki>
 [[MSIR.1108]]<nowiki> </nowiki>
 [[MSIR.1109]]<nowiki> </nowiki>
 [[MSIR.1110]]<nowiki> </nowiki>
 [[MSIR.1111]]<nowiki> </nowiki>
 [[MSIR.1112]]<nowiki> </nowiki>
 [[MSIR.1113]]<nowiki> </nowiki>
 [[MSIR.1114]]<nowiki> </nowiki>
 [[MSIR.1115]]<nowiki> </nowiki>
 [[MSIR.1116]]<nowiki> </nowiki>
 [[MSIR.1117]]<nowiki> </nowiki>
 [[MSIR.1118]]<nowiki> </nowiki>
 [[MSIR.1119]]<nowiki> </nowiki>
 [[MSIR.1120]]<nowiki> </nowiki>
 [[MSIR.1121]]<nowiki> </nowiki>
 [[MSIR.1122]]<nowiki> </nowiki>
 [[MSIR.1123]]<nowiki> </nowiki>
 [[MSIR.1124]]<nowiki> </nowiki>
 [[MSIR.1125]]<nowiki> </nowiki>
 [[MSIR.1126]]<nowiki> </nowiki>
 [[MSIR.1127]]<nowiki> </nowiki>
 [[MSIR.1128]]<nowiki> </nowiki>
 [[MSIR.1129]]<nowiki> </nowiki>
 [[MSIR.1130]]<nowiki> </nowiki>
 [[MSIR.1131]]<nowiki> </nowiki>
 [[MSIR.1132]]<nowiki> </nowiki>
 [[MSIR.1133]]<nowiki> </nowiki>
 [[MSIR.1134]]<nowiki> </nowiki>
 [[MSIR.1135]]<nowiki> </nowiki>
 [[MSIR.1136]]<nowiki> </nowiki>
 [[MSIR.1137]]<nowiki> </nowiki>
 [[MSIR.1138]]<nowiki> </nowiki>
 [[MSIR.1139]]<nowiki> </nowiki>
 [[MSIR.1140]]<nowiki> </nowiki>
 [[MSIR.1141]]<nowiki> </nowiki>
 [[MSIR.1142]]<nowiki> </nowiki>
 [[MSIR.1143]]<nowiki> </nowiki>
 [[MSIR.1144]]<nowiki> </nowiki>
 [[MSIR.1145]]<nowiki> </nowiki>
 [[MSIR.1146]]<nowiki> </nowiki>
 [[MSIR.1147]]<nowiki> </nowiki>
 [[MSIR.1148]]<nowiki> </nowiki>

===Return code 2===
 [[M204.1694]]<nowiki> Null ordered record loop implied</nowiki>

===Return code 4===
 [[M204.0001]]<nowiki> Illegal ANALYZE command</nowiki>
 [[M204.0002]]<nowiki> No ANALYZE work file</nowiki>
 [[M204.0006]]<nowiki> Errors exceed ERMX</nowiki>
 [[M204.0007]]<nowiki> Unable to add SCLASS to array</nowiki>
 [[M204.0008]]<nowiki> Double use of proc dictionary page </nowiki>
 [[M204.0009]]<nowiki> Double use of proc text page </nowiki>
 [[M204.0010]]<nowiki> Proc text page loop</nowiki>
 [[M204.0011]]<nowiki> Double use of ACT page </nowiki>
 [[M204.0012]]<nowiki> Double use of record description page </nowiki>
 [[M204.0013]]<nowiki> Please specify ANALYZE work file, then field</nowiki>
 [[M204.0014]]<nowiki> New free page BP not found</nowiki>
 [[M204.0015]]<nowiki> IX says list, not BP</nowiki>
 [[M204.0016]]<nowiki> Newfr </nowiki>
 [[M204.0019]]<nowiki> *ZAP verify reject, storage remains unchanged</nowiki>
 [[M204.0021]]<nowiki> NSERVS+NUSERS(if swapping)+NSUBTKS+1 > 32767</nowiki>
 [[M204.0023]]<nowiki> Unknown option: </nowiki>
 [[M204.0024]]<nowiki> Unable to include subsystem procedure: </nowiki>
 [[M204.0025]]<nowiki> Bug .. APSY use count</nowiki>
 [[M204.0026]]<nowiki> Too much audit data</nowiki>
 [[M204.0027]]<nowiki> Aux procedure dictionary full</nowiki>
 [[M204.0029]]<nowiki> File in use by subsystem , command rejected</nowiki>
 [[M204.0030]]<nowiki> Model 204 needs 370 instruction set</nowiki>
 [[M204.0032]]<nowiki> Equal sign not found</nowiki>
 [[M204.0033]]<nowiki> Invalid expression</nowiki>
 [[M204.0034]]<nowiki> Variable parameters too large</nowiki>
 [[M204.0035]]<nowiki> Variable parameters may not be reset</nowiki>
 [[M204.0036]]<nowiki> Variable length must be positive</nowiki>
 [[M204.0037]]<nowiki> Invalid syntax</nowiki>
 [[M204.0038]]<nowiki> %variable already defined - </nowiki>
 [[M204.0039]]<nowiki> Request too long -- STBL, LSTBL=</nowiki>
 [[M204.0040]]<nowiki> Invalid array declaration</nowiki>
 [[M204.0041]]<nowiki> Too many dimensions declared</nowiki>
 [[M204.0042]]<nowiki> Dimension declaration must be positive</nowiki>
 [[M204.0043]]<nowiki> Dimension declaration too large</nowiki>
 [[M204.0044]]<nowiki> Too few/many subscripts</nowiki>
 [[M204.0045]]<nowiki> Invalid index variable</nowiki>
 [[M204.0046]]<nowiki> User restart during APSY restart</nowiki>
 [[M204.0047]]<nowiki> From/To missing</nowiki>
 [[M204.0048]]<nowiki> Redundant From/To/By</nowiki>
 [[M204.0049]]<nowiki> Missing right paren</nowiki>
 [[M204.0050]]<nowiki> Invalid value, count, or occurrence</nowiki>
 [[M204.0051]]<nowiki> Unexpected right paren or comma</nowiki>
 [[M204.0052]]<nowiki> Illegal term</nowiki>
 [[M204.0053]]<nowiki> Field name reference not in a For loop</nowiki>
 [[M204.0054]]<nowiki> Overflow in re-scaling constant</nowiki>
 [[M204.0055]]<nowiki> I/O error - </nowiki>
 [[M204.0056]]<nowiki> Trailing pad character not allowed on preallocated ORDERED or KEY field=, recnum=X'', value=X''</nowiki>
 [[M204.0057]]<nowiki> Len or DP parameter too large</nowiki>
 [[M204.0058]]<nowiki> Len must be positive</nowiki>
 [[M204.0059]]<nowiki> Type inconsistent with Len or DP</nowiki>
 [[M204.0063]]<nowiki> Insufficient main storage to perform enqueue</nowiki>
 [[M204.0064]]<nowiki> NDBSERVS cannot be less than NSERVS+2, reset to NSERVS+2</nowiki>
 [[M204.0065]]<nowiki> NSERVS cannot be greater than NUSERS, reset to NUSERS</nowiki>
 [[M204.0068]]<nowiki> Server size increased to user's fixed size of </nowiki>
 [[M204.0073]]<nowiki> CHKP module was not linked in or journal dataset(s) could not be opened for roll forward logging</nowiki>
 [[M204.0076]]<nowiki> No files to process, REGENERATE ending</nowiki>
 [[M204.0078]]<nowiki> Unable to open CCAGRP</nowiki>
 [[M204.0080]]<nowiki> Expecting single identifier for file name</nowiki>
 [[M204.0081]]<nowiki> Can't open CCATEMP</nowiki>
 [[M204.0083]]<nowiki> was created by a later release</nowiki>
 [[M204.0084]]<nowiki> Insufficient FTBL space for NGROUP, LFTBL=</nowiki>
 [[M204.0087]]<nowiki> The 'p' or 'np' options are valid only with CMS</nowiki>
 [[M204.0088]]<nowiki> can no longer be opened by this release</nowiki>
 [[M204.0089]]<nowiki> No I/O allowed on terminal while process-to-process is in effect</nowiki>
 [[M204.0093]]<nowiki> is a recursive stream definition</nowiki>
 [[M204.0094]]<nowiki> Open failed for member of concatenated stream </nowiki>
 [[M204.0095]]<nowiki> Parallel stream disabled, number of members below MINAVAIL</nowiki>
 [[M204.0097]]<nowiki> support not linked in</nowiki>
 [[M204.0100]]<nowiki> Files must be closed to change XTBL</nowiki>
 [[M204.0103]]<nowiki> Invalid option - UTABLE</nowiki>
 [[M204.0104]]<nowiki> Errors detected, table sizes not reset</nowiki>
 [[M204.0105]]<nowiki> New table sizes will not fit in server, table sizes not reset</nowiki>
 [[M204.0106]]<nowiki> RESTOREG not allowed during roll back</nowiki>
 [[M204.0107]]<nowiki> DUMPG not allowed during roll back</nowiki>
 [[M204.0108]]<nowiki> Change applied to disk CCASTAT, further updates to CCASTAT not allowed in this run</nowiki>
 [[M204.0119]]<nowiki> Internal SQL compilation error</nowiki>
 [[M204.0120]]<nowiki> CHKP - increase NSUBTKS</nowiki>
 [[M204.0123]]<nowiki> Unable to open the checkpoint stream</nowiki>
 [[M204.0124]]<nowiki> Checkpoints are not allowed during recovery</nowiki>
 [[M204.0125]]<nowiki> Checkpointing not active</nowiki>
 [[M204.0126]]<nowiki> File not located in directory</nowiki>
 [[M204.0127]]<nowiki> File name required if not administrator</nowiki>
 [[M204.0128]]<nowiki> Output set to normal</nowiki>
 [[M204.0129]]<nowiki> Request cancelled due to I/O error on USE output file </nowiki>
 [[M204.0130]]<nowiki> Checkpoint not in progress</nowiki>
 [[M204.0133]]<nowiki> USE data set has a maximum record length of but the current value of LOBUFF is </nowiki>
 [[M204.0134]]<nowiki> RESTART must be first command</nowiki>
 [[M204.0140]]<nowiki> NDIR must be increased. RESTART aborted.</nowiki>
 [[M204.0141]]<nowiki> Bug .. duplicate file name in checkpoint record</nowiki>
 [[M204.0145]]<nowiki> The following files cannot be recovered:</nowiki>
 [[M204.0146]]<nowiki> - </nowiki>
 [[M204.0150]]<nowiki> Read past beginning of RESTART stream</nowiki>
 [[M204.0152]]<nowiki> Unknown checkpoint record type</nowiki>
 [[M204.0153]]<nowiki> Bug .. roll back LPM/DSL grew</nowiki>
 [[M204.0159]]<nowiki> Can't perform roll forward</nowiki>
 [[M204.0160]]<nowiki> Roll back not successful, RF not allowed</nowiki>
 [[M204.0161]]<nowiki> Warning: pre-compile prefix </nowiki>
 [[M204.0164]]<nowiki> Storage allocation failed during roll forward</nowiki>
 [[M204.0165]]<nowiki> Missing an update unit from ICL (InComplete List)</nowiki>
 [[M204.0166]]<nowiki> Checkpoint missing from CCARF</nowiki>
 [[M204.0167]]<nowiki> Checkpointing terminated, run cancelled</nowiki>
 [[M204.0168]]<nowiki> Bug .. illegal option for roll forward </nowiki>
 [[M204.0169]]<nowiki> Bug .. reapplying RF entry type , subtype from updunit to </nowiki>
 [[M204.0174]]<nowiki> Bug .. roll forward did not get the same record number for old recno: new recno: </nowiki>
 [[M204.0176]]<nowiki> Backout log mismatch during roll forward</nowiki>
 [[M204.0177]]<nowiki> Reserved word = </nowiki>
 [[M204.0178]]<nowiki> Field name omitted</nowiki>
 [[M204.0180]]<nowiki> Table B search implied for field = in </nowiki>
 [[M204.0181]]<nowiki> Can't reserve buffer, not enough left.</nowiki>
 [[M204.0182]]<nowiki> Statement label expected, not </nowiki>
 [[M204.0183]]<nowiki> Insufficient access to select on field </nowiki>
 [[M204.0184]]<nowiki> Missing ')'</nowiki>
 [[M204.0185]]<nowiki> Illegal use of fieldname variable</nowiki>
 [[M204.0186]]<nowiki> New or invalid list name in list$ clause</nowiki>
 [[M204.0187]]<nowiki> Point$ not allowed in groups</nowiki>
 [[M204.0188]]<nowiki> No sorted groups</nowiki>
 [[M204.0189]]<nowiki> File is not sorted</nowiki>
 [[M204.0190]]<nowiki> File$ and Location$ must be in group context</nowiki>
 [[M204.0191]]<nowiki> File not in current group: file = </nowiki>
 [[M204.0192]]<nowiki> And or Than required, not </nowiki>
 [[M204.0193]]<nowiki> Inconsistent range conditions</nowiki>
 [[M204.0194]]<nowiki> Than required, not </nowiki>
 [[M204.0195]]<nowiki> Unit used by DD statement currently in use</nowiki>
 [[M204.0196]]<nowiki> Data set used by DD statement currently in use</nowiki>
 [[M204.0198]]<nowiki> Request too long -- VTBL, LVTBL=</nowiki>
 [[M204.0199]]<nowiki> Open failed for VTAM applid with reason code X""</nowiki>
 [[M204.0200]]<nowiki> Insufficient access to read field </nowiki>
 [[M204.0201]]<nowiki> Unable to start PST, increase NSUBTKS</nowiki>
 [[M204.0202]]<nowiki> File records requires either an INVISIBLE, KEY or INVISIBLE, ORDERED field: field = </nowiki>
 [[M204.0203]]<nowiki> "Store" requires update file</nowiki>
 [[M204.0205]]<nowiki> Sort/hash key required in new record</nowiki>
 [[M204.0206]]<nowiki> Unsorted file, sort key rejected</nowiki>
 [[M204.0208]]<nowiki> Updating sort key not permitted</nowiki>
 [[M204.0209]]<nowiki> New value null or too long for </nowiki>
 [[M204.0210]]<nowiki> Number required, not: </nowiki>
 [[M204.0211]]<nowiki> Request too long - QTBL, LQTBL=</nowiki>
 [[M204.0212]]<nowiki> Word too long</nowiki>
 [[M204.0213]]<nowiki> Phrase too long</nowiki>
 [[M204.0214]]<nowiki> Field names unavailable in groups</nowiki>
 [[M204.0215]]<nowiki> Illegal destination - </nowiki>
 [[M204.0216]]<nowiki> Missing call destination statement label</nowiki>
 [[M204.0217]]<nowiki> Too many parts in called statement number</nowiki>
 [[M204.0218]]<nowiki> Rest of line ignored after: </nowiki>
 [[M204.0219]]<nowiki> Return valid only in subroutine</nowiki>
 [[M204.0220]]<nowiki> Subroutine statement cannot be nested</nowiki>
 [[M204.0221]]<nowiki> VTAM close error: X15, errflag= x'' x''</nowiki>
 [[M204.0222]]<nowiki> Retry valid only within an On unit</nowiki>
 [[M204.0224]]<nowiki> Request too long -- NTBL, LNTBL=</nowiki>
 [[M204.0225]]<nowiki> Too many parts in statement number</nowiki>
 [[M204.0226]]<nowiki> Request too long -- QTBL, LQTBL=</nowiki>
 [[M204.0227]]<nowiki> User may not access file/group</nowiki>
 [[M204.0228]]<nowiki> Part of statement ignored</nowiki>
 [[M204.0229]]<nowiki> Invalid statement</nowiki>
 [[M204.0230]]<nowiki> Invalid text after "end"</nowiki>
 [[M204.0231]]<nowiki> Too many files in group</nowiki>
 [[M204.0232]]<nowiki> File or group isn't open - </nowiki>
 [[M204.0233]]<nowiki> Duplicate files in group - </nowiki>
 [[M204.0234]]<nowiki> Functions illegal in group definitions</nowiki>
 [[M204.0235]]<nowiki> Group support not linked in</nowiki>
 [[M204.0236]]<nowiki> Invalid function in 'in' clause</nowiki>
 [[M204.0237]]<nowiki> $Curfile must be in For loop</nowiki>
 [[M204.0238]]<nowiki> Current group has no update file</nowiki>
 [[M204.0239]]<nowiki> Cto statement must be within record loop</nowiki>
 [[M204.0240]]<nowiki> FRV impossible: field = </nowiki>
 [[M204.0241]]<nowiki> Sorted/group FRV support not linked in</nowiki>
 [[M204.0242]]<nowiki> SORTKEY or ORDERED field not found -- "IN ORDER" ignored</nowiki>
 [[M204.0243]]<nowiki> "in order" not valid in group context</nowiki>
 [[M204.0244]]<nowiki> Positive number required</nowiki>
 [[M204.0245]]<nowiki> Maximum pause time is 600 seconds</nowiki>
 [[M204.0246]]<nowiki> VTAM failure for : X0,FDBK2=x'',x''</nowiki>
 [[M204.0247]]<nowiki> Screen, menu, or image name not specified</nowiki>
 [[M204.0248]]<nowiki> Clear Tag must refer to input item</nowiki>
 [[M204.0249]]<nowiki> Use of menu requires non-zero LFSCB</nowiki>
 [[M204.0250]]<nowiki> is an invalid menu option</nowiki>
 [[M204.0251]]<nowiki> Title must be first menu line</nowiki>
 [[M204.0252]]<nowiki> Menus limited to 23 lines</nowiki>
 [[M204.0253]]<nowiki> "end menu" missing</nowiki>
 [[M204.0254]]<nowiki> Name given is not a screen</nowiki>
 [[M204.0255]]<nowiki> Name given is not a menu</nowiki>
 [[M204.0256]]<nowiki> Negative message length on VTAM send</nowiki>
 [[M204.0257]]<nowiki> VTAM send exception for : SSENSEI, SSENSMI, USENSEI - X''</nowiki>
 [[M204.0258]]<nowiki> Invalid option: </nowiki>
 [[M204.0259]]<nowiki> Unexpected end of statement</nowiki>
 [[M204.0260]]<nowiki> must be quoted string or %variable</nowiki>
 [[M204.0261]]<nowiki> Logon failed - ; increase number of M204 VTAM terminals</nowiki>
 [[M204.0262]]<nowiki> FSCB full, LFSCB=. Screen/Menu/Image compilation aborted.</nowiki>
 [[M204.0263]]<nowiki> At/to must be between 1 and </nowiki>
 [[M204.0264]]<nowiki> VTAM closedown/crash</nowiki>
 [[M204.0265]]<nowiki> Use of screen requires non-zero LFSCB</nowiki>
 [[M204.0266]]<nowiki> Line ignored after invalid item: </nowiki>
 [[M204.0267]]<nowiki> Title must be first screen line</nowiki>
 [[M204.0268]]<nowiki> Unexpected end of line in screen/menu item</nowiki>
 [[M204.0269]]<nowiki> Null item not allowed</nowiki>
 [[M204.0270]]<nowiki> At column already used</nowiki>
 [[M204.0271]]<nowiki> Len must be between 1 and </nowiki>
 [[M204.0272]]<nowiki> Duplicate At, To, or Len specification</nowiki>
 [[M204.0273]]<nowiki> Default must be quoted string</nowiki>
 [[M204.0274]]<nowiki> Duplicate Default specification</nowiki>
 [[M204.0275]]<nowiki> Duplicate Tag specification</nowiki>
 [[M204.0276]]<nowiki> Tag must be single quoted character</nowiki>
 [[M204.0277]]<nowiki> Numeric conflicts with Alpha or Alphanum</nowiki>
 [[M204.0279]]<nowiki> Nonnumeric value specified for range</nowiki>
 [[M204.0280]]<nowiki> Verify string should be quoted</nowiki>
 [[M204.0281]]<nowiki> Screen itemid must be between 1 and 32767</nowiki>
 [[M204.0282]]<nowiki> "end screen" missing</nowiki>
 [[M204.0284]]<nowiki> Input item name must be unquoted</nowiki>
 [[M204.0285]]<nowiki> "" is a reserved item name</nowiki>
 [[M204.0286]]<nowiki> Permanent 3270 I/O error on , SENSE = </nowiki>
 [[M204.0287]]<nowiki> VTAM receive failed for terminal </nowiki>
 [[M204.0288]]<nowiki> Skip requires positive number</nowiki>
 [[M204.0289]]<nowiki> Invalid syntax for skip</nowiki>
 [[M204.0290]]<nowiki> Index change error, , field=, recnum=x'', type=x'', field value=x''</nowiki>
 [[M204.0291]]<nowiki> Index delete error, , field=, recnum=x'', type=x'', field value=x''</nowiki>
 [[M204.0293]]<nowiki> NUMERIC RANGE delete failure on recnum=x''; value not found for field=, type=x''</nowiki>
 [[M204.0294]]<nowiki> NUMERIC RANGE add failure on recnum=x''; value already defined for field=, type=x''</nowiki>
 [[M204.0295]]<nowiki> Item name missing</nowiki>
 [[M204.0296]]<nowiki> Default title must appear before title line</nowiki>
 [[M204.0297]]<nowiki> Tag must refer to input item</nowiki>
 [[M204.0298]]<nowiki> Invalid option: </nowiki>
 [[M204.0299]]<nowiki> VTAM logon failed - ; X0, FDBK2 = x'' x''</nowiki>
 [[M204.0300]]<nowiki> VTAM for terminal code - , reason code - x''</nowiki>
 [[M204.0301]]<nowiki> Referenced statement label undefined</nowiki>
 [[M204.0302]]<nowiki> List name can't begin with %</nowiki>
 [[M204.0304]]<nowiki> Subscripts required for </nowiki>
 [[M204.0305]]<nowiki> Subscripts or length specification not allowed</nowiki>
 [[M204.0306]]<nowiki> Default Len not positive</nowiki>
 [[M204.0307]]<nowiki> Default Len or DP too large</nowiki>
 [[M204.0308]]<nowiki> Illegal variable type for field name variable</nowiki>
 [[M204.0309]]<nowiki> Illegal use of %variable</nowiki>
 [[M204.0311]]<nowiki> Unacceptable statement reference</nowiki>
 [[M204.0312]]<nowiki> Disk version of password table too large to read into allocated storage</nowiki>
 [[M204.0313]]<nowiki> name expected, not reserved word: </nowiki>
 [[M204.0314]]<nowiki> Insufficient access to update field </nowiki>
 [[M204.0315]]<nowiki> Insufficient access to add field </nowiki>
 [[M204.0316]]<nowiki> Recursive ON units exceed MAXOND: Evaluation stopped</nowiki>
 [[M204.0317]]<nowiki> USE $JOB or USE READER accepts no arguments</nowiki>
 [[M204.0318]]<nowiki> Invalid use of subscript</nowiki>
 [[M204.0319]]<nowiki> Invalid subscript syntax</nowiki>
 [[M204.0320]]<nowiki> Field is INVISIBLE: field = </nowiki>
 [[M204.0321]]<nowiki> Invalid cross-reference</nowiki>
 [[M204.0322]]<nowiki> Expected argument missing</nowiki>
 [[M204.0323]]<nowiki> Invalid use of %variable</nowiki>
 [[M204.0324]]<nowiki> Screen, menu, or image name not defined: </nowiki>
 [[M204.0325]]<nowiki> Only 32767 items allowed per screen panel</nowiki>
 [[M204.0326]]<nowiki> Colon not allowed in screen, menu, or image name</nowiki>
 [[M204.0327]]<nowiki> Duplicate screen, menu, or image name: </nowiki>
 [[M204.0328]]<nowiki> Duplicate input/prompt name: </nowiki>
 [[M204.0329]]<nowiki> Screen or image item name not found: </nowiki>
 [[M204.0330]]<nowiki> Bug .. full screen item name</nowiki>
 [[M204.0331]]<nowiki> POLLNO must start at 1 and ascend</nowiki>
 [[M204.0333]]<nowiki> Parameter too long: </nowiki>
 [[M204.0334]]<nowiki> LOUTPB > PAGESIZE minus 40; NBKPG will be reset to zero</nowiki>
 [[M204.0335]]<nowiki> LOUTPB parameter too small</nowiki>
 [[M204.0337]]<nowiki> Wrong version for CCASTAT - </nowiki>
 [[M204.0338]]<nowiki> Incorrect format for CCASTAT</nowiki>
 [[M204.0340]]<nowiki> Unable to open CCASTAT</nowiki>
 [[M204.0343]]<nowiki> Change applies only to this run, updates to CCASTAT not allowed</nowiki>
 [[M204.0346]]<nowiki> Restart during update, CCASTAT updates disallowed</nowiki>
 [[M204.0348]]<nowiki> System shutdown in progress, logins not allowed</nowiki>
 [[M204.0349]]<nowiki> </nowiki>
 [[M204.0351]]<nowiki> New password rejected</nowiki>
 [[M204.0355]]<nowiki> Invalid keyword: </nowiki>
 [[M204.0356]]<nowiki> Password may not be changed</nowiki>
 [[M204.0359]]<nowiki> Invalid password</nowiki>
 [[M204.0360]]<nowiki> Terminal security violation - </nowiki>
 [[M204.0361]]<nowiki> Password table not in core, file not secured</nowiki>
 [[M204.0363]]<nowiki> is not secured, command ignored</nowiki>
 [[M204.0364]]<nowiki> Password table has been corrupted - notify system manager</nowiki>
 [[M204.0365]]<nowiki> Argument too long</nowiki>
 [[M204.0366]]<nowiki> LOGCTL or LOGIN command being processed, try again</nowiki>
 [[M204.0368]]<nowiki> New key rejected</nowiki>
 [[M204.0369]]<nowiki> Password table not in core</nowiki>
 [[M204.0370]]<nowiki> Table in use, try again</nowiki>
 [[M204.0371]]<nowiki> Invalid LOGCTL syntax</nowiki>
 [[M204.0372]]<nowiki> Entry already exists</nowiki>
 [[M204.0373]]<nowiki> Entry not deleted</nowiki>
 [[M204.0375]]<nowiki> Entry not added/changed</nowiki>
 [[M204.0377]]<nowiki> Insufficient table space to process request</nowiki>
 [[M204.0378]]<nowiki> Specified entry not found</nowiki>
 [[M204.0380]]<nowiki> Invalid syntax for terminal list, all assumed</nowiki>
 [[M204.0381]]<nowiki> Expected address or offset</nowiki>
 [[M204.0382]]<nowiki> Expected file name</nowiki>
 [[M204.0383]]<nowiki> Invalid or missing page number</nowiki>
 [[M204.0384]]<nowiki> Expected offset</nowiki>
 [[M204.0385]]<nowiki> Invalid Model 204 program or table name</nowiki>
 [[M204.0386]]<nowiki> Program not linked in</nowiki>
 [[M204.0387]]<nowiki> *ZAP invalid syntax</nowiki>
 [[M204.0388]]<nowiki> File not open</nowiki>
 [[M204.0389]]<nowiki> exception occurred at </nowiki>
 [[M204.0392]]<nowiki> Invalid display option: </nowiki>
 [[M204.0394]]<nowiki> File not open: </nowiki>
 [[M204.0395]]<nowiki> Dynamic allocation failed</nowiki>
 [[M204.0396]]<nowiki> Invalid DISPLAY FIELD option</nowiki>
 [[M204.0397]]<nowiki> Must specify name list or "all"</nowiki>
 [[M204.0399]]<nowiki> Record description unavailable for </nowiki>
 [[M204.0400]]<nowiki> Unable to allocate sufficient storage to perform concatenation on data set</nowiki>
 [[M204.0401]]<nowiki> Non-positive length detected on journal entry</nowiki>
 [[M204.0402]]<nowiki> No preallocated fields in </nowiki>
 [[M204.0403]]<nowiki> Invalid option list</nowiki>
 [[M204.0404]]<nowiki> Bug .. display record</nowiki>
 [[M204.0405]]<nowiki> Invalid DEFINE option: </nowiki>
 [[M204.0406]]<nowiki> Redundant specification: </nowiki>
 [[M204.0407]]<nowiki> Invalid REDEFINE attribute: </nowiki>
 [[M204.0408]]<nowiki> OCCURS must be between 1 and 255</nowiki>
 [[M204.0409]]<nowiki> LENGTH must be between 1 and 255</nowiki>
 [[M204.0410]]<nowiki> Invalid use of FEW-VALUED or MANY-VALUED</nowiki>
 [[M204.0411]]<nowiki> Conflicting attributes: </nowiki>
 [[M204.0412]]<nowiki> Record security override required</nowiki>
 [[M204.0413]]<nowiki> FEW-VALUED field rejected because FVFPG=0</nowiki>
 [[M204.0414]]<nowiki> Invalid RENAME syntax</nowiki>
 [[M204.0415]]<nowiki> Only VISIBLE or ORDERED fields can be renamed</nowiki>
 [[M204.0416]]<nowiki> New name already exists</nowiki>
 [[M204.0417]]<nowiki> Cannot delete sort/hash key field</nowiki>
 [[M204.0418]]<nowiki> Cannot delete record security field</nowiki>
 [[M204.0419]]<nowiki> Invalid REDEFINE syntax</nowiki>
 [[M204.0420]]<nowiki> MANY-VALUED field rejected because MVFPG=0</nowiki>
 [[M204.0421]]<nowiki> Dictionary page full, can't extend</nowiki>
 [[M204.0423]]<nowiki> Range field occurs more than once in record </nowiki>
 [[M204.0425]]<nowiki> DP parameter must be positive</nowiki>
 [[M204.0427]]<nowiki> Insufficient getvis storage to locate the label for </nowiki>
 [[M204.0428]]<nowiki> Data set resides on DOS device type which is not currently supported</nowiki>
 [[M204.0429]]<nowiki> # of private buffers required GT # allocated for current M204 session: </nowiki>
 [[M204.0432]]<nowiki> Unable to login user for subsystem </nowiki>
 [[M204.0433]]<nowiki> No procedures selected for subsystem </nowiki>
 [[M204.0436]]<nowiki> Unable to allocate PD for subsystem </nowiki>
 [[M204.0437]]<nowiki> Bug .. APSY PD empty for subsystem </nowiki>
 [[M204.0438]]<nowiki> Unable to run subsystem initialization procedure - </nowiki>
 [[M204.0442]]<nowiki> Unable to run subsystem login procedure - GTBL full, LGTBL=</nowiki>
 [[M204.0444]]<nowiki> Subsystem must be stopped for test option</nowiki>
 [[M204.0445]]<nowiki> Not enough chunks in Table D in </nowiki>
 [[M204.0446]]<nowiki> temporarily disabled</nowiki>
 [[M204.0448]]<nowiki> Subsystem test in progress, command rejected</nowiki>
 [[M204.0449]]<nowiki> Invalid argument to $chktag or $chkmod</nowiki>
 [[M204.0451]]<nowiki> DKFUB .. page was being modified in </nowiki>
 [[M204.0453]]<nowiki> No DD card for file </nowiki>
 [[M204.0454]]<nowiki> Unable to open file dataset </nowiki>
 [[M204.0455]]<nowiki> Insufficient SPCORE</nowiki>
 [[M204.0456]]<nowiki> Illegal PAGESZ parameter, file: </nowiki>
 [[M204.0457]]<nowiki> Unit type incompatible with page size, file: </nowiki>
 [[M204.0458]]<nowiki> Bug .. dead subtask</nowiki>
 [[M204.0459]]<nowiki> Resource locking table full. Subsystem needs entries</nowiki>
 [[M204.0465]]<nowiki> I/O error formatting extent</nowiki>
 [[M204.0466]]<nowiki> Login violation by userid </nowiki>
 [[M204.0469]]<nowiki> One subsystem () cannot invoke another ()</nowiki>
 [[M204.0470]]<nowiki> Error opening file </nowiki>
 [[M204.0471]]<nowiki> Invalid EOD option, , ON assumed</nowiki>
 [[M204.0472]]<nowiki> not available</nowiki>
 [[M204.0473]]<nowiki> Unable to initialize </nowiki>
 [[M204.0475]]<nowiki> Close failed for file </nowiki>
 [[M204.0476]]<nowiki> DP * only valid with string</nowiki>
 [[M204.0482]]<nowiki> unused </nowiki>
 [[M204.0483]]<nowiki> unused </nowiki>
 [[M204.0484]]<nowiki> unused </nowiki>
 [[M204.0485]]<nowiki> unused </nowiki>
 [[M204.0486]]<nowiki> unused </nowiki>
 [[M204.0487]]<nowiki> unused </nowiki>
 [[M204.0488]]<nowiki> unused </nowiki>
 [[M204.0489]]<nowiki> unused </nowiki>
 [[M204.0491]]<nowiki> unused </nowiki>
 [[M204.0492]]<nowiki> unused </nowiki>
 [[M204.0493]]<nowiki> $unbin argument not 2 or 4 characters</nowiki>
 [[M204.0494]]<nowiki> FLOAT LENGTH must be 4, 8 or 16</nowiki>
 [[M204.0495]]<nowiki> Screen option requires terminal option within a procedure</nowiki>
 [[M204.0496]]<nowiki> Screen option requires a full screen terminal</nowiki>
 [[M204.0498]]<nowiki> Transaction backout files must be updated without accessing non-TBO files</nowiki>
 [[M204.0499]]<nowiki> File not freed: </nowiki>
 [[M204.0501]]<nowiki> MODEL parameter invalid: </nowiki>
 [[M204.0502]]<nowiki> unused </nowiki>
 [[M204.0503]]<nowiki> unused </nowiki>
 [[M204.0504]]<nowiki> unused </nowiki>
 [[M204.0505]]<nowiki> unused </nowiki>
 [[M204.0506]]<nowiki> unused </nowiki>
 [[M204.0507]]<nowiki> unused </nowiki>
 [[M204.0508]]<nowiki> unused </nowiki>
 [[M204.0511]]<nowiki> unused </nowiki>
 [[M204.0512]]<nowiki> unused </nowiki>
 [[M204.0514]]<nowiki> unused </nowiki>
 [[M204.0515]]<nowiki> unused </nowiki>
 [[M204.0516]]<nowiki> unused </nowiki>
 [[M204.0517]]<nowiki> VTAM input exception, user is restarted</nowiki>
 [[M204.0518]]<nowiki> unused </nowiki>
 [[M204.0519]]<nowiki> unused </nowiki>
 [[M204.0520]]<nowiki> unused </nowiki>
 [[M204.0521]]<nowiki> unused </nowiki>
 [[M204.0522]]<nowiki> unused </nowiki>
 [[M204.0523]]<nowiki> unused </nowiki>
 [[M204.0524]]<nowiki> Maximum number () of exceeded</nowiki>
 [[M204.0525]]<nowiki> Warning: can't edit into procedure</nowiki>
 [[M204.0527]]<nowiki> Rest of line ignored, invalid operation = </nowiki>
 [[M204.0528]]<nowiki> Rest of line ignored. Cancelled operation = </nowiki>
 [[M204.0529]]<nowiki> Not found; will ignore rest of line</nowiki>
 [[M204.0530]]<nowiki> Procedure name too long, rest of line ignored</nowiki>
 [[M204.0531]]<nowiki> Procedure name syntax error, rest of line ignored</nowiki>
 [[M204.0532]]<nowiki> Invalid previous request number</nowiki>
 [[M204.0534]]<nowiki> Nested iteration not allowed</nowiki>
 [[M204.0535]]<nowiki> Iteration string exceeds 256 characters</nowiki>
 [[M204.0536]]<nowiki> Skipping to next ')'</nowiki>
 [[M204.0537]]<nowiki> Positive iteration count required, count = </nowiki>
 [[M204.0538]]<nowiki> unused </nowiki>
 [[M204.0539]]<nowiki> Can't edit into procedure</nowiki>
 [[M204.0540]]<nowiki> Bug .. edit, enq chain</nowiki>
 [[M204.0541]]<nowiki> Procedure is in use: </nowiki>
 [[M204.0543]]<nowiki> Warning: procedure can't COPY into itself; </nowiki>
 [[M204.0544]]<nowiki> Ignoring 256 characters. Delimiter=</nowiki>
 [[M204.0545]]<nowiki> Space not allowed as delimiter</nowiki>
 [[M204.0546]]<nowiki> Procedure not defined</nowiki>
 [[M204.0547]]<nowiki> Procedure line too long</nowiki>
 [[M204.0548]]<nowiki> - cannot modify procedure dictionary</nowiki>
 [[M204.0549]]<nowiki> Cannot define new procedure </nowiki>
 [[M204.0551]]<nowiki> Request too long -- STBL, LSTBL=</nowiki>
 [[M204.0552]]<nowiki> Variable too small for result</nowiki>
 [[M204.0553]]<nowiki> Subscript range error for </nowiki>
 [[M204.0554]]<nowiki> Divide by zero</nowiki>
 [[M204.0557]]<nowiki> File Records Under requires either an INVISIBLE,KEY or INVISIBLE,ORDERED field: field = </nowiki>
 [[M204.0558]]<nowiki> $setl not allowed for full screen device</nowiki>
 [[M204.0559]]<nowiki> Updating sort key: field = </nowiki>
 [[M204.0560]]<nowiki> INVISIBLE field: field = </nowiki>
 [[M204.0561]]<nowiki> Value non-numerical: value = </nowiki>
 [[M204.0562]]<nowiki> Request too long - </nowiki>
 [[M204.0563]]<nowiki> Arithmetic overflow</nowiki>
 [[M204.0564]]<nowiki> Connection to user lost (phone was hung up)</nowiki>
 [[M204.0565]]<nowiki> Can't process on - VTBL full, LVTBL=</nowiki>
 [[M204.0567]]<nowiki> Insufficient CCATEMP space to process command</nowiki>
 [[M204.0568]]<nowiki> unused </nowiki>
 [[M204.0570]]<nowiki> NON-FRV, NON-ORDERED field: field = </nowiki>
 [[M204.0571]]<nowiki> Point$ argument syntax error</nowiki>
 [[M204.0572]]<nowiki> New value null, pad, or too long for </nowiki>
 [[M204.0574]]<nowiki> Request too long -- VTBL, LVTBL=</nowiki>
 [[M204.0575]]<nowiki> unused </nowiki>
 [[M204.0576]]<nowiki> unused </nowiki>
 [[M204.0577]]<nowiki> QTBL full, LQTBL= -- direct search</nowiki>
 [[M204.0578]]<nowiki> Too many call levels - VTBL, LVTBL=</nowiki>
 [[M204.0579]]<nowiki> Cannot return - empty stack</nowiki>
 [[M204.0580]]<nowiki> Bug .. SOR</nowiki>
 [[M204.0584]]<nowiki> File is in use: </nowiki>
 [[M204.0585]]<nowiki> Shared dasd enq list overlaid for </nowiki>
 [[M204.0586]]<nowiki> ENQCTL not allowed during roll back</nowiki>
 [[M204.0587]]<nowiki> ENQCTL invalid argument - </nowiki>
 [[M204.0589]]<nowiki> Command requires z/OS or CMS environment</nowiki>
 [[M204.0591]]<nowiki> Share dasd enq list full for </nowiki>
 [[M204.0592]]<nowiki> Invalid string type specification</nowiki>
 [[M204.0593]]<nowiki> Invalid file name: </nowiki>
 [[M204.0594]]<nowiki> DP is invalid with pure DBCS</nowiki>
 [[M204.0595]]<nowiki> Undeclared variables are not permitted with the Undefined option</nowiki>
 [[M204.0596]]<nowiki> unused </nowiki>
 [[M204.0597]]<nowiki> In Order clause is invalid against sorted set</nowiki>
 [[M204.0598]]<nowiki> FREE failed - </nowiki>
 [[M204.0599]]<nowiki> There is no current default string length</nowiki>
 [[M204.0600]]<nowiki> unused </nowiki>
 [[M204.0601]]<nowiki> unused </nowiki>
 [[M204.0602]]<nowiki> File is in use</nowiki>
 [[M204.0603]]<nowiki> No default file/group</nowiki>
 [[M204.0605]]<nowiki> unused </nowiki>
 [[M204.0606]]<nowiki> File is member of open temp group - not </nowiki>
 [[M204.0607]]<nowiki> Active procedure file not closed - </nowiki>
 [[M204.0609]]<nowiki> must be transformed using a release of Model 204 prior to 8.0</nowiki>
 [[M204.0610]]<nowiki> File directory is full</nowiki>
 [[M204.0611]]<nowiki> All file DCB's are in use</nowiki>
 [[M204.0612]]<nowiki> No opens allowed during roll back</nowiki>
 [[M204.0613]]<nowiki> Group not found; open rejected</nowiki>
 [[M204.0614]]<nowiki> Argument missing</nowiki>
 [[M204.0616]]<nowiki> Tag must refer to input item: </nowiki>
 [[M204.0617]]<nowiki> Checkpoint required to update </nowiki>
 [[M204.0618]]<nowiki> Roll forward logging required to update </nowiki>
 [[M204.0629]]<nowiki> FLIO not linked in</nowiki>
 [[M204.0630]]<nowiki> command rejected</nowiki>
 [[M204.0631]]<nowiki> Maximum number of files open already</nowiki>
 [[M204.0632]]<nowiki> unused </nowiki>
 [[M204.0633]]<nowiki> Dataset incorrectly DUMP/RESTORED, file: </nowiki>
 [[M204.0634]]<nowiki> Trouble with disk I/O, possible incorrect DD card, file="" </nowiki>
 [[M204.0635]]<nowiki> Reserved prefix used</nowiki>
 [[M204.0636]]<nowiki> File security violation</nowiki>
 [[M204.0637]]<nowiki> No room for record description</nowiki>
 [[M204.0642]]<nowiki> Invalid TABLEB option</nowiki>
 [[M204.0643]]<nowiki> An operand is invalid or missing</nowiki>
 [[M204.0644]]<nowiki> Invalid operand following first number</nowiki>
 [[M204.0645]]<nowiki> Page numbers in wrong order</nowiki>
 [[M204.0646]]<nowiki> is not a sorted file</nowiki>
 [[M204.0647]]<nowiki> Bug .. TABLEB</nowiki>
 [[M204.0648]]<nowiki> Too many specified options</nowiki>
 [[M204.0649]]<nowiki> Page number must be positive</nowiki>
 [[M204.0650]]<nowiki> Page number specified is too small</nowiki>
 [[M204.0651]]<nowiki> Page number specified is too big</nowiki>
 [[M204.0652]]<nowiki> Deferred update ddName must start with "TAPE"</nowiki>
 [[M204.0653]]<nowiki> Can't open deferred update dataset: </nowiki>
 [[M204.0654]]<nowiki> Insufficient core for deferred update dataset: </nowiki>
 [[M204.0655]]<nowiki> Can't reposition deferred update dataset: </nowiki>
 [[M204.0658]]<nowiki> Trouble with deferred update I/O: </nowiki>
 [[M204.0662]]<nowiki> Can't defer updates, FLOD aborted</nowiki>
 [[M204.0663]]<nowiki> unused </nowiki>
 [[M204.0666]]<nowiki> unused </nowiki>
 [[M204.0668]]<nowiki> Invalid EDIT option: </nowiki>
 [[M204.0669]]<nowiki> Server initialization error: $status= $statusd=</nowiki>
 [[M204.0673]]<nowiki> Error procedure not defined or cancelled in subsys - error code: </nowiki>
 [[M204.0675]]<nowiki> Record description unavailable</nowiki>
 [[M204.0676]]<nowiki> does not have privilege on .</nowiki>
 [[M204.0677]]<nowiki> Bad line -- ignored</nowiki>
 [[M204.0678]]<nowiki> Duplicate tag -- ignored</nowiki>
 [[M204.0679]]<nowiki> Implied decimal position invalid</nowiki>
 [[M204.0680]]<nowiki> Nesting level too deep</nowiki>
 [[M204.0681]]<nowiki> Too many ENDL's</nowiki>
 [[M204.0686]]<nowiki> Expected SQL evaluation stack exceeded - increase SQLIQBSZ</nowiki>
 [[M204.0687]]<nowiki> All devices in use</nowiki>
 [[M204.0690]]<nowiki> Null field name -- executing D command</nowiki>
 [[M204.0692]]<nowiki> Tag number = </nowiki>
 [[M204.0695]]<nowiki> Invalid binary input</nowiki>
 [[M204.0696]]<nowiki> Decimal point position invalid, not inserted</nowiki>
 [[M204.0706]]<nowiki> Command requires operation in a virtual machine</nowiki>
 [[M204.0708]]<nowiki> Return code from was </nowiki>
 [[M204.0710]]<nowiki> Too many occurrences in recnum=, field=</nowiki>
 [[M204.0711]]<nowiki> Incompressible value in recnum=, field=</nowiki>
 [[M204.0712]]<nowiki> Value too long in recnum=, field=</nowiki>
 [[M204.0713]]<nowiki> End of line -- rcode</nowiki>
 [[M204.0714]]<nowiki> Bad tag or index number</nowiki>
 [[M204.0715]]<nowiki> Invalid command format</nowiki>
 [[M204.0716]]<nowiki> Invalid userID</nowiki>
 [[M204.0717]]<nowiki> Invalid file specification</nowiki>
 [[M204.0718]]<nowiki> Invalid user number specified</nowiki>
 [[M204.0721]]<nowiki> Case command has over 25 entries</nowiki>
 [[M204.0722]]<nowiki> Repeating range field prohibited</nowiki>
 [[M204.0723]]<nowiki> Function not defined</nowiki>
 [[M204.0724]]<nowiki> Communication error - SENSE = </nowiki>
 [[M204.0725]]<nowiki> Too many arguments</nowiki>
 [[M204.0726]]<nowiki> Function not linked in</nowiki>
 [[M204.0727]]<nowiki> Invalid function syntax</nowiki>
 [[M204.0728]]<nowiki> Function must be inside For loop</nowiki>
 [[M204.0729]]<nowiki> Function must be in file context</nowiki>
 [[M204.0730]]<nowiki> String too long</nowiki>
 [[M204.0731]]<nowiki> $unfloat argument not 4 or 8 characters</nowiki>
 [[M204.0732]]<nowiki> Format error</nowiki>
 [[M204.0733]]<nowiki> $encrypt parameter not a positive integer</nowiki>
 [[M204.0734]]<nowiki> Global value is not numeric - $incrg</nowiki>
 [[M204.0735]]<nowiki> No room for new value of global - $incrg, LGTBL=</nowiki>
 [[M204.0736]]<nowiki> Invalid value count</nowiki>
 [[M204.0737]]<nowiki> Undefined %variable</nowiki>
 [[M204.0738]]<nowiki> Value too long - truncation occurred</nowiki>
 [[M204.0739]]<nowiki> Too many values given</nowiki>
 [[M204.0740]]<nowiki> $jobcode argument not in the range 0 to 4095</nowiki>
 [[M204.0741]]<nowiki> Invalid access string - </nowiki>
 [[M204.0742]]<nowiki> Invalid context specification: </nowiki>
 [[M204.0743]]<nowiki> Invalid second argument to $round</nowiki>
 [[M204.0744]]<nowiki> Fortran routines weren't linked in</nowiki>
 [[M204.0745]]<nowiki> Negative argument to $sqrt, return 0</nowiki>
 [[M204.0746]]<nowiki> Argument 2 to $arctan2 was 0, return 0</nowiki>
 [[M204.0747]]<nowiki> Argument too big for trig functions, return 0</nowiki>
 [[M204.0748]]<nowiki> Argument too big for $ixpi,return 0</nowiki>
 [[M204.0749]]<nowiki> Invalid arguments to $rxpi or $ixpi, return 0</nowiki>
 [[M204.0750]]<nowiki> Invalid arguments to $rxpr, return 0</nowiki>
 [[M204.0751]]<nowiki> Invalid argument to $log or $log10, return 0</nowiki>
 [[M204.0752]]<nowiki> Exponent too large for $exp, return 0</nowiki>
 [[M204.0753]]<nowiki> $sinh or $cosh argument invalid, return 0</nowiki>
 [[M204.0754]]<nowiki> Bad argument to $gamma, return 0</nowiki>
 [[M204.0755]]<nowiki> Bad argument to $lgamma, return 0</nowiki>
 [[M204.0756]]<nowiki> No code tables defined</nowiki>
 [[M204.0757]]<nowiki> Invalid code table identifier = </nowiki>
 [[M204.0758]]<nowiki> Insufficient storage for message</nowiki>
 [[M204.0759]]<nowiki> Sort work DD card, CCA2WK01, missing</nowiki>
 [[M204.0760]]<nowiki> Sort return codes - sort 1: , sort 2: </nowiki>
 [[M204.0761]]<nowiki> ATRPG*ASTRPPG exceeds </nowiki>
 [[M204.0762]]<nowiki> Unnecessary sort/hash key ignored</nowiki>
 [[M204.0766]]<nowiki> Type of key expected, not: </nowiki>
 [[M204.0767]]<nowiki> Unnecessary sort/hash key rejected</nowiki>
 [[M204.0768]]<nowiki> Unnecessary record security key rejected</nowiki>
 [[M204.0769]]<nowiki> File option not allowed from operator</nowiki>
 [[M204.0770]]<nowiki> Broadcast message not present</nowiki>
 [[M204.0771]]<nowiki> "=" expected after field name</nowiki>
 [[M204.0772]]<nowiki> "(" expected after field name</nowiki>
 [[M204.0773]]<nowiki> name required</nowiki>
 [[M204.0774]]<nowiki> No creates allowed during roll back</nowiki>
 [[M204.0775]]<nowiki> No name given</nowiki>
 [[M204.0776]]<nowiki> is an invalid option</nowiki>
 [[M204.0777]]<nowiki> Reserved name used</nowiki>
 [[M204.0778]]<nowiki> Device not defined</nowiki>
 [[M204.0779]]<nowiki> Invalid DBCS data encountered</nowiki>
 [[M204.0780]]<nowiki> File already in use</nowiki>
 [[M204.0781]]<nowiki> No FILESAVE areas available</nowiki>
 [[M204.0783]]<nowiki> Incorrect ddName list</nowiki>
 [[M204.0784]]<nowiki> First ddName is not file name</nowiki>
 [[M204.0785]]<nowiki> Duplicate ddNames</nowiki>
 [[M204.0786]]<nowiki> Specified user not active: </nowiki>
 [[M204.0788]]<nowiki> Invalid parameter card</nowiki>
 [[M204.0789]]<nowiki> Sorted file parameters ignored</nowiki>
 [[M204.0790]]<nowiki> File too big</nowiki>
 [[M204.0791]]<nowiki> An even length is required for pure DBCS</nowiki>
 [[M204.0792]]<nowiki> Total table size too large</nowiki>
 [[M204.0793]]<nowiki> I/O error forced formatting</nowiki>
 [[M204.0795]]<nowiki> Data type must be reset</nowiki>
 [[M204.0796]]<nowiki> ASIZE cannot exceed 16777216</nowiki>
 [[M204.0797]]<nowiki> BSIZE*BRECPPG exceeds maximum value</nowiki>
 [[M204.0798]]<nowiki> File allocation not permitted during roll back pass 1</nowiki>
 [[M204.0799]]<nowiki> I/O error while formatting extent</nowiki>
 [[M204.0800]]<nowiki> Mixed DBCS screen items not supported on this device</nowiki>
 [[M204.0801]]<nowiki> CREATE command rejected</nowiki>
 [[M204.0802]]<nowiki> Direct file hash key feature used</nowiki>
 [[M204.0803]]<nowiki> Invalid INCREASE amount</nowiki>
 [[M204.0804]]<nowiki> Not enough free space</nowiki>
 [[M204.0805]]<nowiki> INCREASE makes file too big</nowiki>
 [[M204.0806]]<nowiki> ENQCTL invalid argument - </nowiki>
 [[M204.0808]]<nowiki> No ddNames given</nowiki>
 [[M204.0810]]<nowiki> Invalid command format</nowiki>
 [[M204.0812]]<nowiki> INCREASE command rejected</nowiki>
 [[M204.0813]]<nowiki> Printer SVC is not installed</nowiki>
 [[M204.0814]]<nowiki> Invalid DECREASE amount</nowiki>
 [[M204.0815]]<nowiki> Not enough room in table</nowiki>
 [[M204.0816]]<nowiki> INITIALIZE rejected for file with active procedure</nowiki>
 [[M204.0818]]<nowiki> DECREASE command rejected</nowiki>
 [[M204.0819]]<nowiki> FTBL full, LFTBL= .. can't add GFT entry</nowiki>
 [[M204.0820]]<nowiki> In sorted files BPGPMSTR and BPGPOVFL must be between 1 and 32767</nowiki>
 [[M204.0822]]<nowiki> Can't close group because of active procedure</nowiki>
 [[M204.0823]]<nowiki> has been defined as a stream - streams are not currently supported by this function</nowiki>
 [[M204.0824]]<nowiki> Permanent groups not available</nowiki>
 [[M204.0826]]<nowiki> Invalid parameter line, command rejected</nowiki>
 [[M204.0827]]<nowiki> Invalid parameter, command rejected: </nowiki>
 [[M204.0829]]<nowiki> Group is in use</nowiki>
 [[M204.0831]]<nowiki> Missing FROM clause, CREATE rejected</nowiki>
 [[M204.0832]]<nowiki> Too many files, CREATE rejected</nowiki>
 [[M204.0833]]<nowiki> Duplicate files "" : rejected</nowiki>
 [[M204.0834]]<nowiki> Update file must be group member</nowiki>
 [[M204.0835]]<nowiki> not allocated</nowiki>
 [[M204.0836]]<nowiki> CCAGRP already exists</nowiki>
 [[M204.0838]]<nowiki> VTAM interface has been closed forever</nowiki>
 [[M204.0839]]<nowiki> CCAGRP dataset too small</nowiki>
 [[M204.0840]]<nowiki> Disk I/O error while formatting</nowiki>
 [[M204.0841]]<nowiki> Bug .. CCAGRP already in directory</nowiki>
 [[M204.0842]]<nowiki> CREATEG command rejected</nowiki>
 [[M204.0845]]<nowiki> Updates not allowed during recovery</nowiki>
 [[M204.0846]]<nowiki> Group is in use</nowiki>
 [[M204.0847]]<nowiki> Close group before deleting</nowiki>
 [[M204.0849]]<nowiki> Group not found: </nowiki>
 [[M204.0850]]<nowiki> Bug .. FSPUT - output page buffer overflow</nowiki>
 [[M204.0853]]<nowiki> Invalid DISPLAY option</nowiki>
 [[M204.0854]]<nowiki> Procedure cannot redefine included procedure</nowiki>
 [[M204.0856]]<nowiki> Undefined group name ignored: </nowiki>
 [[M204.0857]]<nowiki> Group left open with old privileges</nowiki>
 [[M204.0860]]<nowiki> Open group limit (NGROUP) exceeded</nowiki>
 [[M204.0861]]<nowiki> FTBL full, LFTBL= can't open group</nowiki>
 [[M204.0863]]<nowiki> Group open failed, files left open</nowiki>
 [[M204.0864]]<nowiki> Group open failed, closing partial group</nowiki>
 [[M204.0868]]<nowiki> Group already exists</nowiki>
 [[M204.0870]]<nowiki> Current function not allowed with sorted record/set</nowiki>
 [[M204.0875]]<nowiki> Compilation name required</nowiki>
 [[M204.0879]]<nowiki> Wrong compilation type</nowiki>
 [[M204.0890]]<nowiki> Syntax error: </nowiki>
 [[M204.0896]]<nowiki> Invalid parameter</nowiki>
 [[M204.0897]]<nowiki> IFEPRM - result too long</nowiki>
 [[M204.0903]]<nowiki> - result too long</nowiki>
 [[M204.0904]]<nowiki> EDIT_SPEC syntax error</nowiki>
 [[M204.0905]]<nowiki> Value too long for STBL, LSTBL=</nowiki>
 [[M204.0906]]<nowiki> Unknown specification type</nowiki>
 [[M204.0907]]<nowiki> IFAM job too long -- QTBL, LQTBL=</nowiki>
 [[M204.0908]]<nowiki> Name list syntax error</nowiki>
 [[M204.0909]]<nowiki> Argument passed to $SETL is out of range: value = </nowiki>
 [[M204.0910]]<nowiki> Illegal subscript</nowiki>
 [[M204.0911]]<nowiki> Field or variable name list too long - QTBL, LQTBL=</nowiki>
 [[M204.0912]]<nowiki> Extra )</nowiki>
 [[M204.0915]]<nowiki> Upcase is invalid with DBCS data types</nowiki>
 [[M204.0916]]<nowiki> IFAM job too long -- VTBL, LVTBL=</nowiki>
 [[M204.0917]]<nowiki> IFAM job too long -- NTBL, LNTBL=</nowiki>
 [[M204.0918]]<nowiki> Undefined compilation</nowiki>
 [[M204.0919]]<nowiki> $enter fixed point value incorrect</nowiki>
 [[M204.0920]]<nowiki> Value or name list syntax error</nowiki>
 [[M204.0921]]<nowiki> No message specified</nowiki>
 [[M204.0922]]<nowiki> Invalid language code</nowiki>
 [[M204.0923]]<nowiki> Invalid string argument</nowiki>
 [[M204.0925]]<nowiki> Function requires file context</nowiki>
 [[M204.0926]]<nowiki> Function requires file manager privilege</nowiki>
 [[M204.0928]]<nowiki> IFDFLD requires file context</nowiki>
 [[M204.0930]]<nowiki> Requires subsystem command privilege</nowiki>
 [[M204.0931]]<nowiki> Unable to allocate subsystem control block</nowiki>
 [[M204.0933]]<nowiki> Unexpected end-of-procedure during request compilation. Type 'END NORUN' to cancel.</nowiki>
 [[M204.0934]]<nowiki> Procedure tried to define procedure but failed</nowiki>
 [[M204.0939]]<nowiki> = required, not </nowiki>
 [[M204.0943]]<nowiki> Syntax error -- IFFILE</nowiki>
 [[M204.0944]]<nowiki> Nonexistent record referenced in </nowiki>
 [[M204.0945]]<nowiki> Record security violation</nowiki>
 [[M204.0946]]<nowiki> Invalid file specification</nowiki>
 [[M204.0947]]<nowiki> No current record</nowiki>
 [[M204.0948]]<nowiki> Max Pfkey must be greater than 0</nowiki>
 [[M204.0949]]<nowiki> Duplicate Max Pfkey rejected</nowiki>
 [[M204.0950]]<nowiki> At Column + Len must not exceed </nowiki>
 [[M204.0951]]<nowiki> Undefined field </nowiki>
 [[M204.0952]]<nowiki> Specified access not allowed for field </nowiki>
 [[M204.0953]]<nowiki> Invalid access string </nowiki>
 [[M204.0956]]<nowiki> Serious CRAM error, thread halted: error code = </nowiki>
 [[M204.0959]]<nowiki> Release 5 IFIF, call rejected for: </nowiki>
 [[M204.0960]]<nowiki> Apparent restart loop, thread halted after </nowiki>
 [[M204.0967]]<nowiki> Can't ask for a checkpoint without a wait</nowiki>
 [[M204.0972]]<nowiki> IFAM2 master ICB not open</nowiki>
 [[M204.0973]]<nowiki> IFAM2 not drained, IFAMCLOSE not allowed</nowiki>
 [[M204.0974]]<nowiki> IFAM2 not initialized in this run</nowiki>
 [[M204.0975]]<nowiki> IFAM2 not active</nowiki>
 [[M204.0976]]<nowiki> IFAM2 drained</nowiki>
 [[M204.0977]]<nowiki> IFAM2 drain in progress, active threads= </nowiki>
 [[M204.0978]]<nowiki> Invalid channel type - </nowiki>
 [[M204.0979]]<nowiki> No threads are active</nowiki>
 [[M204.0980]]<nowiki> Invalid thread number- </nowiki>
 [[M204.0981]]<nowiki> Specified thread is not active - </nowiki>
 [[M204.0982]]<nowiki> No threads defined for IFAM2 channel </nowiki>
 [[M204.0983]]<nowiki> IFAM2 already halted</nowiki>
 [[M204.0984]]<nowiki> Conflicting attribute rejected: </nowiki>
 [[M204.0985]]<nowiki> Thread halted, or halt pending - </nowiki>
 [[M204.0986]]<nowiki> Default cursor column must be between 1 and 80</nowiki>
 [[M204.0987]]<nowiki> IFAM2 master icb not closed</nowiki>
 [[M204.0988]]<nowiki> Default cursor row must be between 1 and end of screen</nowiki>
 [[M204.0989]]<nowiki> IFAM2 master ICB not open, IFAMSTART impossible</nowiki>
 [[M204.0990]]<nowiki> Thread not started, halted due to restart loop - </nowiki>
 [[M204.0991]]<nowiki> Else incorrectly paired with If</nowiki>
 [[M204.0992]]<nowiki> , float transform already completed, command ignored</nowiki>
 [[M204.0996]]<nowiki> Bug .. sick record found by transform</nowiki>
 [[M204.0997]]<nowiki> Duplicate default cursor options rejected</nowiki>
 [[M204.0998]]<nowiki> Unable to enter the subsystem</nowiki>
 [[M204.0999]]<nowiki> Number %variable used for variable-name variable</nowiki>
 [[M204.1000]]<nowiki> Variable-name variable cannot be resolved: value = </nowiki>
 [[M204.1001]]<nowiki> Screen item variable required, not </nowiki>
 [[M204.1004]]<nowiki> Data inconsistent with EDIT_SPEC</nowiki>
 [[M204.1005]]<nowiki> Variable-name variable must resolve to screen item: value = </nowiki>
 [[M204.1006]]<nowiki> File must be defined with a dataset type of direct or sequential</nowiki>
 [[M204.1007]]<nowiki> DLBL statement for must specify direct access</nowiki>
 [[M204.1008]]<nowiki> LOUTPB must be increased to at least </nowiki>
 [[M204.1009]]<nowiki> Device support not linked in</nowiki>
 [[M204.1010]]<nowiki> Bug .. PUTL</nowiki>
 [[M204.1011]]<nowiki> Reading a printer</nowiki>
 [[M204.1012]]<nowiki> Writing a reader</nowiki>
 [[M204.1013]]<nowiki> Ejecting a reader</nowiki>
 [[M204.1014]]<nowiki> Output page buffer full</nowiki>
 [[M204.1015]]<nowiki> Bug .. full screen length</nowiki>
 [[M204.1016]]<nowiki> Bug .. PGOUT</nowiki>
 [[M204.1018]]<nowiki> Restart during initialization or termination</nowiki>
 [[M204.1019]]<nowiki> Restart during restart</nowiki>
 [[M204.1021]]<nowiki> PST restarted</nowiki>
 [[M204.1022]]<nowiki> User restarting </nowiki>
 [[M204.1023]]<nowiki> User suspended</nowiki>
 [[M204.1025]]<nowiki> support not linked in</nowiki>
 [[M204.1026]]<nowiki> Bug .. MAINCMDL</nowiki>
 [[M204.1027]]<nowiki> Time -- no more requests</nowiki>
 [[M204.1029]]<nowiki> User connection lost (phone was hung up)</nowiki>
 [[M204.1030]]<nowiki> Invalid Model 204 command</nowiki>
 [[M204.1031]]<nowiki> Please login</nowiki>
 [[M204.1032]]<nowiki> Default file or group needed</nowiki>
 [[M204.1033]]<nowiki> Invalid option with DBCS data type</nowiki>
 [[M204.1034]]<nowiki> Command requires file manager privilege</nowiki>
 [[M204.1035]]<nowiki> Command invalid from procedure</nowiki>
 [[M204.1036]]<nowiki> Updates not permitted</nowiki>
 [[M204.1037]]<nowiki> Command requires single file</nowiki>
 [[M204.1038]]<nowiki> Invalid print font specification</nowiki>
 [[M204.1039]]<nowiki> Feature not linked in</nowiki>
 [[M204.1040]]<nowiki> Run aborted</nowiki>
 [[M204.1041]]<nowiki> More is invalid -- ignored</nowiki>
 [[M204.1044]]<nowiki> Output set to normal</nowiki>
 [[M204.1045]]<nowiki> Request cancelled - unable to lock all records</nowiki>
 [[M204.1046]]<nowiki> Bug .. MACMPLX</nowiki>
 [[M204.1047]]<nowiki> is an invalid </nowiki>
 [[M204.1048]]<nowiki> Command invalid from terminals</nowiki>
 [[M204.1049]]<nowiki> command not supported</nowiki>
 [[M204.1054]]<nowiki> Print n fieldName invalid in this environment</nowiki>
 [[M204.1060]]<nowiki> not allowed with non swappable servers</nowiki>
 [[M204.1061]]<nowiki> There are no interface statistics to display</nowiki>
 [[M204.1062]]<nowiki> No name given, command rejected</nowiki>
 [[M204.1063]]<nowiki> File or group not open, command rejected</nowiki>
 [[M204.1065]]<nowiki> was not previously defined</nowiki>
 [[M204.1066]]<nowiki> not specified</nowiki>
 [[M204.1067]]<nowiki> Invalid specified</nowiki>
 [[M204.1068]]<nowiki> </nowiki>
 [[M204.1069]]<nowiki> ALLOCATE/FREE failed with return code , error reason code , information reason code , SMS reason code </nowiki>
 [[M204.1070]]<nowiki> ALLOCATE failed - </nowiki>
 [[M204.1077]]<nowiki> Reply = </nowiki>
 [[M204.1078]]<nowiki> Please reply "y" or "n"</nowiki>
 [[M204.1079]]<nowiki> 'end more' not supported for procs with DB2 statements</nowiki>
 [[M204.1081]]<nowiki> Message facility restart</nowiki>
 [[M204.1082]]<nowiki> Subtask was abended with abcode </nowiki>
 [[M204.1084]]<nowiki> Broadcast message not present</nowiki>
 [[M204.1085]]<nowiki> Insufficient storage for </nowiki>
 [[M204.1086]]<nowiki> Itemid not found: </nowiki>
 [[M204.1087]]<nowiki> Command requires open file</nowiki>
 [[M204.1088]]<nowiki> and are mutually exclusive options</nowiki>
 [[M204.1089]]<nowiki> Message too long for file broadcast</nowiki>
 [[M204.1090]]<nowiki> Default cursor item name not found</nowiki>
 [[M204.1091]]<nowiki> Invalid user ID</nowiki>
 [[M204.1092]]<nowiki> Invalid user number specified</nowiki>
 [[M204.1093]]<nowiki> Sorry, that command is not allowed for a Model 204 system dataset.</nowiki>
 [[M204.1095]]<nowiki> "" is invalid - specify "on" or "off"</nowiki>
 [[M204.1097]]<nowiki> No message specified</nowiki>
 [[M204.1098]]<nowiki> Specified user not active: </nowiki>
 [[M204.1100]]<nowiki> Horizon transport error -- process=, remoteid=, @SESD=</nowiki>
 [[M204.1101]]<nowiki> Unexpected receipt -- rh=, ru=...</nowiki>
 [[M204.1105]]<nowiki> ONINIT -- Online monitor needs statistics module STAT</nowiki>
 [[M204.1106]]<nowiki> ONINIT -- too few pseudo subtasks</nowiki>
 [[M204.1107]]<nowiki> No statistics in run - MONITOR command invalid</nowiki>
 [[M204.1108]]<nowiki> Conflicting keywords specified</nowiki>
 [[M204.1109]]<nowiki> File not open: </nowiki>
 [[M204.1110]]<nowiki> QTBL, LQTBL= - too small for selective display</nowiki>
 [[M204.1111]]<nowiki> Performance monitoring not active</nowiki>
 [[M204.1112]]<nowiki> </nowiki>
 [[M204.1113]]<nowiki> Conflicting refresh specifications</nowiki>
 [[M204.1114]]<nowiki> Refresh time must be greater than zero</nowiki>
 [[M204.1115]]<nowiki> Undefined word: </nowiki>
 [[M204.1116]]<nowiki> No closing parenthesis for </nowiki>
 [[M204.1117]]<nowiki> Refresh option required after word "every"</nowiki>
 [[M204.1118]]<nowiki> Parameter not viewable = </nowiki>
 [[M204.1120]]<nowiki> No current file</nowiki>
 [[M204.1121]]<nowiki> The value of cannot be than </nowiki>
 [[M204.1122]]<nowiki> Invalid parameter = </nowiki>
 [[M204.1123]]<nowiki> Parameter not reset</nowiki>
 [[M204.1125]]<nowiki> Parameter 'input' must specify a valid programmer logical unit</nowiki>
 [[M204.1126]]<nowiki> Subsystem must be started</nowiki>
 [[M204.1127]]<nowiki> FILEORG specified</nowiki>
 [[M204.1128]]<nowiki> Can't get file exclusive lock - FRCVOPT was not reset</nowiki>
 [[M204.1129]]<nowiki> Previous request not allowed: </nowiki>
 [[M204.1130]]<nowiki> Invalid delimiter</nowiki>
 [[M204.1131]]<nowiki> Can't </nowiki>
 [[M204.1132]]<nowiki> Float field type unavailable without transform</nowiki>
 [[M204.1133]]<nowiki> Illegal value for DBCS parameter</nowiki>
 [[M204.1134]]<nowiki> Can't DEASSIGN alias: </nowiki>
 [[M204.1135]]<nowiki> Can't DEASSIGN a procedure name: </nowiki>
 [[M204.1137]]<nowiki> Unexpected end-of-procedure during procedure definition. Type 'END PROC' to end definition.</nowiki>
 [[M204.1138]]<nowiki> Invalid delimiter after procedure name</nowiki>
 [[M204.1139]]<nowiki> Alias is in use, ignored: </nowiki>
 [[M204.1140]]<nowiki> Procedure already exists</nowiki>
 [[M204.1141]]<nowiki> Invalid class specification</nowiki>
 [[M204.1142]]<nowiki> Aliases ignored on previous request redefinition</nowiki>
 [[M204.1143]]<nowiki> Can't add alias: </nowiki>
 [[M204.1148]]<nowiki> Can't define procedures</nowiki>
 [[M204.1150]]<nowiki> No subsystem files defined for subsystem </nowiki>
 [[M204.1151]]<nowiki> Can't delete procedure that's in use</nowiki>
 [[M204.1153]]<nowiki> Can't delete procedure </nowiki>
 [[M204.1154]]<nowiki> Invalid options specified</nowiki>
 [[M204.1155]]<nowiki> Invalid keyword</nowiki>
 [[M204.1156]]<nowiki> Invalid privilege list</nowiki>
 [[M204.1157]]<nowiki> Subsystem , SCLS definition not found</nowiki>
 [[M204.1158]]<nowiki> Can't procedure: </nowiki>
 [[M204.1159]]<nowiki> Illegal class: </nowiki>
 [[M204.1160]]<nowiki> Can't display class: </nowiki>
 [[M204.1161]]<nowiki> Include level too deep for DISPLAY</nowiki>
 [[M204.1162]]<nowiki> Default must be file</nowiki>
 [[M204.1163]]<nowiki> Must be file manager to display others' privs</nowiki>
 [[M204.1164]]<nowiki> Bug .. procedure loop. Continuing.</nowiki>
 [[M204.1165]]<nowiki> Include too deep</nowiki>
 [[M204.1166]]<nowiki> Too many include argument strings</nowiki>
 [[M204.1167]]<nowiki> ITBL full, LITBL= -- argument string ignored</nowiki>
 [[M204.1169]]<nowiki> Can't Include </nowiki>
 [[M204.1170]]<nowiki> Error while opening files for subsystem </nowiki>
 [[M204.1171]]<nowiki> Can't include</nowiki>
 [[M204.1172]]<nowiki> Previous request not defined</nowiki>
 [[M204.1173]]<nowiki> Can't edit </nowiki>
 [[M204.1174]]<nowiki> No procedure file</nowiki>
 [[M204.1175]]<nowiki> Proc.dict: not enough space at page, cell: </nowiki>
 [[M204.1176]]<nowiki> Can't EDIT (not authorized) into </nowiki>
 [[M204.1177]]<nowiki> Procedure rejected. PDSIZE=0 in file </nowiki>
 [[M204.1178]]<nowiki> No user classes defined for subsystem </nowiki>
 [[M204.1179]]<nowiki> Unable to allocate enough storage to process password table</nowiki>
 [[M204.1180]]<nowiki> Invalid keyword: </nowiki>
 [[M204.1181]]<nowiki> Unexpected SNA control message for , CONTROL = X'', SENSE = X''</nowiki>
 [[M204.1182]]<nowiki> Invalid class: </nowiki>
 [[M204.1183]]<nowiki> Alias buffer overflow</nowiki>
 [[M204.1184]]<nowiki> Alias name syntax error, alias ignored: </nowiki>
 [[M204.1185]]<nowiki> Invalid syntax for procedure name</nowiki>
 [[M204.1186]]<nowiki> Bad previous request number</nowiki>
 [[M204.1187]]<nowiki> VTAM logmsg failed, logmsg length , please logon.</nowiki>
 [[M204.1188]]<nowiki> Unable to run procedure for subsystem -GTBL full, LGTBL=</nowiki>
 [[M204.1189]]<nowiki> No procedure name given</nowiki>
 [[M204.1191]]<nowiki> Maximum header or trailer number exceeded</nowiki>
 [[M204.1192]]<nowiki> Can't expand ACT in </nowiki>
 [[M204.1194]]<nowiki> Destination must be a list of paired processgroup-symbolic names or a single processgroup</nowiki>
 [[M204.1195]]<nowiki> Can't close all files from a subsystem</nowiki>
 [[M204.1196]]<nowiki> Missing arguments</nowiki>
 [[M204.1197]]<nowiki> Error in ACT modification</nowiki>
 [[M204.1198]]<nowiki> Have not added user class: </nowiki>
 [[M204.1199]]<nowiki> UCLASS=ALL not allowed. ACT does not exist in </nowiki>
 [[M204.1201]]<nowiki> Unexpected end of command</nowiki>
 [[M204.1202]]<nowiki> More than one name and/or UCLASS keyword</nowiki>
 [[M204.1204]]<nowiki> Invalid procedure name: </nowiki>
 [[M204.1205]]<nowiki> Buffer overflow</nowiki>
 [[M204.1206]]<nowiki> More than one UCLASS or PCLASS keyword</nowiki>
 [[M204.1207]]<nowiki> Invalid class number: </nowiki>
 [[M204.1208]]<nowiki> Invalid access: </nowiki>
 [[M204.1209]]<nowiki> Retry is not valid in an On unit</nowiki>
 [[M204.1210]]<nowiki> "ALL" is invalid for name list in SECURE command</nowiki>
 [[M204.1211]]<nowiki> Invalid PCLASS list</nowiki>
 [[M204.1212]]<nowiki> On Error on-unit ignored - VTBL full, LVTBL=</nowiki>
 [[M204.1213]]<nowiki> P.D. page full. Can't secure proc: </nowiki>
 [[M204.1215]]<nowiki> XTBL, LXTBL= - not enough space</nowiki>
 [[M204.1219]]<nowiki> Record locking table full</nowiki>
 [[M204.1224]]<nowiki> Bug .. CENQ</nowiki>
 [[M204.1226]]<nowiki> Bug .. CDEQ</nowiki>
 [[M204.1227]]<nowiki> Record locking table full</nowiki>
 [[M204.1228]]<nowiki> Bug .. reuse queue error, </nowiki>
 [[M204.1232]]<nowiki> Value cannot be converted for preallocated field </nowiki>
 [[M204.1233]]<nowiki> , bad record number for </nowiki>
 [[M204.1234]]<nowiki> Adding too many occurrences of </nowiki>
 [[M204.1235]]<nowiki> Zap missing for patch number (hex)</nowiki>
 [[M204.1236]]<nowiki> Table D list page bug: </nowiki>
 [[M204.1239]]<nowiki> Extension missing for in </nowiki>
 [[M204.1240]]<nowiki> Field descriptions not supported</nowiki>
 [[M204.1241]]<nowiki> Invalid field name: </nowiki>
 [[M204.1242]]<nowiki> Old- and new-style definitions may not be mixed</nowiki>
 [[M204.1243]]<nowiki> Invalid delimiter following field name</nowiki>
 [[M204.1244]]<nowiki> Backout is invalid for non-transaction backout files (as listed by M204.2792)</nowiki>
 [[M204.1245]]<nowiki> Parameter not reset due to conflicting attributes</nowiki>
 [[M204.1246]]<nowiki> Bug .. DFIN, bad record number for </nowiki>
 [[M204.1249]]<nowiki> Unexpected end of subsystem procedure</nowiki>
 [[M204.1250]]<nowiki> End of input data</nowiki>
 [[M204.1251]]<nowiki> Line too long</nowiki>
 [[M204.1252]]<nowiki> Unable to stop subsystem </nowiki>
 [[M204.1253]]<nowiki> Unexpected end of included data</nowiki>
 [[M204.1254]]<nowiki> User language statement is invalid in this conversation state</nowiki>
 [[M204.1256]]<nowiki> Period expected: character = </nowiki>
 [[M204.1257]]<nowiki> File must be defined with a dataset type of SEQUENTIAL</nowiki>
 [[M204.1258]]<nowiki> DLBL statement for cannot specify direct access</nowiki>
 [[M204.1260]]<nowiki> was previously defined with different attributes, new options ignored</nowiki>
 [[M204.1261]]<nowiki> New field names not permitted</nowiki>
 [[M204.1262]]<nowiki> No new preallocated fields allowed</nowiki>
 [[M204.1263]]<nowiki> Record description full for </nowiki>
 [[M204.1264]]<nowiki> Preallocated field block too big in </nowiki>
 [[M204.1265]]<nowiki> No such name: = </nowiki>
 [[M204.1266]]<nowiki> Nonexistent record referenced - in </nowiki>
 [[M204.1267]]<nowiki> Multiple field name definitions not allowed when field option specified</nowiki>
 [[M204.1268]]<nowiki> Bug .. SBNU$+: damaged record - in </nowiki>
 [[M204.1271]]<nowiki> The ALTIODEV parameter is valid only in the CMS version</nowiki>
 [[M204.1273]]<nowiki> Table C full - REDEFINE: </nowiki>
 [[M204.1274]]<nowiki> Bug .. FILESWP</nowiki>
 [[M204.1275]]<nowiki> Bug2 .. FILESWP</nowiki>
 [[M204.1276]]<nowiki> Insufficient access to select on field </nowiki>
 [[M204.1277]]<nowiki> Insufficient access to read field </nowiki>
 [[M204.1278]]<nowiki> Insufficient access to update field </nowiki>
 [[M204.1279]]<nowiki> Insufficient access to add field </nowiki>
 [[M204.1280]]<nowiki> Field not found</nowiki>
 [[M204.1281]]<nowiki> Can not initialize more than NSUBTKS pseudo subtasks</nowiki>
 [[M204.1282]]<nowiki> Parallel stream disabled, record is not the same for all members</nowiki>
 [[M204.1283]]<nowiki> Bug .. SERVSWAP</nowiki>
 [[M204.1284]]<nowiki> Bug .. too few buffers</nowiki>
 [[M204.1286]]<nowiki> Bug .. TIMERENQ</nowiki>
 [[M204.1287]]<nowiki> Bug .. TIMEREXP</nowiki>
 [[M204.1289]]<nowiki> (LGTBL - GTBLHASH*10) must be at least 288 for subsystem processing, LGTBL=</nowiki>
 [[M204.1290]]<nowiki> Invalid PRIORITY specification</nowiki>
 [[M204.1291]]<nowiki> Invalid PRIORITY specification</nowiki>
 [[M204.1292]]<nowiki> Invalid option '' -- type '*TRACE ?' for usage</nowiki>
 [[M204.1293]]<nowiki> Entry to blockmode disallowed</nowiki>
 [[M204.1294]]<nowiki> LU62 VTAM failure; RETNCD, FDBK2 = , ; SENSE = </nowiki>
 [[M204.1295]]<nowiki> No audit trail or journaling stream(s)</nowiki>
 [[M204.1297]]<nowiki> Audit trail message(s) have been lost</nowiki>
 [[M204.1298]]<nowiki> Unable to open CCAJRNL</nowiki>
 [[M204.1299]]<nowiki> Auditing not possible</nowiki>
 [[M204.1301]]<nowiki> No journal stream(s) opened</nowiki>
 [[M204.1302]]<nowiki> Abnormal timeout return from in ACB services</nowiki>
 [[M204.1305]]<nowiki> Unbind failed for bumped or timed out session</nowiki>
 [[M204.1306]]<nowiki> Merged journal not allowed for RESTART</nowiki>
 [[M204.1307]]<nowiki> logon rejected - (reason code: )</nowiki>
 [[M204.1308]]<nowiki> Concatenation not allowed for CCARF</nowiki>
 [[M204.1309]]<nowiki> Journalling terminated, run cancelled</nowiki>
 [[M204.1310]]<nowiki> Journalling terminated</nowiki>
 [[M204.1311]]<nowiki> CCAAUDIT formatting terminated</nowiki>
 [[M204.1312]]<nowiki> CCAAUDIT formatting terminated</nowiki>
 [[M204.1313]]<nowiki> Unable to open </nowiki>
 [[M204.1315]]<nowiki> Transport=CRAM is not supported in CMS</nowiki>
 [[M204.1316]]<nowiki> Can't allocate the journal buffer</nowiki>
 [[M204.1317]]<nowiki> Can't process </nowiki>
 [[M204.1318]]<nowiki> Incorrect volume mounted for </nowiki>
 [[M204.1321]]<nowiki> Alias argument isn't compatible with previous call</nowiki>
 [[M204.1322]]<nowiki> Block of length read from is not a multiple of the LRECL of </nowiki>
 [[M204.1323]]<nowiki> Block of length read from with a block descriptor word which specifies a length of </nowiki>
 [[M204.1324]]<nowiki> Block of length read from contains a record at offset with a record descriptor word which specifies a length of </nowiki>
 [[M204.1325]]<nowiki> LU62 VTAM link failure; RETNCD, FDBK2 = ; SENSE = </nowiki>
 [[M204.1328]]<nowiki> System pushdown list overflowed</nowiki>
 [[M204.1329]]<nowiki> User's pushdown list overflowed</nowiki>
 [[M204.1330]]<nowiki> PRT-PART -- NSUBTKS too small</nowiki>
 [[M204.1332]]<nowiki> Long request - exceeded <= </nowiki>
 [[M204.1334]]<nowiki> Insufficient main storage for operator reply</nowiki>
 [[M204.1335]]<nowiki> Insufficient storage available to allocate bytes for </nowiki>
 [[M204.1337]]<nowiki> Constraint inconsistency encountered</nowiki>
 [[M204.1340]]<nowiki> Incorrect TRANSFORM command parameter</nowiki>
 [[M204.1341]]<nowiki> Locked for subsystem is already opened</nowiki>
 [[M204.1342]]<nowiki> Unable to run CCASYS procedure: </nowiki>
 [[M204.1347]]<nowiki> Sessiongroup winners cannot exceed maximum</nowiki>
 [[M204.1351]]<nowiki> LU62 VTAM X15, X0 = X ; RETNCD, FDBK2 = ; SENSE = </nowiki>
 [[M204.1353]]<nowiki> IDAL count exceeded, EXCPVR not possible</nowiki>
 [[M204.1354]]<nowiki> Application loop involving error procedure in subsystem </nowiki>
 [[M204.1355]]<nowiki> Unknown error message for VTAMLU62 exit</nowiki>
 [[M204.1356]]<nowiki> LU62 VTAM error; FMH5 (attach) expected</nowiki>
 [[M204.1357]]<nowiki> Open error - </nowiki>
 [[M204.1358]]<nowiki> Open failed for </nowiki>
 [[M204.1359]]<nowiki> Unable to allocate sufficient storage to open </nowiki>
 [[M204.1361]]<nowiki> DD statement currently in use</nowiki>
 [[M204.1362]]<nowiki> is an invalid logical unit</nowiki>
 [[M204.1363]]<nowiki> is currently in use</nowiki>
 [[M204.1368]]<nowiki> Insufficient real storage to perform PFIX</nowiki>
 [[M204.1369]]<nowiki> PFREE issued for storage which was not page fixed</nowiki>
 [[M204.1370]]<nowiki> Authorization required for </nowiki>
 [[M204.1371]]<nowiki> Insufficient main storage for operator message</nowiki>
 [[M204.1372]]<nowiki> TIME=1440 may not be specified with Timer SVC</nowiki>
 [[M204.1377]]<nowiki> Vs only option ignored - </nowiki>
 [[M204.1378]]<nowiki> Authorization under APF required for </nowiki>
 [[M204.1379]]<nowiki> Model 204 SNAP failed</nowiki>
 [[M204.1380]]<nowiki> Invalid NOTERM or POLLNO value</nowiki>
 [[M204.1383]]<nowiki> X3270CHK error for terminal ; return code = x""</nowiki>
 [[M204.1384]]<nowiki> X3270OUT error for terminal ; return code = x""</nowiki>
 [[M204.1385]]<nowiki> X3270IN error for terminal ; return code = x""</nowiki>
 [[M204.1386]]<nowiki> Error invoking subsystem through the AUTOSYS parameter</nowiki>
 [[M204.1387]]<nowiki> ALLOCATE failed; ddName=, DSN= could not be located</nowiki>
 [[M204.1388]]<nowiki> CHUNK size exceeds maximum of </nowiki>
 [[M204.1389]]<nowiki> Mismatch between user image and internal image</nowiki>
 [[M204.1390]]<nowiki> Permanent terminal I/O error - </nowiki>
 [[M204.1391]]<nowiki> File argument isn't compatible with previous call</nowiki>
 [[M204.1393]]<nowiki> CHUNK clause not of format "CHUNK chunkSize FOR chunkTargetFieldName"</nowiki>
 [[M204.1394]]<nowiki> CHUNK chunkSize value invalid: </nowiki>
 [[M204.1395]]<nowiki> CHUNK target field invalid type: </nowiki>
 [[M204.1396]]<nowiki> CHUNK fields must be INVISIBLE ORDERED NUMERIC</nowiki>
 [[M204.1399]]<nowiki> Same server area defined for server above the bar and non swappable server</nowiki>
 [[M204.1400]]<nowiki> Server areas ATB require server swapping in memory</nowiki>
 [[M204.1402]]<nowiki> Invalid value for CHUNK target: =''; values must be -999999999999999->999999999999999</nowiki>
 [[M204.1406]]<nowiki> Missing journal was detected between and for file </nowiki>
 [[M204.1407]]<nowiki> discontinuity occurred at for file </nowiki>
 [[M204.1408]]<nowiki> No updates in after = of file </nowiki>
 [[M204.1409]]<nowiki> Missing stopping point for file </nowiki>
 [[M204.1411]]<nowiki> Null lines are not allowed</nowiki>
 [[M204.1412]]<nowiki> not allowed with ATB servers</nowiki>
 [[M204.1413]]<nowiki> Stop time earlier than or same as start time for file </nowiki>
 [[M204.1414]]<nowiki> Error: sort record > 16meg </nowiki>
 [[M204.1415]]<nowiki> Expecting a "file" clause</nowiki>
 [[M204.1416]]<nowiki> unused </nowiki>
 [[M204.1417]]<nowiki> TTY DD card missing - </nowiki>
 [[M204.1418]]<nowiki> Line error during open</nowiki>
 [[M204.1419]]<nowiki> Unexpected I/O return code</nowiki>
 [[M204.1420]]<nowiki> User deactivated</nowiki>
 [[M204.1421]]<nowiki> Too many I/O errors</nowiki>
 [[M204.1425]]<nowiki> 2741 DD card missing - </nowiki>
 [[M204.1426]]<nowiki> Invalid "FROM" clause</nowiki>
 [[M204.1427]]<nowiki> Invalid stopping point clause</nowiki>
 [[M204.1428]]<nowiki> Missing an "OF" clause</nowiki>
 [[M204.1429]]<nowiki> Failed to allocate </nowiki>
 [[M204.1430]]<nowiki> Failed to open file </nowiki>
 [[M204.1431]]<nowiki> Error during the restore step</nowiki>
 [[M204.1432]]<nowiki> Process , lost session, SENSE CODE X''</nowiki>
 [[M204.1433]]<nowiki> : </nowiki>
 [[M204.1434]]<nowiki> Transfer failed, REMOTEID is unavailable to VTAM</nowiki>
 [[M204.1435]]<nowiki> Error during regenerate, REGENERATE is cancelled, RF entry number </nowiki>
 [[M204.1436]]<nowiki> Stopped processing file </nowiki>
 [[M204.1438]]<nowiki> Incorrect target clause, should be CHECKPOINT or UPDATE</nowiki>
 [[M204.1439]]<nowiki> Invalid stopping point date or time: </nowiki>
 [[M204.1440]]<nowiki> Expected byte count</nowiki>
 [[M204.1441]]<nowiki> Process , link failed, SENSE CODE X''</nowiki>
 [[M204.1442]]<nowiki> Cannot enter data mode from data mode</nowiki>
 [[M204.1443]]<nowiki> unused </nowiki>
 [[M204.1444]]<nowiki> OUTLPP too small for backpaging</nowiki>
 [[M204.1445]]<nowiki> was previously defined/allocated</nowiki>
 [[M204.1446]]<nowiki> Outboard formatting halted, maximum error count exceeded</nowiki>
 [[M204.1447]]<nowiki> Outboard formatting halted, screen request not current</nowiki>
 [[M204.1448]]<nowiki> Outboard formatting halted, screen error - x''</nowiki>
 [[M204.1450]]<nowiki> Unexpected outboard formatting command x'', outboard formatting halted</nowiki>
 [[M204.1451]]<nowiki> Terminal not outboard formatting compatible, outboard formatting halted</nowiki>
 [[M204.1452]]<nowiki> Unable to allocate sufficient storage for VSAM parameter list</nowiki>
 [[M204.1454]]<nowiki> System manager has restricted use of this command</nowiki>
 [[M204.1456]]<nowiki> Open failed for VSAM dataset , reason code x''</nowiki>
 [[M204.1457]]<nowiki> Unable to scan list of subsystem names</nowiki>
 [[M204.1458]]<nowiki> LRECL must be at least for CCAAUDIT</nowiki>
 [[M204.1459]]<nowiki> Insufficient Table D space to define ordered field</nowiki>
 [[M204.1460]]<nowiki> Access to file parameters not authorized</nowiki>
 [[M204.1461]]<nowiki> Access to file parameter not authorized</nowiki>
 [[M204.1462]]<nowiki> Access to file parameter not authorized</nowiki>
 [[M204.1463]]<nowiki> Invalid parameter: </nowiki>
 [[M204.1464]]<nowiki> has already been specified</nowiki>
 [[M204.1465]]<nowiki> Name expected</nowiki>
 [[M204.1466]]<nowiki> Invalid name: </nowiki>
 [[M204.1467]]<nowiki> 'with' or 'like' expected</nowiki>
 [[M204.1468]]<nowiki> 'with' expected</nowiki>
 [[M204.1470]]<nowiki> Illegal compilation name</nowiki>
 [[M204.1471]]<nowiki> is required for this command</nowiki>
 [[M204.1472]]<nowiki> One of the following is required for this command:</nowiki>
 [[M204.1473]]<nowiki> is required when is specified</nowiki>
 [[M204.1474]]<nowiki> The name of a ring member cannot match the offload name</nowiki>
 [[M204.1475]]<nowiki> The offload name cannot match the streamname</nowiki>
 [[M204.1476]]<nowiki> The name of a ring member cannot match the control name</nowiki>
 [[M204.1477]]<nowiki> The control name cannot match the streamname</nowiki>
 [[M204.1478]]<nowiki> The control name cannot match the offload name</nowiki>
 [[M204.1479]]<nowiki> The name of a member cannot match the stream name</nowiki>
 [[M204.1480]]<nowiki> Duplicate member name - </nowiki>
 [[M204.1482]]<nowiki> Block ended already</nowiki>
 [[M204.1483]]<nowiki> Not enough Table D space to store procedure</nowiki>
 [[M204.1484]]<nowiki> Misplaced End statement</nowiki>
 [[M204.1485]]<nowiki> Block End statement cannot be numbered</nowiki>
 [[M204.1486]]<nowiki> Unable to close VSAM dataset , reason code x''</nowiki>
 [[M204.1487]]<nowiki> Possible I/O error detected for VSAM dataset </nowiki>
 [[M204.1488]]<nowiki> Not enough temporary space to store procedure</nowiki>
 [[M204.1489]]<nowiki> Not enough file space to continue procedure definition - </nowiki>
 [[M204.1490]]<nowiki> Invalid AUTHCTL syntax</nowiki>
 [[M204.1491]]<nowiki> $usrpriv argument 2 must specify 'log' or 'nolog'</nowiki>
 [[M204.1492]]<nowiki> Link is already open or being closed</nowiki>
 [[M204.1493]]<nowiki> Stop processgroup in progress</nowiki>
 [[M204.1494]]<nowiki> Link not open or close/stop link in progress</nowiki>
 [[M204.1495]]<nowiki> Maximum conversations exceeded for processgroup </nowiki>
 [[M204.1496]]<nowiki> No session blocks available for link </nowiki>
 [[M204.1497]]<nowiki> Remote specification conflicts with open type</nowiki>
 [[M204.1498]]<nowiki> Two processgroups using different links point to the same REMOTEID and SESPARMS</nowiki>
 [[M204.1499]]<nowiki> Process already open</nowiki>
 [[M204.1501]]<nowiki> system not operational</nowiki>
 [[M204.1502]]<nowiki> Interface delete is disabled</nowiki>
 [[M204.1505]]<nowiki> clause required</nowiki>
 [[M204.1506]]<nowiki> </nowiki>
 [[M204.1507]]<nowiki> CMS VTAM interface SATTACH failed</nowiki>
 [[M204.1508]]<nowiki> is not authorized to use Model 204</nowiki>
 [[M204.1509]]<nowiki> Account not authorized</nowiki>
 [[M204.1510]]<nowiki> VTAM storage shortage detected during user transfer</nowiki>
 [[M204.1511]]<nowiki> Transfer failed, invalid REMOTEID defined for VTAM transfer</nowiki>
 [[M204.1512]]<nowiki> Remote VTAM application rejected the transfer</nowiki>
 [[M204.1513]]<nowiki> Transfer failed, Model 204 is not authorized for VTAM transfer</nowiki>
 [[M204.1514]]<nowiki> Transfer failed, invalid data area or data length</nowiki>
 [[M204.1515]]<nowiki> Transfer failed, REMOTEID equals VTAMNAME</nowiki>
 [[M204.1516]]<nowiki> VTAM transfer failed, clsdst=pass failure, X0,FDBK2=x'',x''</nowiki>
 [[M204.1517]]<nowiki> Job submission is not authorized</nowiki>
 [[M204.1518]]<nowiki> Userid is currently logged on</nowiki>
 [[M204.1519]]<nowiki> Invalid call from interprocess IODEV</nowiki>
 [[M204.1520]]<nowiki> Command requires privilege</nowiki>
 [[M204.1521]]<nowiki> does not exist or requested access not authorized</nowiki>
 [[M204.1522]]<nowiki> Roll forward stream missing or cannot be opened, run terminated</nowiki>
 [[M204.1524]]<nowiki> Unable to start second pass on roll back, RESTART failed</nowiki>
 [[M204.1525]]<nowiki> No inbound threads available</nowiki>
 [[M204.1526]]<nowiki> Checkpoint -- insufficient storage for checkpoint work area</nowiki>
 [[M204.1527]]<nowiki> file option prohibits delete records</nowiki>
 [[M204.1528]]<nowiki> Where/With clause is invalid against sorted set</nowiki>
 [[M204.1529]]<nowiki> Maximum deferred update files already open</nowiki>
 [[M204.1530]]<nowiki> statement contains options that are incompatible with this link type</nowiki>
 [[M204.1531]]<nowiki> Block began with different label</nowiki>
 [[M204.1532]]<nowiki> End expected, not End </nowiki>
 [[M204.1533]]<nowiki> Statement numbers prohibited</nowiki>
 [[M204.1534]]<nowiki> Statement labels prohibited</nowiki>
 [[M204.1535]]<nowiki> Label reference needed</nowiki>
 [[M204.1536]]<nowiki> IUCV connect to GCS machine failed; return code = </nowiki>
 [[M204.1537]]<nowiki> IUCV failed; return code = </nowiki>
 [[M204.1538]]<nowiki> VT204 program not available on </nowiki>
 [[M204.1539]]<nowiki> IUCV message completed abnormally, ipaudit = </nowiki>
 [[M204.1540]]<nowiki> LRESERVE must be between 0 and 99</nowiki>
 [[M204.1541]]<nowiki> NRESERVE must be between 0 and 99</nowiki>
 [[M204.1542]]<nowiki> SPLITPCT must be between 1 and 100</nowiki>
 [[M204.1543]]<nowiki> IMMED must be between 0 and 255</nowiki>
 [[M204.1544]]<nowiki> LEVEL must be between 0 and 255</nowiki>
 [[M204.1545]]<nowiki> Session not established for inbound process </nowiki>
 [[M204.1546]]<nowiki> You have taken all the available strings, current request denied</nowiki>
 [[M204.1547]]<nowiki> Maximum number of data and image clauses exceeded</nowiki>
 [[M204.1557]]<nowiki> IFFDV errors</nowiki>
 [[M204.1559]]<nowiki> Invalid IFGETV spec syntax</nowiki>
 [[M204.1560]]<nowiki> Invalid sort option: </nowiki>
 [[M204.1566]]<nowiki> Pad must be a single quoted character</nowiki>
 [[M204.1567]]<nowiki> Duplicate pad specification</nowiki>
 [[M204.1568]]<nowiki> Image item variable required</nowiki>
 [[M204.1569]]<nowiki> Referenced item not in active image</nowiki>
 [[M204.1572]]<nowiki> not open</nowiki>
 [[M204.1573]]<nowiki> File not positioned before Read Next</nowiki>
 [[M204.1576]]<nowiki> Keyed read attempted on sequential file </nowiki>
 [[M204.1577]]<nowiki> Error reading </nowiki>
 [[M204.1578]]<nowiki> Record not found by position in </nowiki>
 [[M204.1579]]<nowiki> No position to release</nowiki>
 [[M204.1580]]<nowiki> Image depending variable not numeric</nowiki>
 [[M204.1581]]<nowiki> Image depending variable negative or exceeds maximum</nowiki>
 [[M204.1582]]<nowiki> VSAM string unavailable for position</nowiki>
 [[M204.1583]]<nowiki> Referenced item has unknown length or location</nowiki>
 [[M204.1584]]<nowiki> Occurs must be between 0 and 32767</nowiki>
 [[M204.1585]]<nowiki> Length invalid for item type, DP, or BP</nowiki>
 [[M204.1586]]<nowiki> Option duplicates or conflicts with previous options</nowiki>
 [[M204.1587]]<nowiki> FSCB full, image too large: LFSCB required = , bytes available in FSCB = </nowiki>
 [[M204.1588]]<nowiki> Unknown length or location not allowed with align</nowiki>
 [[M204.1589]]<nowiki> Maximum Image length is 32767: LFSCB required = </nowiki>
 [[M204.1590]]<nowiki> Conflicting inbound and outbound parameters</nowiki>
 [[M204.1592]]<nowiki> VTBL full, LVTBL=, sorted output impossible</nowiki>
 [[M204.1593]]<nowiki> CICS printer not available, </nowiki>
 [[M204.1594]]<nowiki> Dimension must be 1, 2, or 3</nowiki>
 [[M204.1595]]<nowiki> is not an array variable</nowiki>
 [[M204.1596]]<nowiki> File is referenced within this request</nowiki>
 [[M204.1597]]<nowiki> Password incorrect for </nowiki>
 [[M204.1598]]<nowiki> Attempt to read past end of file </nowiki>
 [[M204.1599]]<nowiki> Group name blank</nowiki>
 [[M204.1600]]<nowiki> No global name given</nowiki>
 [[M204.1601]]<nowiki> CICS printer error, </nowiki>
 [[M204.1602]]<nowiki> CICS printer close failed, </nowiki>
 [[M204.1603]]<nowiki> Outboard formatting: too many lines on screen without "new page" statement</nowiki>
 [[M204.1604]]<nowiki> unused </nowiki>
 [[M204.1605]]<nowiki> At position not valid within an array</nowiki>
 [[M204.1606]]<nowiki> Invalid relational operator for key: </nowiki>
 [[M204.1607]]<nowiki> "for" clause conflicts with open type</nowiki>
 [[M204.1608]]<nowiki> "for" clause required</nowiki>
 [[M204.1609]]<nowiki> Use of image requires non-zero LFSCB</nowiki>
 [[M204.1610]]<nowiki> Only 4095 images allowed for a single block</nowiki>
 [[M204.1611]]<nowiki> Digits must be between 1 and 15</nowiki>
 [[M204.1612]]<nowiki> DP must be between 0 and 15</nowiki>
 [[M204.1613]]<nowiki> Bits must be 8, 16, 24, or 32</nowiki>
 [[M204.1614]]<nowiki> At position must be between 1 and 32767</nowiki>
 [[M204.1615]]<nowiki> Current item is not in the same image as </nowiki>
 [[M204.1616]]<nowiki> Image, item, or array name not defined: </nowiki>
 [[M204.1617]]<nowiki> Current item must be in same array as target of At</nowiki>
 [[M204.1618]]<nowiki> BP must be between 0 and 31</nowiki>
 [[M204.1619]]<nowiki> Len must be positive number or "unknown"</nowiki>
 [[M204.1620]]<nowiki> Occurs must be between 1 and 32767 or "unknown"</nowiki>
 [[M204.1621]]<nowiki> Depending variable not defined or not an item</nowiki>
 [[M204.1622]]<nowiki> "end image" missing</nowiki>
 [[M204.1623]]<nowiki> Image, array, and item names must be unique</nowiki>
 [[M204.1624]]<nowiki> Invalid value for Pad or Initial character</nowiki>
 [[M204.1625]]<nowiki> To position must be between start of item and 32767</nowiki>
 [[M204.1626]]<nowiki> Skip must be between 1 and 32767</nowiki>
 [[M204.1627]]<nowiki> Array with depending variable cannot be overlaid</nowiki>
 [[M204.1628]]<nowiki> Duplicate Occurs clause</nowiki>
 [[M204.1629]]<nowiki> "unknown" not allowed inside an array</nowiki>
 [[M204.1630]]<nowiki> Occurs clause required for array</nowiki>
 [[M204.1631]]<nowiki> Array with depending variable must have known location</nowiki>
 [[M204.1632]]<nowiki> Item length must be specified</nowiki>
 [[M204.1633]]<nowiki> Number or variable required, not: </nowiki>
 [[M204.1634]]<nowiki> Item must be defined with "Len Unknown"</nowiki>
 [[M204.1635]]<nowiki> Array or item must be defined with "occurs unknown"</nowiki>
 [[M204.1636]]<nowiki> Occurs must be between 0 and 32767</nowiki>
 [[M204.1637]]<nowiki> Length invalid for item type, DP, or BP</nowiki>
 [[M204.1638]]<nowiki> Name required for array with Occurs Unknown</nowiki>
 [[M204.1639]]<nowiki> "to" invalid for item with unknown location</nowiki>
 [[M204.1640]]<nowiki> Invalid Initial value for item type: </nowiki>
 [[M204.1641]]<nowiki> Maximum Image length is 32767</nowiki>
 [[M204.1642]]<nowiki> No active array</nowiki>
 [[M204.1643]]<nowiki> Item type required</nowiki>
 [[M204.1644]]<nowiki> Line ignored after invalid option: </nowiki>
 [[M204.1645]]<nowiki> Image cannot overlay item with subscript or unknown location</nowiki>
 [[M204.1646]]<nowiki> Name given is not an image</nowiki>
 [[M204.1647]]<nowiki> Illegal item used as depending variable</nowiki>
 [[M204.1648]]<nowiki> "to" invalid inside an array</nowiki>
 [[M204.1649]]<nowiki> All "unknown" data must follow depending arrays and variables</nowiki>
 [[M204.1650]]<nowiki> Openc invalid for external file</nowiki>
 [[M204.1651]]<nowiki> Invalid reference to array or skip name: </nowiki>
 [[M204.1652]]<nowiki> Enter a valid procedure name or hit attention to exit</nowiki>
 [[M204.1653]]<nowiki> is a required member of active subsystem(s)</nowiki>
 [[M204.1654]]<nowiki> has been stopped</nowiki>
 [[M204.1655]]<nowiki> All blocks ended, label not found</nowiki>
 [[M204.1656]]<nowiki> Entity name or type exceeds 8 characters</nowiki>
 [[M204.1657]]<nowiki> "with" expected</nowiki>
 [[M204.1658]]<nowiki> ID required for ROUTER=VM</nowiki>
 [[M204.1659]]<nowiki> Invalid entity for USE command</nowiki>
 [[M204.1660]]<nowiki> ROUTER= not supported for this operating system</nowiki>
 [[M204.1661]]<nowiki> VOLUME must be specified and not 'SCRTCH' when POSITION > 1</nowiki>
 [[M204.1662]]<nowiki> Invalid At or After position for aligned item</nowiki>
 [[M204.1663]]<nowiki> I/O error or EOF on first read of CCARF stream</nowiki>
 [[M204.1664]]<nowiki> "TO UPDATE" only allowed on first line of REGENerate</nowiki>
 [[M204.1665]]<nowiki> unused </nowiki>
 [[M204.1666]]<nowiki> JECL statement cannot be longer than 71 characters</nowiki>
 [[M204.1667]]<nowiki> unused </nowiki>
 [[M204.1668]]<nowiki> unused </nowiki>
 [[M204.1669]]<nowiki> Image to be is not active</nowiki>
 [[M204.1670]]<nowiki> not open for output</nowiki>
 [[M204.1671]]<nowiki> File is not open</nowiki>
 [[M204.1672]]<nowiki> Percent variable required</nowiki>
 [[M204.1673]]<nowiki> End of line expected, found </nowiki>
 [[M204.1674]]<nowiki> File name cannot be null</nowiki>
 [[M204.1675]]<nowiki> Position not valid for sequential file</nowiki>
 [[M204.1676]]<nowiki> Invalid 3270 SBA in input stream: x''</nowiki>
 [[M204.1677]]<nowiki> Prompt/title items must have the "protected" attribute</nowiki>
 [[M204.1678]]<nowiki> CICS terminal required for ROUTER=CICS</nowiki>
 [[M204.1679]]<nowiki> Variable redefinition conflicts with complex subroutine feature</nowiki>
 [[M204.1680]]<nowiki> Invalid "in range" syntax</nowiki>
 [[M204.1681]]<nowiki> Alphabetically and Numerically illegal with Like, Present</nowiki>
 [[M204.1682]]<nowiki> Bug .. Like pattern, string = '', pattern = ''</nowiki>
 [[M204.1683]]<nowiki> VMCF message limit exceeded</nowiki>
 [[M204.1684]]<nowiki> Missing right paren in find specs</nowiki>
 [[M204.1685]]<nowiki> Subsystem does not exist</nowiki>
 [[M204.1686]]<nowiki> Unable to re-establish connection after VTAM transfer failed, X0, FDBK2=x'',x''</nowiki>
 [[M204.1687]]<nowiki> FNV on Ordered For loop was not an ORDERED field: field = </nowiki>
 [[M204.1688]]<nowiki> in pattern '' near character </nowiki>
 [[M204.1689]]<nowiki> in pattern '' near character </nowiki>
 [[M204.1690]]<nowiki> Unmatched parenthesis in pattern </nowiki>
 [[M204.1691]]<nowiki> Unmatched parenthesis in pattern </nowiki>
 [[M204.1692]]<nowiki> Ordered retrieval syntax error</nowiki>
 [[M204.1693]]<nowiki> "in order" invalid with sorted set</nowiki>
 [[M204.1695]]<nowiki> ORDERED fields are not allowed in files created before Release 9.0</nowiki>
 [[M204.1696]]<nowiki> Image not active</nowiki>
 [[M204.1698]]<nowiki> not open for deferred updates to the ordered index</nowiki>
 [[M204.1699]]<nowiki> Redefinition failed, insufficient space to create the ordered index</nowiki>
 [[M204.1700]]<nowiki> UNIQUE fields are not allowed in files created before Release 9.0</nowiki>
 [[M204.1701]]<nowiki> Non-unique value found for field in record number ; conflicts with record number </nowiki>
 [[M204.1702]]<nowiki> Uniqueness violation detected for = in </nowiki>
 [[M204.1703]]<nowiki> Uniqueness violation detected</nowiki>
 [[M204.1704]]<nowiki> File Records requires a non-UNIQUE field</nowiki>
 [[M204.1705]]<nowiki> File Records requires a non-UNIQUE field</nowiki>
 [[M204.1706]]<nowiki> Non-unique value found for ORDERED field </nowiki>
 [[M204.1709]]<nowiki> interface is not supported in this operating system</nowiki>
 [[M204.1710]]<nowiki> 'at' option not supported</nowiki>
 [[M204.1711]]<nowiki> "From" clause required for files created prior to Release 9.0</nowiki>
 [[M204.1712]]<nowiki> Invalid or undeclared member variable specified</nowiki>
 [[M204.1713]]<nowiki> Member not found in </nowiki>
 [[M204.1714]]<nowiki> Cannot store record into , key required in update </nowiki>
 [[M204.1715]]<nowiki> Cannot store record into , has no sort/hash key</nowiki>
 [[M204.1716]]<nowiki> Cannot store record into , no update file</nowiki>
 [[M204.1717]]<nowiki> file option prohibits delete records</nowiki>
 [[M204.1718]]<nowiki> Frn in group context requires "member" clause</nowiki>
 [[M204.1722]]<nowiki> Parameter list expected</nowiki>
 [[M204.1723]]<nowiki> is illegal syntax in parameter list</nowiki>
 [[M204.1724]]<nowiki> "FS" or "Field Save" expected, not </nowiki>
 [[M204.1725]]<nowiki> Parameter number is type incompatible</nowiki>
 [[M204.1726]]<nowiki> Parameter refers to undeclared list</nowiki>
 [[M204.1727]]<nowiki> Reference to invalid subroutine name</nowiki>
 [[M204.1728]]<nowiki> Assignment to input parameter illegal</nowiki>
 [[M204.1729]]<nowiki> Duplicate type specification - </nowiki>
 [[M204.1730]]<nowiki> List already defined</nowiki>
 [[M204.1731]]<nowiki> Subroutine with parameters should not begin with a label</nowiki>
 [[M204.1732]]<nowiki> Parameter count is not equal to the original parameter count</nowiki>
 [[M204.1733]]<nowiki> Label already defined</nowiki>
 [[M204.1734]]<nowiki> Invalid use of array name as parameter</nowiki>
 [[M204.1735]]<nowiki> Type incompatibility between Common variables</nowiki>
 [[M204.1736]]<nowiki> File/group incompatibility between Common lists</nowiki>
 [[M204.1737]]<nowiki> not opened for input</nowiki>
 [[M204.1738]]<nowiki> Image data truncated</nowiki>
 [[M204.1739]]<nowiki> Option duplicates or conflicts with previous options</nowiki>
 [[M204.1740]]<nowiki> Image array must contain some items</nowiki>
 [[M204.1741]]<nowiki> "for" clause required</nowiki>
 [[M204.1742]]<nowiki> "for" clause conflicts with open type</nowiki>
 [[M204.1743]]<nowiki> not found</nowiki>
 [[M204.1744]]<nowiki> Close statement invalid for file or group</nowiki>
 [[M204.1745]]<nowiki> Data sent has been truncated</nowiki>
 [[M204.1746]]<nowiki> Missing process name</nowiki>
 [[M204.1747]]<nowiki> After position not valid with image</nowiki>
 [[M204.1748]]<nowiki> Subsystem name required</nowiki>
 [[M204.1749]]<nowiki> Subsystem parameters lost, GTBL full, LGTBL=</nowiki>
 [[M204.1750]]<nowiki> CCASYS missing field </nowiki>
 [[M204.1751]]<nowiki> Invalid alphanumeric edit pattern (): missing "!" character</nowiki>
 [[M204.1752]]<nowiki> Null alphanumeric edit pattern not allowed</nowiki>
 [[M204.1753]]<nowiki> Null numeric edit pattern not allowed</nowiki>
 [[M204.1754]]<nowiki> Invalid numeric edit pattern (): illegal character</nowiki>
 [[M204.1755]]<nowiki> Invalid numeric edit pattern (): missing $$,++,--,z,*,9</nowiki>
 [[M204.1756]]<nowiki> Invalid numeric edit pattern (): too many digits</nowiki>
 [[M204.1757]]<nowiki> Invalid numeric edit pattern (): extra character(s) at end</nowiki>
 [[M204.1758]]<nowiki> Invalid numeric edit pattern (): "" in wrong position</nowiki>
 [[M204.1763]]<nowiki> Maximum parameter count exceeded</nowiki>
 [[M204.1764]]<nowiki> Input/output incompatibility: parameter number </nowiki>
 [[M204.1765]]<nowiki> Subroutine name multiply defined</nowiki>
 [[M204.1766]]<nowiki> Duplicate DP specification - </nowiki>
 [[M204.1767]]<nowiki> Null parameter list is illegal</nowiki>
 [[M204.1768]]<nowiki> Null parameter is illegal</nowiki>
 [[M204.1769]]<nowiki> Common/global is allowed only on first image</nowiki>
 [[M204.1770]]<nowiki> Illegal label specified</nowiki>
 [[M204.1771]]<nowiki> Expecting "Common" or "Global" not </nowiki>
 [[M204.1772]]<nowiki> Duplicate Len specification - </nowiki>
 [[M204.1773]]<nowiki> not allowed following Declare</nowiki>
 [[M204.1774]]<nowiki> Replication file must be TBO, and have roll forward and checkpoint logging enabled</nowiki>
 [[M204.1775]]<nowiki> Cannot use percent variable with file$ or list$ or location$</nowiki>
 [[M204.1776]]<nowiki> not valid in an expression</nowiki>
 [[M204.1777]]<nowiki> Condition missing on Repeat While statement</nowiki>
 [[M204.1778]]<nowiki> INCREASE/DECREASE rejected for file with active procedure</nowiki>
 [[M204.1779]]<nowiki> Return invalid in On units, use Bypass statement</nowiki>
 [[M204.1780]]<nowiki> Word "Times" required on Repeat n Times statement</nowiki>
 [[M204.1781]]<nowiki> Invalid condition on Repeat While statement</nowiki>
 [[M204.1782]]<nowiki> Active procedure - not restored</nowiki>
 [[M204.1784]]<nowiki> Invalid process-to-process status code</nowiki>
 [[M204.1785]]<nowiki> Data received has been truncated</nowiki>
 [[M204.1786]]<nowiki> Process-to-process not supported on this thread</nowiki>
 [[M204.1787]]<nowiki> The defined process-to-process buffer size is too large</nowiki>
 [[M204.1788]]<nowiki> Unable to allocate necessary process-to-process data areas</nowiki>
 [[M204.1789]]<nowiki> Invalid process-to-process message</nowiki>
 [[M204.1790]]<nowiki> CLOSE for Link failed</nowiki>
 [[M204.1791]]<nowiki> Partner process will not accept defined PROTOCOL, MODE, or TERMINAL</nowiki>
 [[M204.1792]]<nowiki> Odd length not allowed for String DBCS field</nowiki>
 [[M204.1793]]<nowiki> Partner process is not active</nowiki>
 [[M204.1794]]<nowiki> Invalid option , Synclevel assumed</nowiki>
 [[M204.1795]]<nowiki> function requires scattered group context</nowiki>
 [[M204.1796]]<nowiki> Process-to-process communications link has been closed</nowiki>
 [[M204.1797]]<nowiki> clause required for statement for this link type</nowiki>
 [[M204.1798]]<nowiki> Shadow group open failure</nowiki>
 [[M204.1799]]<nowiki> Shadow group communication failure</nowiki>
 [[M204.1801]]<nowiki> function index out of range</nowiki>
 [[M204.1803]]<nowiki> No inbound threads allocated</nowiki>
 [[M204.1804]]<nowiki> Insufficient CSA storage for cross-memory control block allocation</nowiki>
 [[M204.1805]]<nowiki> Error initializing cross-memory environment</nowiki>
 [[M204.1806]]<nowiki> Process not defined for transfer</nowiki>
 [[M204.1807]]<nowiki> Invalid Open: process not defined as master</nowiki>
 [[M204.1808]]<nowiki> Error in executing Transfer statement</nowiki>
 [[M204.1809]]<nowiki> Receive into input parameter is illegal</nowiki>
 [[M204.1810]]<nowiki> Open for link failed</nowiki>
 [[M204.1811]]<nowiki> User language statement is not supported for this link type</nowiki>
 [[M204.1812]]<nowiki> Proc file must be group member or *</nowiki>
 [[M204.1813]]<nowiki> Command not allowed in PROCFILE=* context</nowiki>
 [[M204.1815]]<nowiki> Temp group does not match numlock perm files-not logged into </nowiki>
 [[M204.1816]]<nowiki> Procedure already exists -- specify "replace"</nowiki>
 [[M204.1817]]<nowiki> CMS external security interface disabled - not running in CMS</nowiki>
 [[M204.1818]]<nowiki> Error initializing CMS external security </nowiki>
 [[M204.1819]]<nowiki> Error initializing PST for CMS external security</nowiki>
 [[M204.1820]]<nowiki> Unexpected IUCV interrupt type </nowiki>
 [[M204.1821]]<nowiki> CMS external security terminating due to error</nowiki>
 [[M204.1822]]<nowiki> error in routine function return code reason code </nowiki>
 [[M204.1823]]<nowiki> Security error in routine return code </nowiki>
 [[M204.1824]]<nowiki> error msg - see messages manual </nowiki>
 [[M204.1827]]<nowiki> Open failed for member of parallel stream </nowiki>
 [[M204.1831]]<nowiki> Invalid value specified for Signal</nowiki>
 [[M204.1832]]<nowiki> File skewed for different device type, file: </nowiki>
 [[M204.1836]]<nowiki> Ring stream created with members, DEFINE specified members</nowiki>
 [[M204.1837]]<nowiki> No records found on control stream for ring stream </nowiki>
 [[M204.1838]]<nowiki> Offload disabled for ring stream due to error on stream </nowiki>
 [[M204.1839]]<nowiki> Offload PST for ring stream failed to initialize</nowiki>
 [[M204.1841]]<nowiki> hardware feature required for </nowiki>
 [[M204.1842]]<nowiki> I/O error detected on stream due to error on </nowiki>
 [[M204.1843]]<nowiki> Autooffload value must be less than the number of ring members</nowiki>
 [[M204.1844]]<nowiki> Time specified exceeds 24 hours</nowiki>
 [[M204.1847]]<nowiki> Syntax error, command rejected</nowiki>
 [[M204.1848]]<nowiki> is an invalid name</nowiki>
 [[M204.1849]]<nowiki> Unable to allocate sufficient storage for work area, COPY command rejected</nowiki>
 [[M204.1850]]<nowiki> Nothing to be copied, COPY command failed</nowiki>
 [[M204.1851]]<nowiki> Unable to open stream, COPY command failed</nowiki>
 [[M204.1853]]<nowiki> I/O error on , COPY command failed</nowiki>
 [[M204.1854]]<nowiki> File full condition on output, COPY command failed</nowiki>
 [[M204.1855]]<nowiki> Stream is not a ring, or does not exist, command rejected</nowiki>
 [[M204.1856]]<nowiki> Stream to be ed is not opened for output, command rejected</nowiki>
 [[M204.1857]]<nowiki> Offload failed</nowiki>
 [[M204.1860]]<nowiki> Second argument to $View invalid with CURFILE</nowiki>
 [[M204.1861]]<nowiki> Invalid DBCS escape in input stream: x''</nowiki>
 [[M204.1862]]<nowiki> Insufficient length for String Mixed DBCS field</nowiki>
 [[M204.1863]]<nowiki> $stat arg "" is not a valid user statistic name</nowiki>
 [[M204.1865]]<nowiki> Cross-memory options are not supported in this environment</nowiki>
 [[M204.1866]]<nowiki> I/O error occurred while CCASTAT dataset</nowiki>
 [[M204.1867]]<nowiki> Unable to reposition the CCASTAT dataset to the beginning of the dataset</nowiki>
 [[M204.1868]]<nowiki> $stat type "" is not a valid statistic type</nowiki>
 [[M204.1869]]<nowiki> Invalid argument supplied to $hex</nowiki>
 [[M204.1870]]<nowiki> Second attempt to identify array or item size is invalid</nowiki>
 [[M204.1873]]<nowiki> DBCS parameter cannot be reset when DBCSENV=0</nowiki>
 [[M204.1875]]<nowiki> Unable to reset MODEL to </nowiki>
 [[M204.1876]]<nowiki> NJBUFF not resettable under z/VSE, NJBUFF=1 assumed</nowiki>
 [[M204.1879]]<nowiki> was not stopped</nowiki>
 [[M204.1880]]<nowiki> was not started</nowiki>
 [[M204.1881]]<nowiki> Too many signals received on session</nowiki>
 [[M204.1882]]<nowiki> Invalid value specified for timeout</nowiki>
 [[M204.1883]]<nowiki> value cannot be changed for this processgroup</nowiki>
 [[M204.1884]]<nowiki> is not operational</nowiki>
 [[M204.1885]]<nowiki> </nowiki>
 [[M204.1886]]<nowiki> </nowiki>
 [[M204.1887]]<nowiki> </nowiki>
 [[M204.1888]]<nowiki> </nowiki>
 [[M204.1899]]<nowiki> Transfer statement from to complete, User disconnected</nowiki>
 [[M204.1900]]<nowiki> User transferred to from </nowiki>
 [[M204.1901]]<nowiki> Location name expected after AT, not a comma</nowiki>
 [[M204.1902]]<nowiki> Location name expected after AT, not end of line</nowiki>
 [[M204.1903]]<nowiki> exceeds characters in length</nowiki>
 [[M204.1904]]<nowiki> Invalid option , must be OPTIONAL, MANDATORY, OPT or MAND</nowiki>
 [[M204.1905]]<nowiki> Missing ) after file option</nowiki>
 [[M204.1906]]<nowiki> BLDGFT=YES not allowed on scattered group</nowiki>
 [[M204.1907]]<nowiki> PROCFILE=* not allowed on scattered group</nowiki>
 [[M204.1908]]<nowiki> PROCFILE may not be remote</nowiki>
 [[M204.1909]]<nowiki> Location name is required</nowiki>
 [[M204.1910]]<nowiki> MAXFAIL greater than number of optional files</nowiki>
 [[M204.1911]]<nowiki> Invalid MAXFAIL specification, must be * or number <= count of optional files</nowiki>
 [[M204.1912]]<nowiki> MAXFAIL may only be specified on groups with optional members</nowiki>
 [[M204.1913]]<nowiki> Reopen only valid on group that was previously opened</nowiki>
 [[M204.1915]]<nowiki> Group open error: mandatory file at could not be opened</nowiki>
 [[M204.1916]]<nowiki> Group open error: more than MAXFAIL optional files could not be opened</nowiki>
 [[M204.1919]]<nowiki> Too many locations in scattered group</nowiki>
 [[M204.1920]]<nowiki> File - RPRA entry not initialized</nowiki>
 [[M204.1921]]<nowiki> Global lists/foundsets invalid in ad hoc group context</nowiki>
 [[M204.1924]]<nowiki> function requires group context</nowiki>
 [[M204.1925]]<nowiki> option requires </nowiki>
 [[M204.1926]]<nowiki> Bad replication record operation : </nowiki>
 [[M204.1927]]<nowiki> The initial 'by' value or direction parameter must be positive</nowiki>
 [[M204.1928]]<nowiki> Link is not open</nowiki>
 [[M204.1935]]<nowiki> UNIQUE fields are not allowed in non-TBO files</nowiki>
 [[M204.1936]]<nowiki> Missing bracket for incoming signal</nowiki>
 [[M204.1937]]<nowiki> is not open</nowiki>
 [[M204.1940]]<nowiki> Procedure file does not match subsysmgmt specification</nowiki>
 [[M204.1941]]<nowiki> New LFTBL must be at least , files must be closed</nowiki>
 [[M204.1943]]<nowiki> requires a string percent variable</nowiki>
 [[M204.1944]]<nowiki> IUCV connection with security machine severed</nowiki>
 [[M204.1945]]<nowiki> IUCV reply error - IPAUDIT = </nowiki>
 [[M204.1946]]<nowiki> Test or Debug privileges required when temp group used as procfile</nowiki>
 [[M204.1947]]<nowiki> and cannot both be specified</nowiki>
 [[M204.1948]]<nowiki> Open Process must run within a subsystem</nowiki>
 [[M204.1949]]<nowiki> 'OPEN' must be specified on DEFINE command</nowiki>
 [[M204.1950]]<nowiki> Password must be specified</nowiki>
 [[M204.1951]]<nowiki> Security violation</nowiki>
 [[M204.1952]]<nowiki> SESPARMS entity not supported</nowiki>
 [[M204.1953]]<nowiki> Type of 'open process' conflicts with type of process definition</nowiki>
 [[M204.1954]]<nowiki> LOGIN=TRUST must be specified if GUESTUSER=ACCEPT</nowiki>
 [[M204.1955]]<nowiki> Reserved names are not allowed in Open Process</nowiki>
 [[M204.1956]]<nowiki> Remote at must be re-opened</nowiki>
 [[M204.1957]]<nowiki> Not allowed in remote context</nowiki>
 [[M204.1958]]<nowiki> NFILES + NRMTFILE > 16383</nowiki>
 [[M204.1959]]<nowiki> PQO not linked in</nowiki>
 [[M204.1961]]<nowiki> Reopen failed: no such file</nowiki>
 [[M204.1962]]<nowiki> Reopen failed: file not previously opened</nowiki>
 [[M204.1963]]<nowiki> Invalid pattern </nowiki>
 [[M204.1964]]<nowiki> Sorted output not possible</nowiki>
 [[M204.1965]]<nowiki> Global name not found: </nowiki>
 [[M204.1966]]<nowiki> Non-subsystem file reference by temp group, recompiling</nowiki>
 [[M204.1967]]<nowiki> Remote access not allowed from IFAM</nowiki>
 [[M204.1970]]<nowiki> No remote file save area available</nowiki>
 [[M204.1971]]<nowiki> Remote file unavailable</nowiki>
 [[M204.1972]]<nowiki> Remote file physically broken</nowiki>
 [[M204.1973]]<nowiki> Non-TBO remote file</nowiki>
 [[M204.1974]]<nowiki> Input alias requires use of WITH NOALIAS keywords</nowiki>
 [[M204.1975]]<nowiki> Procedure may not replace alias: </nowiki>
 [[M204.1976]]<nowiki> NOALIAS keyword requires procedure name input</nowiki>
 [[M204.1977]]<nowiki> may not be accessed remotely</nowiki>
 [[M204.1978]]<nowiki> Storage could not be obtained for remote access</nowiki>
 [[M204.1979]]<nowiki> CCATEMP page could not be obtained for remote access </nowiki>
 [[M204.1980]]<nowiki> Conflicting parameter settings: and </nowiki>
 [[M204.1982]]<nowiki> Illegal jump attempted out of complex subroutine On Unit</nowiki>
 [[M204.1983]]<nowiki> Reopen disallowed, open will be done for remote file</nowiki>
 [[M204.1984]]<nowiki> Communication error on remote node processing </nowiki>
 [[M204.1986]]<nowiki> Error on remote node , : </nowiki>
 [[M204.1987]]<nowiki> Remote may not be accessed with multiple process groups</nowiki>
 [[M204.1988]]<nowiki> Data dictionary shipping error</nowiki>
 [[M204.1989]]<nowiki> Data expected and not received</nowiki>
 [[M204.1990]]<nowiki> Send indicator expected</nowiki>
 [[M204.1991]]<nowiki> Invalid conversation state</nowiki>
 [[M204.1993]]<nowiki> Communication error: status = , statusd = </nowiki>
 [[M204.1995]]<nowiki> Scattered commit incomplete</nowiki>
 [[M204.1996]]<nowiki> CMS parameter requires CMS environment</nowiki>
 [[M204.1997]]<nowiki> IN FILE clause required</nowiki>
 [[M204.1999]]<nowiki> Statement too long for PQO buffer</nowiki>
 [[M204.2000]]<nowiki> Too many variables in remote find retrieval conditions</nowiki>
 [[M204.2001]]<nowiki> Find All Values not allowed in remote context</nowiki>
 [[M204.2003]]<nowiki> Location missing for remote file</nowiki>
 [[M204.2004]]<nowiki> Function must be inside On Missing unit</nowiki>
 [[M204.2005]]<nowiki> missing or invalid </nowiki>
 [[M204.2006]]<nowiki> unused </nowiki>
 [[M204.2007]]<nowiki> Remote file at </nowiki>
 [[M204.2008]]<nowiki> LOCATION parameter omitted</nowiki>
 [[M204.2009]]<nowiki> Unexpected conversation state </nowiki>
 [[M204.2010]]<nowiki> Comm error status, statusd = </nowiki>
 [[M204.2011]]<nowiki> Comm error errmsg = </nowiki>
 [[M204.2012]]<nowiki> server error </nowiki>
 [[M204.2013]]<nowiki> Function not valid on current thread type</nowiki>
 [[M204.2014]]<nowiki> Illegal file parameter specified</nowiki>
 [[M204.2020]]<nowiki> ; , OPEN command rejected</nowiki>
 [[M204.2021]]<nowiki> Undefined variable type </nowiki>
 [[M204.2022]]<nowiki> Compiled IFAM is required for IFFIND/IFSORT</nowiki>
 [[M204.2023]]<nowiki> Cannot flush compilation or variable</nowiki>
 [[M204.2024]]<nowiki> Invalid 'in' clause specified</nowiki>
 [[M204.2025]]<nowiki> Invalid record set specification</nowiki>
 [[M204.2026]]<nowiki> Access security error: </nowiki>
 [[M204.2029]]<nowiki> Required record set parameter omitted</nowiki>
 [[M204.2030]]<nowiki> Invalid IFFIND specification</nowiki>
 [[M204.2031]]<nowiki> Open Process failed: CID=, remote ID=, SENSE=</nowiki>
 [[M204.2032]]<nowiki> "auto logout" required with "auto login" when security interface active</nowiki>
 [[M204.2033]]<nowiki> "in order" not valid on remote file</nowiki>
 [[M204.2034]]<nowiki> FRV not valid in remote context</nowiki>
 [[M204.2035]]<nowiki> Process name or cid too long</nowiki>
 [[M204.2036]]<nowiki> Sync level not supported</nowiki>
 [[M204.2046]]<nowiki> Invalid cursor specification</nowiki>
 [[M204.2047]]<nowiki> Cursor already opened</nowiki>
 [[M204.2048]]<nowiki> Invalid cursor name specified</nowiki>
 [[M204.2049]]<nowiki> Position lost during evaluation or it was never declared</nowiki>
 [[M204.2051]]<nowiki> Invalid - cursor is not open</nowiki>
 [[M204.2052]]<nowiki> Illegal image definition - previous image has no items</nowiki>
 [[M204.2054]]<nowiki> Conflicting file contexts</nowiki>
 [[M204.2057]]<nowiki> No physical extent information for this dataset, Open statement or command rejected</nowiki>
 [[M204.2059]]<nowiki> LOUTPB too small for Hitachi data stream</nowiki>
 [[M204.2060]]<nowiki> name '' is too long</nowiki>
 [[M204.2061]]<nowiki> No Horizon request available for response</nowiki>
 [[M204.2062]]<nowiki> DMSFRET error, return code = - run terminated</nowiki>
 [[M204.2063]]<nowiki> FRN not valid in remote context</nowiki>
 [[M204.2064]]<nowiki> is not initialized</nowiki>
 [[M204.2065]]<nowiki> Close-type keyword 'force' is required</nowiki>
 [[M204.2070]]<nowiki> statement does not support member=*, group=</nowiki>
 [[M204.2071]]<nowiki> Group member clause may not be used with file$ or location$</nowiki>
 [[M204.2084]]<nowiki> Referencing bad screen</nowiki>
 [[M204.2088]]<nowiki> Required cursor parameter missing</nowiki>
 [[M204.2089]]<nowiki> Cursor parameter invalid on this thread type</nowiki>
 [[M204.2090]]<nowiki> must be less than or equal to </nowiki>
 [[M204.2094]]<nowiki> invalid in group context</nowiki>
 [[M204.2100]]<nowiki> Invalid address specified</nowiki>
 [[M204.2101]]<nowiki> Reset not allowed, checkpointing not active</nowiki>
 [[M204.2102]]<nowiki> CPTIME cannot be reset from zero</nowiki>
 [[M204.2103]]<nowiki> Zero is an invalid reset value</nowiki>
 [[M204.2105]]<nowiki> Insufficient heap. MALLOC failed in </nowiki>
 [[M204.2107]]<nowiki> File was created by a later release</nowiki>
 [[M204.2108]]<nowiki> File was created by a later release</nowiki>
 [[M204.2109]]<nowiki> is a DUMP dataset</nowiki>
 [[M204.2110]]<nowiki> 1NF FILEMODL files must be TBO</nowiki>
 [[M204.2111]]<nowiki> 1NF FILEMODL requires field attribute AT-MOST-ONE</nowiki>
 [[M204.2112]]<nowiki> NUMERIC RANGE fields are incompatible with 1nf FILEMODL</nowiki>
 [[M204.2113]]<nowiki> Files cannot be reset to 1NF FILEMODL</nowiki>
 [[M204.2114]]<nowiki> fields are not supported in files created before </nowiki>
 [[M204.2116]]<nowiki> does not contain an ordered index</nowiki>
 [[M204.2117]]<nowiki> fields cannot be defined in a non-TBO file</nowiki>
 [[M204.2118]]<nowiki> 1NF FILEMODL requires field attribute AT-MOST-ONE</nowiki>
 [[M204.2119]]<nowiki> AT-MOST/EXACTLY-ONE constraint violation in record , field ignored: = </nowiki>
 [[M204.2121]]<nowiki> Repeating AT-MOST-ONE field prohibited</nowiki>
 [[M204.2122]]<nowiki> constraint violation for field in record </nowiki>
 [[M204.2123]]<nowiki> Value specified violates binary data type validation in record , field ignored: = </nowiki>
 [[M204.2124]]<nowiki> Value specified violates FLOAT data type validation in record , field ignored: = </nowiki>
 [[M204.2125]]<nowiki> FOR EACH VALUE fields are incompatible with 1NF FILEMODL</nowiki>
 [[M204.2126]]<nowiki> User's pushdown list overflowed</nowiki>
 [[M204.2128]]<nowiki> There were no updates to file in </nowiki>
 [[M204.2129]]<nowiki> Direction cannot be set to 0 for value set cursors</nowiki>
 [[M204.2130]]<nowiki> Invalid 'by' value. value = 0</nowiki>
 [[M204.2131]]<nowiki> FILEMODL can only be set to numeric validation during create - reset not allowed</nowiki>
 [[M204.2132]]<nowiki> 1NF FILEMODL requires numeric validation</nowiki>
 [[M204.2135]]<nowiki> "into" arguments must be string arrays</nowiki>
 [[M204.2137]]<nowiki> Group update file is unavailable</nowiki>
 [[M204.2139]]<nowiki> $pack precision must be in range 1-16</nowiki>
 [[M204.2140]]<nowiki> Function cannot execute while cursor is open against specified set</nowiki>
 [[M204.2141]]<nowiki> NSUBTKS too low, cant initialize DKBMTIME PST</nowiki>
 [[M204.2142]]<nowiki> Maximum number of iterations exceeded for procedure: </nowiki>
 [[M204.2146]]<nowiki> "count" argument cannot be a literal</nowiki>
 [[M204.2148]]<nowiki> Btree ordering impossible - cursor not opened</nowiki>
 [[M204.2153]]<nowiki> Dataset is already open</nowiki>
 [[M204.2155]]<nowiki> '' is invalid -- type '*trace ?' for usage</nowiki>
 [[M204.2156]]<nowiki> Unable to allocate sufficient storage for message buffer: rc = </nowiki>
 [[M204.2158]]<nowiki> Global definition doesn't match value in GTBL, , name hash=</nowiki>
 [[M204.2159]]<nowiki> $date/$datej/$datep format parameter must be 0, 1 or 2</nowiki>
 [[M204.2160]]<nowiki> Global screens may not contain multiple pages</nowiki>
 [[M204.2161]]<nowiki> Secondary declarations of globals must specify 'Common'</nowiki>
 [[M204.2162]]<nowiki> Global Images may not contain Len/Occurs Unknown</nowiki>
 [[M204.2165]]<nowiki> Subroutine parameter list incorrectly defined</nowiki>
 [[M204.2168]]<nowiki> Nonsensical If statement</nowiki>
 [[M204.2169]]<nowiki> unused </nowiki>
 [[M204.2170]]<nowiki> unused </nowiki>
 [[M204.2171]]<nowiki> unused </nowiki>
 [[M204.2172]]<nowiki> unused </nowiki>
 [[M204.2173]]<nowiki> unused </nowiki>
 [[M204.2174]]<nowiki> unused </nowiki>
 [[M204.2175]]<nowiki> unused </nowiki>
 [[M204.2176]]<nowiki> unused </nowiki>
 [[M204.2177]]<nowiki> unused </nowiki>
 [[M204.2178]]<nowiki> unused </nowiki>
 [[M204.2179]]<nowiki> unused </nowiki>
 [[M204.2180]]<nowiki> unused </nowiki>
 [[M204.2181]]<nowiki> unused </nowiki>
 [[M204.2182]]<nowiki> unused </nowiki>
 [[M204.2183]]<nowiki> unused </nowiki>
 [[M204.2184]]<nowiki> unused </nowiki>
 [[M204.2185]]<nowiki> unused </nowiki>
 [[M204.2186]]<nowiki> unused </nowiki>
 [[M204.2187]]<nowiki> unused </nowiki>
 [[M204.2188]]<nowiki> unused </nowiki>
 [[M204.2189]]<nowiki> unused </nowiki>
 [[M204.2190]]<nowiki> unused </nowiki>
 [[M204.2191]]<nowiki> unused </nowiki>
 [[M204.2192]]<nowiki> unused </nowiki>
 [[M204.2193]]<nowiki> unused </nowiki>
 [[M204.2194]]<nowiki> unused </nowiki>
 [[M204.2195]]<nowiki> unused </nowiki>
 [[M204.2196]]<nowiki> unused </nowiki>
 [[M204.2197]]<nowiki> unused </nowiki>
 [[M204.2198]]<nowiki> unused </nowiki>
 [[M204.2199]]<nowiki> unused </nowiki>
 [[M204.2200]]<nowiki> unused </nowiki>
 [[M204.2201]]<nowiki> unused </nowiki>
 [[M204.2202]]<nowiki> unused </nowiki>
 [[M204.2203]]<nowiki> unused </nowiki>
 [[M204.2204]]<nowiki> unused </nowiki>
 [[M204.2205]]<nowiki> unused </nowiki>
 [[M204.2206]]<nowiki> unused </nowiki>
 [[M204.2207]]<nowiki> unused </nowiki>
 [[M204.2208]]<nowiki> unused </nowiki>
 [[M204.2209]]<nowiki> unused </nowiki>
 [[M204.2210]]<nowiki> unused </nowiki>
 [[M204.2211]]<nowiki> unused </nowiki>
 [[M204.2212]]<nowiki> unused </nowiki>
 [[M204.2213]]<nowiki> unused </nowiki>
 [[M204.2214]]<nowiki> unused </nowiki>
 [[M204.2215]]<nowiki> unused </nowiki>
 [[M204.2216]]<nowiki> unused </nowiki>
 [[M204.2217]]<nowiki> unused </nowiki>
 [[M204.2218]]<nowiki> unused </nowiki>
 [[M204.2219]]<nowiki> unused </nowiki>
 [[M204.2220]]<nowiki> unused </nowiki>
 [[M204.2221]]<nowiki> unused </nowiki>
 [[M204.2222]]<nowiki> unused </nowiki>
 [[M204.2223]]<nowiki> unused </nowiki>
 [[M204.2224]]<nowiki> unused </nowiki>
 [[M204.2225]]<nowiki> unused </nowiki>
 [[M204.2226]]<nowiki> unused </nowiki>
 [[M204.2227]]<nowiki> unused </nowiki>
 [[M204.2228]]<nowiki> unused </nowiki>
 [[M204.2229]]<nowiki> unused </nowiki>
 [[M204.2230]]<nowiki> unused </nowiki>
 [[M204.2231]]<nowiki> unused </nowiki>
 [[M204.2232]]<nowiki> unused </nowiki>
 [[M204.2233]]<nowiki> unused </nowiki>
 [[M204.2234]]<nowiki> unused </nowiki>
 [[M204.2235]]<nowiki> unused </nowiki>
 [[M204.2236]]<nowiki> unused </nowiki>
 [[M204.2237]]<nowiki> unused </nowiki>
 [[M204.2238]]<nowiki> unused </nowiki>
 [[M204.2239]]<nowiki> unused </nowiki>
 [[M204.2240]]<nowiki> unused </nowiki>
 [[M204.2241]]<nowiki> unused </nowiki>
 [[M204.2242]]<nowiki> unused </nowiki>
 [[M204.2243]]<nowiki> unused </nowiki>
 [[M204.2244]]<nowiki> unused </nowiki>
 [[M204.2245]]<nowiki> unused </nowiki>
 [[M204.2246]]<nowiki> unused </nowiki>
 [[M204.2247]]<nowiki> unused </nowiki>
 [[M204.2248]]<nowiki> unused </nowiki>
 [[M204.2249]]<nowiki> unused </nowiki>
 [[M204.2250]]<nowiki> Model204 must run either with M204XSVC installed or from an APF-authorized library</nowiki>
 [[M204.2251]]<nowiki> IFLCKGET error: </nowiki>
 [[M204.2253]]<nowiki> Subsystem , - record contains invalid data</nowiki>
 [[M204.2254]]<nowiki> Value specified in LDC violates FLOAT data type validation, field ignored: = </nowiki>
 [[M204.2255]]<nowiki> Value specified in LDC violates BINARY data type validation, field ignored: = </nowiki>
 [[M204.2257]]<nowiki> Connection rejected by with explanation: </nowiki>
 [[M204.2258]]<nowiki> SESSIONS parameter too low on DEFINE to complete connection with </nowiki>
 [[M204.2261]]<nowiki> "end more" not supported for procs with DB2 statements</nowiki>
 [[M204.2262]]<nowiki> DB2: invalid statement: </nowiki>
 [[M204.2263]]<nowiki> DB2: invalid stmt: expected '', found ''</nowiki>
 [[M204.2264]]<nowiki> DB2: cursor name longer than 18 chars: </nowiki>
 [[M204.2265]]<nowiki> DB2: maximum number of cursors exceeded</nowiki>
 [[M204.2266]]<nowiki> DB2: string too long: </nowiki>
 [[M204.2267]]<nowiki> DB2: indicator variable not supported for stmt</nowiki>
 [[M204.2268]]<nowiki> DB2: (limitation) host variable may not be </nowiki>
 [[M204.2269]]<nowiki> DB2: CONNECT must be first DB2 command</nowiki>
 [[M204.2270]]<nowiki> DB2: only 1-byte kanji shifts supported</nowiki>
 [[M204.2271]]<nowiki> DB2: z/OS environment required</nowiki>
 [[M204.2272]]<nowiki> DB2: insufficient memory</nowiki>
 [[M204.2273]]<nowiki> DB2: undeclared cursor: </nowiki>
 [[M204.2274]]<nowiki> Invalid D2CB offset</nowiki>
 [[M204.2275]]<nowiki> File access rule table truncated</nowiki>
 [[M204.2276]]<nowiki> $wdwrap: invalid width value</nowiki>
 [[M204.2277]]<nowiki> $wdwrap: line too long</nowiki>
 [[M204.2278]]<nowiki> $wdwrap: hyp point cannot exceed width</nowiki>
 [[M204.2279]]<nowiki> $wdwrap: invalid hyphenation point</nowiki>
 [[M204.2280]]<nowiki> $justify: justification type invalid</nowiki>
 [[M204.2281]]<nowiki> $justify: invalid width value</nowiki>
 [[M204.2282]]<nowiki> No "on missing" unit or transaction is lost</nowiki>
 [[M204.2283]]<nowiki> Commit failed</nowiki>
 [[M204.2284]]<nowiki> 'Datalen' was invalid or omitted in process definition</nowiki>
 [[M204.2286]]<nowiki> Error processing remote node: , unable to stop subsystems</nowiki>
 [[M204.2287]]<nowiki> TCP/IP error: </nowiki>
 [[M204.2289]]<nowiki> valid when REMOTEID specifies an internet address </nowiki>
 [[M204.2290]]<nowiki> error: errno </nowiki>
 [[M204.2291]]<nowiki> MVS IUCV emulation failure</nowiki>
 [[M204.2292]]<nowiki> IUCV connection refused by TCPIP - sever reason code=</nowiki>
 [[M204.2294]]<nowiki> TCP/IP interface '' has already been created</nowiki>
 [[M204.2295]]<nowiki> TCP/IP interface name must be 1-8 characters long</nowiki>
 [[M204.2296]]<nowiki> TCP/IP interface '' is disabled or has not been created</nowiki>
 [[M204.2297]]<nowiki> Conditions not met for backward processing</nowiki>
 [[M204.2298]]<nowiki> is disabled </nowiki>
 [[M204.2299]]<nowiki> Conflicting parameters, NRMTLOCS and NRMTFILE</nowiki>
 [[M204.2300]]<nowiki> CPU ID authorization zap must be applied</nowiki>
 [[M204.2301]]<nowiki> Error processing remote node: , increase NRMTLOCS</nowiki>
 [[M204.2302]]<nowiki> No room in GTBL, LGTBL= - SETGRC</nowiki>
 [[M204.2303]]<nowiki> SETGRC variable(s) missing</nowiki>
 [[M204.2304]]<nowiki> Reset not allowed, CHKPTIMR PST not active</nowiki>
 [[M204.2305]]<nowiki> Node references do not match saved compilation references, recompiling</nowiki>
 [[M204.2306]]<nowiki> Error during remote APSY load: </nowiki>
 [[M204.2308]]<nowiki> Single-node update violation: </nowiki>
 [[M204.2309]]<nowiki> User not defined in sclass </nowiki>
 [[M204.2310]]<nowiki> Client and service node record security IDs do not match</nowiki>
 [[M204.2311]]<nowiki> Subsystem is being started</nowiki>
 [[M204.2312]]<nowiki> Subsystem stopped at </nowiki>
 [[M204.2313]]<nowiki> Communication error on remote node processing subsystem </nowiki>
 [[M204.2314]]<nowiki> Error on remote node : </nowiki>
 [[M204.2315]]<nowiki> Subsystem at is unavailable</nowiki>
 [[M204.2318]]<nowiki> is disabled</nowiki>
 [[M204.2319]]<nowiki> Open for failed: all members missing</nowiki>
 [[M204.2320]]<nowiki> Foundset or list not specified on the Position statement</nowiki>
 [[M204.2321]]<nowiki> Position name not specified on the Position statement</nowiki>
 [[M204.2322]]<nowiki> Synonym results in duplicate file entry for </nowiki>
 [[M204.2323]]<nowiki> "remember" can be specified within a record loop only</nowiki>
 [[M204.2324]]<nowiki> LANGFILE index= not found in NLANG for </nowiki>
 [[M204.2325]]<nowiki> Backout/Commit statistics overflow: </nowiki>
 [[M204.2326]]<nowiki> Number of lines to be skipped must be between 0 and 100</nowiki>
 [[M204.2327]]<nowiki> PQO version incompatibility with remote node: </nowiki>
 [[M204.2329]]<nowiki> at unavailable</nowiki>
 [[M204.2331]]<nowiki> File isn't defined to service subsystem </nowiki>
 [[M204.2332]]<nowiki> Requested privileges for file exceed allowed maximum</nowiki>
 [[M204.2333]]<nowiki> Subsystem definition does not allow remote access</nowiki>
 [[M204.2334]]<nowiki> Location pattern is required</nowiki>
 [[M204.2337]]<nowiki> Location$ is valid in the PQO environment only</nowiki>
 [[M204.2338]]<nowiki> Subsystem could not be stopped at </nowiki>
 [[M204.2339]]<nowiki> Subsystem not active at </nowiki>
 [[M204.2340]]<nowiki> Invalid language argument: '' for $function: </nowiki>
 [[M204.2341]]<nowiki> No active subsystem like </nowiki>
 [[M204.2342]]<nowiki> No active subsystem like from </nowiki>
 [[M204.2343]]<nowiki> The location must specify a remote node</nowiki>
 [[M204.2344]]<nowiki> This command only valid in z/OS or CMS</nowiki>
 [[M204.2345]]<nowiki> Remote access not allowed, NRMTLOCS not set</nowiki>
 [[M204.2346]]<nowiki> Remote file location name not found</nowiki>
 [[M204.2347]]<nowiki> Compilation not saved - </nowiki>
 [[M204.2348]]<nowiki> Subsystem record locking conflict</nowiki>
 [[M204.2349]]<nowiki> Referenced list undefined</nowiki>
 [[M204.2350]]<nowiki> Socket call completed abnormally due to </nowiki>
 [[M204.2352]]<nowiki> TCIU sever in progress for interface - reason=</nowiki>
 [[M204.2353]]<nowiki> Socket call completed with IBM errno=</nowiki>
 [[M204.2354]]<nowiki> Socket call cancellation failed - errno=</nowiki>
 [[M204.2355]]<nowiki> Link being closed due to </nowiki>
 [[M204.2356]]<nowiki> Unable to allocate sufficient sockets to open , requested , received </nowiki>
 [[M204.2357]]<nowiki> TCPIP late response for from -- TUHSQN=, SEICBSQN=, TH=</nowiki>
 [[M204.2358]]<nowiki> Expecting "global" not </nowiki>
 [[M204.2359]]<nowiki> Position name not specified on the Remember statement</nowiki>
 [[M204.2360]]<nowiki> Position has not been declared</nowiki>
 [[M204.2361]]<nowiki> Foundset or list not specified on the Remember statement</nowiki>
 [[M204.2362]]<nowiki> Position name not specified on the Declare statement</nowiki>
 [[M204.2363]]<nowiki> Position has already been defined</nowiki>
 [[M204.2364]]<nowiki> "position" can not be used in a for loop</nowiki>
 [[M204.2365]]<nowiki> "remember" is invalid in ad hoc group context</nowiki>
 [[M204.2366]]<nowiki> "remember" is invalid in a for loop that has no foundset</nowiki>
 [[M204.2370]]<nowiki> DKUPDTWT must be <= CPTIME*30</nowiki>
 [[M204.2371]]<nowiki> CHKP - increase NSUBTKS or set DKUPDTWT=0</nowiki>
 [[M204.2378]]<nowiki> Security trusted login feature disabled</nowiki>
 [[M204.2379]]<nowiki> Invalid trusted user-id length=</nowiki>
 [[M204.2380]]<nowiki> Could not find DSN for file selected in $dsn</nowiki>
 [[M204.2381]]<nowiki> No file entered in $dsn</nowiki>
 [[M204.2382]]<nowiki> No DSN number or DSN out of range</nowiki>
 [[M204.2383]]<nowiki> Processgroup must specify link or sessiongroup</nowiki>
 [[M204.2384]]<nowiki> was previously allocated to </nowiki>
 [[M204.2386]]<nowiki> An LU services error was received from REMOTEID= PROCESS= SENSE CODE=</nowiki>
 [[M204.2387]]<nowiki> Unknown or unsupported gds type received from remoteid= process= gdsid=</nowiki>
 [[M204.2389]]<nowiki> Error in sortget exit, sort terminated.</nowiki>
 [[M204.2390]]<nowiki> Sorted files may not specify a non-US LANGFILE</nowiki>
 [[M204.2391]]<nowiki> Subsystem , - translation failed for field </nowiki>
 [[M204.2392]]<nowiki> Invalid LOADNULLS option: must be ON or OFF</nowiki>
 [[M204.2393]]<nowiki> Subsystem , can't login PQO user</nowiki>
 [[M204.2394]]<nowiki> Subsystem , no remote login after autostart</nowiki>
 [[M204.2395]]<nowiki> Subsystem , - record missing</nowiki>
 [[M204.2397]]<nowiki> '' is not a valid option for the CLOSE LINK command</nowiki>
 [[M204.2398]]<nowiki> REMOTEID='' MODENAME='': undefined for link ''</nowiki>
 [[M204.2399]]<nowiki> Conversation state undefined</nowiki>
 [[M204.2400]]<nowiki> Ipcd buffer pointer is zero</nowiki>
 [[M204.2401]]<nowiki> Ipcd session pointer is zero</nowiki>
 [[M204.2402]]<nowiki> Failed to connect with TCP/IP server=</nowiki>
 [[M204.2403]]<nowiki> Global label does not reference a record set</nowiki>
 [[M204.2405]]<nowiki> Declare not allowed in IFAM</nowiki>
 [[M204.2406]]<nowiki> Only string variables allowed in IFAM</nowiki>
 [[M204.2407]]<nowiki> Remote location name expected</nowiki>
 [[M204.2408]]<nowiki> File or group keyword expected</nowiki>
 [[M204.2409]]<nowiki> File or group name expected</nowiki>
 [[M204.2410]]<nowiki> Keyword At expected</nowiki>
 [[M204.2411]]<nowiki> Specified file or group does not exist</nowiki>
 [[M204.2412]]<nowiki> ENABLE/DISABLE command complete</nowiki>
 [[M204.2413]]<nowiki> invalid outside of On unit</nowiki>
 [[M204.2414]]<nowiki> DBCS values cannot be truncated or padded on the left</nowiki>
 [[M204.2416]]<nowiki> Pure DBCS values cannot be padded on the right</nowiki>
 [[M204.2417]]<nowiki> Empty RESTART stream assumed in first pass</nowiki>
 [[M204.2422]]<nowiki> Roll forward did not get the same record number for old recno: new recno: </nowiki>
 [[M204.2423]]<nowiki> Type RF entry from update unit to was not reapplied</nowiki>
 [[M204.2424]]<nowiki> Integrity clause missing</nowiki>
 [[M204.2429]]<nowiki> Command requires administrator privileges</nowiki>
 [[M204.2430]]<nowiki> CREATEPQ command rejected</nowiki>
 [[M204.2433]]<nowiki> CCAPRQ required, but not present</nowiki>
 [[M204.2434]]<nowiki> Incorrect define print queue syntax, command rejected</nowiki>
 [[M204.2435]]<nowiki> Print queue facility not active</nowiki>
 [[M204.2436]]<nowiki> Print queue already exists</nowiki>
 [[M204.2438]]<nowiki> Option "" already specified, command rejected</nowiki>
 [[M204.2442]]<nowiki> Invalid specification, command rejected</nowiki>
 [[M204.2446]]<nowiki> DEBUGUL parm must be set before subsystem is started</nowiki>
 [[M204.2447]]<nowiki> Komm must be page fixed to use PCTIMER</nowiki>
 [[M204.2448]]<nowiki> DEBUGUL is set and no DEBUG information can be found for current statement</nowiki>
 [[M204.2450]]<nowiki> Testing</nowiki>
 [[M204.2454]]<nowiki> A link may not specify an application ID used by a remote that it owns</nowiki>
 [[M204.2455]]<nowiki> A remote may not specify an application ID used by the link that owns it</nowiki>
 [[M204.2456]]<nowiki> Replication field , not defined in </nowiki>
 [[M204.2460]]<nowiki> Global context does not match global definition</nowiki>
 [[M204.2461]]<nowiki> Continue is only valid in an On unit invoked from a For loop processing a scattered group</nowiki>
 [[M204.2462]]<nowiki> Invalid specified: </nowiki>
 [[M204.2465]]<nowiki> Invalid value '' for the parameter</nowiki>
 [[M204.2466]]<nowiki> The parameter requires that the parameter be specified</nowiki>
 [[M204.2467]]<nowiki> Operator rejected future date verification</nowiki>
 [[M204.2468]]<nowiki> SYSDATE/SYSTIME parameter is not within range of tod clock value</nowiki>
 [[M204.2469]]<nowiki> SYSDATE/SYSTIME parameter cannot be set to value prior to current system date/time</nowiki>
 [[M204.2470]]<nowiki> Please reply "y" or "n"</nowiki>
 [[M204.2471]]<nowiki> Length of parameter value is too large</nowiki>
 [[M204.2473]]<nowiki> was last updated in the future and has failed the future date check; current date: - date of file: </nowiki>
 [[M204.2474]]<nowiki> bad global variable: </nowiki>
 [[M204.2475]]<nowiki> Display of procedure would fill CCATEMP - command rejected</nowiki>
 [[M204.2476]]<nowiki> The following gds variable is not known to remote ID : </nowiki>
 [[M204.2477]]<nowiki> A map error was reported by the remote LU but no map was in use: remoteid= process=</nowiki>
 [[M204.2478]]<nowiki> '' rejected, would overwrite currently active proc</nowiki>
 [[M204.2479]]<nowiki> The following error log was received from REMOTEID : </nowiki>
 [[M204.2481]]<nowiki> Login conflicts with that specified by </nowiki>
 [[M204.2482]]<nowiki> MODENAME SNASVCMG is reserved for internal use</nowiki>
 [[M204.2483]]<nowiki> is not a valid name</nowiki>
 [[M204.2484]]<nowiki> On operation, image not active</nowiki>
 [[M204.2485]]<nowiki> , value not valid during evaluation</nowiki>
 [[M204.2487]]<nowiki> Data mover (M204XDM) is not active</nowiki>
 [[M204.2488]]<nowiki> restart of user after EOJ - attempted file update blocked </nowiki>
 [[M204.2489]]<nowiki> IODEV parameter expected</nowiki>
 [[M204.2490]]<nowiki> Illegal assignment to static %variable</nowiki>
 [[M204.2491]]<nowiki> Static %variables must have the Initial attribute</nowiki>
 [[M204.2492]]<nowiki> Invalid variable type for Initial attribute</nowiki>
 [[M204.2494]]<nowiki> updating a shared page</nowiki>
 [[M204.2495]]<nowiki> missing $function argument</nowiki>
 [[M204.2496]]<nowiki> Cleanx: invalid SVAR VTYPE</nowiki>
 [[M204.2497]]<nowiki> Cleanx: loop in SVAR chain</nowiki>
 [[M204.2498]]<nowiki> Cleanx: invalid SVAR chain pointer</nowiki>
 [[M204.2500]]<nowiki> SQL error : </nowiki>
 [[M204.2501]]<nowiki> Release incompatability</nowiki>
 [[M204.2502]]<nowiki> error, DSNAME = , return code = , reason code = </nowiki>
 [[M204.2503]]<nowiki> IBM system interface macro abended, abend code = , reason code = </nowiki>
 [[M204.2510]]<nowiki> Missing or incomplete CCAIN file</nowiki>
 [[M204.2513]]<nowiki> Non-ORDERED field for Value In clause</nowiki>
 [[M204.2514]]<nowiki> Remote Value In clause not supported</nowiki>
 [[M204.2515]]<nowiki> data set is invalid for </nowiki>
 [[M204.2516]]<nowiki> MQ/204 option error: require </nowiki>
 [[M204.2517]]<nowiki> More than 10 images specified</nowiki>
 [[M204.2518]]<nowiki> Fill character is invalid: it must have a value less than 256 (X'FF')</nowiki>
 [[M204.2520]]<nowiki> Illegal use of screen item name variable</nowiki>
 [[M204.2521]]<nowiki> Queue manager: not found</nowiki>
 [[M204.2522]]<nowiki> Message specification is invalid</nowiki>
 [[M204.2523]]<nowiki> The value of cannot be than </nowiki>
 [[M204.2524]]<nowiki> is an invalid </nowiki>
 [[M204.2525]]<nowiki> None may not be specified with other keywords on the Report option</nowiki>
 [[M204.2526]]<nowiki> and are mutually exclusive options</nowiki>
 [[M204.2527]]<nowiki> has already been specified</nowiki>
 [[M204.2528]]<nowiki> is an invalid option</nowiki>
 [[M204.2529]]<nowiki> Invalid run-time options variable</nowiki>
 [[M204.2530]]<nowiki> Reserved for MQ/204 use</nowiki>
 [[M204.2533]]<nowiki> MQMXTASK less than MQINTASK; MQMXTASK reset</nowiki>
 [[M204.2534]]<nowiki> Insufficient storage to allocate MQUSERD</nowiki>
 [[M204.2535]]<nowiki> MQ/204 disabled (MQINTASK is 0)</nowiki>
 [[M204.2536]]<nowiki> MQ/204 operations not allowed during recovery</nowiki>
 [[M204.2537]]<nowiki> Subtask abended with abcode and rsn code </nowiki>
 [[M204.2538]]<nowiki> Subtask terminated prematurely</nowiki>
 [[M204.2539]]<nowiki> Command invalid when MQINTASK is 0</nowiki>
 [[M204.2540]]<nowiki> Queue manager name required</nowiki>
 [[M204.2541]]<nowiki> Queue manager is not defined</nowiki>
 [[M204.2542]]<nowiki> No MQ/204 subtasks available</nowiki>
 [[M204.2543]]<nowiki> Connection to queue manager failed, reason code </nowiki>
 [[M204.2544]]<nowiki> Unable to start queue manager</nowiki>
 [[M204.2545]]<nowiki> Queue manager has not been started</nowiki>
 [[M204.2549]]<nowiki> command illegal from within a subsystem ()</nowiki>
 [[M204.2550]]<nowiki> More than extents specified, file: </nowiki>
 [[M204.2551]]<nowiki> is invalid for file: </nowiki>
 [[M204.2552]]<nowiki> IGCLM244 version 71D or higher is required</nowiki>
 [[M204.2553]]<nowiki> ECMSUBS less than ECISUBS; ECMSUBS reset</nowiki>
 [[M204.2556]]<nowiki> Insufficient storage to allocate </nowiki>
 [[M204.2565]]<nowiki> =, restart=</nowiki>
 [[M204.2574]]<nowiki> This operation is not supported from user zero</nowiki>
 [[M204.2575]]<nowiki> RENAME rejected, </nowiki>
 [[M204.2577]]<nowiki> Subsystem name exceeds 10 characters in length</nowiki>
 [[M204.2580]]<nowiki> Error creating dataspace - failed R15= R0=</nowiki>
 [[M204.2581]]<nowiki> APF authorization required for XMEMOPT=2 (IOS Branch Entry) and XMEMOPT=2 required for </nowiki>
 [[M204.2582]]<nowiki> Error creating dataspace - </nowiki>
 [[M204.2583]]<nowiki> PCBPTTRD not zero following passive socket close</nowiki>
 [[M204.2584]]<nowiki> SOCD not found</nowiki>
 [[M204.2585]]<nowiki> Close attempted for socket without SESD</nowiki>
 [[M204.2586]]<nowiki> Close attempted after API termination</nowiki>
 [[M204.2593]]<nowiki> SESD for socket was unexpectedly reallocated</nowiki>
 [[M204.2597]]<nowiki> command invalid from an RCL thread</nowiki>
 [[M204.2599]]<nowiki> TCP/IP PC call handler "SNMPGPCN" not linked in</nowiki>
 [[M204.2600]]<nowiki> Sessinit rejected: socket remoteid= port= link=</nowiki>
 [[M204.2601]]<nowiki> ECF module name not </nowiki>
 [[M204.2607]]<nowiki> CPQZACTN and CPQZSECS are corequisite parameters</nowiki>
 [[M204.2608]]<nowiki> CPQZACTN value is invalid or more than one mutually exclusive value set</nowiki>
 [[M204.2609]]<nowiki> Posting not allowed for named ECBs</nowiki>
 [[M204.2612]]<nowiki> CHECKPOINT command unsuccessful - </nowiki>
 [[M204.2616]]<nowiki> command ignored - system in extended quiesce</nowiki>
 [[M204.2617]]<nowiki> Extended quiesce ring journal offload failed</nowiki>
 [[M204.2618]]<nowiki> User entered a nonswappable SWAIT during extended quiesce processing - KJWHAT= x''</nowiki>
 [[M204.2619]]<nowiki> restarted - extended quiesce processing may be affected</nowiki>
 [[M204.2623]]<nowiki> JCL ddNames not allowed for GDG members; use DEFINE DATASET</nowiki>
 [[M204.2624]]<nowiki> Insert not supported for large object fields</nowiki>
 [[M204.2625]]<nowiki> User restart due to end-of-screen page pause with open Model 204 file pages</nowiki>
 [[M204.2629]]<nowiki> ONEPASS disallowed across file recovery</nowiki>
 [[M204.2630]]<nowiki> Statement too complicated</nowiki>
 [[M204.2631]]<nowiki> Too many subroutines</nowiki>
 [[M204.2637]]<nowiki> Unable to add entry: the maximum have already been added</nowiki>
 [[M204.2639]]<nowiki> Your password has expired</nowiki>
 [[M204.2640]]<nowiki> Command rejected: another user password table entry for </nowiki>
 [[M204.2641]]<nowiki> A new password must be entered: the current one </nowiki>
 [[M204.2642]]<nowiki> Your userid has been revoked: excessive failed login attempts</nowiki>
 [[M204.2643]]<nowiki> Passwords do not match</nowiki>
 [[M204.2645]]<nowiki> 'KEEPDEFS' specified and </nowiki>
 [[M204.2647]]<nowiki> Unable to update active definition, is no longer active.</nowiki>
 [[M204.2648]]<nowiki> Buffer or large object reference has </nowiki>
 [[M204.2650]]<nowiki> Pause time not in range </nowiki>
 [[M204.2653]]<nowiki> Refresh privileges required for subsystem </nowiki>
 [[M204.2654]]<nowiki> Table does not exist</nowiki>
 [[M204.2655]]<nowiki> Unable to resume subsystem </nowiki>
 [[M204.2656]]<nowiki> Unable to suspend subsystem </nowiki>
 [[M204.2658]]<nowiki> Subsystem not in suspend state</nowiki>
 [[M204.2660]]<nowiki> Bug .. roll forward did not put page on the reuse queue in </nowiki>
 [[M204.2662]]<nowiki> has no Table E pages</nowiki>
 [[M204.2663]]<nowiki> Remote files not allowed</nowiki>
 [[M204.2664]]<nowiki> Temp groups not allowed for subsystem procedure group</nowiki>
 [[M204.2668]]<nowiki> not found in any active subsystem</nowiki>
 [[M204.2669]]<nowiki> Procedure is in use by subsystem </nowiki>
 [[M204.2670]]<nowiki> Subsystem is unavailable</nowiki>
 [[M204.2671]]<nowiki> Parameter is not supported for files created before version </nowiki>
 [[M204.2672]]<nowiki> Refresh in progress for subsystem procedure: </nowiki>
 [[M204.2673]]<nowiki> Command requires an unordered file organization. </nowiki>
 [[M204.2674]]<nowiki> Invalid parameter: </nowiki>
 [[M204.2675]]<nowiki> Invalid value entered for parameter: </nowiki>
 [[M204.2676]]<nowiki> Insufficient free space in Table B. is full. Command COMPACTB ends.</nowiki>
 [[M204.2677]]<nowiki> : all free pages allowed for compaction have been used. Command COMPACTB ends.</nowiki>
 [[M204.2678]]<nowiki> Bug .. roll forward did not get the same extension record length for </nowiki>
 [[M204.2679]]<nowiki> Bug .. roll forward did not get the same extension pointer for </nowiki>
 [[M204.2680]]<nowiki> Bug .. roll forward did not get the same CHUNK length for </nowiki>
 [[M204.2681]]<nowiki> Bug .. roll forward did not get the same new record length for </nowiki>
 [[M204.2682]]<nowiki> : variable did not resolve to </nowiki>
 [[M204.2683]]<nowiki> REFRESH SUBSYSPROC command failed</nowiki>
 [[M204.2688]]<nowiki> CHKPNTS DD not open; sub-transaction checkpointing not active</nowiki>
 [[M204.2689]]<nowiki> Not enough Table E pages</nowiki>
 [[M204.2691]]<nowiki> Buffer assignment must reference large object field</nowiki>
 [[M204.2693]]<nowiki> Source and target lengths must be equal</nowiki>
 [[M204.2694]]<nowiki> Object extended too far</nowiki>
 [[M204.2695]]<nowiki> No buffer available</nowiki>
 [[M204.2696]]<nowiki> Attempt to access data past buffer end</nowiki>
 [[M204.2699]]<nowiki> $Lob functions require BLOB/CLOB field</nowiki>
 [[M204.2700]]<nowiki> CHECKPOINT command ignored: sub-transaction checkpoint in progress </nowiki>
 [[M204.2702]]<nowiki> mismatch between Table queue length after rebuild and number of pages added to the queue: </nowiki>
 [[M204.2703]]<nowiki> Open failed. File update in progress</nowiki>
 [[M204.2704]]<nowiki> Buffer reference requires LOB field</nowiki>
 [[M204.2705]]<nowiki> Compilation syntax required large object field, but evaluation found '' </nowiki>
 [[M204.2706]]<nowiki> Reserve clause invalid on Change statement</nowiki>
 [[M204.2707]]<nowiki> Table B auto increase parameters are not supported for hash files</nowiki>
 [[M204.2710]]<nowiki> Error setting TCP/IP SYSID </nowiki>
 [[M204.2713]]<nowiki> Insert not supported for large object fields</nowiki>
 [[M204.2715]]<nowiki> Attempt to access data past end of LOB</nowiki>
 [[M204.2717]]<nowiki> Automatic increase for Table is not done due to empty free space</nowiki>
 [[M204.2718]]<nowiki> Send statement bytes value less than one</nowiki>
 [[M204.2719]]<nowiki> Open or OpenC failed. Update statements already compiled, read only privileges insufficient</nowiki>
 [[M204.2720]]<nowiki> VIO not allowed with XMEMOPT=2</nowiki>
 [[M204.2721]]<nowiki> TCP address already uses port on interface </nowiki>
 [[M204.2723]]<nowiki> FOPT=x'10' invalid when DTSFN not specified in run</nowiki>
 [[M204.2725]]<nowiki> File options x'10' and x'02' are incompatible</nowiki>
 [[M204.2726]]<nowiki> Previous compaction for has not finished</nowiki>
 [[M204.2727]]<nowiki> Can't delete DTS field when FOPT=X'10' is on</nowiki>
 [[M204.2728]]<nowiki> Date time stamp field may not be INVISIBLE, UNIQUE, nor have multiple occurrences</nowiki>
 [[M204.2729]]<nowiki> Date time stamp file may not be opened when DTSFN not specified in run</nowiki>
 [[M204.2730]]<nowiki> Date time stamp file, but DTSFN not defined in file</nowiki>
 [[M204.2732]]<nowiki> has no Table X defined. Parameter "DELETE" not allowed.</nowiki>
 [[M204.2733]]<nowiki> DTS option is not allowed for files created before release 6.1</nowiki>
 [[M204.2734]]<nowiki> IARV error - return code=, reason code=x''</nowiki>
 [[M204.2735]]<nowiki> has too many records per Table B page to satisfy record limit requirement</nowiki>
 [[M204.2738]]<nowiki> Command requires file manager privilege for </nowiki>
 [[M204.2739]]<nowiki> Parameter cannot be reset on user 0's parameter line: </nowiki>
 [[M204.2740]]<nowiki> Invalid parameter : support not linked in</nowiki>
 [[M204.2742]]<nowiki> Bug .. new record number not basic for </nowiki>
 [[M204.2743]]<nowiki> Bug .. first record not basic for </nowiki>
 [[M204.2744]]<nowiki> Bug .. not enough space on page for </nowiki>
 [[M204.2745]]<nowiki> Bug .. extension pointer not zero for </nowiki>
 [[M204.2746]]<nowiki> XSIZE*XRECPPG may not be 1 nor exceed 536870911</nowiki>
 [[M204.2747]]<nowiki> Table X not supported under sorted or hashed organization</nowiki>
 [[M204.2748]]<nowiki> Starting record number is too big</nowiki>
 [[M204.2755]]<nowiki> unexpected error during physical delete. Compaction ends.</nowiki>
 [[M204.2759]]<nowiki> not supported under CMS</nowiki>
 [[M204.2760]]<nowiki> not allowed with NUMBUFG > 0</nowiki>
 [[M204.2762]]<nowiki> has no Table X defined. Parameter "TABLEX" not allowed.</nowiki>
 [[M204.2770]]<nowiki> parameter RECRDOPT=1 requires Table X to be defined.</nowiki>
 [[M204.2771]]<nowiki> Attempt to update TBO and non-TBO files in the same transaction</nowiki>
 [[M204.2772]]<nowiki> File already at dynamic maximum</nowiki>
 [[M204.2773]]<nowiki> The LPM will be too big</nowiki>
 [[M204.2774]]<nowiki> Another command is in progress</nowiki>
 [[M204.2775]]<nowiki> Invalid expression in Initial clause</nowiki>
 [[M204.2776]]<nowiki> scheduler abend, Model 204 terminating</nowiki>
 [[M204.2778]]<nowiki> DB2THRD not zero but module ULDB is not linked.</nowiki>
 [[M204.2779]]<nowiki> Undeclared variable in Initial clause</nowiki>
 [[M204.2780]]<nowiki> Abend during initialization, Model 204 terminating</nowiki>
 [[M204.2781]]<nowiki> Gstatus must be G, L, spaces, or null</nowiki>
 [[M204.2782]]<nowiki> XSIZE must be specified</nowiki>
 [[M204.2783]]<nowiki> Temp group does not match saved compilation, recompiling</nowiki>
 [[M204.2789]]<nowiki> Error executing Fast/Unload request for PGM=FUNLOAD: </nowiki>
 [[M204.2792]]<nowiki> </nowiki>
 [[M204.2793]]<nowiki> Initial must be specified in first Common declaration</nowiki>
 [[M204.2795]]<nowiki> Reserve keyword expected</nowiki>
 [[M204.2796]]<nowiki> SMTP </nowiki>
 [[M204.2797]]<nowiki> Expected comma - found </nowiki>
 [[M204.2798]]<nowiki> BLOB/CLOB field or FNV required</nowiki>
 [[M204.2799]]<nowiki> $SndMail error </nowiki>
 [[M204.2800]]<nowiki> >><<</nowiki>
 [[M204.2801]]<nowiki> </nowiki>
 [[M204.2802]]<nowiki> </nowiki>
 [[M204.2803]]<nowiki> (File = , procedure = , line = )</nowiki>
 [[M204.2808]]<nowiki> BLOB/CLOB field not allowed</nowiki>
 [[M204.2809]]<nowiki> wrong segment for page </nowiki>
 [[M204.2810]]<nowiki> descriptor not found for object at record number </nowiki>
 [[M204.2818]]<nowiki> record has no field pointing to object at </nowiki>
 [[M204.2819]]<nowiki> record not found for object at </nowiki>
 [[M204.2820]]<nowiki> discrepancy found for page </nowiki>
 [[M204.2821]]<nowiki> object at stretches past EHIGHPG</nowiki>
 [[M204.2822]]<nowiki> Compaction ends abnormally. has to be recovered</nowiki>
 [[M204.2823]]<nowiki> bug during object move</nowiki>
 [[M204.2824]]<nowiki> Bug .. DKFPE: no object found</nowiki>
 [[M204.2826]]<nowiki> compaction not allowed</nowiki>
 [[M204.2827]]<nowiki> Bug .. DKFPE: different record number</nowiki>
 [[M204.2828]]<nowiki> Bug .. DKFPE: different attribute</nowiki>
 [[M204.2830]]<nowiki> Unable to allocate SDASDENQ work area - more entries exist</nowiki>
 [[M204.2831]]<nowiki> Updates to DTS files not supported in this environment</nowiki>
 [[M204.2833]]<nowiki> fields cannot be defined in a file with ATRPG*ASTRPPG>4000</nowiki>
 [[M204.2837]]<nowiki> No logical connection between process and remoteid </nowiki>
 [[M204.2838]]<nowiki> only valid in FILEORG x'100' files</nowiki>
 [[M204.2839]]<nowiki> is a , not a </nowiki>
 [[M204.2840]]<nowiki> Statement has too many intermediate results</nowiki>
 [[M204.2841]]<nowiki> Remote fieldgroups not supported</nowiki>
 [[M204.2842]]<nowiki> Invalid context for fieldgroup</nowiki>
 [[M204.2843]]<nowiki> Maximum fieldgroup ID exceeded in record in </nowiki>
 [[M204.2844]]<nowiki> Mix of fields and fieldgroups, name = </nowiki>
 [[M204.2845]]<nowiki> Invalid fieldgroup context for </nowiki>
 [[M204.2846]]<nowiki> Invalid fieldgroup context for </nowiki>
 [[M204.2847]]<nowiki> Fieldgroup context lost in record in </nowiki>
 [[M204.2848]]<nowiki> Invalid fieldgroup ID: </nowiki>
 [[M204.2849]]<nowiki> Required keyword missing</nowiki>
 [[M204.2850]]<nowiki> value missing</nowiki>
 [[M204.2851]]<nowiki> value '' too big, must be </nowiki>
 [[M204.2852]]<nowiki> Update to missing fieldgroup occurrence in record in </nowiki>
 [[M204.2853]]<nowiki> not allowed for EXACTLY-ONE field</nowiki>
 [[M204.2854]]<nowiki> Attempt to do for EXACTLY-ONE field: </nowiki>
 [[M204.2855]]<nowiki> Field depth+length unrepresentable in record in </nowiki>
 [[M204.2856]]<nowiki> Fieldname variable : expected , got </nowiki>
 [[M204.2857]]<nowiki> COUNT-OCCURRENCES-OF field not allowed for field</nowiki>
 [[M204.2858]]<nowiki> Fieldgroup context mismatch between COUNT-OCCURRENCES-OF field and counted field</nowiki>
 [[M204.2859]]<nowiki> New field not allowed for non-empty file</nowiki>
 [[M204.2860]]<nowiki> Field already has a COUNT-OCCURRENCES-OF field</nowiki>
 [[M204.2861]]<nowiki> Occurrence counter overflowed</nowiki>
 [[M204.2862]]<nowiki> Attempt to update automatic field </nowiki>
 [[M204.2863]]<nowiki> Attempt to do for automatic field: </nowiki>
 [[M204.2865]]<nowiki> Attempt to invalid DATETIME value: = </nowiki>
 [[M204.2866]]<nowiki> File already has field</nowiki>
 [[M204.2867]]<nowiki> Fieldgroup already has field</nowiki>
 [[M204.2868]]<nowiki> MINLOBE must be between 0 and </nowiki>
 [[M204.2869]]<nowiki> Change refused: MINLOBE > 0 for field </nowiki>
 [[M204.2870]]<nowiki> Change refused: MINLOBE > 0 for field </nowiki>
 [[M204.2871]]<nowiki> Fieldgroup context mismatch between CONCATENATION-OF field and component field</nowiki>
 [[M204.2872]]<nowiki> Concatenation value too long for field </nowiki>
 [[M204.2873]]<nowiki> Concatenation field component field contains separator character</nowiki>
 [[M204.2874]]<nowiki> Attempt to a value that's : = </nowiki>
 [[M204.2875]]<nowiki> Concatenation list invalid: </nowiki>
 [[M204.2876]]<nowiki> Invalid value: </nowiki>
 [[M204.2877]]<nowiki> With clause invalid: </nowiki>
 [[M204.2878]]<nowiki> With clause invalid: field in </nowiki>
 [[M204.2880]]<nowiki> Memory datasets cannot be part of multi-dataset file</nowiki>
 [[M204.2881]]<nowiki> Data conversion error</nowiki>
 [[M204.2884]]<nowiki> was previously defined as a , new definition ignored</nowiki>
 [[M204.2885]]<nowiki> Invalid fieldgroup ID: </nowiki>
 [[M204.2886]]<nowiki> Fieldgroup ID already exists in record in </nowiki>
 [[M204.2887]]<nowiki> ABANDON option invalid for this type of link</nowiki>
 [[M204.2893]]<nowiki> '' is not a valid option for the OPEN LINK command</nowiki>
 [[M204.2894]]<nowiki> Link cannot be replaced - it is not a VTAM LU 6.2 link</nowiki>
 [[M204.2895]]<nowiki> Link has not been abandoned, is open, or was closed ok</nowiki>
 [[M204.2898]]<nowiki> Print To not supported for LOB fields</nowiki>
 [[M204.2899]]<nowiki> Remote fieldgroup updates not supported</nowiki>
 [[M204.2900]]<nowiki> Cannot delete that </nowiki>
 [[M204.2906]]<nowiki> IEANTCR cannot be loaded - code rc </nowiki>
 [[M204.2908]]<nowiki> Processgroup not found for remote </nowiki>
 [[M204.2909]]<nowiki> IEANTDL return code - name/token not deleted</nowiki>
 [[M204.2910]]<nowiki> IEANTDL cannot be loaded - code rc </nowiki>
 [[M204.2911]]<nowiki> Attempted connect from processgroup to IPV6 server , but link is IPV4</nowiki>
 [[M204.2912]]<nowiki> IEANTCR return code - name/token not created</nowiki>
 [[M204.2913]]<nowiki> "new" option requires single user run</nowiki>
 [[M204.2914]]<nowiki> CCASERVR in memory is required for </nowiki>
 [[M204.2916]]<nowiki> requires at least one area to be set in </nowiki>
 [[M204.2917]]<nowiki> Server dataset is allocated above 64k cyl. Servers above 64k cyl are not supported.</nowiki>
 [[M204.2918]]<nowiki> Parameter SERVNSSZ is only valid when servers in memory are used</nowiki>
 [[M204.2920]]<nowiki> Non-zero SERVNSSZ is required</nowiki>
 [[M204.2921]]<nowiki> Server areas above the bar are not supported in VSE</nowiki>
 [[M204.2922]]<nowiki> bit setting is not valid</nowiki>
 [[M204.2929]]<nowiki> Can't open file with UTF fields without Sirius unicode support</nowiki>
 [[M204.2932]]<nowiki> Increase SERVNSSZ to at least for required non swappable server areas</nowiki>
 [[M204.2933]]<nowiki> Module version mismatch, KOMM=, =</nowiki>
 [[M204.2934]]<nowiki> FILEORG X'200' not supported for hashed or sorted file organizations</nowiki>
 [[M204.2935]]<nowiki> fields may not be RENAMED or DELETED</nowiki>
 [[M204.2936]]<nowiki> A CHUNK field of size already exists for this field</nowiki>
 [[M204.2937]]<nowiki> CHUNK size: is not an integral multiple/divisor of the existing CHUNK size: </nowiki>
 [[M204.2938]]<nowiki> You may not define more than CHUNKS for a field</nowiki>
 [[M204.2940]]<nowiki> Attempt to use filename () after INITIALIZE keyword disallowed because it is misleading</nowiki>
 [[M204.2941]]<nowiki> File being initialized () does not match name given after INITIALIZE command: </nowiki>
 [[M204.2942]]<nowiki> Extraneous string after field attribute list: </nowiki>
 [[M204.2943]]<nowiki> Error using filename phrase for file : FILE keyword required</nowiki>
 [[M204.2944]]<nowiki> Should have end of INITIALIZE command but instead found: </nowiki>
 [[M204.2945]]<nowiki> Error(s) encountered, command not performed</nowiki>
 [[M204.2948]]<nowiki> Setting of 1 in SIRFUNC is required for zIIP usage when FUNDLE is linked in</nowiki>
 [[M204.2949]]<nowiki> Expecting on command, found: ''</nowiki>
 [[M204.2950]]<nowiki> IODEV 25 line not allowed with FUNTSKN > 0</nowiki>
 [[M204.2955]]<nowiki> Universal buffer allocation failed.</nowiki>
 [[M204.2958]]<nowiki> APSYPAGE is obsolete as of 7.6. Rocket recommends using RESPAGE and/or TEMPPAGE as the alternative</nowiki>
 [[M204.2959]]<nowiki> Invalid product keyword: </nowiki>
 [[M204.2964]]<nowiki> Password missing or too long</nowiki>
 [[M204.2969]]<nowiki> MBSCAN () exceeded, records to be searched = </nowiki>
 [[M204.2971]]<nowiki> No 2PC ports named with coordinators named defined</nowiki>
 [[M204.2973]]<nowiki> Unable to reset Model to : </nowiki>
 [[M204.2974]]<nowiki> Action disabled by commit exit</nowiki>
 [[M204.2976]]<nowiki> Attempt to update non-TBO file in a global transaction</nowiki>
 [[M204.2978]]<nowiki> Implicit commit of global transaction failed</nowiki>
 [[M204.2980]]<nowiki> unused </nowiki>
 [[M204.2981]]<nowiki> unused </nowiki>
 [[M204.2982]]<nowiki> unused </nowiki>
 [[M204.2983]]<nowiki> unused </nowiki>
 [[M204.2984]]<nowiki> unused </nowiki>
 [[M204.2985]]<nowiki> unused </nowiki>
 [[M204.2986]]<nowiki> unused </nowiki>
 [[M204.2987]]<nowiki> unused </nowiki>
 [[M204.2988]]<nowiki> VTAM transfer failed, Session Parameters(LOGMODE, Cryptography, or VPACING) are invalid</nowiki>
 [[M204.2989]]<nowiki> unused </nowiki>
 [[M204.2990]]<nowiki> unused </nowiki>
 [[M204.2991]]<nowiki> unused </nowiki>
 [[M204.2992]]<nowiki> unused </nowiki>
 [[M204.2993]]<nowiki> unused </nowiki>
 [[M204.2994]]<nowiki> unused </nowiki>
 [[M204.2995]]<nowiki> unused </nowiki>
 [[M204.2996]]<nowiki> unused </nowiki>
 [[M204.2997]]<nowiki> unused </nowiki>
 [[M204.2998]]<nowiki> unused </nowiki>
 [[M204.2999]]<nowiki> unused </nowiki>
 [[M204.3000]]<nowiki> unused </nowiki>
 [[M204.3001]]<nowiki> unused </nowiki>
 [[M204.3002]]<nowiki> unused </nowiki>
 [[M204.3003]]<nowiki> unused </nowiki>
 [[M204.3004]]<nowiki> unused </nowiki>
 [[M204.3005]]<nowiki> unused </nowiki>
 [[M204.3006]]<nowiki> unused </nowiki>
 [[M204.3007]]<nowiki> unused </nowiki>
 [[M204.3008]]<nowiki> unused </nowiki>
 [[M204.3009]]<nowiki> unused </nowiki>
 [[M204.3010]]<nowiki> unused </nowiki>
 [[M204.3011]]<nowiki> unused </nowiki>
 [[M204.3012]]<nowiki> unused </nowiki>
 [[M204.3013]]<nowiki> unused </nowiki>
 [[M204.3014]]<nowiki> unused </nowiki>
 [[M204.3015]]<nowiki> unused </nowiki>
 [[M204.3016]]<nowiki> unused </nowiki>
 [[M204.3017]]<nowiki> unused </nowiki>
 [[M204.3018]]<nowiki> unused </nowiki>
 [[M204.3019]]<nowiki> unused </nowiki>
 [[M204.3020]]<nowiki> unused </nowiki>
 [[M204.3021]]<nowiki> unused </nowiki>
 [[M204.3022]]<nowiki> unused </nowiki>
 [[M204.3023]]<nowiki> unused </nowiki>
 [[M204.3024]]<nowiki> unused </nowiki>
 [[M204.3025]]<nowiki> unused </nowiki>
 [[M204.3026]]<nowiki> TPN: Requesting User: </nowiki>
 [[M204.3027]]<nowiki> Source was </nowiki>
 [[M204.3028]]<nowiki> unused </nowiki>
 [[M204.3029]]<nowiki> unused </nowiki>
 [[M204.3030]]<nowiki> unused </nowiki>
 [[M204.3031]]<nowiki> unused </nowiki>
 [[M204.3032]]<nowiki> unused </nowiki>
 [[M204.3033]]<nowiki> unused </nowiki>
 [[M204.3034]]<nowiki> unused </nowiki>
 [[M204.3035]]<nowiki> unused </nowiki>
 [[M204.3036]]<nowiki> unused </nowiki>
 [[M204.3037]]<nowiki> unused </nowiki>
 [[M204.3038]]<nowiki> unused </nowiki>
 [[M204.3039]]<nowiki> unused </nowiki>
 [[M204.3040]]<nowiki> unused </nowiki>
 [[M204.3041]]<nowiki> unused </nowiki>
 [[M204.3042]]<nowiki> unused </nowiki>
 [[M204.3043]]<nowiki> unused </nowiki>
 [[M204.3044]]<nowiki> unused </nowiki>
 [[M204.3045]]<nowiki> unused </nowiki>
 [[M204.3046]]<nowiki> unused </nowiki>
 [[M204.3047]]<nowiki> unused </nowiki>
 [[M204.3048]]<nowiki> unused </nowiki>
 [[M204.3049]]<nowiki> unused </nowiki>
 [[M204.3050]]<nowiki> unused </nowiki>
 [[M204.3051]]<nowiki> unused </nowiki>
 [[M204.3052]]<nowiki> unused </nowiki>
 [[M204.3053]]<nowiki> unused </nowiki>
 [[M204.3054]]<nowiki> unused </nowiki>
 [[M204.3055]]<nowiki> unused </nowiki>
 [[M204.3056]]<nowiki> unused </nowiki>
 [[M204.3057]]<nowiki> unused </nowiki>
 [[M204.3058]]<nowiki> unused </nowiki>
 [[M204.3059]]<nowiki> unused </nowiki>
 [[M204.3060]]<nowiki> unused </nowiki>
 [[M204.3061]]<nowiki> unused </nowiki>
 [[M204.3062]]<nowiki> unused </nowiki>
 [[M204.3063]]<nowiki> unused </nowiki>
 [[M204.3064]]<nowiki> unused </nowiki>
 [[M204.3065]]<nowiki> unused </nowiki>
 [[M204.3066]]<nowiki> unused </nowiki>
 [[M204.3067]]<nowiki> unused </nowiki>
 [[M204.3068]]<nowiki> unused </nowiki>
 [[M204.3069]]<nowiki> unused </nowiki>
 [[M204.3070]]<nowiki> unused </nowiki>
 [[M204.3071]]<nowiki> unused </nowiki>
 [[M204.3072]]<nowiki> unused </nowiki>
 [[M204.3073]]<nowiki> unused </nowiki>
 [[M204.3074]]<nowiki> unused </nowiki>
 [[M204.3075]]<nowiki> unused </nowiki>
 [[M204.3076]]<nowiki> unused </nowiki>
 [[M204.3077]]<nowiki> unused </nowiki>
 [[M204.3078]]<nowiki> unused </nowiki>
 [[M204.3079]]<nowiki> unused </nowiki>
 [[M204.3080]]<nowiki> unused </nowiki>
 [[M204.3081]]<nowiki> unused </nowiki>
 [[M204.3082]]<nowiki> unused </nowiki>
 [[M204.3083]]<nowiki> unused </nowiki>
 [[M204.3084]]<nowiki> unused </nowiki>
 [[M204.3085]]<nowiki> unused </nowiki>
 [[M204.3086]]<nowiki> unused </nowiki>
 [[M204.3087]]<nowiki> unused </nowiki>
 [[M204.3088]]<nowiki> unused </nowiki>
 [[M204.3089]]<nowiki> unused </nowiki>
 [[M204.3090]]<nowiki> unused </nowiki>
 [[M204.3091]]<nowiki> unused </nowiki>
 [[M204.3092]]<nowiki> unused </nowiki>
 [[M204.3093]]<nowiki> unused </nowiki>
 [[M204.3094]]<nowiki> unused </nowiki>
 [[M204.3095]]<nowiki> unused </nowiki>
 [[M204.3096]]<nowiki> unused </nowiki>
 [[M204.3097]]<nowiki> unused </nowiki>
 [[M204.3098]]<nowiki> unused </nowiki>
 [[M204.3099]]<nowiki> unused </nowiki>
 [[M204.3100]]<nowiki> unused </nowiki>
 [[M204.3101]]<nowiki> unused </nowiki>
 [[M204.3102]]<nowiki> unused </nowiki>
 [[M204.3103]]<nowiki> unused </nowiki>
 [[M204.3104]]<nowiki> unused </nowiki>
 [[M204.3105]]<nowiki> unused </nowiki>
 [[M204.3106]]<nowiki> unused </nowiki>
 [[M204.3107]]<nowiki> unused </nowiki>
 [[M204.3108]]<nowiki> unused </nowiki>
 [[M204.3109]]<nowiki> unused </nowiki>
 [[M204.3110]]<nowiki> unused </nowiki>
 [[M204.3111]]<nowiki> unused </nowiki>
 [[M204.3112]]<nowiki> unused </nowiki>
 [[M204.3113]]<nowiki> unused </nowiki>
 [[M204.3114]]<nowiki> unused </nowiki>
 [[M204.3115]]<nowiki> unused </nowiki>
 [[M204.3116]]<nowiki> unused </nowiki>
 [[M204.3117]]<nowiki> unused </nowiki>
 [[M204.3118]]<nowiki> unused </nowiki>
 [[M204.3119]]<nowiki> unused </nowiki>
 [[M204.3120]]<nowiki> unused </nowiki>
 [[M204.3121]]<nowiki> unused </nowiki>
 [[M204.3122]]<nowiki> unused </nowiki>
 [[M204.3123]]<nowiki> unused </nowiki>
 [[M204.3124]]<nowiki> unused </nowiki>
 [[M204.3125]]<nowiki> unused </nowiki>
 [[M204.3126]]<nowiki> unused </nowiki>
 [[M204.3127]]<nowiki> unused </nowiki>
 [[M204.3128]]<nowiki> unused </nowiki>
 [[M204.3129]]<nowiki> unused </nowiki>
 [[M204.3130]]<nowiki> unused </nowiki>
 [[M204.3131]]<nowiki> unused </nowiki>
 [[M204.3132]]<nowiki> unused </nowiki>
 [[M204.3133]]<nowiki> unused </nowiki>
 [[M204.3134]]<nowiki> unused </nowiki>
 [[M204.3135]]<nowiki> unused </nowiki>
 [[M204.3136]]<nowiki> unused </nowiki>
 [[M204.3137]]<nowiki> unused </nowiki>
 [[M204.3138]]<nowiki> unused </nowiki>
 [[M204.3139]]<nowiki> unused </nowiki>
 [[M204.3140]]<nowiki> unused </nowiki>
 [[M204.3141]]<nowiki> unused </nowiki>
 [[M204.3142]]<nowiki> unused </nowiki>
 [[M204.3143]]<nowiki> unused </nowiki>
 [[M204.3144]]<nowiki> unused </nowiki>
 [[M204.3145]]<nowiki> unused </nowiki>
 [[M204.3146]]<nowiki> unused </nowiki>
 [[M204.3147]]<nowiki> unused </nowiki>
 [[M204.3148]]<nowiki> unused </nowiki>
 [[M204.3149]]<nowiki> unused </nowiki>
 [[M204.3150]]<nowiki> unused </nowiki>
 [[MSIR.0001]]<nowiki> IUCV not installed</nowiki>
 [[MSIR.0002]]<nowiki> Unable to load IUCVMULT</nowiki>
 [[MSIR.0003]]<nowiki> IUCVMINI error, rc = </nowiki>
 [[MSIR.0004]]<nowiki> HNDIUCV error, rc = </nowiki>
 [[MSIR.0005]]<nowiki> Unable to connect to , rc = </nowiki>
 [[MSIR.0006]]<nowiki> Connection severed, IPUSER = </nowiki>
 [[MSIR.0007]]<nowiki> Unexpected IUCV interrupt, IPTYPE = </nowiki>
 [[MSIR.0008]]<nowiki> IUCV send error, IPTRGCLS = , IPRCODE = </nowiki>
 [[MSIR.0009]]<nowiki> IUCV message rejected, IPTRGCLS = </nowiki>
 [[MSIR.0010]]<nowiki> IUCV audit error, IPTRGCLS = , IPAUDIT = </nowiki>
 [[MSIR.0011]]<nowiki> Invalid response from initial message = </nowiki>
 [[MSIR.0012]]<nowiki> Unable to attach JANUS PST, rc = </nowiki>
 [[MSIR.0013]]<nowiki> Bind error, port number already in use</nowiki>
 [[MSIR.0014]]<nowiki> Bind error, errno = : - </nowiki>
 [[MSIR.0015]]<nowiki> Bind error, PST shutting down</nowiki>
 [[MSIR.0016]]<nowiki> Socket error, rc = , errno = </nowiki>
 [[MSIR.0017]]<nowiki> GETSOCKOPT error, rc = , errno = </nowiki>
 [[MSIR.0018]]<nowiki> Main path IOCTL error, rc = , errno = </nowiki>
 [[MSIR.0019]]<nowiki> request rejected for port , MAXCON exceeded</nowiki>
 [[MSIR.0020]]<nowiki> request rejected for port , no SDAEMONS available</nowiki>
 [[MSIR.0021]]<nowiki> LISTEN error, rc = , errno = </nowiki>
 [[MSIR.0022]]<nowiki> Main path SELECT error, rc = , errno = </nowiki>
 [[MSIR.0023]]<nowiki> Connection request rejected for port , couldn't get storage for buffers</nowiki>
 [[MSIR.0024]]<nowiki> ACCEPT error, rc = , errno = </nowiki>
 [[MSIR.0025]]<nowiki> GIVESOCKET error, rc = , errno = </nowiki>
 [[MSIR.0026]]<nowiki> Connection request rejected for port , connection limit exceeded</nowiki>
 [[MSIR.0027]]<nowiki> TAKESOCKET error, rc = , errno = </nowiki>
 [[MSIR.0028]]<nowiki> Client path error, rc = , errno = </nowiki>
 [[MSIR.0029]]<nowiki> CLOSE error, rc = , errno = </nowiki>
 [[MSIR.0030]]<nowiki> Port name missing for JANUS command</nowiki>
 [[MSIR.0040]]<nowiki> Invalid JANUS subcommand ''</nowiki>
 [[MSIR.0041]]<nowiki> No ports named defined</nowiki>
 [[MSIR.0042]]<nowiki> Port name invalid</nowiki>
 [[MSIR.0043]]<nowiki> Can't define port, </nowiki>
 [[MSIR.0044]]<nowiki> CMD required for port</nowiki>
 [[MSIR.0045]]<nowiki> Insufficient storage for JANUS control blocks</nowiki>
 [[MSIR.0046]]<nowiki> Insufficient storage for JANUS buffers</nowiki>
 [[MSIR.0047]]<nowiki> Insufficient storage for tables</nowiki>
 [[MSIR.0048]]<nowiki> PST shutting down, can't start </nowiki>
 [[MSIR.0049]]<nowiki> name missing for JANUS command</nowiki>
 [[MSIR.0051]]<nowiki> Invalid parameter</nowiki>
 [[MSIR.0052]]<nowiki> called when not an Open Server</nowiki>
 [[MSIR.0054]]<nowiki> BUG condition - </nowiki>
 [[MSIR.0055]]<nowiki> Subcommand missing for JANUS command</nowiki>
 [[MSIR.0058]]<nowiki> Remote server name must be 30 characters or fewer</nowiki>
 [[MSIR.0059]]<nowiki> host missing for JANUS command</nowiki>
 [[MSIR.0061]]<nowiki> Can't issue SDAEMON command from SDAEMON</nowiki>
 [[MSIR.0062]]<nowiki> SDAEMON command can only be issued on IODEV 3</nowiki>
 [[MSIR.0063]]<nowiki> Insufficient storage to start SDAEMON</nowiki>
 [[MSIR.0064]]<nowiki> No free IODEV number to use for SDAEMON</nowiki>
 [[MSIR.0065]]<nowiki> LOBUFF must be at least 256 for SDAEMONS</nowiki>
 [[MSIR.0066]]<nowiki> Unable to add $COMM output to output $LIST</nowiki>
 [[MSIR.0067]]<nowiki> Error doing $COMM output</nowiki>
 [[MSIR.0069]]<nowiki> Can't issue SDAEMON command from subsystem</nowiki>
 [[MSIR.0070]]<nowiki> Insufficient storage to initialize TCPIP</nowiki>
 [[MSIR.0071]]<nowiki> Port name must be 30 characters or fewer</nowiki>
 [[MSIR.0072]]<nowiki> Can't issue SDAEMON command while web port(s) started</nowiki>
 [[MSIR.0073]]<nowiki> Invalid port type </nowiki>
 [[MSIR.0074]]<nowiki> Invalid - must be number between and </nowiki>
 [[MSIR.0075]]<nowiki> '' is not valid for ports</nowiki>
 [[MSIR.0076]]<nowiki> No remote servers named defined on port(s) </nowiki>
 [[MSIR.0080]]<nowiki> Invalid value for </nowiki>
 [[MSIR.0081]]<nowiki> Maximum connections cannot exceed number of SDAEMONS ()</nowiki>
 [[MSIR.0082]]<nowiki> Maximum connections cannot exceed authorization limit ()</nowiki>
 [[MSIR.0084]]<nowiki> Unable to resolve host name </nowiki>
 [[MSIR.0085]]<nowiki> Unable to connect to port </nowiki>
 [[MSIR.0086]]<nowiki> Invalid parameter </nowiki>
 [[MSIR.0087]]<nowiki> Port name already defined</nowiki>
 [[MSIR.0088]]<nowiki> Maximum number of portS () already defined</nowiki>
 [[MSIR.0089]]<nowiki> port missing for JANUS command</nowiki>
 [[MSIR.0090]]<nowiki> Name must follow 'OPEN' keyword</nowiki>
 [[MSIR.0091]]<nowiki> OPEN name must be 8 characters or fewer</nowiki>
 [[MSIR.0092]]<nowiki> SDAEMON unable to open </nowiki>
 [[MSIR.0093]]<nowiki> Port name missing for JANUS DEFINE command</nowiki>
 [[MSIR.0094]]<nowiki> Port number missing for JANUS DEFINE command</nowiki>
 [[MSIR.0095]]<nowiki> Port type missing for JANUS DEFINE command</nowiki>
 [[MSIR.0096]]<nowiki> Value missing for in JANUS DEFINE command</nowiki>
 [[MSIR.0097]]<nowiki> No ports named with remote servers named defined</nowiki>
 [[MSIR.0098]]<nowiki> No SDAEMONS available to load tables</nowiki>
 [[MSIR.0099]]<nowiki> SDAEMON could not load tables</nowiki>
 [[MSIR.0102]]<nowiki> Invalid initial data from IFDIAL client at </nowiki>
 [[MSIR.0103]]<nowiki> Incompatible IFDIAL client at </nowiki>
 [[MSIR.0104]]<nowiki> Invalid data received from IFDIAL client at </nowiki>
 [[MSIR.0106]]<nowiki> Port in use</nowiki>
 [[MSIR.0107]]<nowiki> Port not stopped, can't delete</nowiki>
 [[MSIR.0108]]<nowiki> Buffer size mist follow 'RBSIZE' keyword</nowiki>
 [[MSIR.0109]]<nowiki> JANCAT filename must be 8 characters or fewer</nowiki>
 [[MSIR.0110]]<nowiki> Insufficient storage for JANUS RPC buffers</nowiki>
 [[MSIR.0111]]<nowiki> Connection from terminated, insufficient storage for </nowiki>
 [[MSIR.0112]]<nowiki> Connection from terminated, pacing protocol violation</nowiki>
 [[MSIR.0113]]<nowiki> Connection from terminated, terminal input required</nowiki>
 [[MSIR.0117]]<nowiki> Invalid response to LOGIN RECEIVED from remote server </nowiki>
 [[MSIR.0118]]<nowiki> TCPTYPE must be set to 'IBM', 'INTERLNK', 'KNET', or 'HPNS'</nowiki>
 [[MSIR.0119]]<nowiki> TCPTYPE of '' is only valid under MVS</nowiki>
 [[MSIR.0120]]<nowiki> AOPEN error, RETCODE = , ERRCODE = DIAGCODE = </nowiki>
 [[MSIR.0121]]<nowiki> error, RETCODE = , COMPCODE = TPLRTNCD = </nowiki>
 [[MSIR.0125]]<nowiki> Invalid TRUST option </nowiki>
 [[MSIR.0126]]<nowiki> Parameter missing for TRUST command</nowiki>
 [[MSIR.0127]]<nowiki> Insufficient storage to add entry for </nowiki>
 [[MSIR.0129]]<nowiki> Insufficient storage to add RESTAUTH entry </nowiki>
 [[MSIR.0130]]<nowiki> command only valid under CMS</nowiki>
 [[MSIR.0131]]<nowiki> USERID '' too long for RESTAUTH command</nowiki>
 [[MSIR.0132]]<nowiki> Restart utility is not running</nowiki>
 [[MSIR.0134]]<nowiki> No JANUS defined</nowiki>
 [[MSIR.0135]]<nowiki> Invalid </nowiki>
 [[MSIR.0136]]<nowiki> Invalid IP address </nowiki>
 [[MSIR.0137]]<nowiki> Invalid port number - for port</nowiki>
 [[MSIR.0138]]<nowiki> INONLY invalid, Janus Open Server support not linked in</nowiki>
 [[MSIR.0139]]<nowiki> OUTONLY invalid, Janus Open Client support not linked in</nowiki>
 [[MSIR.0140]]<nowiki> Can't define a remote server as both INONLY and OUTONLY</nowiki>
 [[MSIR.0141]]<nowiki> value must be 10 characters or fewer</nowiki>
 [[MSIR.0142]]<nowiki> </nowiki>
 [[MSIR.0143]]<nowiki> Can't add to port because not port</nowiki>
 [[MSIR.0144]]<nowiki> already added to port </nowiki>
 [[MSIR.0145]]<nowiki> Insufficient storage to add to port </nowiki>
 [[MSIR.0173]]<nowiki> SYBMSG(20173,15,1) Request from server at IP address rejected, remote server not defined.</nowiki>
 [[MSIR.0174]]<nowiki> SYBMSG(20174,15,1) Request from server at IP address rejected, already have incoming connection.</nowiki>
 [[MSIR.0175]]<nowiki> SYBMSG(20175,15,1) Request from server at IP address rejected, incoming connections not allowed.</nowiki>
 [[MSIR.0176]]<nowiki> SYBMSG(20176,15,1) Request from server at IP address rejected, couldn't resolve host name for VERIP.</nowiki>
 [[MSIR.0177]]<nowiki> SYBMSG(20177,15,1) Request from server at IP address rejected, source is not expected IP address.</nowiki>
 [[MSIR.0178]]<nowiki> Protocol error, connection with server at IP address terminated.</nowiki>
 [[MSIR.0179]]<nowiki> Unable to set up subchannel for server , .</nowiki>
 [[MSIR.0180]]<nowiki> RECV error, rc = , errno = </nowiki>
 [[MSIR.0181]]<nowiki> Unexpected token received connection with server at IP address terminated.</nowiki>
 [[MSIR.0186]]<nowiki> Connection to server terminated, insufficient RPC buffer space</nowiki>
 [[MSIR.0187]]<nowiki> Connection to server terminated, unsupported datatype received</nowiki>
 [[MSIR.0188]]<nowiki> Connection to server terminated, return code from </nowiki>
 [[MSIR.0189]]<nowiki> SDAEMON (USER ) still active port </nowiki>
 [[MSIR.0190]]<nowiki> Error creating User Language proc</nowiki>
 [[MSIR.0191]]<nowiki> Error compiling User Language proc</nowiki>
 [[MSIR.0192]]<nowiki> No defined in </nowiki>
 [[MSIR.0194]]<nowiki> SDAEMON for port is logging off</nowiki>
 [[MSIR.0195]]<nowiki> Invalid value for in record of </nowiki>
 [[MSIR.0196]]<nowiki> Missing value for in record of </nowiki>
 [[MSIR.0197]]<nowiki> Error opening </nowiki>
 [[MSIR.0198]]<nowiki> Insufficient CCATEMP for tables</nowiki>
 [[MSIR.0199]]<nowiki> No columns defined for table </nowiki>
 [[MSIR.0201]]<nowiki> Invalid NBUFF parameter</nowiki>
 [[MSIR.0202]]<nowiki> Invalid DUMP option ''</nowiki>
 [[MSIR.0203]]<nowiki> Unsupported format for DDNAME ''</nowiki>
 [[MSIR.0204]]<nowiki> Invalid RESTORE option ''</nowiki>
 [[MSIR.0205]]<nowiki> CCATEMP usage exceeded limit</nowiki>
 [[MSIR.0206]]<nowiki> Insufficient CCATEMP pages remaining to continue</nowiki>
 [[MSIR.0207]]<nowiki> File must be created with current release for SIRFIELD</nowiki>
 [[MSIR.0208]]<nowiki> SIRFIELD command not allowed after record added to file</nowiki>
 [[MSIR.0209]]<nowiki> Expecting on SIRFIELD command, found </nowiki>
 [[MSIR.0210]]<nowiki> SIRFIELD command failed</nowiki>
 [[MSIR.0211]]<nowiki> Field on SIRFIELD RELATE does not have FORMAT: </nowiki>
 [[MSIR.0212]]<nowiki> Previous SIRFIELD RELATE () differs from new value: </nowiki>
 [[MSIR.0213]]<nowiki> Previous SIRFIELD format () differs from new value: </nowiki>
 [[MSIR.0214]]<nowiki> Too many SIRFIELD commands for </nowiki>
 [[MSIR.0215]]<nowiki> Invalid on SIRFIELD command: </nowiki>
 [[MSIR.0216]]<nowiki> Option for SIRFIELD SET command already set or excluded: </nowiki>
 [[MSIR.0217]]<nowiki> No year specified in SIRFIELD date format: </nowiki>
 [[MSIR.0219]]<nowiki> not allowed on SIRFIELD FORMAT command with 3- or 4-digit year</nowiki>
 [[MSIR.0222]]<nowiki> Can't pass off to , invalid FRELPREV of </nowiki>
 [[MSIR.0223]]<nowiki> Can't pass off to , FRELPREV procedure currently open</nowiki>
 [[MSIR.0224]]<nowiki> Can't pass off to , unable to open FRELPREV procedure for output</nowiki>
 [[MSIR.0225]]<nowiki> Can't pass off to , insufficient CCATEMP</nowiki>
 [[MSIR.0226]]<nowiki> Can't pass off to , FLOD$ not linked in</nowiki>
 [[MSIR.0227]]<nowiki> Can't pass off to , already at maximum include level</nowiki>
 [[MSIR.0230]]<nowiki> Missing on APPDATE command</nowiki>
 [[MSIR.0231]]<nowiki> Invalid on APPDATE command: </nowiki>
 [[MSIR.0232]]<nowiki> Expecting on APPDATE command, found: </nowiki>
 [[MSIR.0233]]<nowiki> Unexpected parameter on APPDATE command: </nowiki>
 [[MSIR.0234]]<nowiki> Target time but reference time on APPDATE command</nowiki>
 [[MSIR.0235]]<nowiki> APPDATE requires SYSTEM before USER 0 parameter line</nowiki>
 [[MSIR.0236]]<nowiki> APPDATE and SYSDATE cannot coexist</nowiki>
 [[MSIR.0237]]<nowiki> RELATE of pair of 2-digit year fields not allowed</nowiki>
 [[MSIR.0238]]<nowiki> Pair of not allowed on SIRFIELD FORMAT command</nowiki>
 [[MSIR.0239]]<nowiki> Duplicate EXCEPTIONS value on SIRFIELD RELATE command: </nowiki>
 [[MSIR.0240]]<nowiki> Insufficent Table D space for SIRFIELD command</nowiki>
 [[MSIR.0241]]<nowiki> specified twice on SIRFIELD command</nowiki>
 [[MSIR.0242]]<nowiki> Expecting '' on APPDATE command, found: </nowiki>
 [[MSIR.0243]]<nowiki> '' conflicts with previous DATE_ERR keyword on APPDATE command</nowiki>
 [[MSIR.0244]]<nowiki> Value format in record = </nowiki>
 [[MSIR.0245]]<nowiki> Date out of range in record = </nowiki>
 [[MSIR.0246]]<nowiki> Unknown on SIRFIELD comand: </nowiki>
 [[MSIR.0248]]<nowiki> SIRFIELD of field not allowed</nowiki>
 [[MSIR.0249]]<nowiki> SIRFIELD constraint violation</nowiki>
 [[MSIR.0251]]<nowiki> SYBMSG(41101,15,1) Unable to process language request from Sybase Server.</nowiki>
 [[MSIR.0252]]<nowiki> SYBMSG(41101,15,1) full, can't process request.</nowiki>
 [[MSIR.0253]]<nowiki> SYBMSG(41101,15,1) Can't open , can't process request</nowiki>
 [[MSIR.0254]]<nowiki> Invalid COLUMN numbers for TABLE </nowiki>
 [[MSIR.0255]]<nowiki> SYBMSG(41101,15,1) Table not found.</nowiki>
 [[MSIR.0256]]<nowiki> SYBMSG(41101,15,1) Column not found for table </nowiki>
 [[MSIR.0257]]<nowiki> SYBMSG(41101,15,1) access is not allowed for table by user .</nowiki>
 [[MSIR.0258]]<nowiki> SYBMSG(41101,15,1) Column not found.</nowiki>
 [[MSIR.0259]]<nowiki> SYBMSG(41101,15,1) Ambiguous column name .</nowiki>
 [[MSIR.0260]]<nowiki> SYBMSG(41101,15,1) Unable to process request because of invisible field constraints.</nowiki>
 [[MSIR.0262]]<nowiki> Unable to load KNETAPPL</nowiki>
 [[MSIR.0263]]<nowiki> Error initializing KNET interface</nowiki>
 [[MSIR.0264]]<nowiki> KNET error - Event Code = , Return Code = </nowiki>
 [[MSIR.0265]]<nowiki> TCPTYPE of 'KNET' is only valid under MVS</nowiki>
 [[MSIR.0266]]<nowiki> No K-ROUTINES SLU'S available</nowiki>
 [[MSIR.0267]]<nowiki> Only K-ROUTINES SLU'S available</nowiki>
 [[MSIR.0269]]<nowiki> name missing for JANUS command</nowiki>
 [[MSIR.0270]]<nowiki> missing for JANUS command</nowiki>
 [[MSIR.0271]]<nowiki> name must be 30 characters or fewer</nowiki>
 [[MSIR.0272]]<nowiki> Maximum of exceeded for JANUS command</nowiki>
 [[MSIR.0273]]<nowiki> already defined</nowiki>
 [[MSIR.0274]]<nowiki> not found</nowiki>
 [[MSIR.0275]]<nowiki> can't be deleted because it is associated with ALLOW rules</nowiki>
 [[MSIR.0278]]<nowiki> Invalid port name </nowiki>
 [[MSIR.0279]]<nowiki> Invalid REMOTE server name </nowiki>
 [[MSIR.0280]]<nowiki> Userid too long, must be 11 characters or shorter</nowiki>
 [[MSIR.0281]]<nowiki> JANUS rule type missing</nowiki>
 [[MSIR.0282]]<nowiki> Invalid JANUS rule type </nowiki>
 [[MSIR.0283]]<nowiki> JANUS WEB URL missing</nowiki>
 [[MSIR.0284]]<nowiki> value missing for JANUS command</nowiki>
 [[MSIR.0285]]<nowiki> specified twice in JANUS command</nowiki>
 [[MSIR.0286]]<nowiki> Can't specify both and in JANUS command</nowiki>
 [[MSIR.0287]]<nowiki> Invalid parameter in JANUS command</nowiki>
 [[MSIR.0288]]<nowiki> missing for JANUS command</nowiki>
 [[MSIR.0289]]<nowiki> JANUS command does not apply to non- port </nowiki>
 [[MSIR.0290]]<nowiki> Insufficient storage to add JANUS to port </nowiki>
 [[MSIR.0291]]<nowiki> IP address is not a subnet in </nowiki>
 [[MSIR.0294]]<nowiki> Invalid JANUS DISPLAYWEB type - </nowiki>
 [[MSIR.0295]]<nowiki> No ports named with WEB s for URL defined.</nowiki>
 [[MSIR.0296]]<nowiki> No s defined</nowiki>
 [[MSIR.0297]]<nowiki> No s named defined</nowiki>
 [[MSIR.0298]]<nowiki> Maximum connections missing for JANUS DEFINE command</nowiki>
 [[MSIR.0299]]<nowiki> not valid for method in JANUS WEB command</nowiki>
 [[MSIR.0307]]<nowiki> Can't mix LAI and non-LAI statements</nowiki>
 [[MSIR.0308]]<nowiki> Can't run LAI against Pre-Release8 files</nowiki>
 [[MSIR.0309]]<nowiki> Can't reload data from obsolete version of Fast/Unload</nowiki>
 [[MSIR.0310]]<nowiki> version requires newer version of Fast/Reload to load data</nowiki>
 [[MSIR.0311]]<nowiki> Input data was not created with required HASH/SORT key</nowiki>
 [[MSIR.0312]]<nowiki> Input HASH/SORT key does not match key in database file</nowiki>
 [[MSIR.0313]]<nowiki> Unable to initialize ordered index, Table D probably too small</nowiki>
 [[MSIR.0314]]<nowiki> Premature EOF for TAPEI</nowiki>
 [[MSIR.0315]]<nowiki> Format error in TAPEI</nowiki>
 [[MSIR.0317]]<nowiki> Terminal input not supported by Fast/Reload</nowiki>
 [[MSIR.0318]]<nowiki> Unsupported input format</nowiki>
 [[MSIR.0319]]<nowiki> support is not authorized</nowiki>
 [[MSIR.0320]]<nowiki> $LIST capacity exceeded</nowiki>
 [[MSIR.0321]]<nowiki> Error in $ call in line , procedure , file - </nowiki>
 [[MSIR.0322]]<nowiki> Error in $ call in line of command level program - </nowiki>
 [[MSIR.0323]]<nowiki> Error in $ call, no Sirius debug info - </nowiki>
 [[MSIR.0324]]<nowiki> Cancelling request because of $ error</nowiki>
 [[MSIR.0327]]<nowiki> Unexpected word on SIRFIELD command </nowiki>
 [[MSIR.0328]]<nowiki> SIRFIELD ALIAS error: already defined</nowiki>
 [[MSIR.0332]]<nowiki> No SIRFIELD information in </nowiki>
 [[MSIR.0333]]<nowiki> No SIRFIELD attributes for </nowiki>
 [[MSIR.0334]]<nowiki> not allowed on SIRFIELD FORMAT command of related field</nowiki>
 [[MSIR.0335]]<nowiki> Fields previously specified in other order on SIRFIELD RELATE command</nowiki>
 [[MSIR.0336]]<nowiki> SET PAI and REFERENCE CANCEL are conflicting SIRFIELD attributes</nowiki>
 [[MSIR.0341]]<nowiki> SIRFIELD DELETE not allowed for alias which is current PAI name</nowiki>
 [[MSIR.0342]]<nowiki> SIRFIELD RELATE not allowed for field which has FORMAT </nowiki>
 [[MSIR.0343]]<nowiki> File has been updated with incompatible version of Sir2000 Field Migration facility: .()</nowiki>
 [[MSIR.0344]]<nowiki> referenced in and CANCEL set by SIRFIELD command</nowiki>
 [[MSIR.0346]]<nowiki> Attempt to define field which is already SIRFIELD ALIAS for field </nowiki>
 [[MSIR.0347]]<nowiki> cannot be opened because it has SIRFIELD information and SIRFIELD is unavailable</nowiki>
 [[MSIR.0348]]<nowiki> may not be specified on SIRFIELD FORMAT command because datetime format has not been specified</nowiki>
 [[MSIR.0349]]<nowiki> New CENTSPAN/SPANSIZE (/) does not fully contain old values (/)</nowiki>
 [[MSIR.0350]]<nowiki> Invalid IP address in </nowiki>
 [[MSIR.0351]]<nowiki> Invalid subnet mask in </nowiki>
 [[MSIR.0352]]<nowiki> Invalid subnet bit count in </nowiki>
 [[MSIR.0353]]<nowiki> Insufficient Web request buffer space</nowiki>
 [[MSIR.0354]]<nowiki> Web request has invalid format</nowiki>
 [[MSIR.0355]]<nowiki> Web request field is too long</nowiki>
 [[MSIR.0356]]<nowiki> Procedure in - </nowiki>
 [[MSIR.0357]]<nowiki> Web post entity has invalid format</nowiki>
 [[MSIR.0358]]<nowiki> $WEB_PROCSEND Error - </nowiki>
 [[MSIR.0360]]<nowiki> Unable to open </nowiki>
 [[MSIR.0362]]<nowiki> $WEB_CERTSEND error - </nowiki>
 [[MSIR.0364]]<nowiki> Cancelling Web request because </nowiki>
 [[MSIR.0367]]<nowiki> Maximum persistent/legacy sessions for IP address exceeded - session terminated</nowiki>
 [[MSIR.0368]]<nowiki> JANUS WEB screen rule too large</nowiki>
 [[MSIR.0370]]<nowiki> SSL filename must be 8 characters or fewer</nowiki>
 [[MSIR.0371]]<nowiki> SSL procedure name missing</nowiki>
 [[MSIR.0372]]<nowiki> SSL support not linked in</nowiki>
 [[MSIR.0373]]<nowiki> Unable to open SSL file </nowiki>
 [[MSIR.0374]]<nowiki> SSL procedure is enqueued</nowiki>
 [[MSIR.0375]]<nowiki> SSL procedure not found</nowiki>
 [[MSIR.0376]]<nowiki> Invalid X509 certificate</nowiki>
 [[MSIR.0377]]<nowiki> Missing X509 certificate</nowiki>
 [[MSIR.0378]]<nowiki> Invalid RSA private key</nowiki>
 [[MSIR.0379]]<nowiki> Missing RSA private key</nowiki>
 [[MSIR.0380]]<nowiki> SSLCACHE must be greater than or equal to number of threads on port</nowiki>
 [[MSIR.0381]]<nowiki> RSA private key too long</nowiki>
 [[MSIR.0382]]<nowiki> SSL protocol error</nowiki>
 [[MSIR.0383]]<nowiki> SSL client does not support any of the same ciphers as Janus Web</nowiki>
 [[MSIR.0384]]<nowiki> Connection from terminated, insufficient storage for SSL buffer</nowiki>
 [[MSIR.0385]]<nowiki> Incorrect RSA encryption</nowiki>
 [[MSIR.0386]]<nowiki> SSL input message too long - increase SSLBSIZE</nowiki>
 [[MSIR.0387]]<nowiki> RSA private key does not correspond to public key in X509 certificate</nowiki>
 [[MSIR.0389]]<nowiki> Private key password missing or invalid</nowiki>
 [[MSIR.0392]]<nowiki> Call Rocket Software for a new authorization</nowiki>
 [[MSIR.0394]]<nowiki> RELATEd fields have different in date formats</nowiki>
 [[MSIR.0395]]<nowiki> New name has SIRFIELD attributes</nowiki>
 [[MSIR.0396]]<nowiki> command not allowed for field with SIRFIELD attributes: </nowiki>
 [[MSIR.0397]]<nowiki> Invalid change on REDEFINE command of field with SIRFIELD attributes: </nowiki>
 [[MSIR.0398]]<nowiki> Unable to RELATE fields due to mismatched attributes</nowiki>
 [[MSIR.0400]]<nowiki> SIRFIELD command too long: </nowiki>
 [[MSIR.0402]]<nowiki> Unable to RELATE field to itself</nowiki>
 [[MSIR.0403]]<nowiki> SIRFIELD enqueueing conflict</nowiki>
 [[MSIR.0404]]<nowiki> Null EXCEPTIONS value not allowed on SIRFIELD RELATE command of preallocated and non-preallocated fields</nowiki>
 [[MSIR.0405]]<nowiki> Null EXCEPTIONS value paired with non-null value on SIRFIELD RELATE command</nowiki>
 [[MSIR.0406]]<nowiki> Duplicate ALTERNATES format on SIRFIELD RELATE command: </nowiki>
 [[MSIR.0407]]<nowiki> ALTERNATES * on SIRFIELD command</nowiki>
 [[MSIR.0408]]<nowiki> Missing * in ERROR format on SIRFIELD command</nowiki>
 [[MSIR.0409]]<nowiki> Missing or mis-placed CANCEL/WARN/NOWARN on SIRFIELD command: </nowiki>
 [[MSIR.0410]]<nowiki> Unloaded file had SIRFIELD rules defined but Sir2000 Field Migration Facility is not </nowiki>
 [[MSIR.0412]]<nowiki> Attempt to load field from multiple fields - and .</nowiki>
 [[MSIR.0413]]<nowiki> Attempt to load multiple fields and from but FAMSPLIT not set.</nowiki>
 [[MSIR.0414]]<nowiki> Value of for field SIRFIELD format</nowiki>
 [[MSIR.0416]]<nowiki> Date maps to exception value or different format pair in record = </nowiki>
 [[MSIR.0417]]<nowiki> New exception value for matches a format and so can't be added after records have been added to the file</nowiki>
 [[MSIR.0418]]<nowiki> SIRFIELD command contains unquoted alpha EXCEPTIONS value: </nowiki>
 [[MSIR.0419]]<nowiki> Different on Fast/Unload trailer record; found , expected </nowiki>
 [[MSIR.0420]]<nowiki> Dumped file has SIRFIELD attributes, can't RESTORE on non-SIRFIELD system</nowiki>
 [[MSIR.0421]]<nowiki> Invalid value for CENTSPAN</nowiki>
 [[MSIR.0422]]<nowiki> ALTERNATES not allowed on SIRFIELD command because ERROR format already specified and records have been added to the file</nowiki>
 [[MSIR.0423]]<nowiki> Cannot change CENTSPAN/SPANSIZE on SIRFIELD command because ERROR or ALTERNATES have been set and records have been added to the file</nowiki>
 [[MSIR.0425]]<nowiki> Alternate date formats respecified but incomplete or out of order on SIRFIELD command</nowiki>
 [[MSIR.0426]]<nowiki> Error updating second field of related pair in record = - FISTAT set to physically broken</nowiki>
 [[MSIR.0430]]<nowiki> Invalid value for in JANUS command</nowiki>
 [[MSIR.0431]]<nowiki> not supported under </nowiki>
 [[MSIR.0433]]<nowiki> Insufficient storage to set tracing for port </nowiki>
 [[MSIR.0436]]<nowiki> Value of for field out of SIRFIELD date range</nowiki>
 [[MSIR.0437]]<nowiki> Value of for field maps to SIRFIELD exception value or different format pair</nowiki>
 [[MSIR.0439]]<nowiki> User pushdown list overflowed</nowiki>
 [[MSIR.0440]]<nowiki> Invalid signature parameter in </nowiki>
 [[MSIR.0441]]<nowiki> Signature only valid for site in </nowiki>
 [[MSIR.0442]]<nowiki> Signature expired in </nowiki>
 [[MSIR.0443]]<nowiki> Invalid checksum in authorization zap created </nowiki>
 [[MSIR.0444]]<nowiki> Invalid argument '', request cancelled</nowiki>
 [[MSIR.0445]]<nowiki> Bad in record , input record number , reason </nowiki>
 [[MSIR.0446]]<nowiki> Two digit year ALTERNATES format invalid for field because primary format is not two digit</nowiki>
 [[MSIR.0449]]<nowiki> in call to </nowiki>
 [[MSIR.0450]]<nowiki> Too many , max = </nowiki>
 [[MSIR.0451]]<nowiki> Multiple OPEN files/groups only allowed when CMD specified</nowiki>
 [[MSIR.0453]]<nowiki> Can't allocate expanded storage, installation limit exceeded</nowiki>
 [[MSIR.0454]]<nowiki> SIRAPSY command unavailable because RESLTHR set to 0</nowiki>
 [[MSIR.0455]]<nowiki> missing for SIRAPSY command</nowiki>
 [[MSIR.0456]]<nowiki> Invalid SIRAPSY subcommand </nowiki>
 [[MSIR.0457]]<nowiki> Subsystem not started</nowiki>
 [[MSIR.0458]]<nowiki> Procedure not found for subsystem </nowiki>
 [[MSIR.0461]]<nowiki> procedure not eligible for pre-compilation</nowiki>
 [[MSIR.0462]]<nowiki> Unable to load HPNS interface module</nowiki>
 [[MSIR.0463]]<nowiki> Unable to auto-detect TCP/IP type</nowiki>
 [[MSIR.0464]]<nowiki> HPNS API error, function=, rc=, errno=</nowiki>
 [[MSIR.0466]]<nowiki> TCPTYPE of 'HPNS' is only valid under MVS</nowiki>
 [[MSIR.0467]]<nowiki> Command disabled</nowiki>
 [[MSIR.0468]]<nowiki> argument for $</nowiki>
 [[MSIR.0478]]<nowiki> Unsupported log file type - </nowiki>
 [[MSIR.0479]]<nowiki> mismatch in shared log file </nowiki>
 [[MSIR.0480]]<nowiki> ASSERT statement requires condition</nowiki>
 [[MSIR.0481]]<nowiki> SIRFACT statement requires ON or OFF</nowiki>
 [[MSIR.0482]]<nowiki> Shutting down port because of error on required log file </nowiki>
 [[MSIR.0483]]<nowiki> LOGAPPEND not valid under CMS or VSE</nowiki>
 [[MSIR.0484]]<nowiki> Can't define WEBSERV port in MP/KNET environment</nowiki>
 [[MSIR.0485]]<nowiki> $: in line , proc , file </nowiki>
 [[MSIR.0486]]<nowiki> $: in line , command level</nowiki>
 [[MSIR.0487]]<nowiki> $: with no Sirius debug info</nowiki>
 [[MSIR.0488]]<nowiki> not valid for JANUS command</nowiki>
 [[MSIR.0489]]<nowiki> Method not valid for JANUS WEB command</nowiki>
 [[MSIR.0490]]<nowiki> File/group list and commands too long for JANUS WEB command</nowiki>
 [[MSIR.0491]]<nowiki> Assert: line , proc , file </nowiki>
 [[MSIR.0492]]<nowiki> Assert: line , command level</nowiki>
 [[MSIR.0493]]<nowiki> Assert: no Sirius debug info</nowiki>
 [[MSIR.0495]]<nowiki> Assert: line , proc , file </nowiki>
 [[MSIR.0496]]<nowiki> Assert: line , command level</nowiki>
 [[MSIR.0497]]<nowiki> Assert: no Sirius debug info</nowiki>
 [[MSIR.0498]]<nowiki> USER or USGROUP required on JANUS WEB ALLOW command when specified</nowiki>
 [[MSIR.0499]]<nowiki> System/subsystem global substitution failed: GTBL full</nowiki>
 [[MSIR.0500]]<nowiki> Subcommand missing for SIRFACT command</nowiki>
 [[MSIR.0501]]<nowiki> Invalid SIRFACT subcommand ''</nowiki>
 [[MSIR.0502]]<nowiki> Missing entity for SIRFACT command</nowiki>
 [[MSIR.0503]]<nowiki> Invalid entity for SIRFACT command</nowiki>
 [[MSIR.0504]]<nowiki> Missing values for SIRFACT command</nowiki>
 [[MSIR.0505]]<nowiki> Insufficient storage for SIRFACT command</nowiki>
 [[MSIR.0506]]<nowiki> Invalid value for SIRFACT command</nowiki>
 [[MSIR.0507]]<nowiki> Too many values for SIRFACT command</nowiki>
 [[MSIR.0508]]<nowiki> SIRFACT already set for </nowiki>
 [[MSIR.0509]]<nowiki> Invalid type for SIRFACT DISPLAY command</nowiki>
 [[MSIR.0510]]<nowiki> Cancelling request because of SIRFACT CANCEL $ </nowiki>
 [[MSIR.0511]]<nowiki> Error in $ call in line , procedure , file </nowiki>
 [[MSIR.0512]]<nowiki> Error in $ call in line of command level program</nowiki>
 [[MSIR.0513]]<nowiki> Error in $ call, no Sirius debug info</nowiki>
 [[MSIR.0514]]<nowiki> error in call in line , procedure , file </nowiki>
 [[MSIR.0515]]<nowiki> error in call from command level</nowiki>
 [[MSIR.0516]]<nowiki> error in call, no Sirius debug info</nowiki>
 [[MSIR.0517]]<nowiki> Cancelling request because of $SirParm LISTFC setting (CCATEMP full)</nowiki>
 [[MSIR.0518]]<nowiki> Cancelling request because of $SirParm LISTFC setting (limit exceeded)</nowiki>
 [[MSIR.0519]]<nowiki> Missing value</nowiki>
 [[MSIR.0520]]<nowiki> Invalid value , must be number between 0 and </nowiki>
 [[MSIR.0521]]<nowiki> Invalid value for in JANUS DEFINE command</nowiki>
 [[MSIR.0522]]<nowiki> Missing for SIRFACT DUMP command</nowiki>
 [[MSIR.0523]]<nowiki> value too long for SIRFACT DUMP command</nowiki>
 [[MSIR.0524]]<nowiki> value invalid for SIRFACT DUMP command</nowiki>
 [[MSIR.0525]]<nowiki> Invalid qualifier for SIRFACT DUMP command</nowiki>
 [[MSIR.0526]]<nowiki> Couldn't install SirFact dump hooks</nowiki>
 [[MSIR.0527]]<nowiki> Couldn't take SirFact dump - </nowiki>
 [[MSIR.0531]]<nowiki> Message number required for SIRFACT </nowiki>
 [[MSIR.0532]]<nowiki> Invalid message number for SIRFACT </nowiki>
 [[MSIR.0533]]<nowiki> Invalid character X'' in for JANUS WEB command</nowiki>
 [[MSIR.0534]]<nowiki> can't end with escape (") character iin JANUS WEB command</nowiki>
 [[MSIR.0535]]<nowiki> New password missing in post data</nowiki>
 [[MSIR.0536]]<nowiki> New password only appears once in post data</nowiki>
 [[MSIR.0537]]<nowiki> New password mismatch in post data</nowiki>
 [[MSIR.0538]]<nowiki> SirSafe is OPTIONAL, visible passwords not allowed</nowiki>
 [[MSIR.0539]]<nowiki> Only one WEBRUN allowed in JANUS WEB ON command</nowiki>
 [[MSIR.0540]]<nowiki> Janus DBCS parameter invalid when DBCSENV0</nowiki>
 [[MSIR.0541]]<nowiki> SirSafe: missing required external authorization evironment</nowiki>
 [[MSIR.0542]]<nowiki> Cannot delete SirSafe until all visible passwords removed</nowiki>
 [[MSIR.0543]]<nowiki> Invalid AUTHCTL syntax. Expected OPTIONAL or REQUIRED, got ""</nowiki>
 [[MSIR.0544]]<nowiki> Invalid interface name: </nowiki>
 [[MSIR.0545]]<nowiki> Security group name not provided</nowiki>
 [[MSIR.0546]]<nowiki> Value too long: ""</nowiki>
 [[MSIR.0547]]<nowiki> Too many rules: =</nowiki>
 [[MSIR.0548]]<nowiki> Group mask is invalid: ""</nowiki>
 [[MSIR.0549]]<nowiki> Asterisk must be last character of mask: ""</nowiki>
 [[MSIR.0555]]<nowiki> BPX error for user , retval = , retcode = reason = : - </nowiki>
 [[MSIR.0556]]<nowiki> Unable to initialize BPX API</nowiki>
 [[MSIR.0558]]<nowiki> SirFact global error: GTBL full</nowiki>
 [[MSIR.0559]]<nowiki> WEBLOGCOOKIE and WEBPUBLOG are mutually eclusive parameters</nowiki>
 [[MSIR.0560]]<nowiki> Invalid zap for Sirius customization: </nowiki>
 [[MSIR.0561]]<nowiki> : in line , procedure , file </nowiki>
 [[MSIR.0562]]<nowiki> : in line of command level program</nowiki>
 [[MSIR.0563]]<nowiki> : , no Sirius debug info</nowiki>
 [[MSIR.0564]]<nowiki> !IF stack overflow</nowiki>
 [[MSIR.0565]]<nowiki> Unexpected </nowiki>
 [[MSIR.0566]]<nowiki> Duplicate !ELSE invalid</nowiki>
 [[MSIR.0567]]<nowiki> !DUPEXIT invalid at command level</nowiki>
 [[MSIR.0568]]<nowiki> Extra data at end of invalid</nowiki>
 [[MSIR.0569]]<nowiki> Macro language error, </nowiki>
 [[MSIR.0570]]<nowiki> Variable missing for </nowiki>
 [[MSIR.0571]]<nowiki> Procname length >= LAUDPROC for naked !DUPEXIT</nowiki>
 [[MSIR.0572]]<nowiki> STAT must be linked in for PERFOPT2 X'10' to be set.</nowiki>
 [[MSIR.0573]]<nowiki> SSL client trying to use unsupported protocol: </nowiki>
 [[MSIR.0574]]<nowiki> No ports named defined</nowiki>
 [[MSIR.0575]]<nowiki> : in line , procedure , file </nowiki>
 [[MSIR.0576]]<nowiki> : in line of command level program</nowiki>
 [[MSIR.0577]]<nowiki> : , no Sirius debug info</nowiki>
 [[MSIR.0579]]<nowiki> PRSTOK item: </nowiki>
 [[MSIR.0580]]<nowiki> Invalid statement parameter </nowiki>
 [[MSIR.0581]]<nowiki> Missing value for </nowiki>
 [[MSIR.0582]]<nowiki> Value invalid or too long for </nowiki>
 [[MSIR.0583]]<nowiki> Expression longer than LIBUFF</nowiki>
 [[MSIR.0584]]<nowiki> Invalid expression</nowiki>
 [[MSIR.0585]]<nowiki> Userid or user number required for SIRFACT SNAP</nowiki>
 [[MSIR.0586]]<nowiki> Multiple users logged on as , must specify SIRFACT SNAP usernum</nowiki>
 [[MSIR.0587]]<nowiki> User not logged on</nowiki>
 [[MSIR.0588]]<nowiki> Invalid SIRFACT parameter </nowiki>
 [[MSIR.0589]]<nowiki> User holds critical file resources, specify SIRFACT SNAP user FORCE to force snap</nowiki>
 [[MSIR.0590]]<nowiki> SIRFACT SNAP impossible with NSERVS=1</nowiki>
 [[MSIR.0591]]<nowiki> Current/user being snapped server sizes make SIRFACT SNAP impossible</nowiki>
 [[MSIR.0592]]<nowiki> User , SIRFACT SNAP impossible</nowiki>
 [[MSIR.0593]]<nowiki> User too busy doing journal or checkpoint I/O for SirFact dump</nowiki>
 [[MSIR.0595]]<nowiki> User already being SIRFACT SNAP'ed by user </nowiki>
 [[MSIR.0596]]<nowiki> Cancelling request due to lost Janus Sockets connection ID , print was captured</nowiki>
 [[MSIR.0600]]<nowiki> No requests found to debug for JAN(US)DEB(UG) command</nowiki>
 [[MSIR.0601]]<nowiki> JAN(US)DEB(UG) not valid on an SDAEMON thread</nowiki>
 [[MSIR.0602]]<nowiki> JAN(US)DEB(UG) commands cannot be nested</nowiki>
 [[MSIR.0603]]<nowiki> Insufficient storage for JAN(US)DEB(UG) command</nowiki>
 [[MSIR.0604]]<nowiki> No INCLUDE levels available for JAN(US)DEB(UG)</nowiki>
 [[MSIR.0605]]<nowiki> Connection being debugged lost</nowiki>
 [[MSIR.0606]]<nowiki> Severe error in request being debugged</nowiki>
 [[MSIR.0615]]<nowiki> Subsystem too long, must be 11 characters or shorter</nowiki>
 [[MSIR.0616]]<nowiki> Filename too long, must be 9 characters or shorter</nowiki>
 [[MSIR.0617]]<nowiki> Connection from terminated, terminal input required</nowiki>
 [[MSIR.0618]]<nowiki> ports not supported with TCPTYPE=</nowiki>
 [[MSIR.0619]]<nowiki> Connection request rejected for port due to DRAIN or FORCE</nowiki>
 [[MSIR.0620]]<nowiki> Invalid data in table at line , reason </nowiki>
 [[MSIR.0621]]<nowiki> Invalid number of characters in table, 512 characters required</nowiki>
 [[MSIR.0622]]<nowiki> Insufficient memory for Janus translate tables</nowiki>
 [[MSIR.0623]]<nowiki> Procedure in - </nowiki>
 [[MSIR.0624]]<nowiki> Unable to open </nowiki>
 [[MSIR.0625]]<nowiki> Translate table is not defined</nowiki>
 [[MSIR.0626]]<nowiki> Invalid or missing Janus LOADXT parameter</nowiki>
 [[MSIR.0627]]<nowiki> No Janus Sockets ports named defined which have rules</nowiki>
 [[MSIR.0628]]<nowiki> Invalid JANUS DISPLAYSOCK type - </nowiki>
 [[MSIR.0629]]<nowiki> Connection request rejected due to JANUS SRVSOCK rule</nowiki>
 [[MSIR.0630]]<nowiki> missing for JANUS command</nowiki>
 [[MSIR.0631]]<nowiki> Invalid for JANUS command</nowiki>
 [[MSIR.0632]]<nowiki> Invalid parameter for JANUS command</nowiki>
 [[MSIR.0633]]<nowiki> Can't open file for ADDCA</nowiki>
 [[MSIR.0634]]<nowiki> Can't open proc for ADDCA - </nowiki>
 [[MSIR.0635]]<nowiki> Invalid certificate - </nowiki>
 [[MSIR.0636]]<nowiki> Insufficient storage to </nowiki>
 [[MSIR.0638]]<nowiki> Can't add CA to port because not an SSL port</nowiki>
 [[MSIR.0639]]<nowiki> File , proc already added as CA to port </nowiki>
 [[MSIR.0640]]<nowiki> Identical certificate already added to port from file , proc </nowiki>
 [[MSIR.0641]]<nowiki> Insufficient storage to add CA from file , proc to port </nowiki>
 [[MSIR.0643]]<nowiki> No ports named with CA's from file , proc defined</nowiki>
 [[MSIR.0645]]<nowiki> Error connecting with SSL to , port - </nowiki>
 [[MSIR.0646]]<nowiki> Error requesting client certificate - </nowiki>
 [[MSIR.0647]]<nowiki> SSL fatal alert received, AlertDescription = </nowiki>
 [[MSIR.0648]]<nowiki> SSL closure alert received</nowiki>
 [[MSIR.0649]]<nowiki> too long for JANUS command</nowiki>
 [[MSIR.0650]]<nowiki> NEWSESCMD error -- </nowiki>
 [[MSIR.0651]]<nowiki> for $LIST_CAPTURE'ed data in line , procedure , file </nowiki>
 [[MSIR.0652]]<nowiki> for $LIST_CAPTURE'ed data at command level</nowiki>
 [[MSIR.0653]]<nowiki> for $LIST_CAPTURE'ed data, no Sirius debug info</nowiki>
 [[MSIR.0654]]<nowiki> Macro variable not defined</nowiki>
 [[MSIR.0655]]<nowiki> URL too long for session</nowiki>
 [[MSIR.0656]]<nowiki> GET received while waiting for POST - session terminated</nowiki>
 [[MSIR.0658]]<nowiki> Persistent/legacy session on port terminated, about to exceed site's connection limit</nowiki>
 [[MSIR.0660]]<nowiki> Null string invalid in clause of JANUS command</nowiki>
 [[MSIR.0666]]<nowiki> You probably want JANUS TRACE or SIRIUS DEBUG</nowiki>
 [[MSIR.0667]]<nowiki> Janus Sockets failed: </nowiki>
 [[MSIR.0668]]<nowiki> XML doc parse error: near or before position </nowiki>
 [[MSIR.0669]]<nowiki> cancelled</nowiki>
 [[MSIR.0670]]<nowiki> CSI TCP error - Return code = </nowiki>
 [[MSIR.0671]]<nowiki> Unable to locate phase in SVA</nowiki>
 [[MSIR.0672]]<nowiki> TCPTYPE of '' is only valid under VSE</nowiki>
 [[MSIR.0673]]<nowiki> Can't initialize Janus, no Open MVS segment defined</nowiki>
 [[MSIR.0674]]<nowiki> not supported for LONGSTRING's</nowiki>
 [[MSIR.0675]]<nowiki> Missing on command</nowiki>
 [[MSIR.0676]]<nowiki> Invalid on command: </nowiki>
 [[MSIR.0677]]<nowiki> Unknown $function: </nowiki>
 [[MSIR.0679]]<nowiki> </nowiki>
 [[MSIR.0680]]<nowiki> LONGSTRING error: truncation in line , procedure , file </nowiki>
 [[MSIR.0681]]<nowiki> LONGSTRING error: truncation in line of command level program</nowiki>
 [[MSIR.0682]]<nowiki> LONGSTRING error: truncation, no Sirius debug info</nowiki>
 [[MSIR.0683]]<nowiki> Invalid parameter </nowiki>
 [[MSIR.0684]]<nowiki> $LIST parameter missing</nowiki>
 [[MSIR.0685]]<nowiki> near or before position :</nowiki>
 [[MSIR.0686]]<nowiki> full: </nowiki>
 [[MSIR.0691]]<nowiki> XmlDoc internal error</nowiki>
 [[MSIR.0692]]<nowiki> Insufficient storage for compression data structures</nowiki>
 [[MSIR.0694]]<nowiki> Insufficient storage for new subsystem procedure</nowiki>
 [[MSIR.0695]]<nowiki> Insufficient storage to save new compilation</nowiki>
 [[MSIR.0696]]<nowiki> Saved compilation not used - </nowiki>
 [[MSIR.0697]]<nowiki> Procedure file has invalid deferred name format</nowiki>
 [[MSIR.0698]]<nowiki> Subsystem name missing for SIRFACT </nowiki>
 [[MSIR.0699]]<nowiki> SIRFACT not valid if X'80' bit not set in SIRFACT parameter</nowiki>
 [[MSIR.0700]]<nowiki> Invalid parameter for SIRFACT </nowiki>
 [[MSIR.0701]]<nowiki> Subsystem not started</nowiki>
 [[MSIR.0702]]<nowiki> Subsystem not quiesced</nowiki>
 [[MSIR.0705]]<nowiki> Subsystem resumed before quiesce completed</nowiki>
 [[MSIR.0706]]<nowiki> Subsystem not quiesced within seconds</nowiki>
 [[MSIR.0707]]<nowiki> Invalid SIRFACT QUIESCE WAIT time </nowiki>
 [[MSIR.0713]]<nowiki> XmlDoc with over 16M items</nowiki>
 [[MSIR.0714]]<nowiki> name already used ()</nowiki>
 [[MSIR.0715]]<nowiki> Can't create new ()</nowiki>
 [[MSIR.0716]]<nowiki> </nowiki>
 [[MSIR.0717]]<nowiki> </nowiki>
 [[MSIR.0718]]<nowiki> Equals symbol required after </nowiki>
 [[MSIR.0719]]<nowiki> Value missing for </nowiki>
 [[MSIR.0720]]<nowiki> name already in use as </nowiki>
 [[MSIR.0721]]<nowiki> END expected, got END </nowiki>
 [[MSIR.0722]]<nowiki> VTLAPSY failed to login user</nowiki>
 [[MSIR.0723]]<nowiki> has no </nowiki>
 [[MSIR.0724]]<nowiki> name missing or invalid</nowiki>
 [[MSIR.0725]]<nowiki> not defined</nowiki>
 [[MSIR.0726]]<nowiki> Already an image or screen named </nowiki>
 [[MSIR.0727]]<nowiki> has same name as variable</nowiki>
 [[MSIR.0728]]<nowiki> variable invalid in </nowiki>
 [[MSIR.0729]]<nowiki> Variable doesn't have required suffix </nowiki>
 [[MSIR.0730]]<nowiki> not defined</nowiki>
 [[MSIR.0731]]<nowiki> is not a structure, object, image, screen or menu</nowiki>
 [[MSIR.0732]]<nowiki> Invalid context for </nowiki>
 [[MSIR.0733]]<nowiki> not found in </nowiki>
 [[MSIR.0734]]<nowiki> variable name invalid</nowiki>
 [[MSIR.0735]]<nowiki> Subscripts not allowed for </nowiki>
 [[MSIR.0736]]<nowiki> Assignment to must be from </nowiki>
 [[MSIR.0737]]<nowiki> Assignment from must be to </nowiki>
 [[MSIR.0738]]<nowiki> Assignment mismatch -- input is , output is </nowiki>
 [[MSIR.0739]]<nowiki> Variable name invalid</nowiki>
 [[MSIR.0740]]<nowiki> AllowNull only allowed for Objects</nowiki>
 [[MSIR.0741]]<nowiki> does not return a structure or object</nowiki>
 [[MSIR.0742]]<nowiki> Argument for missing</nowiki>
 [[MSIR.0743]]<nowiki> Argument for invalid</nowiki>
 [[MSIR.0744]]<nowiki> Too many arguments for </nowiki>
 [[MSIR.0745]]<nowiki> Invalid syntax for </nowiki>
 [[MSIR.0746]]<nowiki> Object variable required for </nowiki>
 [[MSIR.0747]]<nowiki> during in line , procedure , file </nowiki>
 [[MSIR.0748]]<nowiki> during at command level</nowiki>
 [[MSIR.0749]]<nowiki> during , no Sirius debug info</nowiki>
 [[MSIR.0750]]<nowiki> Class , : in line , procedure , file </nowiki>
 [[MSIR.0751]]<nowiki> Class , : in line of command level program</nowiki>
 [[MSIR.0752]]<nowiki> Class , : , no Sirius debug info</nowiki>
 [[MSIR.0753]]<nowiki> Explicit not allowed for class </nowiki>
 [[MSIR.0754]]<nowiki> Class , : not </nowiki>
 [[MSIR.0755]]<nowiki> Assignment source for invalid</nowiki>
 [[MSIR.0756]]<nowiki> Unexpected left parenthesis</nowiki>
 [[MSIR.0757]]<nowiki> not allowed for ARRAY parameters</nowiki>
 [[MSIR.0758]]<nowiki> Class , returns no value so can only be used in standalone call, or has no arguments</nowiki>
 [[MSIR.0759]]<nowiki> Order comparison (GE, LE, LT, GT) not valid for </nowiki>
 [[MSIR.0760]]<nowiki> Comparison mismatch -- against </nowiki>
 [[MSIR.0761]]<nowiki> $ not callable</nowiki>
 [[MSIR.0764]]<nowiki> Invalid class reference</nowiki>
 [[MSIR.0765]]<nowiki> in class </nowiki>
 [[MSIR.0766]]<nowiki> can't be Global or Session</nowiki>
 [[MSIR.0767]]<nowiki> Invalid global/session name</nowiki>
 [[MSIR.0768]]<nowiki> name already bound to other variable</nowiki>
 [[MSIR.0769]]<nowiki> Local not supported</nowiki>
 [[MSIR.0770]]<nowiki> already defined</nowiki>
 [[MSIR.0771]]<nowiki> invalid after </nowiki>
 [[MSIR.0772]]<nowiki> Member already declared</nowiki>
 [[MSIR.0773]]<nowiki> qualifier in section</nowiki>
 [[MSIR.0774]]<nowiki> not valid for </nowiki>
 [[MSIR.0775]]<nowiki> required for </nowiki>
 [[MSIR.0776]]<nowiki> Mismatch between declaration and definition</nowiki>
 [[MSIR.0777]]<nowiki> error in compiler, compilation aborted</nowiki>
 [[MSIR.0778]]<nowiki> not declared</nowiki>
 [[MSIR.0779]]<nowiki> Already have method</nowiki>
 [[MSIR.0780]]<nowiki> END expected</nowiki>
 [[MSIR.0781]]<nowiki> END expected, not END </nowiki>
 [[MSIR.0782]]<nowiki> Block not associated with name </nowiki>
 [[MSIR.0783]]<nowiki> Already have method for property</nowiki>
 [[MSIR.0784]]<nowiki> method missing for property</nowiki>
 [[MSIR.0785]]<nowiki> already defined</nowiki>
 [[MSIR.0786]]<nowiki> Result required for method/property</nowiki>
 [[MSIR.0787]]<nowiki> Result has incorrect type</nowiki>
 [[MSIR.0788]]<nowiki> Subroutines cannot have a datatype</nowiki>
 [[MSIR.0789]]<nowiki> Implied return not valid for methods that return a value</nowiki>
 [[MSIR.0790]]<nowiki> Non-readOnly property cannot be called THIS</nowiki>
 [[MSIR.0791]]<nowiki> not valid for property</nowiki>
 [[MSIR.0792]]<nowiki> in class never defined</nowiki>
 [[MSIR.0793]]<nowiki> Inconsistent in class header</nowiki>
 [[MSIR.0794]]<nowiki> Invalid name: ''</nowiki>
 [[MSIR.0795]]<nowiki> Unsupported method: </nowiki>
 [[MSIR.0796]]<nowiki> is not allowed as a member name</nowiki>
 [[MSIR.0797]]<nowiki> No method linking for implied object</nowiki>
 [[MSIR.0798]]<nowiki> Explicit name required for shared variables</nowiki>
 [[MSIR.0799]]<nowiki> Null object passed as non-allowNull parameter</nowiki>
 [[MSIR.0800]]<nowiki> must be </nowiki>
 [[MSIR.0801]]<nowiki> READ SCREEN encountered in NOSCREEN mode</nowiki>
 [[MSIR.0802]]<nowiki> may not be nested</nowiki>
 [[MSIR.0803]]<nowiki> Optional or default parameter required for presence test</nowiki>
 [[MSIR.0804]]<nowiki> Class too big</nowiki>
 [[MSIR.0805]]<nowiki> Statement label multiply defined</nowiki>
 [[MSIR.0806]]<nowiki> Arrays not allowed in Public/Private block -- use Collections</nowiki>
 [[MSIR.0807]]<nowiki> Can't declare after </nowiki>
 [[MSIR.0808]]<nowiki> New must be disallowed in Public block to be a Private constructor</nowiki>
 [[MSIR.0809]]<nowiki> only valid in Public block</nowiki>
 [[MSIR.0810]]<nowiki> required for class </nowiki>
 [[MSIR.0811]]<nowiki> not allowed</nowiki>
 [[MSIR.0812]]<nowiki> Class requires not </nowiki>
 [[MSIR.0813]]<nowiki> Maximum number of parameters, , exceeded</nowiki>
 [[MSIR.0814]]<nowiki> expected</nowiki>
 [[MSIR.0815]]<nowiki> only valid for </nowiki>
 [[MSIR.0816]]<nowiki> disallowed</nowiki>
 [[MSIR.0817]]<nowiki> SIRMETH rule type missing or invalid</nowiki>
 [[MSIR.0818]]<nowiki> SIRMETH action missing or invalid</nowiki>
 [[MSIR.0820]]<nowiki> SIRMETH name missing or invalid</nowiki>
 [[MSIR.0821]]<nowiki> File in use for file/group objects, command rejected</nowiki>
 [[MSIR.0822]]<nowiki> Invalid SIRMETH qualifier </nowiki>
 [[MSIR.0823]]<nowiki> Insufficient storage for SIRMETH command</nowiki>
 [[MSIR.0824]]<nowiki> No qualifiers allowed for SIRMETH DISPLAY</nowiki>
 [[MSIR.0825]]<nowiki> SUBSYSTEM without NONPRE doesn't make sense for SUBSYSTEMSET</nowiki>
 [[MSIR.0826]]<nowiki> NONPRE doesn't make sense for DISALLOW</nowiki>
 [[MSIR.0827]]<nowiki> AUTO not supported for </nowiki>
 [[MSIR.0828]]<nowiki> AUTO value missing or invalid</nowiki>
 [[MSIR.0829]]<nowiki> AUTO inconsistency for Common/Global/Session variable</nowiki>
 [[MSIR.0830]]<nowiki> Only one TO clause allowed</nowiki>
 [[MSIR.0831]]<nowiki> Target of TO must be a StringList object</nowiki>
 [[MSIR.0832]]<nowiki> Can't end with ellipses with TO clause </nowiki>
 [[MSIR.0833]]<nowiki> Can't set Model 6 -- </nowiki>
 [[MSIR.0834]]<nowiki> Un-named parameters not allowed after named parameters</nowiki>
 [[MSIR.0835]]<nowiki> has no named parameters</nowiki>
 [[MSIR.0836]]<nowiki> Named parameters should not begin with %</nowiki>
 [[MSIR.0837]]<nowiki> Too many un-named arguments for </nowiki>
 [[MSIR.0838]]<nowiki> Parameter named not found for </nowiki>
 [[MSIR.0839]]<nowiki> can't be performed: FTP Port is started</nowiki>
 [[MSIR.0840]]<nowiki> can't be performed: folder is referred to by HOME or ALLOW rules</nowiki>
 [[MSIR.0841]]<nowiki> HttpRequest ://:: Timeout= exceeded</nowiki>
 [[MSIR.0842]]<nowiki> must be inside a file/group-related FOR loop</nowiki>
 [[MSIR.0843]]<nowiki> file/group does not match the file/group context of the FOR loop</nowiki>
 [[MSIR.0844]]<nowiki> Previous undefined macro variable</nowiki>
 [[MSIR.0845]]<nowiki> Parameter is type incompatible</nowiki>
 [[MSIR.0846]]<nowiki> NameAllowed not allowed after NameRequired</nowiki>
 [[MSIR.0847]]<nowiki> Value already specified for parameter </nowiki>
 [[MSIR.0848]]<nowiki> Invalid InternalNames statement</nowiki>
 [[MSIR.0849]]<nowiki> No parameter named </nowiki>
 [[MSIR.0850]]<nowiki> Invalid parameter name </nowiki>
 [[MSIR.0851]]<nowiki> Parameter name in use</nowiki>
 [[MSIR.0852]]<nowiki> Daemon requires non-command-level input -- restarting</nowiki>
 [[MSIR.0853]]<nowiki> Master lost</nowiki>
 [[MSIR.0854]]<nowiki> Compilation terminated -- before </nowiki>
 [[MSIR.0855]]<nowiki> had , but contains a direct or indirect reference to class , which is not </nowiki>
 [[MSIR.0856]]<nowiki> Allow Auto not allowed for </nowiki>
 [[MSIR.0857]]<nowiki> Input object of class not </nowiki>
 [[MSIR.0858]]<nowiki> Class had , but extends class , which is not </nowiki>
 [[MSIR.0859]]<nowiki> Statement requires object</nowiki>
 [[MSIR.0860]]<nowiki> Can't extend </nowiki>
 [[MSIR.0861]]<nowiki> Class repeatedly extended</nowiki>
 [[MSIR.0862]]<nowiki> Class too big</nowiki>
 [[MSIR.0863]]<nowiki> CONSTRUCT only valid in constructor of an extension class</nowiki>
 [[MSIR.0864]]<nowiki> Class is not a class of </nowiki>
 [[MSIR.0865]]<nowiki> is not a constructor for class </nowiki>
 [[MSIR.0866]]<nowiki> CONSTRUCT invalid -- </nowiki>
 [[MSIR.0867]]<nowiki> Class (maybe) not constructed</nowiki>
 [[MSIR.0868]]<nowiki> Invalid %this reference -- class not constructed</nowiki>
 [[MSIR.0869]]<nowiki> New disallowed in base class , but not disallowed in Public block</nowiki>
 [[MSIR.0870]]<nowiki> Implied constructor before Public block of extension class </nowiki>
 [[MSIR.0871]]<nowiki> Error compiling implied Construct of class for class </nowiki>
 [[MSIR.0872]]<nowiki> not valid for </nowiki>
 [[MSIR.0873]]<nowiki> IMPLEMENTS invalid -- </nowiki>
 [[MSIR.0874]]<nowiki> Class contains unimplemented abstract methods</nowiki>
 [[MSIR.0875]]<nowiki> Implements method inconsistent with base method</nowiki>
 [[MSIR.0876]]<nowiki> Can't create instance of abstract class</nowiki>
 [[MSIR.0877]]<nowiki> Invalid context for Super reference</nowiki>
 [[MSIR.0881]]<nowiki> is an invalid inherit name</nowiki>
 [[MSIR.0882]]<nowiki> is not a member of class </nowiki>
 [[MSIR.0883]]<nowiki> Class -- inherited classes and contain members with the same name</nowiki>
 [[MSIR.0885]]<nowiki> MSGCTL NOCAN ignored for MSIR.</nowiki>
 [[MSIR.0886]]<nowiki> Field has invalid type change between UAI and LAI</nowiki>
 [[MSIR.0887]]<nowiki> Can't auto-define LOB field with </nowiki>
 [[MSIR.0888]]<nowiki> Invalid LOB data, RECNUM = , field = </nowiki>
 [[MSIR.0889]]<nowiki> Classes nested too deeply</nowiki>
 [[MSIR.0894]]<nowiki> Daemon restarting because </nowiki>
 [[MSIR.0895]]<nowiki> Legacy Sessions may not be debugged.</nowiki>
 [[MSIR.0896]]<nowiki> Maximum number of nameservers () exceeded</nowiki>
 [[MSIR.0897]]<nowiki> Nameserver IP address required if none defined yet</nowiki>
 [[MSIR.0899]]<nowiki> Invalid argument for -- </nowiki>
 [[MSIR.0900]]<nowiki> SDAEMDEV and TNDEV can't have the same value</nowiki>
 [[MSIR.0901]]<nowiki> Can't define IODEVs with TNDEV number in CCAIN stream</nowiki>
 [[MSIR.0902]]<nowiki> Can't define port, TNDEV system parameter not set</nowiki>
 [[MSIR.0903]]<nowiki> protocol error</nowiki>
 [[MSIR.0904]]<nowiki> Terminating connection: </nowiki>
 [[MSIR.0905]]<nowiki> requires </nowiki>
 [[MSIR.0906]]<nowiki> SIRTUNE - Invalid command </nowiki>
 [[MSIR.0907]]<nowiki> SIRTUNE - Invalid parameter </nowiki>
 [[MSIR.0908]]<nowiki> SIRTUNE - Invalid range </nowiki>
 [[MSIR.0909]]<nowiki> SIRTUNE - Parameter missing for command</nowiki>
 [[MSIR.0914]]<nowiki> Debugger Error: </nowiki>
 [[MSIR.0916]]<nowiki> Could not connect to client at port : </nowiki>
 [[MSIR.0917]]<nowiki> User's pushdown list overflowed during regular expression </nowiki>
 [[MSIR.0918]]<nowiki> Debugging terminated, DEBUGPAG exceeded.</nowiki>
 [[MSIR.0919]]<nowiki> Object's class () not </nowiki>
 [[MSIR.0924]]<nowiki> Debugger breakpoint maximum exceeded</nowiki>
 [[MSIR.0927]]<nowiki> Debugger session refused: </nowiki>
 [[MSIR.0929]]<nowiki> Janus/Tn3270 Debugger worker terminated: </nowiki>
 [[MSIR.0939]]<nowiki> table too small; increase by at least </nowiki>
 [[MSIR.0941]]<nowiki> Debugger error on port: </nowiki>
 [[MSIR.0944]]<nowiki> Invalid operand of Is Defined test: </nowiki>
 [[MSIR.0945]]<nowiki> field () in line , procedure , file </nowiki>
 [[MSIR.0946]]<nowiki> field () in line of command level program</nowiki>
 [[MSIR.0947]]<nowiki> field (), no Sirius debug info</nowiki>
 [[MSIR.0949]]<nowiki> Fast/Reload </nowiki>
 [[MSIR.0950]]<nowiki> Longstring value longer than 255 bytes while processing Initial clause</nowiki>
 [[MSIR.0951]]<nowiki> : , while processing Initial clause</nowiki>
 [[MSIR.0952]]<nowiki> SUSPEND only valid after TN3270 DEBUG ON</nowiki>
 [[MSIR.0953]]<nowiki> Debugging already suspended.</nowiki>
 [[MSIR.0954]]<nowiki> RESUME only valid after SUSPEND</nowiki>
 [[MSIR.0959]]<nowiki> TCPLOG cannot be specified with either COMPRESS or SSL options</nowiki>
 [[MSIR.0963]]<nowiki> Missing on UNICODE command</nowiki>
 [[MSIR.0964]]<nowiki> Invalid on UNICODE command: ''</nowiki>
 [[MSIR.0966]]<nowiki> Error processing UNICODE command: </nowiki>
 [[MSIR.0967]]<nowiki> not legal for FILEORG=X'100' file</nowiki>
 [[MSIR.0968]]<nowiki> SIRFIELD updates not valid when doing roll-forward logging</nowiki>
 [[MSIR.0970]]<nowiki> Invalid use of '' directive: </nowiki>
 [[MSIR.0971]]<nowiki> not valid after a TO clause</nowiki>
 [[MSIR.0972]]<nowiki> Exception class can't extend non-extension class</nowiki>
 [[MSIR.0973]]<nowiki> THROWS invalid -- </nowiki>
 [[MSIR.0974]]<nowiki> TRY invalid -- </nowiki>
 [[MSIR.0975]]<nowiki> CATCH invalid -- </nowiki>
 [[MSIR.0976]]<nowiki> FINALLY invalid -- </nowiki>
 [[MSIR.0977]]<nowiki> THROW invalid -- </nowiki>
 [[MSIR.0978]]<nowiki> Attempt to store string with negative length () in record , field ignored: </nowiki>
 [[MSIR.0979]]<nowiki> Reference to left side ("@" phrase) invalid: </nowiki>
 [[MSIR.0980]]<nowiki> Invalid assignment to variable</nowiki>
 [[MSIR.0981]]<nowiki> Enhancement methods </nowiki>
 [[MSIR.0982]]<nowiki> Exception On method </nowiki>
 [[MSIR.0983]]<nowiki> Constant method requires constant input</nowiki>
 [[MSIR.0984]]<nowiki> Class , : , compilation</nowiki>
 [[MSIR.0985]]<nowiki> member type missing or invalid</nowiki>
 [[MSIR.0986]]<nowiki> alias not allowed for </nowiki>
 [[MSIR.0987]]<nowiki> variables only allowed in </nowiki>
 [[MSIR.0988]]<nowiki> Only Persistent/Shared variables allowed in Property block</nowiki>
 [[MSIR.0989]]<nowiki> Variable declarations </nowiki>
 [[MSIR.0990]]<nowiki> Common properties can't have parameters</nowiki>
 [[MSIR.0991]]<nowiki> Can't format user PDL: </nowiki>
 [[MSIR.0992]]<nowiki> Local subroutine must be called via %(local): or Call</nowiki>
 [[MSIR.0993]]<nowiki> Assignment invalid: </nowiki>
 [[MSIR.0994]]<nowiki> Variable method invocation invalid: </nowiki>
 [[MSIR.0996]]<nowiki> Incomplete !debugger directive</nowiki>
 [[MSIR.0997]]<nowiki> Invalid !debugger directive: </nowiki>
 [[MSIR.0998]]<nowiki> !debugger must be ON, OFF, PROC or ROUTINE, not </nowiki>
 [[MSIR.1001]]<nowiki> already </nowiki>
 [[MSIR.1009]]<nowiki> Invalid name/pattern on !debugger directive</nowiki>
 [[MSIR.1015]]<nowiki> requires at least of Model 204</nowiki>
 [[MSIR.1016]]<nowiki> Print To not supported for LOB fields</nowiki>
 [[MSIR.1017]]<nowiki> not allowed for collection of intrinsics</nowiki>
 [[MSIR.1018]]<nowiki> Success invalid -- </nowiki>
 [[MSIR.1025]]<nowiki> CLIENTCOMMAND requires Build 53 minimum</nowiki>
 [[MSIR.1027]]<nowiki> CLIENTCOMMAND string missing</nowiki>
 [[MSIR.1029]]<nowiki> Attribute error: </nowiki>
 [[MSIR.1030]]<nowiki> Attribute missing</nowiki>
 [[MSIR.1031]]<nowiki> must be followed by assignment to target</nowiki>
 [[MSIR.1032]]<nowiki> Object not allowed as target of SetText</nowiki>
 [[MSIR.1033]]<nowiki> statement too complicated</nowiki>
 [[MSIR.1034]]<nowiki> Invalid context for </nowiki>
 [[MSIR.1043]]<nowiki> Error defining field in LAI</nowiki>
 [[MSIR.1044]]<nowiki> Invalid DEFAULT-VALUE: </nowiki>
 [[MSIR.1045]]<nowiki> Invalid mix of UTF attributes in group field </nowiki>
 [[MSIR.1046]]<nowiki> PUSHUTABLE already done at current INCLUDE level</nowiki>
 [[MSIR.1047]]<nowiki> CCATEMP full, PUSHUTABLE failed</nowiki>
 [[MSIR.1048]]<nowiki> No PUSHUTABLE done at current INCLUDE level</nowiki>
 [[MSIR.1049]]<nowiki> POPUTABLE failed -- </nowiki>
 [[MSIR.1051]]<nowiki> Session object has direct or indirect reference to locked record(s)</nowiki>
 [[MSIR.1052]]<nowiki> RETHROW invalid -- </nowiki>
 [[MSIR.1053]]<nowiki> Statement after Rethrow must be Catch, Rethrow, Success, or End Try</nowiki>
 [[MSIR.1060]]<nowiki> Unexpected word on command: ""</nowiki>
 [[MSIR.1063]]<nowiki> Screen only allowed in standalone call</nowiki>
 [[MSIR.1064]]<nowiki> XMLSCREEN error: </nowiki>
 [[MSIR.1065]]<nowiki> XMLSCREEN Exit pfKey received</nowiki>
 [[MSIR.1071]]<nowiki> only valid in Shared block</nowiki>
 [[MSIR.1072]]<nowiki> is already a friend of </nowiki>
 [[MSIR.1073]]<nowiki> Public friend not allowed for public class</nowiki>
 [[MSIR.1074]]<nowiki> not allowed because is a private class</nowiki>
 [[MSIR.1075]]<nowiki> Not all ciphers supported on this hardware; SSLCIPH reset to X''</nowiki>
 [[MSIR.1079]]<nowiki> Debugger Client Build: < MINDEBCL: debugger client connection refused</nowiki>
 [[MSIR.1081]]<nowiki> must specify both/neither parameters: Recordnumber/File</nowiki>
 [[MSIR.1082]]<nowiki> : </nowiki>

===Return code 6===
 [[M204.1017]]<nowiki> IFAM1 - user restart</nowiki>
 [[M204.1024]]<nowiki> User restarted </nowiki>

===Return code 8===
 [[M204.2167]]<nowiki> A close error has been detected on dataset </nowiki>
 [[M204.2620]]<nowiki> Subsystem invalid CCATEMP page count </nowiki>
 [[M204.2737]]<nowiki> CHKPOINT dataset must be copied to larger dataset - do not delete and reallocate !</nowiki>
 [[M204.2741]]<nowiki> Roll back/roll forward must be run prior to RERUNRB - RESTART cancelled</nowiki>
 [[M204.2901]]<nowiki> **Fix is available for problem** FOPT=x'10' (dts) is not supported during FLOD/FILELOAD</nowiki>
 [[M204.2903]]<nowiki> FILEORG=x'100' is not supported during FLOD/FILELOAD</nowiki>
 [[M204.2961]]<nowiki> Missing end "/" in PGM=FUNLOAD PARM</nowiki>
 [[M204.2962]]<nowiki> M204Params between "/../" in PGM=FUNLOAD PARM= exceeds characters</nowiki>
 [[MSIR.0316]]<nowiki> LAI cancelled</nowiki>
 [[MSIR.0910]]<nowiki> SIRTUNE - Errors in SIRTUNEI, run cancelled</nowiki>
 [[MSIR.1058]]<nowiki> More than SNAPLIMD occurrences of this snap, snap not generated</nowiki>

===Return code 16===
 [[M204.0533]]<nowiki> Editing space exhausted -- DKBL</nowiki>
 [[M204.0550]]<nowiki> Editing space exhausted -- QTBL, LQTBL=</nowiki>
 [[M204.1042]]<nowiki> Compilation errors</nowiki>

===Return code 20===
 [[M204.0109]]<nowiki> Input to RESTORE has wrong file name: </nowiki>
 [[M204.0110]]<nowiki> Invalid command</nowiki>
 [[M204.0111]]<nowiki> Eof or I/O error on input to RESTORE</nowiki>
 [[M204.0112]]<nowiki> Not enough pages to RESTORE file. At least X'' pages required</nowiki>
 [[M204.0113]]<nowiki> DSL/LPM alteration implied but not authorized</nowiki>
 [[M204.0114]]<nowiki> CCAGRP not included in job</nowiki>
 [[M204.0115]]<nowiki> Invalid RESTORE or RESTOREG option</nowiki>
 [[M204.0116]]<nowiki> Bad input to RESTORE: </nowiki>
 [[M204.0117]]<nowiki> Not enough pages to make requested alterations during RESTORE</nowiki>
 [[M204.1064]]<nowiki> I/O error DUMPing to </nowiki>
 [[M204.2316]]<nowiki> TCPIP error: , process=, remoteid=, seituh=</nowiki>
 [[M204.2621]]<nowiki> No file tables DUMP(G)ed </nowiki>
 [[M204.2711]]<nowiki> is not a DUMP dataset, cannot RESTORE into </nowiki>
 [[M204.2714]]<nowiki> specified for both dump ddName and filename</nowiki>
 [[MSIR.0228]]<nowiki> Invalid input page sequence number: , expected: </nowiki>

===Return code 24===
 [[M204.0659]]<nowiki> Can't open TAPEI</nowiki>
 [[M204.0660]]<nowiki> Unable to attach sort, rc = </nowiki>
 [[M204.0661]]<nowiki> Sort work DD card, CCA1WK01, missing</nowiki>
 [[M204.0664]]<nowiki> Can't open SORT5</nowiki>
 [[M204.0665]]<nowiki> Can't open TAPE5</nowiki>
 [[M204.0670]]<nowiki> is on a read-only device</nowiki>
 [[M204.0671]]<nowiki> File is on a read-only device</nowiki>
 [[M204.0672]]<nowiki> File is in deferred update mode</nowiki>
 [[M204.0674]]<nowiki> Not enough core for sort communications area</nowiki>
 [[M204.0682]]<nowiki> FLOD compilation errors found</nowiki>
 [[M204.1707]]<nowiki> Sort/hash key must be first field loaded into new record</nowiki>
 [[M204.1828]]<nowiki> ORDERED field referenced, no variable length deferred update dataset supplied</nowiki>
 [[M204.1829]]<nowiki> Invalid VL parameter specified</nowiki>
 [[M204.1864]]<nowiki> ORDERED field referenced, no VL specified on FILELOAD command</nowiki>
 [[M204.1933]]<nowiki> Uniqueness violation during Store Record in a non-TBO file</nowiki>
 [[M204.2120]]<nowiki> AT-MOST-ONE violation during Store Record in a non-TBO file</nowiki>
 [[M204.2147]]<nowiki> Deferred update dataset for contains updates for file </nowiki>
 [[M204.2149]]<nowiki> I/O error on TAPE5 dataset, application of index updates aborted</nowiki>
 [[M204.2787]]<nowiki> Output incomplete: UDD lines output = </nowiki>

===Return code 32===
 [[M204.1080]]<nowiki> Too many errors</nowiki>

===Return code 40===
 [[M204.0452]]<nowiki> TTBL full, LTTBL=</nowiki>
 [[M204.0555]]<nowiki> Extra numeric field ignored in recnum=, field=</nowiki>
 [[M204.0573]]<nowiki> Value(s) too long--STBL, LSTBL=</nowiki>

===Return code 44===
 [[M204.1220]]<nowiki> not initialized</nowiki>
 [[M204.1221]]<nowiki> is physically inconsistent</nowiki>

===Return code 48===
 [[M204.0443]]<nowiki> Table full in </nowiki>
 [[M204.0707]]<nowiki> Table B full -- appends</nowiki>
 [[M204.1222]]<nowiki> is full</nowiki>
 [[M204.1229]]<nowiki> Table B full -- inserts --: </nowiki>
 [[M204.1230]]<nowiki> Table full -- appends --: </nowiki>
 [[M204.1231]]<nowiki> Table B full -- spills --: </nowiki>
 [[M204.1259]]<nowiki> Table A full - </nowiki>
 [[M204.1270]]<nowiki> Table C full - property entry, </nowiki>
 [[M204.1272]]<nowiki> Table C full - page entry: </nowiki>
 [[M204.2690]]<nowiki> pages would fill Table E in </nowiki>

===Return code 52===
 [[M204.0122]]<nowiki> Roll forward is cancelled</nowiki>
 [[M204.0135]]<nowiki> No CCARF DD statement - can't perform recovery</nowiki>
 [[M204.0136]]<nowiki> No CHKPOINT DD card - can't perform recovery</nowiki>
 [[M204.0137]]<nowiki> RESTART bypassed</nowiki>
 [[M204.0138]]<nowiki> Unable to open stream</nowiki>
 [[M204.0142]]<nowiki> Serious error during roll back - run aborted</nowiki>
 [[M204.0144]]<nowiki> = but must be at least ()</nowiki>
 [[M204.0147]]<nowiki> RESTART aborted</nowiki>
 [[M204.0151]]<nowiki> I/O error during roll back. RESTART failed.</nowiki>
 [[M204.0156]]<nowiki> Invalid checkpoint date or time: </nowiki>
 [[M204.0162]]<nowiki> Serious error during roll forward - run aborted</nowiki>
 [[M204.0175]]<nowiki> Roll forward optimization error</nowiki>
 [[M204.0357]]<nowiki> Invalid RESTART option: </nowiki>
 [[M204.0393]]<nowiki> Specified checkpoint not found in RESTART stream</nowiki>
 [[M204.0398]]<nowiki> Fatal I/O error on CCARF in pass 2 of roll forward</nowiki>
 [[M204.1300]]<nowiki> RESTART command requires checkpoint logging - run terminated</nowiki>
 [[M204.1455]]<nowiki> Recovery of requested, but file is unavailable</nowiki>
 [[M204.1762]]<nowiki> : ended abnormally</nowiki>
 [[M204.2605]]<nowiki> CHKPOINT too small for roll forward - blocks required; found</nowiki>
 [[M204.2882]]<nowiki> Recovery journal (CCARF) version is not supported</nowiki>
 [[M204.2883]]<nowiki> Mix of journal versions in recovery CCARF</nowiki>
 [[M204.2979]]<nowiki> There were errors before RESTART</nowiki>

===Return code 53===
 [[M204.1404]]<nowiki> Failed to open </nowiki>
 [[M204.1405]]<nowiki> Unknown journal entry</nowiki>
 [[M204.1410]]<nowiki> REGENERATE command rejected</nowiki>

===Return code 56===
 [[M204.0566]]<nowiki> Quadruple missing</nowiki>

===Return code 60===
 [[M204.0071]]<nowiki> LRETBL * NUSERS too high</nowiki>
 [[M204.0074]]<nowiki> Insufficient main storage for MINBUF specification 16meg line, SPCORE = , MINBUF = , MAXBUF = </nowiki>
 [[M204.0441]]<nowiki> CCATEMP full: </nowiki>
 [[M204.1050]]<nowiki> CCATEMP full: </nowiki>
 [[M204.1331]]<nowiki> Run killed - no more time</nowiki>
 [[M204.1333]]<nowiki> Cancelled w/ DUMP</nowiki>
 [[M204.2127]]<nowiki> Sum of MAXBUF + SPCORE exceeds machine size</nowiki>
 [[M204.2143]]<nowiki> Insufficient main storage for SPCORE specification 16meg line, SPCORE = , MINBUF = , MAXBUF = </nowiki>
 [[M204.2563]]<nowiki> Module= returned more than bytes</nowiki>
 [[M204.2904]]<nowiki> Insufficient CCATEMP pages for backout data</nowiki>

===Return code 64===
 [[M204.0310]]<nowiki> Bug .. RDSN</nowiki>
 [[M204.0657]]<nowiki> Sort error</nowiki>
 [[M204.0667]]<nowiki> Unable to attach FRV sort, rc = </nowiki>
 [[M204.0684]]<nowiki> No value supplied -- col=0</nowiki>
 [[M204.0691]]<nowiki> Branched to missing tag</nowiki>
 [[M204.0693]]<nowiki> String too long</nowiki>
 [[M204.0704]]<nowiki> No record defined -- FLOD</nowiki>
 [[M204.0719]]<nowiki> Up too far</nowiki>
 [[M204.0720]]<nowiki> Down too far</nowiki>
 [[M204.1424]]<nowiki> FLOD L statement nested too deeply</nowiki>
 [[M204.2604]]<nowiki> FLOD record definition exceeds record length</nowiki>
 [[MSIR.0892]]<nowiki> Input error: input record number: , start position/length: /</nowiki>

===Return code 72===
 [[M204.0447]]<nowiki> Table D inconsistency in </nowiki>
 [[M204.2626]]<nowiki> XMEMSVC must be set to a valid SVC # if either x'02' or x'80' is set in XMEMOPT</nowiki>

===Return code 80===
 [[M204.0069]]<nowiki> Fixed area for user will not fit in largest server, initialization terminated</nowiki>
 [[M204.0070]]<nowiki> Server too small for user: </nowiki>
 [[M204.0077]]<nowiki> Errors detected -- run cancelled</nowiki>
 [[M204.0197]]<nowiki> Invalid NOTERM value</nowiki>
 [[M204.0332]]<nowiki> from CRFS </nowiki>
 [[M204.0336]]<nowiki> from CRIO </nowiki>
 [[M204.0955]]<nowiki> IFAM2 CRAM open error RC=, IFAM halted - channel = </nowiki>
 [[M204.1336]]<nowiki> Region too small - run terminated</nowiki>
 [[M204.1403]]<nowiki> Increase SERVGSZ to at least for required ATB server areas</nowiki>
 [[M204.2606]]<nowiki> Only licensed, run terminated</nowiki>
 [[M204.2651]]<nowiki> Not all threads processed for IODEV </nowiki>
 [[M204.2731]]<nowiki> DEBUGOPT specified, but XMEMOPT not set</nowiki>
 [[M204.2757]]<nowiki> Insufficient above-the-bar storage -- run terminated</nowiki>
 [[M204.2758]]<nowiki> MAXBUF+NUMBUFG can't exceed 2G</nowiki>
 [[M204.2923]]<nowiki> Increase SERVNSSZ to at least for required non swappable server areas</nowiki>

===Return code 88===
 [[M204.1071]]<nowiki> Finish during finish</nowiki>
 [[M204.2965]]<nowiki> Unable to cleanly close log file(s)</nowiki>

===Return code 96===
 [[M204.0022]]<nowiki> Bug .. </nowiki>
 [[M204.0072]]<nowiki> User zero won't fit in largest server</nowiki>
 [[M204.0390]]<nowiki> exception occurred at </nowiki>
 [[M204.0426]]<nowiki> Wrong page read -- DKWT, file: , hash cell: x''</nowiki>
 [[M204.0439]]<nowiki> Page being illegally modified</nowiki>
 [[M204.0450]]<nowiki> Bug .. DKFLSHP flushing with pages on dirty chain</nowiki>
 [[M204.0461]]<nowiki> Wrong page write attempt on file </nowiki>
 [[M204.0462]]<nowiki> Trouble with disk I/O on file </nowiki>
 [[M204.0463]]<nowiki> Trouble with disk I/O</nowiki>
 [[M204.0464]]<nowiki> Possible incorrect DD statement</nowiki>
 [[M204.0852]]<nowiki> Bug .. GRDOGT</nowiki>
 [[M204.0938]]<nowiki> Fatal record locking table inconsistency</nowiki>
 [[M204.1020]]<nowiki> User restart loop</nowiki>
 [[M204.1225]]<nowiki> Resource locking table full</nowiki>
 [[M204.1269]]<nowiki> Bug .. RTSTRL</nowiki>
 [[M204.1285]]<nowiki> Trouble with server I/O</nowiki>
 [[M204.1346]]<nowiki> Server area greater than cylinder capacity for . Cylinder size = bytes.</nowiki>
 [[M204.1348]]<nowiki> Can't open server dataset: </nowiki>
 [[M204.1349]]<nowiki> Insufficient space allocated to server dataset(s), additional bytes required = </nowiki>
 [[M204.1352]]<nowiki> Server too big by bytes</nowiki>
 [[M204.1366]]<nowiki> Retryable STXIT AB trapped </nowiki>
 [[M204.1367]]<nowiki> Retryable STXIT AB trapped </nowiki>
 [[M204.1373]]<nowiki> Retryable STAE trapped </nowiki>
 [[M204.1375]]<nowiki> Retryable STAE trapped </nowiki>
 [[M204.1376]]<nowiki> Retryable STAE trapped </nowiki>
 [[M204.2104]]<nowiki> Heap storage is required but the LHEAP parameter is set to 0</nowiki>
 [[M204.2106]]<nowiki> Stack overflow. Recursion too deep.</nowiki>
 [[M204.2163]]<nowiki> Trouble with disk I/O on file post code = x'' csw = x''</nowiki>
 [[M204.2164]]<nowiki> Trouble with disk I/O post code = x'' CSW = x''</nowiki>
 [[M204.2369]]<nowiki> DKUPDT disk write failure: , post code = x'' CSW = x''</nowiki>

===Return code 98===
 [[M204.0556]]<nowiki> Extra numeric field ignored in recnum=, field=</nowiki>

===Return code 100===
 [[M204.0460]]<nowiki> SNAPLIM exceeded, snap not generated</nowiki>
 [[M204.1365]]<nowiki> STXIT AB trapped </nowiki>
 [[M204.1374]]<nowiki> STAE trapped </nowiki>
 [[M204.1449]]<nowiki> Error while processing CCASNAP</nowiki>

===Return code 104===
 [[M204.0121]]<nowiki> I/O error detected on CHKPOINT stream</nowiki>
 [[M204.1303]]<nowiki> I/O error detected on stream</nowiki>
[[Category:Messages]]

Messages in order by return code

2020-04-14T15:13:39Z

Dme:

Messages in order by return code

2020-04-14T15:12:58Z

Dme: Created page with "stub"

stub

Loop Next statement

2020-04-10T19:25:43Z

Dme:

It is quite common in any programming language to have a need to
exit a loop under certain conditions.
<var class="product">SOUL</var> has provided this capability with the <var>Loop End</var> statement:
for %i from 1 to %list:count
print %list:item(%i)
if %list:item(%i) eq '***END***' then
loop end
end if
end for


It is almost as common to have the need to simply do the next iteration
of a loop, that is, go to the top of the loop, under certain conditions.
<var class="product">SOUL</var> now provides this capability with the <var>Loop Next</var> statement:
for %i from 1 to %list:count
if %list:item(%i) eq '' then
loop next
end if
print %list:item(%i)
end for


The <var>Loop Next</var> statement takes no parameters.

See also the <var>[[Loop End statement|Loop End]]</var> statement.

[[Category: User Language statements]]

Flow of control in SOUL

2020-04-10T19:24:35Z

Dme: /* Loop End statement */

<div class="toclimit-3">
==Overview==

===Transferring control to another point===

SOUL statements are normally executed in the sequence in which they are written. The following statements can be used to transfer control to another point in the request:
<ul>
<li><var>[[#if|If]]</var> statement</li>
<li>JUMP TO statement</li>
<li>STOP statement</li>
<li>STOP IF COUNT statement</li>
<li>LOOP END statement</li>
</ul>

===Index loops and repeat loops===
<ul>
<li>[[#indexLoops|Index loops]] allow a series of statements to be repeated using an "index" or "counter" variable which is incremented or decremented over a specified range. </li>

<li><var>[[#repeat|Repeat]]</var> loops allow a series of statements to be repeated any number of times, with termination of the loop controlled by arbitrary conditions specified in the loop. </li>
</ul>

===Subroutines===

SOUL lets you treat a single set of statements as a simple or complex subroutine which can be called from different locations within a request.

Subroutines, common elements, and ON units are discussed in [[Subroutines#Subroutines|Subroutines]].

==If statement==

During request execution, you can direct <var class="product">Model 204</var> as to what actions it should take based on the current values of %variables or expressions. You specify a course of action in an <var>If</var> statement. 

The <var>If</var> statement introduces a block. Immediately following the <var>If</var> statement within the block is a set of one or more <var class="product">SOUL</var> statements to execute if the specified conditions are true. The block is ended by an <var>End If</var> or <var>End Block</var> statement.

====Syntax====

The basic format of the IF statement is: 
IF expression THEN statements


where <var class="term">expression</var> specifies an expression in the form described in [[Using variables and values in computation#Expressions|Expressions]] and <var class="term">statements</var> can be any User Language statements. 

===Ending an IF statement===

You must terminate the IF statement with an END IF statement or an END BLOCK statement. 

===Specifying multiple conditions===

You can specify a number of conditions to satisfy in the IF clause by placing them on separate lines. 

You must use a hyphen to indicate line continuation; do not use parentheses. Without the hyphen, starting a new input line within the IF statement implies an AND. The precedence of the implied AND is lower than all other operators. See [[Using variables and values in computation#Operator order of precedence|Operator order of precedence]] for a list of operators and order of precedence.

===Using the THEN clause===

You can place the keyword THEN at the end of the last condition or on a new line. Although the THEN keyword is not required, you should always provide it to avoid confusion and the possibility of unexpected results. The statement or statements included in the THEN clause can be any SOUL statements, as shown in the following example. 
IF POLICY NO EQ 100340
FULLNAME EQ 'ABBOTT, FRANKLIN G'
THEN PRINT DATE OF BIRTH
END IF


The THEN clause is executed only if all conditions are true. If one or more of the conditions are false, the THEN clause is not executed; execution moves to the next statement with a nesting level no deeper than that of the IF statement. In the following example, if the conditional expression is true, the FIND.RECS, PRINT.NAME, and END.PRINT statement are executed. If the expression is false, execution moves to PRINT.MSG.
 .
.
.
CHECK.VAR.A: IF NOT %A LIKE 'JACK*' THEN
FIND.RECS: FIND ALL RECORDS FOR WHICH
AGENT = %A
END FIND
PRINT.NAME: FOR EACH RECORD IN FIND.RECS
PRINT AGENT WITH POLICY NO AT COLUMN 30
END FOR
END.PRINT: JUMP TO PRINT.DONE
END IF
PRINT.MSG: PRINT 'VARIABLES NOT EQUAL'
PRINT.DONE: PRINT 'ALL DONE'


====Example====

If a conditional expression is the last statement within a loop, a false condition continues execution of the loop with the next record or value. 

In the following example, if the condition TOTAL PREMIUM > 300 is true, a second test is performed. If AGENT EQ 'CASOLA' also is true, the birth date is printed. If the first condition is not true, the second test is not performed and execution returns to the top of the FOR loop with the next record. 
FIND.RECS: FIND ALL RECORDS
END FIND
PRINT.DOB: FOR EACH RECORD IN FIND.RECS
IF TOTAL PREMIUM > 300 THEN
IF AGENT EQ 'CASOLA' THEN
PRINT POLICY NO -
WITH DATE OF BIRTH AT COLUMN 30
END IF
END IF
END FOR
SORT.RECS: SORT RECORDS IN FIND.RECS BY POLICY NO
.
.
.


==ELSE clause and ELSEIF clause==

===ELSE clause===

The ELSE clause lets you specify one or more statements to execute when the condition specified in the IF statement is false. For example: 
COMPUTE.A: IF %DIV LE 0 THEN
%X = %X + 1
ELSE
%A = %B / %DIV
END IF


An ELSE clause terminates the THEN clause and must begin on a new line. 

===Nesting IF statements===

A THEN or an ELSE clause can contain an IF statement. When IF statements are embedded, an ELSE clause without a statement label is executed when the condition of the immediately preceding IF is false. 

====Example 1====

In the following example, the ELSE clause is executed when the conditions %W EQ '1' and %X EQ 'A' are true and the condition %Y EQ 'B' is false.
SET.Z.VAR: IF %W EQ '1' THEN
IF %X EQ 'A' THEN
IF %Y EQ 'B' THEN
%Z = 'CASE1'
ELSE
%Z = 'CASE2'
END IF
END IF
END IF


====Example 2====

You can specify an ELSE clause for an IF statement that does not immediately precede the ELSE. The following example illustrates how to use an ELSE clause without a statement to pair each ELSE with the correct IF. In this example, the statement %Z = 'CASE3' is executed whenever the condition %W EQ '1' is true and the condition %X EQ 'A' is false. 
SET.Z.VAR: IF %W EQ '1' THEN
IF %X EQ 'A' THEN
IF %Y EQ 'B' THEN
%Z = 'CASE1'
END IF
ELSE
%Z = 'CASE3'
END IF
END IF


===Using the ELSEIF clause===

The ELSEIF clause provides a convenient way of specifying embedded IF statements when a series of tests are to be made, only one of which will be satisfied. 

The following examples illustrate how to specify a statement using ELSEIF instead of ELSE. 

====Example using ELSE====
IF %X EQ 'A' THEN %I = 1
ELSE
IF %X EQ 'B' THEN %I = 2
ELSE
IF %X EQ 'C' THEN %I = 3
END IF
END IF
END IF


====Example using ELSEIF====
IF %X EQ 'A' THEN %I = 1
ELSEIF %X EQ 'B' THEN %I = 2
ELSEIF %X EQ 'C' THEN %I = 3
END IF


==Using operators with the IF statement==

This section discusses how the following operators are used with IF statements:
<ul>
<li>Comparison </li>
<li>Boolean</li>
<li>IS PRESENT and IS NOT PRESENT</li>
</ul>

[[Using variables and values in computation]] also discusses the use of expressions, operators, and operands.

===Comparison operators===

Comparison operators are used with the assignment or conditional statement to return a value of 1 if the stated relation between operands is true, and a value of 0 if false. If the operands are both numbers or are both character strings, the obvious algebraic or string comparison is made. In conditional clauses, values of non-FLOAT fields and string %variables are treated as character strings whether or not they contain numbers. 

====Conversion====

If one operand is a character string and the other is a number, the character string is converted to a number before the comparison is made. A value of 0 results from the conversion if the string does not follow the rules for numbers used in expressions. Thus:
'+3.0' EQ 3


is true, but:
'THREE' EQ 3


is false.

====Literal number operands====

If one of the operands is a literal number, it should be the second operand. For example:
IF AGE > 3


is acceptable. However:
IF 3 AGE


results in an error message.

====Numeric comparison of string values====

If two operands that normally are strings are to be compared numerically, you must force at least one of the operands to be converted to a number. This is done by preceding the quantity with a unary plus sign. 

====Example 1====

Suppose a request includes these statements:
SET.VAR.A: %A = 21
FOR EACH RECORD IN FIND.RECS


and the user wishes to mark those records where the AGE field is numerically less than the STRING variable %A. If the AGE field for the current record is 9, the comparison:
AGE < %A


is false because both are treated as strings and "9" is greater than "21". Either
+AGE < %A


or
AGE < +%A


produces the desired result. 

====Example 2====

The statement:
IF AGE = 0 THEN
.
.
.


is true if AGE is algebraically equivalent to 0 (0.00, 0, and so on) or if AGE is not a number ('FIVE', ",and so on)
IF AGE = '0' THEN
.
.
.


is true only if AGE is equal to the character "0" (zero).

===Boolean operators===

The power of the IF clause can be expanded by means of the Boolean operators NOT, AND, and OR, which can be used to modify or link together comparison expressions. 

====Examples====
IF AGE > 3 AND AGE < 15 THEN
PRINT AGE


The value of the field AGE is printed if it falls between 3 and 15 inclusively. If the value of AGE is 20, it is not printed because the comparison subclauses are not both true. 

In the following example, the value of the field is printed if either or both of the comparison subclauses are true. Any value greater than 45 is printed as will any value equal to 28. 
IF AGE GT 45 OR AGE EQ 28 THEN
PRINT AGE


====Do not abbreviate conditions====

When the Boolean operators AND, OR, and NOT are used in an IF statement, the conditions they connect cannot be abbreviated as can the conditions in a FIND statement. In a FIND statement, the following are equivalent:
FIND.RECS: FIND ALL RECORDS FOR WHICH
AGE = 24 OR 25 OR 26
END FIND

FIND.RECS: FIND ALL RECORDS FOR WHICH
AGE = 24 OR AGE = 25 OR AGE = 26
END FIND


In an IF statement, the following expressions are not equivalent:
FOR EACH RECORD IN FIND.RECS
IF FIELD EQ 24 OR FIELD EQ 25 -
OR FIELD EQ 26 THEN -
.
.
.

FOR EACH RECORD IN FIND.RECS
IF FIELD EQ 24 OR 25 OR 26 THEN
.
.
.


The first statement is true if the value of FIELD is algebraically equivalent to 24, 25, or 26. The second statement is always true. FIELD EQ 24 is considered to be the first expression. The numbers 25 and 26 are stand-alone expressions that have no algebraic operator. <var class="product">Model 204</var> considers a literal number other than 0 a true value. Character strings are true if they contain nonzero numerical values. 

===ANDIF and ORIF short-circuit operators===

The operators ANDIF and ORIF provide short-circuit logical operations.

The purpose of short-circuit operators is to enable the compiled code to bypass the evaluation of a second expression, depending on the result of the previous expression(s). If the result of the first expression can determine the final result of the operation, there is no need to continue evaluating subsequent expressions since they will not change the outcome.

Consider using short-circuit operators to improve performance if your code can skip evaluation of other expressions, especially if they are complex expressions. Any advantages of using short-circuit operators instead of nested IFs will depend on your code. In most cases, standard nested IF processing will provide better performance.

====Using the ANDIF operator====

Consider the following code that must evaluate each EQ expression before taking action:
IF LASTNAME EQ 'SMITH' AND -
FIRSTNAME EQ 'SAM' AND -
BIRTH.YEAR EQ 1963 THEN
* do something
END IF


You could rewrite the previous code to prevent evaluation of some conditions if the higher level conditions are false. For example, if LASTNAME is not equal to 'SMITH', the subsequent conditions on FIRSTNAME and BIRTH.YEAR are not evaluated:
IF LASTNAME EQ 'SMITH' THEN
IF FIRSTNAME EQ 'SAM' THEN
IF BIRTH.YEAR EQ 1963 THEN
* do something
END IF
END IF
END IF


You could also accomplish the same thing without nested IF statements by using ANDIF. For example, if LASTNAME is not equal to 'SMITH', the subsequent conditions are not evaluated:
IF LASTNAME EQ 'SMITH' ANDIF -
FIRSTNAME EQ 'SAM' ANDIF -
BIRTH.YEAR EQ 1963 THEN
* do something
END IF


====Comparing ANDIF evaluation sequence====

[[#ANDIF and ORIF short-circuit operators|ANDIF and ORIF short-circuit operators]] illustrates how sequential expressions are evaluated when using the ANDIF operator and the result of the operations:
<table>
<caption>Comparing ANDIF evaluation sequence</caption>
<tr class="head">
<th>Expression 1 </th>
<th>Expression 2 </th>
<th>Expression 3 </th>
<th>Result</th>
</tr>

<tr>
<td>TRUE</td>
<td>TRUE</td>
<td>TRUE</td>
<td>TRUE</td>
</tr>

<tr>
<td>TRUE</td>
<td>FALSE</td>
<td>(Not evaluated) </td>
<td>FALSE</td>
</tr>

<tr>
<td>FALSE</td>
<td>(Not evaluated) </td>
<td>(Not evaluated) </td>
<td>FALSE</td>
</tr>
</table>

====Using the ORIF operator====

Similarly, with the ORIF operator:
IF LASTNAME EQ 'SMITH' ORIF -
LASTNAME EQ 'JONES' ORIF -
FIRSTNAME EQ 'FRED' THEN
* do something
END IF


====Comparing ORIF evaluation sequence====

[[#ANDIF and ORIF short-circuit operators|ANDIF and ORIF short-circuit operators]] illustrates how subsequent expressions are evaluated using the ORIF operator and the result of the operations:
<table>
<caption>Comparing ORIF evaluation essence</caption>
<tr class="head">
<th>Expression 1 </th>
<th>Expression 2 </th>
<th>Expression 3 </th>
<th>Result</th>
</tr>

<tr>
<td>TRUE</td>
<td>(Not evaluated) </td>
<td>(Not evaluated) </td>
<td>TRUE</td>
</tr>

<tr>
<td>FALSE</td>
<td>TRUE</td>
<td>(Not evaluated) </td>
<td>TRUE</td>
</tr>

<tr>
<td>FALSE</td>
<td>FALSE</td>
<td>TRUE</td>
<td>TRUE</td>
</tr>

<tr>
<td>FALSE</td>
<td>FALSE</td>
<td>FALSE</td>
<td>FALSE</td>
</tr>
</table>
Note: You can freely intersperse ANDIF evaluations and ORIF evaluations with AND evaluations and OR evaluations.

===IS PRESENT and IS NOT PRESENT operators===

The IS PRESENT and the IS NOT PRESENT operators can be used in expressions within record loops to determine whether or not a field is present on the current record of the loop.

The IS PRESENT operator returns a value of 1 if the specified field is present in a record, and a value of 0 if the specified field is missing. Fields with null values ('') are considered to be present. Conversely, the IS NOT PRESENT operator returns a value of 1 if the specified field is missing in a record, and a value of 0 if the field is present.

The expression: 
fieldname IS NOT PRESENT


is equivalent to:
NOT fieldname IS PRESENT


====Order of precedence====

The IS PRESENT and IS NOT PRESENT operators have higher precedence than any other operators.

====Syntax requirements====
<ul>
<li>The operand must be a field (field name); it cannot be the result of another operator.</li>

<li>You must include the IS keyword as part of the IS PRESENT and IS NOT PRESENT operators.</li>

<li>The IS PRESENT operator cannot be followed by a value. </li>
</ul>

===True and false values===

The final result of a series of comparisons has a numeric value: true equals one and false equals zero. This value can be used in assignment statements. For example:
%CONDITION1 = AGE > 3 AND AGE < 15
%CONDITION2 = NAME EQ 'SMITH' OR NAME EQ 'JONES'
IF %CONDITION1 AND %CONDITION2 THEN
.
.
.


Setting switches equal to 0 or 1, and then testing them in more than one IF statement, is an efficient comparison technique. The condition tested by IF need not contain a comparison operator.

Consider a file containing two record types. If TYPE is a field to be tested in an IF statement, the values assigned to TYPE could be 0 and 1. For example:
BEGIN
FIND.RECS: FIND ALL RECORDS FOR WHICH
NAME = SMITH
END FIND
FOR EACH RECORD IN FIND.RECS
IF TYPE THEN
.
.
.


If TYPE were equal to 1, then the expression is true and the statements following THEN are executed.

==Sample request using IF statements==

The following request demonstrates the use of conditionals. The request finds the average temperature during January, 1999, at each weather station. The CHECK.TEMP statement tests the value of the TEMP field in the current record. If the TEMP field is missing from the record, <var class="product">Model 204</var> assigns it the value of a zero length string (the null string) in expressions. 
BEGIN
NEW PAGE
VARIABLES ARE FLOAT
GET.VALUE: FOR EACH VALUE OF STATION
%TEMP = 0
%NO = 0
FIND.RECS: FIND ALL RECORDS FOR WHICH
TYPE = WEATHER
DATE IS BETWEEN 990100 AND 990132
STATION = VALUE IN GET.VALUE
END FIND
FOR EACH RECORD IN FIND.RECS
CHECK.TEMP: IF TEMP NE " THEN
%NO = %NO + 1
%TEMP = %TEMP + TEMP
END IF
END FOR
IF %NO EQ 0 THEN
PRINT VALUE IN GET.VALUE TAB -
'NO TEMP OBS.-JAN 1999'
JUMP TO SKIP.ONE
END IF
%AVTEMP = %TEMP/%NO
CT.RECS: COUNT RECORDS IN FIND.RECS
%MISS = COUNT IN CT.RECS - %NO
PRINT VALUE IN GET.VALUE TAB %NO WITH -
' TEMP OBS., ' WITH %MISS WITH
' MISSING TEMPERATURE OBSERVATION FOR -
JANUARY 1990' -
TAB %AVTEMP WITH ' MEAN TEMP FOR JAN 1999'
SKIP.ONE: SKIP 1 LINE
END FOR
END


==Branching statements==

The following statements can transfer control and terminate the execution of a loop or request:
<ul>
<li>JUMP TO</li>
<li>STOP</li>
<li>STOP IF COUNT</li>
<li>LOOP END </li>
</ul>

Although these statements typically are used in conjunction with the IF statement, they can be used in other contexts as well.

See [[#Usage with branching statements|Usage with branching statements]] for a discussion of branching statements with repeat loops.

===JUMP TO statement===

The JUMP TO statement transfers control to another statement in the request. 

====Syntax====

The format of the JUMP TO statement is: 
JUMP TO label


where <var class="term">label</var> is the label of the next statement to be processed. 

====Example 1====
 .
.
.
CHECK.DATE: IF DATE OF BIRTH > 19700101 THEN
JUMP TO END.REQUEST
ELSE
%A = TOTAL PREMIUM
END IF
FIND.RECS: FIND ALL RECORDS FOR WHICH
DATE OF BIRTH IS > 19630618
END FIND
FOR EACH RECORD IN FIND.RECS
.
.
.
END FOR
END.REQUEST: PRINT 'INVALID DATE ON FILE'
.
.
.


====Computed JUMP TO====

A more complex form of the JUMP TO statement, called the computed JUMP TO, selects the next statement to be processed based on the current value of some expression. The format of the computed JUMP TO is as follows: 
JUMP TO (label1 [, label2] ...) expression

Where:
<ul>
<li><var class="term">label1</var>, <var class="term">label2</var>, and so on are statement labels</li>

<li><var class="term">expression</var> is any valid arithmetic expression (see the discussion on expressions in [[Using variables and values in computation#Arithmetic operations|Arithmetic operations]]). </li>
</ul>

When the JUMP TO is processed, the expression is evaluated as a number and rounded to an integer (for example, <var class="term">k</var>). A jump is then performed to the <var class="term">k</var>th statement label in the list. 

====Example 2====

For example, if the user enters:
BRANCH: JUMP TO (PRINT.VIN, ACCUM.TOT, ACCUM.GRAND.TOT) -
%A-3
SKIP 1 LINE


then %A-3 is evaluated and rounded to an integer. The next statement processed after BRANCH is PRINT.VIN if %A-3 = 1, ACCUM.TOT if %A-3 = 2, ACCUM.GRAND.TOT if %A-3 = 3, or the SKIP statement if
%A-3 = anything else.

If k is less than one or larger than the number of entries in the list, or if the expression is not a number, no jump occurs. Processing continues with the next sequential statement.

====JUMP TO branching====

Both forms of the JUMP TO statement can branch outside a FOR EACH RECORD loop or refer to other statements within the same loop, but neither form can jump into a loop from outside that loop. 

===STOP statement===

The STOP statement terminates the execution of a request. However, the STOP statement does not cancel compilation and evaluation of a continuation if the terminated request ends with END MORE. 

===STOP IF COUNT statement===

The STOP IF COUNT statement limits the amount of output. 

====Syntax====

The format of the STOP IF COUNT statement is: 
STOP IF COUNT IN label EXCEEDS n


This statement ends a request if the number obtained by a COUNT RECORDS statement is larger than the integer <var class="term">n</var>. STOP IF COUNT must be used outside a loop.

====Example====
BEGIN
DRIVER: FIND ALL RECORDS FOR WHICH
RECTYPE = DRIVER
STATE = VIRGINIA
END FIND
NO.OF.DRIVERS: COUNT RECORDS IN DRIVER
PRINT COUNT IN NO.OF.DRIVERS
STOP IF COUNT IN NO.OF.DRIVERS EXCEEDS 100
FOR EACH RECORD IN DRIVER
PRINT FULLNAME
END FOR
END


If there are 100 or fewer Virginia drivers in the file, <var class="product">Model 204</var> prints the number of drivers and then print the name of each driver. If there are more than 100 drivers in the file, <var class="product">Model 204</var> prints only the number of drivers. 

===Loop End statement===

The <var>Loop End</var> statement transfers control to the statement immediately following the loop that contains the <var>Loop End</var> statement. This, in effect, is a jump outside a loop to just beyond its end. 

====Example:====
BEGIN
FIND.RECS: FIND ALL RECORDS FOR WHICH
RECTYPE = DRIVER
END FIND
LOOP: FOR EACH RECORD IN FIND.RECS
IF DATE OF BIRTH GT 19700101 THEN
LOOP END
END IF
SET.VAR: %AGE = 19900901 - DATE OF BIRTH
.
.
.
END FOR LOOP
PRINT.MSG: PRINT 'MESSAGE'
.
.
.

In the preceding request, if the date of birth is found to be greater than January 1, 1970, the LOOP statement is immediately ended and processing continues beginning with the PRINT.MSG statement.

See also the <var>[[Loop Next statement|Loop Next]]</var> statement.

===Using branching statements to control processing===

Sometimes different sets of records require identical processing. Lists can be used to eliminate the coding of duplicate sets of processing statements and branching statements can be used to control processing, as shown in the following procedure.
BEGIN
MA.POL.HLDR: FIND ALL RECORDS FOR WHICH
RECTYPE = POLICYHOLDER
STATE = MASSACHUSETTS
END FIND
MAKE.LIST: PLACE RECORDS IN MA.POL.HLDR ON LIST GENERAL
SORT.LIST: SORT RECORDS ON LIST GENERAL BY CITY
PRINT.INFO: FOR EACH RECORD IN SORT.LIST
PRINT POLICY NO AND FULLNAME -
WITH CITY AT COLUMN 30
END FOR
ACCUM.CT: %CT = %CT + 1
IF %CT = 2 THEN
JUMP TO STOP
END IF
CLEAR LIST GENERAL
CAL.GOODRICH: FIND ALL RECORDS FOR WHICH
STATE = CALIFORNIA
AGENT = GOODRICH
END FIND
NEW.LIST: PLACE RECORDS IN CAL.GOODRICH ON
LIST GENERAL
JUMP TO SORT.LIST
STOP: END


In the preceding request, the MA.POL.HLDR and MAKE.LIST statements select a set of records that are processed with the SORT.LIST and PRINT.INFO statements. The CAL.GOODRICH and NEW.LIST statements select a second set of records. The request then jumps back to the SORT.LIST statement and the SORT.LIST and PRINT.INFO statements process the second set of records. The ACCUM.CT statement tests a variable and terminates the request after the second set has been processed.

===Using branching statements to continue loops===

====Issue====

It is often necessary to branch around statements in a FOR loop and continue the loop with the next record or value. 

A jump to the FOR EACH RECORD statement or a jump to the first statement in the loop does not accomplish this. If a jump to the FOR EACH RECORD statement is performed within the loop, <var class="product">Model 204</var> starts again with the first record in the set being processed. If a jump to the first statement in the loop is performed, <var class="product">Model 204</var> starts processing the current record again. 

====Solution====

A jump to a comment statement placed at the end of the loop can resolve this problem and allow <var class="product">Model 204</var> to process the next record. For example:
BEGIN
FIND.RECS: FIND ALL RECORDS FOR WHICH
TYPE = PAYROLL
END FIND
FOR EACH RECORD IN FIND.RECS
IF DEPT EQ 'ACCT' THEN
%TIME = %TIME + 40
JUMP TO JUMP.COMM
END IF
IF DEPT EQ 'PAY' THEN
%TIMEP = %TIMEP + 37
END IF
JUMP.COMM: *COMMENTS
END FOR
PRINT %TIME AND %TIMEP
END


==Index loops - For %var From .. To .. By ..==

The index loop statement executes a series of statements for each element of an array, for particular dimensions of the array, or for particular elements of the array. In addition to being used with arrays, index loops can be used any place wherever a set of statements is to be executed a number of times. If the loop is controlled by a number rather than by a value or a FOR loop, an index loop can be used. 

====Syntax====

The format of the index loop statement is:
{{Template:For %i statement syntax}}
Where:
<ul>
<li><var class="term">exp1</var> indicates the first element to be processed by the index loop. Exp1 is not allowed to change during processing.</li>

<li><var class="term">exp2</var> indicates the last element to be processed by the index loop. Exp2 is not allowed to change during processing.</li>

<li><var class="term">exp3</var> indicates the number by which the element number is to be incremented each time the loop is performed. For example, <code>BY 2</code> might be used to process every other array element.

The TO and BY phrases can appear in any order. If BY is omitted, the default increment is 1.
</li>
</ul>

===Index loop processing===

The expressions specified in the index loop are evaluated only once before the first pass through the loop. Exp1 and exp2 are evaluated before the loop, so changes will not affect the loop. However, exp3 can change within the loop.

<var class="product">Model 204</var> performs the test for index loop completion before the loop body. The increment is performed before each pass of the loop except the first. A branch is allowed out of the loop, but not into it.

For all types of variables that represent expr2 and expr3, '''except the FLOAT type''' (see following note), expr2 and expr3 are both evaluated only once. Changing the values of the variable in expr2 and/or expr3 in the body of the FOR loop will not affect the number of times that the loop is run. 
Note: FLOAT variables that represent expr2 and expr3 in a FOR loop are evaluated each time through the FOR loop. You may expand or contract the scope of the loop as well as change the BY SKIP value during the body of the FOR loop each time it is evaluated, so using this type of variable for the expr2 and expr3 expressions can affect the number of times that the loop is run. However, if the expr3 expression evaluates to a negative value, then the loop will terminate. 

====Example====

The following example of an index loop reads inventory items from records and stores them in an array named %PRODUCT. It then reads account numbers and stores them in the array named %ACCTNO. GET.ENTRY processes the array %ACCTNO. It accesses an account number, prints it, sets corresponding items from the %PRODUCT array, and prints them. It then returns to access the next account number, and continues processing.

The following records are used as input to the index loop:
TYPE = ITEM TYPE = ITEM TYPE = ITEM
ACCOUNT = 100 ACCOUNT = 200 ACCOUNT = 300
ITEM = TISSUES ITEM = CORN FLAKES ITEM = WHITE BREAD
ITEM = TOOTHPOWDER ITEM = BRAN FLAKES ITEM = WHOLE WHEAT
ITEM = TOOTHPASTE ITEM = PUFFED WHEAT ITEM = CORN BREAD
ITEM = SOAP ITEM = PUFFED RICE ITEM = HONEY WHEAT
ITEM = TOOTHBRUSH ITEM = SHREDDED WHEAT ITEM = SYRIAN BREAD


The request to process the records is as follows:
BEGIN
%PRODUCT IS STRING LEN 15 ARRAY(3,5)
DECLARE %ACCTNO FLOAT ARRAY(3)
VARIABLES ARE FIXED
%ACCT = 0
FIND.RECS: FIND ALL RECORDS FOR WHICH
TYPE = ITEM
END FIND
GET.ENTRY: FOR EACH RECORD IN FIND.RECS
%ACCT = %ACCT+1
%ACCTNO(%ACCT) = ACCOUNT
FOR %INDEX FROM 1 TO 5
%PRODUCT(%ACCT,%INDEX) = ITEM(%INDEX)
END FOR
END FOR
FOR %ACCT FROM 1 TO 3
PRINT 'CUSTOMER ACCOUNT = ' WITH -
%ACCTNO(%ACCT)
SKIP 1 LINE
FOR %INDEX FROM 1 TO 5
PRINT 'ITEM = ' AT COLUMN 15
WITH %PRODUCT(%ACCT,%INDEX)
END FOR
SKIP 1 LINE
END FOR
END


Output appears as shown below:
CUSTOMER ACCOUNT = 100

ITEM = TISSUES
ITEM = TOOTHPOWDER
ITEM = TOOTHPASTE
ITEM = SOAP
ITEM = TOOTHBRUSH

CUSTOMER ACCOUNT = 200

ITEM = CORN FLAKES
ITEM = BRAN FLAKES
ITEM = PUFFED WHEAT
ITEM = PUFFED RICE
ITEM = SHREDDED WHEAT

CUSTOMER ACCOUNT = 300

ITEM = WHITE BREAD
ITEM = WHOLE WHEAT
ITEM = CORN BREAD
ITEM = HONEY WHEAT
ITEM = SYRIAN BREAD


==Repeat loops==

As discussed previously, you can use the index loop wherever you want to execute a set of statements a specific number of times. However, if the series of statements to be executed either does not need a number specification or if the times of execution occur in a non-uniform manner, you can use a repeat loop. 

===Initiating a repeat loop===

A repeat loop is initiated by using one of the following REPEAT statements. A repeat loop terminates with an END REPEAT statement. You can also end a REPEAT loop with an END BLOCK statement. 
<table>
<tr class="head">
<th>REPEAT... </th>
<th>This statement executes a series of statements...</th>
</tr>

<tr>
<td><var>WHILE </var></td>
<td>As long as a specified condition is true.</td>
</tr>

<tr>
<td><var>UNTIL </var></td>
<td>Until a specified condition is true.</td>
</tr>

<tr>
<td><var class="term">n</var> <var>TIMES </var></td>
<td>A specified number of times.</td>
</tr>

<tr>
<td><var>FOREVER </var></td>
<td>Repeatedly until the loop is exited with a STOP, JUMP, or LOOP END statement. </td>
</tr>
</table>

===Usage with branching statements===

The following rules govern branching into and out of repeat loops:
<table>
<tr class="head">
<th>Statement </th>
<th>Can be used to...</th>
</tr>

<tr>
<td>JUMP TO </td>
<td>Jump out of the repeat loop. However, jumping to a statement within a repeat loop from a statement outside the repeat loop is not allowed. </td>
</tr>

<tr>
<td nowrap>LOOP END </td>
<td>Transfer control to the statement immediately following the repeat loop that contains the LOOP END statement. </td>
</tr>

<tr>

<td>STOP </td>
<td>Terminate processing within repeat loops; however, the STOP IF COUNT statement is not permitted. </td>
</tr>
</table>

Refer to [[#Branching statements|Branching statements]] for a discussion.

===REPEAT WHILE statement===

The REPEAT WHILE statement executes a series of statements, as long as the specified condition is true. The condition is evaluated before each execution of the body of the loop. If the condition is false when the REPEAT WHILE statement is first executed, the statements inside the loop are never executed. 

====Syntax====

The format of the REPEAT WHILE statement is:
REPEAT WHILE condition


where <var class="term">condition</var> can specify one or more conditions. The conditions must be specified on one logical line. A hyphen is used to note the continuation of the set of conditions (with a logical AND implied at each end-of-line) for a logical line. 

====Example 1====

This statement is considered one logical line.
REPEAT WHILE POLICY NO EQ 100340 OR -
(STATE EQ FLORIDA
CITY EQ ORLANDO) OR INCIDENT EQ T3


====Example 2====

This example illustrates the use of the REPEAT WHILE statement: 
 .
.
.
READ IMAGE ACCTPROC
REPEAT WHILE $STATUS = 0
CALL SUB1
READ IMAGE ACCTPROC
END REPEAT
.
.
.


===REPEAT UNTIL statement===

The REPEAT UNTIL statement executes a series of statements until the specified condition is true. The REPEAT UNTIL statement begins executing the body of the loop before evaluating the condition.

====Syntax====

The format of the REPEAT UNTIL statement is:
REPEAT UNTIL condition


where condition can specify one or more conditions. The conditions must be specified on one logical line. A hyphen is used to note the continuation of the set of conditions (with a logical AND implied at each end-of-line) for a logical line. 

====Examples of REPEAT WHILE and REPEAT UNTIL====

Example 1:

The following REPEAT WHILE program results in output of '1':
BEGIN
REPEAT WHILE %I EQ 0
%I = %I + 1
PRINT %I
END


Whereas the following REPEAT UNTIL program results in an endless print loop:
BEGIN
REPEAT UNTIL %I EQ 0
%I = %I + 1
PRINT %I
END


Example 2:
BEGIN
%X IS FLOAT
%TRUE IS BOOLEAN INITIAL(TRUE)
REPEAT UNTIL NOT %TRUE
PRINT 'INSIDE' AND %X AND %TRUE
IF %X = 0 THEN
%TRUE = 'TRUE'
END IF
%X = %X + 1
END REPEAT
PRINT 'OUTSIDE' AND %X AND %TRUE
END
results in:
INSIDE 0 True
OUTSIDE 1 False

But changing REPEAT UNTIL to REPEAT WHILE in the Example 2 code results in:
OUTSIDE 0 True

===REPEAT n TIMES statement===

The <var>REPEAT n TIMES</var> statement executes a series of statements exactly n times. 

====Syntax====

The format of the REPEAT n TIMES statement is:
REPEAT n TIMES


where <var class="term">n</var> (the iteration count) must be either a positive integer literal, for example, 3, 100, 101, or a %variable, for example, %A, %B(%A+1). If the value of <var class="term">n</var> is negative, 0, or a character string when the REPEAT statement is first executed, the statements inside the loop are not executed.

If the value of the %variable is a floating point number, it is converted to an integer before the statement is executed. For example, if REPEAT %I TIMES is specified and the value of %I is 5.9, then the statement is executed five times.

====Example====
 .
.
.
REPEAT 10 TIMES
PRINT '***************'
END REPEAT
.
.
.


You can have a statement within the body of the loop to change the value of a %variable specified as the iteration count. However, such a change has no effect on the number of times the loop is executed because the iteration count is examined only once, prior to the first iteration. 

===REPEAT FOREVER statement===

The REPEAT FOREVER statement executes a series of statements repeatedly until the loop is exited with a STOP, JUMP, or LOOP END statement. 

====Syntax====

The format of the REPEAT FOREVER statement is:
REPEAT [FOREVER]


where the FOREVER keyword is optional. 

====Example====
 .
.
.
REPEAT FOREVER
READ IMAGE ACCTPROC
IF $STATUS = 0 THEN
CALL SUB1
ELSE
LOOP END
END IF
END REPEAT
.
.
.


</div> 

[[Category:SOUL]]

Statement syntax

2020-04-10T19:23:29Z

Dme: /* Loop Next */

This page summarizes SOUL syntax and conventions, which are discussed in more detail throughout this wiki. The SOUL statements are listed in alphabetical order. Many of the section titles or syntax blocks contain links to the wiki page describing the statement or syntax phrase. A [[#Other syntax|later section]] provides other SOUL syntax information, including links to [[#tokens|information about the "tokens"]] of SOUL, such as names in SOUL.

All SOUL statements can be used between a <var>[[BEGIN command|Begin]]</var> (or <var>[[MORE command|More]]</var>) command and an <var>[[End statement|End]]</var> statement. 
External Call Facility (ECF) statements are listed under <var>[[#External|External]]</var>.

Various other [[List of Model 204 commands|Model 204 commands]] also have effects on the results of a SOUL request. 

The following notations prefix some of the statements in the presentation of the SOUL syntax: 
<nowiki>*
**
+
++
C
</nowiki>

See the [[#Notation conventions|notation conventions]] section for an explanation of these usages, as well as other general comments about understanding the syntax of SOUL.

  
<div id="User Language statements"></div> 
<div id="SOUL statements"></div> <div id="SOUL syntax"></div>



===[[Add statement|Add]]===
<table class="noBorder">
<tr>
<td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]]</td>
<td>{{Template:Add fieldname statement syntax}}</td></tr>
</table>

<table class="noBorder">
<tr><td style="padding:0em">{{Template:Add lob-fieldname statement syntax}} </td></tr>
</table>

===[[Array statement|Array]]===

Array [arrayname] Occurs {n | Unknown}
Depending On {itemname | %variable}
[After {itemname | arrayname}
| At {position | itemname | imagename1 | arrayname}]


===[[Assert statement|Assert]]===

{{Template:Assert statement syntax}}

===[[Report generation#Audit statement|Audit]]===

Audit [[#Print specification syntax|print-specifications]]


===[[Audit All Fieldgroup Information statement|Audit All Fieldgroup Information]] (AAFGI)===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:AAFGI statement syntax}} </td></tr>
</table>

===[[Report generation#Audit All Information statement|Audit All Information]]===

<table class="noBorder">
<tr><td>{{Template:Audit All Information statement syntax}} </td></tr>
</table>

===Backout===
<table class="noBorder">
<tr><td/>
<td>[[Backout statement|Backout]] </td></tr>
</table>

===BYPASS===

BYPASS [PENDING STATEMENT] 

===CALL===

CALL {label | subname
[([expression | %variable | [LIST] listname] [,...])]}


===[[Data maintenance#Change statement|Change]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:Change fieldname statement syntax (basic)}} </td></tr>
</table>

<table class="noBorder">
<tr>
<td style="padding:0em">{{Template:Change lob-fieldname statement syntax}} </td></tr>
</table>

===[[Global_features#Using_the_CLEAR_statement|CLEAR]]===

{{Template:Clear statement syntax}}

===CLEAR LIST===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>[[Lists#Clearing a list|CLEAR LIST]] listname </td></tr>
</table>

===CLEAR ON===

{{Template:Clear On statement syntax}}

===CLEAR TAG===

CLEAR TAG {screenname | %screenname:inputname}


===[[Close statement (external I/O)|Close]]===

<table class="noBorder">
<tr><td>{{Template:Close statement (external I/O) syntax}} </td></tr>
</table>

===CLOSE PROCESS===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+C)]] </td>
<td>CLOSE PROCESS {cid | processname | %variable} [SYNCLEVEL | FLUSH | %variable] </td></tr>
</table>

CLOSE PROCESS
{cid | processname | %variable}
[SYNCLEVEL | CONFIRM | FLUSH | ERROR | %variable]


===[[Commit statement|Commit]]===

{{Template:Commit statement syntax}}

===[[Horizon SOUL interface#Confirm statement|Confirm]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Confirm statement syntax}} </td></tr>
</table>

===[[Horizon SOUL interface#Confirmed statement|Confirmed]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Confirmed statement syntax}} </td></tr>
</table>

===CONTINUE===

CONTINUE

===COUNT OCCURRENCES OF===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>COUNT OCCURRENCES OF fieldname</td></tr>
</table>

===COUNT RECORDS===

COUNT RECORDS {IN label | ON [LIST] listname}

===[[Declare statement|Declare]]===

[[[Using variables and values in computation#Declaring|Declare]]] declaration



where <var class="term">declaration</var> is one of the following: 

<div style="margin-left: 20px; background-color: #fBfBfB;">
<ul style="font-family: Consolas,monospace; display:table;">
<li>Label labelname [Global | Common]
</li>

<li>[[Lists#DECLARE LIST syntax|List]] listname [In [File | [Perm | Temp] Group]] name] At location [Global | Common]
</li>

<li><var>Image</var> block:
{{Template:Image statement syntax}} </li>

<li>{{Template:Menu statement syntax}} </li>

<li>{{Template:Screen statement syntax}} </li>

<li>%variable [Is] {Fixed [Dp n] | Float} [Array (d1 [,d2 [,d3]])] 
[[[Initial clause in %variable declaration|Initial]](numeric-expression)] [Static] [Common]
</li>

<li>%variable [Is] String [Len n] [Dp {n | *}] [Array (d1 [,d2[,d3]])] 
[No Field Save] [Common] 
[[[Initial clause in %variable declaration|Initial]]('EBCDIC-string' | expression)] [Static]
</li>

<li>[[Subroutines#DECLARE SUBROUTINE statement|Subroutine]] subname [(type [Input | Output | Input Output] [,...])]

where <var class="term">type</var> is one of the following: 
<ul>
<li>Scalar %variable of the following format:
{String [Len] n [DP {n | *}] | [Fixed [Dp n] | Float]} 
</li>

<li>Array %variable of the following format:
{String [Len n] [Dp [n | *}] [Array (* [,*[,*]]) [No Field Save]] 
| [Fixed [Dp n] | Float] [Array (* [,*[,*]])]} 
</li>

<li>A list of records of the following format:
[List] [In {File | [Perm | Temp] Group} name] 
</li></ul>
</ul>

</div> 

===DEFAULT CURSOR===

DEFAULT CURSOR [READ | REREAD | PRINT]
{ITEMID n | itemname | ROW n COLUMN m}


===DEFAULT===

DEFAULT {TITLE
| PROMPT
| INPUT [DEBLANK | NODEBLANK] [PAD WITH 'c'] [LEN m [DP [k | *}]] [UPCASE | NOCASE]
| [TAG [attributes] [WITH 'c']}
[[READ] attributes] [REREAD attributes] [PRINT attributes]

DEFAULT SKIP n POSITIONS[S]
[INITIAL {NULL | character | BLANK}]

DEFAULT [TYPE]
{STRING | BINARY | PACKED | ZONED | FLOAT | EFORMAT}
{LEN {n | UNKNOWN} | BITS n | DIGITS n}
[DP {k | *}] [BP n]
[SIGNED | UNSIGNED] [PAD {BLANK | character | NULL}]
[STRIP | NOSTRIP] [JUSTIFY {LEFT | RIGHT}]
[INITIAL {BLANK | ZERO | NULL | literal}]


===DELETE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Data maintenance#DELETE statement|DELETE]] fieldname [([[Processing_multiply_occurring_fields_and_field_groups#DELETE_statement_rules|subscript]])] [= value | (expression)]
</td></tr>
</table>

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Data maintenance#Deleting a field group|DELETE FIELDGROUP]] [fieldgroupname] [([[Processing_multiply_occurring_fields_and_field_groups#DELETE_statement_rules|subscript]])] [= value | (expression)]
</td></tr>
</table>

===DELETE EACH===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>DELETE EACH fieldname </td></tr>
</table>

===[[Data maintenance#DELETE RECORD statement|DELETE RECORD]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>DELETE RECORD </td></tr>
</table>

===DELETE RECORDS===

DELETE [ALL] RECORDS {IN label | ON [LIST] listname}


===END BLOCK===

END BLOCK label 

===End===

END {FIND | IF | FOR | ON | REPEAT | STORE | SUBROUTINE} [label]

END {ARRAY | IMAGE | MENU | SCREEN}

[[End statement|End]] [MORE | NORUN | USE]...

===END UPDATE===

END UPDATE

===[[External statement|External]]===

{{Template:External statement syntax}}

===FILE RECORDS===

FILE RECORDS {IN label | ON [LIST] listname}
UNDER fieldname = {value | (expression)}


===[[Find Records statement|Find Records]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{FIND [[ALL] RECORDS] | FD } [IN label | ON [LIST] listname] [FOR WHICH | WITH] [[#Retrieval condition syntax|retrieval-conditions]]</td></tr>
</table>

===[[Find And Reserve statement|Find And Reserve]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{FIND AND RESERVE [[ALL] RECORDS] | FDR} [IN label | ON [LIST] listname] [FOR WHICH | WITH] [[#Retrieval condition syntax|retrieval-conditions]] </td></tr>
</table>

===[[Value loops#Find All Values statement|Find Values Of (FDV)]]===
<table class="noBorder">
<tr>
<td style="padding:0em">{{Template: Find Values Of statement syntax}} </td></tr>
</table>

===FIND AND PRINT COUNT===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{Find And Print Count | FPC} [[[#Retrieval condition syntax|retrieval-conditions]]]
</td></tr>
</table>

===[[Find Records statement|Find Without Locks]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{Find Without Locks [[ALL] Records] | FDWOL} [In label | On [LIST] listname]
[For Which | With] [[#Retrieval condition syntax|retrieval-conditions]]</td></tr>
</table>

===FLUSH PROCESS===

FLUSH PROCESS {cid | processname | %variable}

===FOR EACH OCCURRENCE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>FOR {EACH | k} {OCCURRENCE | OCCURRENCES} OF fieldname </td></tr>
</table>

===[[Record loops#For Each Record statement|For Each Record]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{{Template:For Each Record statement syntax}}</td></tr>
</table>
Note: For <var class="term">retrieval-conditions</var>, see [[#Retrieval condition syntax|Retrieval condition syntax]], below. 

===FOR EACH VALUE OF===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>FOR {EACH | k} {VALUE | VALUES} OF fieldname [FROM {value1 | (expression1)}] [TO {value2 | (expression2)}] [[NOT] LIKE pattern] [IN [ASCENDING | DESCENDING] [CHARACTER | NUMERICAL] [RIGHT-ADJUSTED] ORDER]
</td></tr>
</table>

===FOR EACH VALUE IN===

FOR {EACH | k} {VALUE | VALUES} IN label 

===FOR RECORD NUMBER===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>FOR RECORD NUMBER {value | (expression)}
</td></tr>
</table>

===FOR RECORD NUMBER IN===

FOR RECORD NUMBER {value | IN label} [OPTIMIZING FNV]


===[[For %i statement|For %var From %exp1 To %exp2 By %exp3]]===
<table class="noBorder">
<tr>
<td style="padding:0em">{{Template:For %i statement syntax}} </td></tr>
</table>

Note: The <var>By</var> clause, when omitted, defaults to a value of 1. 

===[[Images#Identify statement|Identify]]===

<table class="noBorder" display="table-column">
<tr><td>{{Template:Identify statement syntax}} </td></tr>
</table>

===[[If statement|If]]...Then...ElseIf...Else===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>If expression Then [statement] [statement] ... [ ElseIf expression Then [statement] [statement] ... ] ... [ Else [statement] [statement] ... ] End If
</td></tr>
</table>

===[[Image statement or block|Image]]===
<var>Image</var> block:
<table class="noBorder">
<tr><td style="padding:0em">{{Template:Image statement syntax}}</td></tr>
</table>

===INCLUDE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*, C)]] </td>
<td>INCLUDE procedurename </td></tr>
</table>

===INPUT===

INPUT inputname [AT [COLUMN] n]
[TO [COLUMN] m | [LEN m] DP {k | *}]]
[UPCASE | NOCASE] [DEFAULT 'value']
[DEBLANK | NODEBLANK] [PAD WITH 'c']
[REQUIRED | ALPHA | ALPHANUM | MUSTFILL
| ONEOF literal [, literal]...
| [NUMERIC] [RANGE lo [TO] hi [AND lo [TO] hi] ...]
| VERIFY 'characters']...
[[READ] attributes] [REREAD attributes] [PRINT attributes]
[TAG [attributes] [WITH 'c']] [ITEMID n]


===INSERT===

INSERT fieldname [(subscript)] = {value | (expression)}


===[[Horizon SOUL interface#Invite statement|Invite]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Invite statement syntax}} </td></tr>
</table>

===IS===

itemname IS [TYPE]
{STRING | BINARY | PACKED | ZONED | FLOAT | EFORMAT}
{LEN {n | UNKNOWN} | BITS n | DIGITS n
| TO position}
[DP {k | *}] [BP n] [SIGNED | UNSIGNED]
[PAD {BLANK | character | NULL}] [STRIP | NOSTRIP]
[ALIGN]
[JUSTIFY {LEFT | RIGHT}]
[INITIAL {BLANK | ZERO | NULL | value}]
[AFTER {itemname | arrayname}
| AT {position | itemname | imagename1 | arrayname}]
[OCCURS {n [DEPENDING ON {itemname | %variable}]
| UNKNOWN}]


===JUMP TO===

JUMP TO label

JUMP TO (label1 [, label2] ...) expression

===[[Loop End statement|Loop End]]===

[[Loop End statement|Loop End]] 

===[[Loop Next statement|Loop Next]]===

[[Loop Next statement|Loop Next]]

===MAX PFKEY===
MAX PFKEY n 

===[[Menu statement or block|Menu]]===
<table class="noBorder">
<tr>
<td>{{Template: Menu statement syntax}} </td></tr>
</table>

===MODIFY===

MODIFY {%menuname:itemname | %screenname:itemname}
[TO] attributes [[FOR] {ALL | READ | REREAD | TAB
| PRINT}]


===MODIFY BUFFER===

MODIFY BUFFER [SIZE=n
| %variable [PRESERVE | NOPRESERVE]]
[FILL [X'nn'] | CLEAR]


===NEW PAGE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>NEW PAGE </td></tr>
</table>

===[[Note statement|Note]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>Note {fieldname [(subscript)]} </td></tr>
</table>
Note 'string'


===[[On statement|On]]===

[[On statement|On]] {Attention | Error | Field Constraint Conflict
| Find Conflict | Missing File | Missing Member
| Record Locking Conflict}
statements
End On [label]


===Open===

{{Template:Open (External I/O) statement syntax}}

 
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>{{Template:Open and OpenC statements syntax}} </td></tr>
</table>

===OPEN PROCESS===

OPEN PROCESS {processname | %variable}
[CID {name | %variable}] 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>OPEN PROCESS {processname | %variable} [CID {name | %variable}] {outbound-options | inbound-options}
</td></tr>
</table>

<div style="margin-left: 30px; background-color: #fBfBfB;">

where <var class="term">outbound-options</var> are:
<ul style="font-family: Consolas,monospace">
<li>[AT DESTINATION] [WITH] [USERID {%variable | 'string'}]

<li>[PASSWORD {%variable | 'string'}]

<li>[{ACCOUNT | PROFILE {%%variable | 'string'}]

<li>[INITIAL {DATA 'string' | DATA %variable | IMAGE imagename] ...]
</ul>

and <var class="term">inbound-options</var> are:

<ul style="font-family: Consolas,monospace">
<li>ACCEPT [INITIAL {DATA %variable | IMAGE image} ...] </li>
</ul>

</div> 

===[[Pause statement|Pause]]===

{{Template:Pause statement syntax}}

===PLACE RECORD ON===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Lists#PLACE RECORD and REMOVE RECORD statements|PLACE RECORD ON]] [LIST] listname
</td></tr>
</table>

===PLACE RECORDS===

PLACE RECORDS {IN label | ON [LIST] listname1} ON [LIST] listname2


===Position===

POSITION {FOUNDSET foundsortset_name | LIST list_name} [AT] position_name

Note: Use the above form of the <var>Position</var> statement with <var>For</var> loop processing; see [[Global features#Position statement|Position statement]].

POSITION {ext-filename | %variable}
AT KEY operator{value | %variable}

Note: Use the above form of the <var>Position</var> statement with external file processing using images; see [[Images#Position statement|Position statement]].

===[[Full-screen feature|PREPARE]]===

PREPARE
{[[[Images#PrepareStmtImage|IMAGE]]] imagename | [[[Full-screen feature#PrepareStmtMenu|MENU]]] menuname
| [[[Full-screen feature#PrepareStmtScrn|SCREEN]]] screenname}


===Print===

Print [[#Print specification syntax|printSpecifications]] 

===Print All Fieldgroup Information (PAFGI)===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:PAFGI statement syntax}} </td></tr>
</table>

===[[Print All Information statement|Print All Information]] or [[PAI statement|PAI]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:PAI statement syntax}} </td></tr>
</table>

===PRINT MENU===

PRINT [MENU] menuname [ALERT]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===PRINT SCREEN===

PRINT SCREEN screenname [ALERT] [[WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===[[Horizon SOUL interface#Query Process statement|Query Process]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Query Process statement syntax}} </td></tr>
</table>

===[[Read Image statement|Read Image]]===

{{Template:Read Image statement syntax}}

===READ menuname===

READ [MENU] menuname [ALERT]
[TITLE ['text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===READ screenname===

READ [SCREEN] screenname [ALERT] [NO REREAD] [ [WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===RECEIVE IMAGE===

RECEIVE {IMAGE imagename | %variable}
FROM {cid | processname | %variable} [RESULT %variable] 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>RECEIVE {IMAGE imagename | %variable} FROM {cid | processname | %variable} RESULT %variable
</td></tr>
</table>

===[[Release All Records statement|Release All Records]]===

{{Template:Release All Records statement syntax}}

===[[Release Position statement|Release Position]]===

<table class="noBorder">
<tr><td>{{Template:Release Position statement syntax}} </td></tr>
</table>

===[[Release Records statement|Release Records]]===

{{Template:Release Records statement syntax}}

===[[Remember statement|Remember]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:Remember statement syntax}}</td></tr>
</table>

===REMOVE RECORD FROM===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Lists#PLACE RECORD and REMOVE RECORD statements|REMOVE RECORD FROM]] [LIST] listname
</td></tr>
</table>

===REMOVE RECORDS===

REMOVE RECORDS {IN label | ON [LIST] listname}
FROM [LIST] listname2


===REPEAT===

REPEAT [FOREVER | n TIMES | WHILE expression]


===REREAD===

REREAD [SCREEN] screenname [ALERT] [[WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===RESET===

RESET {HEADER | TRAILER} m


===[[Exceptions#Rethrow statement|Rethrow]]===

{{Template:Rethrow statement syntax}}

===RETRY===

RETRY [PENDING STATEMENT]


===RETURN===

RETURN


===[[Screen statement or block|Screen]]===

{{Template:Screen statement syntax}}

===SEND===

SEND {IMAGE imagename | 'string' | %variable}
TO {cid | processname | %variable}
[REQSEND %variable]
[FLUSH]

(+)SEND {IMAGE imagename | 'string' | %variable}
TO {cid | processname | %variable}
[FLUSH | CONFIRM]
[REQSEND %variable]


===[[Horizon SOUL interface#Send Error statement|Send Error]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Send Error statement syntax}} </td></tr>
</table>

===SET===

SET {HEADER | TRAILER} m [[#Print specification syntax|print-specifications]]


===[[SetText statement|SetText]]===

{{Template:SetText statement syntax}}

===SIGNAL PROCESS===

SIGNAL PROCESS
{cid | [processname | %variable} {nnn | %variable} 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>SIGNAL PROCESS {cid | [processname | %variable}
</td></tr>
</table>

===[[Sirius Case statement|Sirius Case]] directive===

<table class="noBorder">
<tr><td style="font-family:monoface; padding:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>{{Template:Sirius Case statement syntax}} </td></tr>
</table>

===SKIP LINES===

SKIP n LINE[S]


===[[Skip Position statement|Skip Position]]===

<table class="noBorder">
<tr><td>{{Template:Skip Position statement syntax}} </td></tr>
</table>

===SORT RECORDS===

SORT [k] RECORDS {IN label | ON [LIST] listname}
BY key [AND key] ...


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">key</var> is:
<ul style="font-family: Consolas,monospace">
<li>key = fieldname 
[VALUE {[ASCENDING | DESCENDING] 
[CHARACTER | NUMERICAL] | RIGHT-ADJUSTED]} ...] </li>
</ul>

</div> 

===SORT RECORD KEYS===

SORT [k] RECORD KEYS
{IN label | ON [LIST] listname}
BY key [AND key] ...


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">key</var> is:
<ul style="font-family: Consolas,monospace">
<li>key = fieldname 
[VALUE {[ASCENDING | DESCENDING] 
[CHARACTER | NUMERICAL] | [RIGHT-ADJUSTED]} ...] </li>
</ul>

</div>

===SORT VALUE IN===

SORT VALUE IN label [IN [ASCENDING | DESCENDING]
[CHARACTER | NUMERICAL] | [RIGHT-ADJUSTED] ORDER]


===STOP===

<table class="noBorder">
<tr>
<td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]]</td>
<td>STOP [IF COUNT IN label EXCEEDS n]
</td></tr>
</table>

===STORE RECORD===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>STORE RECORD [sort or hash key value] fieldname1=[value1 | (expression1)] [fieldname2=(expression)] ... [THEN CONTINUE statement statement ...] END STORE
</td></tr>
</table>

===SUBROUTINE===

SUBROUTINE

SUBROUTINE subname
[(formal-parameter [INPUT | OUTPUT | INPUT OUTPUT] [,...])]


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">formal-parameter</var> is one of the following:
<ul style="font-family: Consolas,monospace">
<li>%variable [IS STRING [LEN n] [DP {n | *}] [ARRAY (*[,*[,*]]) [NO FS]] 
| IS {FIXED [DP n] | FLOAT} [ARRAY (*[,*[,*]])]]

<li>LIST listname [IN [FILE | [PERM | TEMP] GROUP] name]
</ul>
</div>

===TAG===

TAG %screenname:inputname [attributes] [WITH 'c']


===[[Horizon SOUL interface#Test Receipt statement|Test Receipt]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Test Receipt statement syntax}} </td></tr>
</table>

===TITLE===

TITLE {'text' | promptname}
[AT [COLUMN] n] [TO [COLUMN] m | [LEN m]
[DP {k | *}]]
[DEFAULT 'value']
[[READ] attributes] [REREAD attributes] [PRINT attributes]


===[[Trace statement|Trace]]===

{{Template:Trace statement syntax}}

Note: The output of the <var>Trace</var> statement is controlled by the <var>[[ULTRACE parameter|ULTRACE]]</var> parameter.

===[[Program Communication facilities#TRANSFER statement format and execution|TRANSFER]]===

TRANSFER [CONTROL] TO PROCESS {processname | %variable}
[WITH] [USERID {string | '%variable'}]
[PASSWORD {variable | 'string'}]
[ACCOUNT {%variable | 'string'}]
[PASSING {IMAGE imagename | 'string' | %variable}]


===UPDATE RECORD===

UPDATE RECORD

===VARIABLES ARE===

VARIABLES ARE
{FIXED [DP n] | FLOAT
| STRING [LEN n] [DP {n | *}]
| UNDEFINED}


===Declare %variable===

[DECLARE] %variable [IS]
{FIXED [DP n] | FLOAT} [ARRAY (d1[,d2[,d3]])]
[COMMON]

[DECLARE] %variable [IS]
STRING [LEN n] [DP {n | *}] [ARRAY (d1[,d2[d3]])]
[NO FIELD SAVE] [COMMON]
%variable [(subscript)] = expression


===WAIT===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>WAIT [{n | %variable} SEC[S]] [FOR] {ANY RECEIPT RETURN %variable | RECEIPT {cid | processname | %variable}}
</td></tr>
</table>

===[[Write Image statement|Write Image]]===

<table class="noBorder">
<tr><td>{{Template:Write Image statement syntax}} </td></tr>
</table>

==Other syntax==

===Names, numbers, literals, comments===

<ul>
<li>Names (for example, %variables, labels): see [[Model 204 naming conventions]]
<li>Other constructs: see [[Basic request structure]] (which also discusses some rules for statement labels)
</ul>

===Value specification syntax===

For all User Language statements and retrieval conditions, wherever the term <var class="term">value</var> appears in the syntax, it can be any of these:
<ul>
<li>Literal number or string </li>
<li><var>VALUE IN</var> clause of the form:
VALUE [IN] label

</li>
<li>%variable</li>
</ul>

===Retrieval condition syntax===

A <var>Find</var> or <var>For Each Record Where</var> statement can be followed by any number of retrieval conditions separated by an end of line or [[LINEND parameter]] character.

Conditions can be constructed as a series of phrases that are combined "in the usual way" with <var>And</var>, <var>Or</var>, <var>Not</var>, and parentheses (()):

[Not] phrase [{And | Or | Nor} [Not] phrase] ...


Where: 

<var class="term">phrase</var> can be constructed from these options: 
<ul style="font-family: Consolas,monospace">
<li><var class="term">fieldname</var> = [Not] value </li>

<li><var class="term">fieldname</var> Like pattern </li>

<li><var class="term">fieldname</var> Is [Not] {Present | Like 'pattern'} </li>

<li><var class="term">fieldname</var> Is [Not] {[Numerically | Alphabetically] 
[Eq | = | Ne | ¬= | Greater Than | Gt | > | Less Than | Lt | < | Le | <= | Ge | >= | Before | After] value} </li>

<li><var class="term">fieldname</var> Is [Not] {[Numerically | Alphabetically] 
{In Range [From | After] value1 {To | [And] Before} 
value2 | Between value1 And value2} </li>

<li>[[Record retrievals#FILE$ condition|File$]] {filename | =} </li>

<li>Find$ <var class="term">label</var> </li>

<li>[[Lists#Using the LIST$ condition|List$]] listname </li>

<li>[[Record retrievals#LOCATION$ condition|Location$]] {location | =} </li>

<li>[[#Point$|Point$]] <var class="term">value</var> </li>

<li>[[#Sfl$ and Sfge$|Sfge$]] <var class="term">value</var> </li>

<li>[[#Sfl$ and Sfge$|Sfl$]] <var class="term">value</var> </li>
</ul>

where <var class="term">value</var> can be: 
<ul>
<li>A literal number or string</li>

<li>A %variable </li>

<li><var>Value</var> {([[#Use of expressions|expression]]) | [<var>In</var>] label}

<var class="term">label</var> points to an existing value set. If an <var>Eq Value In value_set</var> clause, value set values are treated as Boolean OR, for example:

field = value1 OR field = value2 OR.... 

If an <var>Ne Value In value_set</var> clause, values are treated as Boolean AND: 
field <> value1 AND field <> value2 AND.... 

See also [[Basic SOUL statements and commands#Processing a VALUE IN clause|Processing a VALUE IN clause]].</li>
</ul>

Notes:
<ul>
<li>The first character (<code>¬</code>) of the "not-equal" test (<code>¬=</code>) in the fourth of the items in the list of <var class="term">phrase</var> options above is the EBCDIC "not sign," which has the hexadecimal value <code>5f</code>. </li>

<li>For a description of the pattern in the <var>[Is] Like</var> and <var>Is Not</var> clauses, see the syntax of [[Is Like pattern matching#likeSyntax|Is Like patterns]]. </li>

<li>In addition to the discussions in the subsections that follow, see [[Record retrievals]] for a comprehensive description of retrieval conditions. </li>
</ul>

====Omitting repeated first words====

If a sequence of phrases in a particular retrieval condition all have the same first word, that word can be omitted from the latter phrases. For example:
List$ A And Not List$ B


can be written:
List$ A And Not B


And:
x Is 13 Or x Is Less Than 7


can be written:
x Is 13 Or Is Less Than 7


====Omitting duplicated equal signs====

Duplicated equal signs can be omitted. For example, the expression:
a = 3 Or a = 5 Or a = 40


is equivalent to:
a = 3 Or 5 Or 40


====Use of parentheses====

Parentheses can be placed around any sequence of phrases to clarify the condition or force the evaluation to occur in a particular order. For example:
Not (a = 2 Or List$ y)
a = 1 And (b = 2 OR c = 3)


====Use of expressions====

[[Using variables and values in computation#Expressions|Expressions]] can be used in <var>Find</var> and <var>For Each Record</var> statements to provide the retrieval condition for the <var>Point$</var>, <var>Sfl$</var>, and <var>Sfge$</var> conditions, as well as for the <var>Eq Value</var> clause: 

=====Point$=====
Point$ Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. It is preceded by the keyword <var>Value</var>. 

Example: 

This example finds the first <code>MA</code> record on file, and then counts the number of records from this point in the file:
FD1:

IN ICSCUST FPC STATE = MA
END FIND
FOR 1 RECORD IN FD1
PRINT 'CURREC = ' WITH $CURREC
PRINT '>= POINT$'
FD2:
IN ICSCUST FPC POINT$ VALUE($CURREC)
END FIND
END FOR


=====Sfl$ and Sfge$=====
Sfl$ Value(expression)


Or:
Sfge$ Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. It is preceded by the keyword <var>Value</var>. 

Example:

FOR %CT FROM 1 TO 10
IN EXPRESS STORE RECORD ($EDITN(%CT,'999'))
ORD1 = (%REC WITH %CT)
ORD2 = (%CT * 2)
ORD4 = (%CT * 4)
END STORE
END FOR
COMMIT
FOR %CT FROM 1 TO 5
PRINT 'LESS THAN ' WITH %CT
FD1:
IN EXPRESS FPC SFL$ VALUE($EDITN(%CT,'999'))
END FIND
PRINT 'GREATER THAN OR EQUAL TO ' WITH %CT
FD2:
IN EXPRESS FPC SFGE$ VALUE($EDITN(%CT,'999'))
END FIND
END FOR


=====Eq Value=====
fieldname Eq Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. 

Example:

FD: IN FILE PEOPLE FD
LAST EQ VALUE($READ('LAST NAME?') )
END FIND


===Print specification syntax===

A <var>Print</var>, <var>Set</var>, <var>Audit</var>, or <var>Trace</var> statement contains print specifications of the following form:

[term] [And | Tab | With]...[[term] [And | Tab | With] ...] ... [...]

Where:

<var class="term">term</var> can be constructed as follows:
{'string' | %variable | Count In label | Occurrence In label | Value in term | function}
[At [Column] m] [To [Column] n] 

Or, if the statement is within a record loop:

{{Each | term} fieldname | *Record | *Id}
[At [Column] m] [To [Column] n}


Note: For additional <var>Print</var> statement details regarding multiply occurring fields and field groups, see [[Processing multiply occurring fields and field groups#PRINT and PRINT n statements|Print and Print n]] statements for fields. 

===Expression syntax===

The following syntax can be used in: 
<ul>
<li>Assignment statements </li>
<li>Conditional <var>If</var> statements and <var>ElseIf</var> clauses

In the simplified syntax for an <var>If</var> statement, which is:
If condition Then statements


<var class="term">condition</var> expands to the syntax described in this section. </li>

<li>Computed <var>Jump To</var> statements </li>

<li>Subscripts </li>

<li>Function arguments </li>

<li>A value in parenthesis in SOUL "DML" statements, for example:
Add <var class="term">fieldname</var> = (<var class="term">expression</var>)
</ul>

=====Syntax=====
{operand | (expression)} [operator {operand | (expression)}] ...

Where:
<ul>
<li><var class="term">operand</var> can be constructed as follows:
[+ | - | Not]
{'string' | %variable | number
| fieldname [(subscript)] Is [Not] Present
| Count In label | Occurrence In label
| Value In label
| function}
</li>

<li><var class="term">expression</var> (Note: enclosed by parentheses) is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. For further details, see [[Using variables and values in computation#Expressions|Expressions]]. </li>

<li><var class="term">operator</var> may be one of the following:
<table style="table-layout: fixed">
<tr>
<td>+   </td>
<td>=</td>
<td>EQ</td>
<td>And</td>
</tr>

<tr>
<td>-</td>
<td>,=   </td>
<td>NE  </td>
<td>AndIf</td>
</tr>

<tr>
<td>*</td>
<td>></td>
<td>GT</td>
<td>Or</td>
</tr>

<tr>
<td>/</td>
<td><</td>
<td>LT</td>
<td>OrIf</td>
</tr>

<tr>
<td> </td>
<td>>=</td>
<td>GE</td>
<td>With (Note: this can also be achieved via [[Implicit concatenation]])</td>
</tr>

<tr>
<td> </td>
<td><=</td>
<td>LE</td>
<td>Is [Not] Present (Note: applied either to a field or to an [[Methods#optionalParams|optional or default method parameter]])</td>
</tr>

<tr>
<td> </td>
<td> </td>
<td> </td>
<td>Is [Not] Like</td>
</tr>
</table>
<blockquote class="note">Notes:
<ul>
<li>The first character (<code>,</code>) of the inequality test above is the EBCDIC "not sign," which has the hexadecimal value <code>5f</code>. </li>

<li>For a description of the <code>Is Like</code> and <code>Is Not</code> clauses, see the syntax of [[Is Like pattern matching|Is Like patterns]]. </li>

<li>The <var>AndIf</var> and <var>OrIf</var> operators are called "short circuit", because, at a given precedence level, if the value of the conditional expression has been fully determined, the remainder at that level is not evaluated. For example:
%sex eq 'M' and (%ht lt 5.2 orIf %ht gt 6.5)
If the value of <code>%ht</code> is less than 5.2, the final comparison -- <code>%ht gt 6.5</code> -- is never evaluated (that holds regardless of what had been coded as the final comparison).
With the same value of <code>%ht</code>, if the <code>Or</code> operator had been used, then that final comparison is always evaluated.
</li>
<li>For more information about operators, see [[Using variables and values in computation#Operators|Operators]]. </li>
</ul>
</blockquote ></li>
</ul>

===In clause syntax===

The SOUL statements on this page whose syntax display is preceded by an asterisk (<tt>*</tt>) support an <var>In</var> clause. 

The three basic forms of the <var>In</var> clause are: 

In [Permanent | Temporary ] Group groupname
Member [%member | [filename [At {location | =}]]

In file1 [,file2] ...

In {$Curfile | $Update}

The form <var>In $Curfile</var> can be used only within a record loop.

====In Group Member limitations====

In addition to the three basic forms of the In clause shown above, the <var>In Group Member</var> clause restricts the following statements to one member file in a group context:
<ul>
<li><var>Clear List</var></li>

<li><var>Find All Records</var> (and its variants)</li>

<li><var>Find All Values</var></li>

<li><var>For Record Number</var> (or <var>FRN</var>)</li>

<li><var>Store Record</var> </li>
</ul>

You cannot use an <var>In Group Member</var> clause with a <var>For Each Record</var> statement or with an <var>Add</var>, <var>Change</var>, or <var>Delete Record</var> statement. Only the previously listed statements call accept an <var>In Group Member</var> clause.

====Using an In clause in a Begin...End block====

The file name in the <var>In</var> clause used within a <var>Begin...End</var> block is resolved by the compiler. You can hard-code a file name or use some type of dummy string for the file name. Using a %variable for the file name is not allowed. 

===Subscript syntax===

A subscript has the format: 

=====Syntax=====
(subscript1 [,subscript2 [,subscript3]] )

Where:

<var class="term">subscript1</var>, <var class="term">subscript2</var>, and <var class="term">subscript3</var> can be any expression. 

==SOUL macros==
There are [[SOUL macro facility|additional facilities]] supporting <var class="product">SOUL</var>
macro statements. Macro statements allow code to be conditionally compiled.

As an example, in the following SOUL fragment, the <var>Recordset</var> object declaration would be for the file <code>AVEBURY</code>:
!def henge avebury
...
%sites is object recordset in file ?!HENGE


==Terminal display attributes==

One or more of the following terminal display attributes can replace the term attribute in a full-screen formatting statement, if the display attribute is supported by the installation:

<table>
<caption>List of attributes</caption>
<tr>
<td>BLINK</td>
</tr>
<tr>
<td>BLUE</td>
</tr>
<tr>
<td>BRIGHT</td>
</tr>
<tr>
<td>DIM</td>
</tr>
<tr>
<td>GREEN</td>
</tr>
<tr>
<td>INV[IS[BLE]] </td>
</tr>
<tr>
<td>NOBLINK</td>
</tr>
<tr>
<td>NOREV[ERSE]</td>
</tr>
<tr>
<td>NOU[NDER]SCORE</td>
</tr>
<tr>
<td>PINK</td>
</tr>
<tr>
<td>PROT[ECTED]</td>
</tr>
<tr>
<td>RED</td>
</tr>
<tr>
<td>REV[ERSE]</td>
</tr>
<tr>
<td>TURQUOISE</td>
</tr>
<tr>
<td>[UNDER]SCORE</td>
</tr>
<tr>
<td>UNPROT[ECTED]</td>
</tr>
<tr>
<td>VIS[IBLE]</td>
</tr>
<tr>
<td>WHITE</td>
</tr>
<tr>
<td>YELLOW </td>
</tr>
</table>

==Notation conventions==

This page uses the following syntax notation conventions: 

<table>
<tr class="head">
<th>Syntax notation </th>
<th>Indicates that...</th>
</tr>

<tr>
<td>Single asterisk (*) </td>
<td>Statements can be preceded by an IN clause, if there is no reference to a previous set (label or list). See [[#IN clause syntax|IN clause syntax]] for more discussion.</td>
</tr>

<tr>
<td>Two asterisks (**) </td>
<td>Construct can appear only within a record loop.</td>
</tr>

<tr>
<td>Plus sign (+) </td>
<td>Construct requires the optional [[Horizon]] feature.</td>
</tr>

<tr>
<td nowrap>Two plus signs (++) </td>
<td>Construct requires the optional User Language to Database 2 feature.</td>
</tr>

<tr>
<td>C</td>
<td>The (first) keyword of the statement is also a <var class="product">Model 204</var> command; the command's wiki page will be, for example, 'OPEN command'.

<var class="product">Model 204</var> commands are listed alphabetically and documented in [[List of Model 204 commands]]. </td>
</tr>

<tr>
<td>Lowercase italic </td>
<td>Constructs are replaced with variable information.</td>
</tr>
</table>

<ul>
<li>A field name (%%) variable can be used anywhere fieldname appears. The %%variable can contain its own subscript, separate from the field name subscript.
Note: 
The subscript of an array element must be specified before a field name subscript. </li>

<li>The lowercase constructs — retrieval-conditions, print-specifications, expression, subscript, attribute, and type — are discussed separately following the syntax summaries, beginning with [[#Value specification syntax|Value specification syntax]]. </li>

<li>For more Model 204 notation conventions, see [[Notation conventions]].</li>
</ul>

[[Category:SOUL]]

Statement syntax

2020-04-10T19:22:49Z

Dme: /* Loop End */

This page summarizes SOUL syntax and conventions, which are discussed in more detail throughout this wiki. The SOUL statements are listed in alphabetical order. Many of the section titles or syntax blocks contain links to the wiki page describing the statement or syntax phrase. A [[#Other syntax|later section]] provides other SOUL syntax information, including links to [[#tokens|information about the "tokens"]] of SOUL, such as names in SOUL.

All SOUL statements can be used between a <var>[[BEGIN command|Begin]]</var> (or <var>[[MORE command|More]]</var>) command and an <var>[[End statement|End]]</var> statement. 
External Call Facility (ECF) statements are listed under <var>[[#External|External]]</var>.

Various other [[List of Model 204 commands|Model 204 commands]] also have effects on the results of a SOUL request. 

The following notations prefix some of the statements in the presentation of the SOUL syntax: 
<nowiki>*
**
+
++
C
</nowiki>

See the [[#Notation conventions|notation conventions]] section for an explanation of these usages, as well as other general comments about understanding the syntax of SOUL.

  
<div id="User Language statements"></div> 
<div id="SOUL statements"></div> <div id="SOUL syntax"></div>



===[[Add statement|Add]]===
<table class="noBorder">
<tr>
<td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]]</td>
<td>{{Template:Add fieldname statement syntax}}</td></tr>
</table>

<table class="noBorder">
<tr><td style="padding:0em">{{Template:Add lob-fieldname statement syntax}} </td></tr>
</table>

===[[Array statement|Array]]===

Array [arrayname] Occurs {n | Unknown}
Depending On {itemname | %variable}
[After {itemname | arrayname}
| At {position | itemname | imagename1 | arrayname}]


===[[Assert statement|Assert]]===

{{Template:Assert statement syntax}}

===[[Report generation#Audit statement|Audit]]===

Audit [[#Print specification syntax|print-specifications]]


===[[Audit All Fieldgroup Information statement|Audit All Fieldgroup Information]] (AAFGI)===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:AAFGI statement syntax}} </td></tr>
</table>

===[[Report generation#Audit All Information statement|Audit All Information]]===

<table class="noBorder">
<tr><td>{{Template:Audit All Information statement syntax}} </td></tr>
</table>

===Backout===
<table class="noBorder">
<tr><td/>
<td>[[Backout statement|Backout]] </td></tr>
</table>

===BYPASS===

BYPASS [PENDING STATEMENT] 

===CALL===

CALL {label | subname
[([expression | %variable | [LIST] listname] [,...])]}


===[[Data maintenance#Change statement|Change]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:Change fieldname statement syntax (basic)}} </td></tr>
</table>

<table class="noBorder">
<tr>
<td style="padding:0em">{{Template:Change lob-fieldname statement syntax}} </td></tr>
</table>

===[[Global_features#Using_the_CLEAR_statement|CLEAR]]===

{{Template:Clear statement syntax}}

===CLEAR LIST===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>[[Lists#Clearing a list|CLEAR LIST]] listname </td></tr>
</table>

===CLEAR ON===

{{Template:Clear On statement syntax}}

===CLEAR TAG===

CLEAR TAG {screenname | %screenname:inputname}


===[[Close statement (external I/O)|Close]]===

<table class="noBorder">
<tr><td>{{Template:Close statement (external I/O) syntax}} </td></tr>
</table>

===CLOSE PROCESS===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+C)]] </td>
<td>CLOSE PROCESS {cid | processname | %variable} [SYNCLEVEL | FLUSH | %variable] </td></tr>
</table>

CLOSE PROCESS
{cid | processname | %variable}
[SYNCLEVEL | CONFIRM | FLUSH | ERROR | %variable]


===[[Commit statement|Commit]]===

{{Template:Commit statement syntax}}

===[[Horizon SOUL interface#Confirm statement|Confirm]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Confirm statement syntax}} </td></tr>
</table>

===[[Horizon SOUL interface#Confirmed statement|Confirmed]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Confirmed statement syntax}} </td></tr>
</table>

===CONTINUE===

CONTINUE

===COUNT OCCURRENCES OF===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>COUNT OCCURRENCES OF fieldname</td></tr>
</table>

===COUNT RECORDS===

COUNT RECORDS {IN label | ON [LIST] listname}

===[[Declare statement|Declare]]===

[[[Using variables and values in computation#Declaring|Declare]]] declaration



where <var class="term">declaration</var> is one of the following: 

<div style="margin-left: 20px; background-color: #fBfBfB;">
<ul style="font-family: Consolas,monospace; display:table;">
<li>Label labelname [Global | Common]
</li>

<li>[[Lists#DECLARE LIST syntax|List]] listname [In [File | [Perm | Temp] Group]] name] At location [Global | Common]
</li>

<li><var>Image</var> block:
{{Template:Image statement syntax}} </li>

<li>{{Template:Menu statement syntax}} </li>

<li>{{Template:Screen statement syntax}} </li>

<li>%variable [Is] {Fixed [Dp n] | Float} [Array (d1 [,d2 [,d3]])] 
[[[Initial clause in %variable declaration|Initial]](numeric-expression)] [Static] [Common]
</li>

<li>%variable [Is] String [Len n] [Dp {n | *}] [Array (d1 [,d2[,d3]])] 
[No Field Save] [Common] 
[[[Initial clause in %variable declaration|Initial]]('EBCDIC-string' | expression)] [Static]
</li>

<li>[[Subroutines#DECLARE SUBROUTINE statement|Subroutine]] subname [(type [Input | Output | Input Output] [,...])]

where <var class="term">type</var> is one of the following: 
<ul>
<li>Scalar %variable of the following format:
{String [Len] n [DP {n | *}] | [Fixed [Dp n] | Float]} 
</li>

<li>Array %variable of the following format:
{String [Len n] [Dp [n | *}] [Array (* [,*[,*]]) [No Field Save]] 
| [Fixed [Dp n] | Float] [Array (* [,*[,*]])]} 
</li>

<li>A list of records of the following format:
[List] [In {File | [Perm | Temp] Group} name] 
</li></ul>
</ul>

</div> 

===DEFAULT CURSOR===

DEFAULT CURSOR [READ | REREAD | PRINT]
{ITEMID n | itemname | ROW n COLUMN m}


===DEFAULT===

DEFAULT {TITLE
| PROMPT
| INPUT [DEBLANK | NODEBLANK] [PAD WITH 'c'] [LEN m [DP [k | *}]] [UPCASE | NOCASE]
| [TAG [attributes] [WITH 'c']}
[[READ] attributes] [REREAD attributes] [PRINT attributes]

DEFAULT SKIP n POSITIONS[S]
[INITIAL {NULL | character | BLANK}]

DEFAULT [TYPE]
{STRING | BINARY | PACKED | ZONED | FLOAT | EFORMAT}
{LEN {n | UNKNOWN} | BITS n | DIGITS n}
[DP {k | *}] [BP n]
[SIGNED | UNSIGNED] [PAD {BLANK | character | NULL}]
[STRIP | NOSTRIP] [JUSTIFY {LEFT | RIGHT}]
[INITIAL {BLANK | ZERO | NULL | literal}]


===DELETE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Data maintenance#DELETE statement|DELETE]] fieldname [([[Processing_multiply_occurring_fields_and_field_groups#DELETE_statement_rules|subscript]])] [= value | (expression)]
</td></tr>
</table>

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Data maintenance#Deleting a field group|DELETE FIELDGROUP]] [fieldgroupname] [([[Processing_multiply_occurring_fields_and_field_groups#DELETE_statement_rules|subscript]])] [= value | (expression)]
</td></tr>
</table>

===DELETE EACH===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>DELETE EACH fieldname </td></tr>
</table>

===[[Data maintenance#DELETE RECORD statement|DELETE RECORD]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>DELETE RECORD </td></tr>
</table>

===DELETE RECORDS===

DELETE [ALL] RECORDS {IN label | ON [LIST] listname}


===END BLOCK===

END BLOCK label 

===End===

END {FIND | IF | FOR | ON | REPEAT | STORE | SUBROUTINE} [label]

END {ARRAY | IMAGE | MENU | SCREEN}

[[End statement|End]] [MORE | NORUN | USE]...

===END UPDATE===

END UPDATE

===[[External statement|External]]===

{{Template:External statement syntax}}

===FILE RECORDS===

FILE RECORDS {IN label | ON [LIST] listname}
UNDER fieldname = {value | (expression)}


===[[Find Records statement|Find Records]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{FIND [[ALL] RECORDS] | FD } [IN label | ON [LIST] listname] [FOR WHICH | WITH] [[#Retrieval condition syntax|retrieval-conditions]]</td></tr>
</table>

===[[Find And Reserve statement|Find And Reserve]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{FIND AND RESERVE [[ALL] RECORDS] | FDR} [IN label | ON [LIST] listname] [FOR WHICH | WITH] [[#Retrieval condition syntax|retrieval-conditions]] </td></tr>
</table>

===[[Value loops#Find All Values statement|Find Values Of (FDV)]]===
<table class="noBorder">
<tr>
<td style="padding:0em">{{Template: Find Values Of statement syntax}} </td></tr>
</table>

===FIND AND PRINT COUNT===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{Find And Print Count | FPC} [[[#Retrieval condition syntax|retrieval-conditions]]]
</td></tr>
</table>

===[[Find Records statement|Find Without Locks]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{Find Without Locks [[ALL] Records] | FDWOL} [In label | On [LIST] listname]
[For Which | With] [[#Retrieval condition syntax|retrieval-conditions]]</td></tr>
</table>

===FLUSH PROCESS===

FLUSH PROCESS {cid | processname | %variable}

===FOR EACH OCCURRENCE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>FOR {EACH | k} {OCCURRENCE | OCCURRENCES} OF fieldname </td></tr>
</table>

===[[Record loops#For Each Record statement|For Each Record]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{{Template:For Each Record statement syntax}}</td></tr>
</table>
Note: For <var class="term">retrieval-conditions</var>, see [[#Retrieval condition syntax|Retrieval condition syntax]], below. 

===FOR EACH VALUE OF===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>FOR {EACH | k} {VALUE | VALUES} OF fieldname [FROM {value1 | (expression1)}] [TO {value2 | (expression2)}] [[NOT] LIKE pattern] [IN [ASCENDING | DESCENDING] [CHARACTER | NUMERICAL] [RIGHT-ADJUSTED] ORDER]
</td></tr>
</table>

===FOR EACH VALUE IN===

FOR {EACH | k} {VALUE | VALUES} IN label 

===FOR RECORD NUMBER===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>FOR RECORD NUMBER {value | (expression)}
</td></tr>
</table>

===FOR RECORD NUMBER IN===

FOR RECORD NUMBER {value | IN label} [OPTIMIZING FNV]


===[[For %i statement|For %var From %exp1 To %exp2 By %exp3]]===
<table class="noBorder">
<tr>
<td style="padding:0em">{{Template:For %i statement syntax}} </td></tr>
</table>

Note: The <var>By</var> clause, when omitted, defaults to a value of 1. 

===[[Images#Identify statement|Identify]]===

<table class="noBorder" display="table-column">
<tr><td>{{Template:Identify statement syntax}} </td></tr>
</table>

===[[If statement|If]]...Then...ElseIf...Else===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>If expression Then [statement] [statement] ... [ ElseIf expression Then [statement] [statement] ... ] ... [ Else [statement] [statement] ... ] End If
</td></tr>
</table>

===[[Image statement or block|Image]]===
<var>Image</var> block:
<table class="noBorder">
<tr><td style="padding:0em">{{Template:Image statement syntax}}</td></tr>
</table>

===INCLUDE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*, C)]] </td>
<td>INCLUDE procedurename </td></tr>
</table>

===INPUT===

INPUT inputname [AT [COLUMN] n]
[TO [COLUMN] m | [LEN m] DP {k | *}]]
[UPCASE | NOCASE] [DEFAULT 'value']
[DEBLANK | NODEBLANK] [PAD WITH 'c']
[REQUIRED | ALPHA | ALPHANUM | MUSTFILL
| ONEOF literal [, literal]...
| [NUMERIC] [RANGE lo [TO] hi [AND lo [TO] hi] ...]
| VERIFY 'characters']...
[[READ] attributes] [REREAD attributes] [PRINT attributes]
[TAG [attributes] [WITH 'c']] [ITEMID n]


===INSERT===

INSERT fieldname [(subscript)] = {value | (expression)}


===[[Horizon SOUL interface#Invite statement|Invite]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Invite statement syntax}} </td></tr>
</table>

===IS===

itemname IS [TYPE]
{STRING | BINARY | PACKED | ZONED | FLOAT | EFORMAT}
{LEN {n | UNKNOWN} | BITS n | DIGITS n
| TO position}
[DP {k | *}] [BP n] [SIGNED | UNSIGNED]
[PAD {BLANK | character | NULL}] [STRIP | NOSTRIP]
[ALIGN]
[JUSTIFY {LEFT | RIGHT}]
[INITIAL {BLANK | ZERO | NULL | value}]
[AFTER {itemname | arrayname}
| AT {position | itemname | imagename1 | arrayname}]
[OCCURS {n [DEPENDING ON {itemname | %variable}]
| UNKNOWN}]


===JUMP TO===

JUMP TO label

JUMP TO (label1 [, label2] ...) expression

===[[Loop End statement|Loop End]]===

[[Loop End statement|Loop End]] 

===[[Loop Next statement|Loop Next]]===

Loop Next

===MAX PFKEY===
MAX PFKEY n 

===[[Menu statement or block|Menu]]===
<table class="noBorder">
<tr>
<td>{{Template: Menu statement syntax}} </td></tr>
</table>

===MODIFY===

MODIFY {%menuname:itemname | %screenname:itemname}
[TO] attributes [[FOR] {ALL | READ | REREAD | TAB
| PRINT}]


===MODIFY BUFFER===

MODIFY BUFFER [SIZE=n
| %variable [PRESERVE | NOPRESERVE]]
[FILL [X'nn'] | CLEAR]


===NEW PAGE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>NEW PAGE </td></tr>
</table>

===[[Note statement|Note]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>Note {fieldname [(subscript)]} </td></tr>
</table>
Note 'string'


===[[On statement|On]]===

[[On statement|On]] {Attention | Error | Field Constraint Conflict
| Find Conflict | Missing File | Missing Member
| Record Locking Conflict}
statements
End On [label]


===Open===

{{Template:Open (External I/O) statement syntax}}

 
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>{{Template:Open and OpenC statements syntax}} </td></tr>
</table>

===OPEN PROCESS===

OPEN PROCESS {processname | %variable}
[CID {name | %variable}] 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>OPEN PROCESS {processname | %variable} [CID {name | %variable}] {outbound-options | inbound-options}
</td></tr>
</table>

<div style="margin-left: 30px; background-color: #fBfBfB;">

where <var class="term">outbound-options</var> are:
<ul style="font-family: Consolas,monospace">
<li>[AT DESTINATION] [WITH] [USERID {%variable | 'string'}]

<li>[PASSWORD {%variable | 'string'}]

<li>[{ACCOUNT | PROFILE {%%variable | 'string'}]

<li>[INITIAL {DATA 'string' | DATA %variable | IMAGE imagename] ...]
</ul>

and <var class="term">inbound-options</var> are:

<ul style="font-family: Consolas,monospace">
<li>ACCEPT [INITIAL {DATA %variable | IMAGE image} ...] </li>
</ul>

</div> 

===[[Pause statement|Pause]]===

{{Template:Pause statement syntax}}

===PLACE RECORD ON===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Lists#PLACE RECORD and REMOVE RECORD statements|PLACE RECORD ON]] [LIST] listname
</td></tr>
</table>

===PLACE RECORDS===

PLACE RECORDS {IN label | ON [LIST] listname1} ON [LIST] listname2


===Position===

POSITION {FOUNDSET foundsortset_name | LIST list_name} [AT] position_name

Note: Use the above form of the <var>Position</var> statement with <var>For</var> loop processing; see [[Global features#Position statement|Position statement]].

POSITION {ext-filename | %variable}
AT KEY operator{value | %variable}

Note: Use the above form of the <var>Position</var> statement with external file processing using images; see [[Images#Position statement|Position statement]].

===[[Full-screen feature|PREPARE]]===

PREPARE
{[[[Images#PrepareStmtImage|IMAGE]]] imagename | [[[Full-screen feature#PrepareStmtMenu|MENU]]] menuname
| [[[Full-screen feature#PrepareStmtScrn|SCREEN]]] screenname}


===Print===

Print [[#Print specification syntax|printSpecifications]] 

===Print All Fieldgroup Information (PAFGI)===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:PAFGI statement syntax}} </td></tr>
</table>

===[[Print All Information statement|Print All Information]] or [[PAI statement|PAI]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:PAI statement syntax}} </td></tr>
</table>

===PRINT MENU===

PRINT [MENU] menuname [ALERT]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===PRINT SCREEN===

PRINT SCREEN screenname [ALERT] [[WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===[[Horizon SOUL interface#Query Process statement|Query Process]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Query Process statement syntax}} </td></tr>
</table>

===[[Read Image statement|Read Image]]===

{{Template:Read Image statement syntax}}

===READ menuname===

READ [MENU] menuname [ALERT]
[TITLE ['text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===READ screenname===

READ [SCREEN] screenname [ALERT] [NO REREAD] [ [WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===RECEIVE IMAGE===

RECEIVE {IMAGE imagename | %variable}
FROM {cid | processname | %variable} [RESULT %variable] 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>RECEIVE {IMAGE imagename | %variable} FROM {cid | processname | %variable} RESULT %variable
</td></tr>
</table>

===[[Release All Records statement|Release All Records]]===

{{Template:Release All Records statement syntax}}

===[[Release Position statement|Release Position]]===

<table class="noBorder">
<tr><td>{{Template:Release Position statement syntax}} </td></tr>
</table>

===[[Release Records statement|Release Records]]===

{{Template:Release Records statement syntax}}

===[[Remember statement|Remember]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:Remember statement syntax}}</td></tr>
</table>

===REMOVE RECORD FROM===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Lists#PLACE RECORD and REMOVE RECORD statements|REMOVE RECORD FROM]] [LIST] listname
</td></tr>
</table>

===REMOVE RECORDS===

REMOVE RECORDS {IN label | ON [LIST] listname}
FROM [LIST] listname2


===REPEAT===

REPEAT [FOREVER | n TIMES | WHILE expression]


===REREAD===

REREAD [SCREEN] screenname [ALERT] [[WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===RESET===

RESET {HEADER | TRAILER} m


===[[Exceptions#Rethrow statement|Rethrow]]===

{{Template:Rethrow statement syntax}}

===RETRY===

RETRY [PENDING STATEMENT]


===RETURN===

RETURN


===[[Screen statement or block|Screen]]===

{{Template:Screen statement syntax}}

===SEND===

SEND {IMAGE imagename | 'string' | %variable}
TO {cid | processname | %variable}
[REQSEND %variable]
[FLUSH]

(+)SEND {IMAGE imagename | 'string' | %variable}
TO {cid | processname | %variable}
[FLUSH | CONFIRM]
[REQSEND %variable]


===[[Horizon SOUL interface#Send Error statement|Send Error]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Send Error statement syntax}} </td></tr>
</table>

===SET===

SET {HEADER | TRAILER} m [[#Print specification syntax|print-specifications]]


===[[SetText statement|SetText]]===

{{Template:SetText statement syntax}}

===SIGNAL PROCESS===

SIGNAL PROCESS
{cid | [processname | %variable} {nnn | %variable} 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>SIGNAL PROCESS {cid | [processname | %variable}
</td></tr>
</table>

===[[Sirius Case statement|Sirius Case]] directive===

<table class="noBorder">
<tr><td style="font-family:monoface; padding:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>{{Template:Sirius Case statement syntax}} </td></tr>
</table>

===SKIP LINES===

SKIP n LINE[S]


===[[Skip Position statement|Skip Position]]===

<table class="noBorder">
<tr><td>{{Template:Skip Position statement syntax}} </td></tr>
</table>

===SORT RECORDS===

SORT [k] RECORDS {IN label | ON [LIST] listname}
BY key [AND key] ...


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">key</var> is:
<ul style="font-family: Consolas,monospace">
<li>key = fieldname 
[VALUE {[ASCENDING | DESCENDING] 
[CHARACTER | NUMERICAL] | RIGHT-ADJUSTED]} ...] </li>
</ul>

</div> 

===SORT RECORD KEYS===

SORT [k] RECORD KEYS
{IN label | ON [LIST] listname}
BY key [AND key] ...


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">key</var> is:
<ul style="font-family: Consolas,monospace">
<li>key = fieldname 
[VALUE {[ASCENDING | DESCENDING] 
[CHARACTER | NUMERICAL] | [RIGHT-ADJUSTED]} ...] </li>
</ul>

</div>

===SORT VALUE IN===

SORT VALUE IN label [IN [ASCENDING | DESCENDING]
[CHARACTER | NUMERICAL] | [RIGHT-ADJUSTED] ORDER]


===STOP===

<table class="noBorder">
<tr>
<td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]]</td>
<td>STOP [IF COUNT IN label EXCEEDS n]
</td></tr>
</table>

===STORE RECORD===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>STORE RECORD [sort or hash key value] fieldname1=[value1 | (expression1)] [fieldname2=(expression)] ... [THEN CONTINUE statement statement ...] END STORE
</td></tr>
</table>

===SUBROUTINE===

SUBROUTINE

SUBROUTINE subname
[(formal-parameter [INPUT | OUTPUT | INPUT OUTPUT] [,...])]


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">formal-parameter</var> is one of the following:
<ul style="font-family: Consolas,monospace">
<li>%variable [IS STRING [LEN n] [DP {n | *}] [ARRAY (*[,*[,*]]) [NO FS]] 
| IS {FIXED [DP n] | FLOAT} [ARRAY (*[,*[,*]])]]

<li>LIST listname [IN [FILE | [PERM | TEMP] GROUP] name]
</ul>
</div>

===TAG===

TAG %screenname:inputname [attributes] [WITH 'c']


===[[Horizon SOUL interface#Test Receipt statement|Test Receipt]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Test Receipt statement syntax}} </td></tr>
</table>

===TITLE===

TITLE {'text' | promptname}
[AT [COLUMN] n] [TO [COLUMN] m | [LEN m]
[DP {k | *}]]
[DEFAULT 'value']
[[READ] attributes] [REREAD attributes] [PRINT attributes]


===[[Trace statement|Trace]]===

{{Template:Trace statement syntax}}

Note: The output of the <var>Trace</var> statement is controlled by the <var>[[ULTRACE parameter|ULTRACE]]</var> parameter.

===[[Program Communication facilities#TRANSFER statement format and execution|TRANSFER]]===

TRANSFER [CONTROL] TO PROCESS {processname | %variable}
[WITH] [USERID {string | '%variable'}]
[PASSWORD {variable | 'string'}]
[ACCOUNT {%variable | 'string'}]
[PASSING {IMAGE imagename | 'string' | %variable}]


===UPDATE RECORD===

UPDATE RECORD

===VARIABLES ARE===

VARIABLES ARE
{FIXED [DP n] | FLOAT
| STRING [LEN n] [DP {n | *}]
| UNDEFINED}


===Declare %variable===

[DECLARE] %variable [IS]
{FIXED [DP n] | FLOAT} [ARRAY (d1[,d2[,d3]])]
[COMMON]

[DECLARE] %variable [IS]
STRING [LEN n] [DP {n | *}] [ARRAY (d1[,d2[d3]])]
[NO FIELD SAVE] [COMMON]
%variable [(subscript)] = expression


===WAIT===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>WAIT [{n | %variable} SEC[S]] [FOR] {ANY RECEIPT RETURN %variable | RECEIPT {cid | processname | %variable}}
</td></tr>
</table>

===[[Write Image statement|Write Image]]===

<table class="noBorder">
<tr><td>{{Template:Write Image statement syntax}} </td></tr>
</table>

==Other syntax==

===Names, numbers, literals, comments===

<ul>
<li>Names (for example, %variables, labels): see [[Model 204 naming conventions]]
<li>Other constructs: see [[Basic request structure]] (which also discusses some rules for statement labels)
</ul>

===Value specification syntax===

For all User Language statements and retrieval conditions, wherever the term <var class="term">value</var> appears in the syntax, it can be any of these:
<ul>
<li>Literal number or string </li>
<li><var>VALUE IN</var> clause of the form:
VALUE [IN] label

</li>
<li>%variable</li>
</ul>

===Retrieval condition syntax===

A <var>Find</var> or <var>For Each Record Where</var> statement can be followed by any number of retrieval conditions separated by an end of line or [[LINEND parameter]] character.

Conditions can be constructed as a series of phrases that are combined "in the usual way" with <var>And</var>, <var>Or</var>, <var>Not</var>, and parentheses (()):

[Not] phrase [{And | Or | Nor} [Not] phrase] ...


Where: 

<var class="term">phrase</var> can be constructed from these options: 
<ul style="font-family: Consolas,monospace">
<li><var class="term">fieldname</var> = [Not] value </li>

<li><var class="term">fieldname</var> Like pattern </li>

<li><var class="term">fieldname</var> Is [Not] {Present | Like 'pattern'} </li>

<li><var class="term">fieldname</var> Is [Not] {[Numerically | Alphabetically] 
[Eq | = | Ne | ¬= | Greater Than | Gt | > | Less Than | Lt | < | Le | <= | Ge | >= | Before | After] value} </li>

<li><var class="term">fieldname</var> Is [Not] {[Numerically | Alphabetically] 
{In Range [From | After] value1 {To | [And] Before} 
value2 | Between value1 And value2} </li>

<li>[[Record retrievals#FILE$ condition|File$]] {filename | =} </li>

<li>Find$ <var class="term">label</var> </li>

<li>[[Lists#Using the LIST$ condition|List$]] listname </li>

<li>[[Record retrievals#LOCATION$ condition|Location$]] {location | =} </li>

<li>[[#Point$|Point$]] <var class="term">value</var> </li>

<li>[[#Sfl$ and Sfge$|Sfge$]] <var class="term">value</var> </li>

<li>[[#Sfl$ and Sfge$|Sfl$]] <var class="term">value</var> </li>
</ul>

where <var class="term">value</var> can be: 
<ul>
<li>A literal number or string</li>

<li>A %variable </li>

<li><var>Value</var> {([[#Use of expressions|expression]]) | [<var>In</var>] label}

<var class="term">label</var> points to an existing value set. If an <var>Eq Value In value_set</var> clause, value set values are treated as Boolean OR, for example:

field = value1 OR field = value2 OR.... 

If an <var>Ne Value In value_set</var> clause, values are treated as Boolean AND: 
field <> value1 AND field <> value2 AND.... 

See also [[Basic SOUL statements and commands#Processing a VALUE IN clause|Processing a VALUE IN clause]].</li>
</ul>

Notes:
<ul>
<li>The first character (<code>¬</code>) of the "not-equal" test (<code>¬=</code>) in the fourth of the items in the list of <var class="term">phrase</var> options above is the EBCDIC "not sign," which has the hexadecimal value <code>5f</code>. </li>

<li>For a description of the pattern in the <var>[Is] Like</var> and <var>Is Not</var> clauses, see the syntax of [[Is Like pattern matching#likeSyntax|Is Like patterns]]. </li>

<li>In addition to the discussions in the subsections that follow, see [[Record retrievals]] for a comprehensive description of retrieval conditions. </li>
</ul>

====Omitting repeated first words====

If a sequence of phrases in a particular retrieval condition all have the same first word, that word can be omitted from the latter phrases. For example:
List$ A And Not List$ B


can be written:
List$ A And Not B


And:
x Is 13 Or x Is Less Than 7


can be written:
x Is 13 Or Is Less Than 7


====Omitting duplicated equal signs====

Duplicated equal signs can be omitted. For example, the expression:
a = 3 Or a = 5 Or a = 40


is equivalent to:
a = 3 Or 5 Or 40


====Use of parentheses====

Parentheses can be placed around any sequence of phrases to clarify the condition or force the evaluation to occur in a particular order. For example:
Not (a = 2 Or List$ y)
a = 1 And (b = 2 OR c = 3)


====Use of expressions====

[[Using variables and values in computation#Expressions|Expressions]] can be used in <var>Find</var> and <var>For Each Record</var> statements to provide the retrieval condition for the <var>Point$</var>, <var>Sfl$</var>, and <var>Sfge$</var> conditions, as well as for the <var>Eq Value</var> clause: 

=====Point$=====
Point$ Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. It is preceded by the keyword <var>Value</var>. 

Example: 

This example finds the first <code>MA</code> record on file, and then counts the number of records from this point in the file:
FD1:

IN ICSCUST FPC STATE = MA
END FIND
FOR 1 RECORD IN FD1
PRINT 'CURREC = ' WITH $CURREC
PRINT '>= POINT$'
FD2:
IN ICSCUST FPC POINT$ VALUE($CURREC)
END FIND
END FOR


=====Sfl$ and Sfge$=====
Sfl$ Value(expression)


Or:
Sfge$ Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. It is preceded by the keyword <var>Value</var>. 

Example:

FOR %CT FROM 1 TO 10
IN EXPRESS STORE RECORD ($EDITN(%CT,'999'))
ORD1 = (%REC WITH %CT)
ORD2 = (%CT * 2)
ORD4 = (%CT * 4)
END STORE
END FOR
COMMIT
FOR %CT FROM 1 TO 5
PRINT 'LESS THAN ' WITH %CT
FD1:
IN EXPRESS FPC SFL$ VALUE($EDITN(%CT,'999'))
END FIND
PRINT 'GREATER THAN OR EQUAL TO ' WITH %CT
FD2:
IN EXPRESS FPC SFGE$ VALUE($EDITN(%CT,'999'))
END FIND
END FOR


=====Eq Value=====
fieldname Eq Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. 

Example:

FD: IN FILE PEOPLE FD
LAST EQ VALUE($READ('LAST NAME?') )
END FIND


===Print specification syntax===

A <var>Print</var>, <var>Set</var>, <var>Audit</var>, or <var>Trace</var> statement contains print specifications of the following form:

[term] [And | Tab | With]...[[term] [And | Tab | With] ...] ... [...]

Where:

<var class="term">term</var> can be constructed as follows:
{'string' | %variable | Count In label | Occurrence In label | Value in term | function}
[At [Column] m] [To [Column] n] 

Or, if the statement is within a record loop:

{{Each | term} fieldname | *Record | *Id}
[At [Column] m] [To [Column] n}


Note: For additional <var>Print</var> statement details regarding multiply occurring fields and field groups, see [[Processing multiply occurring fields and field groups#PRINT and PRINT n statements|Print and Print n]] statements for fields. 

===Expression syntax===

The following syntax can be used in: 
<ul>
<li>Assignment statements </li>
<li>Conditional <var>If</var> statements and <var>ElseIf</var> clauses

In the simplified syntax for an <var>If</var> statement, which is:
If condition Then statements


<var class="term">condition</var> expands to the syntax described in this section. </li>

<li>Computed <var>Jump To</var> statements </li>

<li>Subscripts </li>

<li>Function arguments </li>

<li>A value in parenthesis in SOUL "DML" statements, for example:
Add <var class="term">fieldname</var> = (<var class="term">expression</var>)
</ul>

=====Syntax=====
{operand | (expression)} [operator {operand | (expression)}] ...

Where:
<ul>
<li><var class="term">operand</var> can be constructed as follows:
[+ | - | Not]
{'string' | %variable | number
| fieldname [(subscript)] Is [Not] Present
| Count In label | Occurrence In label
| Value In label
| function}
</li>

<li><var class="term">expression</var> (Note: enclosed by parentheses) is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. For further details, see [[Using variables and values in computation#Expressions|Expressions]]. </li>

<li><var class="term">operator</var> may be one of the following:
<table style="table-layout: fixed">
<tr>
<td>+   </td>
<td>=</td>
<td>EQ</td>
<td>And</td>
</tr>

<tr>
<td>-</td>
<td>,=   </td>
<td>NE  </td>
<td>AndIf</td>
</tr>

<tr>
<td>*</td>
<td>></td>
<td>GT</td>
<td>Or</td>
</tr>

<tr>
<td>/</td>
<td><</td>
<td>LT</td>
<td>OrIf</td>
</tr>

<tr>
<td> </td>
<td>>=</td>
<td>GE</td>
<td>With (Note: this can also be achieved via [[Implicit concatenation]])</td>
</tr>

<tr>
<td> </td>
<td><=</td>
<td>LE</td>
<td>Is [Not] Present (Note: applied either to a field or to an [[Methods#optionalParams|optional or default method parameter]])</td>
</tr>

<tr>
<td> </td>
<td> </td>
<td> </td>
<td>Is [Not] Like</td>
</tr>
</table>
<blockquote class="note">Notes:
<ul>
<li>The first character (<code>,</code>) of the inequality test above is the EBCDIC "not sign," which has the hexadecimal value <code>5f</code>. </li>

<li>For a description of the <code>Is Like</code> and <code>Is Not</code> clauses, see the syntax of [[Is Like pattern matching|Is Like patterns]]. </li>

<li>The <var>AndIf</var> and <var>OrIf</var> operators are called "short circuit", because, at a given precedence level, if the value of the conditional expression has been fully determined, the remainder at that level is not evaluated. For example:
%sex eq 'M' and (%ht lt 5.2 orIf %ht gt 6.5)
If the value of <code>%ht</code> is less than 5.2, the final comparison -- <code>%ht gt 6.5</code> -- is never evaluated (that holds regardless of what had been coded as the final comparison).
With the same value of <code>%ht</code>, if the <code>Or</code> operator had been used, then that final comparison is always evaluated.
</li>
<li>For more information about operators, see [[Using variables and values in computation#Operators|Operators]]. </li>
</ul>
</blockquote ></li>
</ul>

===In clause syntax===

The SOUL statements on this page whose syntax display is preceded by an asterisk (<tt>*</tt>) support an <var>In</var> clause. 

The three basic forms of the <var>In</var> clause are: 

In [Permanent | Temporary ] Group groupname
Member [%member | [filename [At {location | =}]]

In file1 [,file2] ...

In {$Curfile | $Update}

The form <var>In $Curfile</var> can be used only within a record loop.

====In Group Member limitations====

In addition to the three basic forms of the In clause shown above, the <var>In Group Member</var> clause restricts the following statements to one member file in a group context:
<ul>
<li><var>Clear List</var></li>

<li><var>Find All Records</var> (and its variants)</li>

<li><var>Find All Values</var></li>

<li><var>For Record Number</var> (or <var>FRN</var>)</li>

<li><var>Store Record</var> </li>
</ul>

You cannot use an <var>In Group Member</var> clause with a <var>For Each Record</var> statement or with an <var>Add</var>, <var>Change</var>, or <var>Delete Record</var> statement. Only the previously listed statements call accept an <var>In Group Member</var> clause.

====Using an In clause in a Begin...End block====

The file name in the <var>In</var> clause used within a <var>Begin...End</var> block is resolved by the compiler. You can hard-code a file name or use some type of dummy string for the file name. Using a %variable for the file name is not allowed. 

===Subscript syntax===

A subscript has the format: 

=====Syntax=====
(subscript1 [,subscript2 [,subscript3]] )

Where:

<var class="term">subscript1</var>, <var class="term">subscript2</var>, and <var class="term">subscript3</var> can be any expression. 

==SOUL macros==
There are [[SOUL macro facility|additional facilities]] supporting <var class="product">SOUL</var>
macro statements. Macro statements allow code to be conditionally compiled.

As an example, in the following SOUL fragment, the <var>Recordset</var> object declaration would be for the file <code>AVEBURY</code>:
!def henge avebury
...
%sites is object recordset in file ?!HENGE


==Terminal display attributes==

One or more of the following terminal display attributes can replace the term attribute in a full-screen formatting statement, if the display attribute is supported by the installation:

<table>
<caption>List of attributes</caption>
<tr>
<td>BLINK</td>
</tr>
<tr>
<td>BLUE</td>
</tr>
<tr>
<td>BRIGHT</td>
</tr>
<tr>
<td>DIM</td>
</tr>
<tr>
<td>GREEN</td>
</tr>
<tr>
<td>INV[IS[BLE]] </td>
</tr>
<tr>
<td>NOBLINK</td>
</tr>
<tr>
<td>NOREV[ERSE]</td>
</tr>
<tr>
<td>NOU[NDER]SCORE</td>
</tr>
<tr>
<td>PINK</td>
</tr>
<tr>
<td>PROT[ECTED]</td>
</tr>
<tr>
<td>RED</td>
</tr>
<tr>
<td>REV[ERSE]</td>
</tr>
<tr>
<td>TURQUOISE</td>
</tr>
<tr>
<td>[UNDER]SCORE</td>
</tr>
<tr>
<td>UNPROT[ECTED]</td>
</tr>
<tr>
<td>VIS[IBLE]</td>
</tr>
<tr>
<td>WHITE</td>
</tr>
<tr>
<td>YELLOW </td>
</tr>
</table>

==Notation conventions==

This page uses the following syntax notation conventions: 

<table>
<tr class="head">
<th>Syntax notation </th>
<th>Indicates that...</th>
</tr>

<tr>
<td>Single asterisk (*) </td>
<td>Statements can be preceded by an IN clause, if there is no reference to a previous set (label or list). See [[#IN clause syntax|IN clause syntax]] for more discussion.</td>
</tr>

<tr>
<td>Two asterisks (**) </td>
<td>Construct can appear only within a record loop.</td>
</tr>

<tr>
<td>Plus sign (+) </td>
<td>Construct requires the optional [[Horizon]] feature.</td>
</tr>

<tr>
<td nowrap>Two plus signs (++) </td>
<td>Construct requires the optional User Language to Database 2 feature.</td>
</tr>

<tr>
<td>C</td>
<td>The (first) keyword of the statement is also a <var class="product">Model 204</var> command; the command's wiki page will be, for example, 'OPEN command'.

<var class="product">Model 204</var> commands are listed alphabetically and documented in [[List of Model 204 commands]]. </td>
</tr>

<tr>
<td>Lowercase italic </td>
<td>Constructs are replaced with variable information.</td>
</tr>
</table>

<ul>
<li>A field name (%%) variable can be used anywhere fieldname appears. The %%variable can contain its own subscript, separate from the field name subscript.
Note: 
The subscript of an array element must be specified before a field name subscript. </li>

<li>The lowercase constructs — retrieval-conditions, print-specifications, expression, subscript, attribute, and type — are discussed separately following the syntax summaries, beginning with [[#Value specification syntax|Value specification syntax]]. </li>

<li>For more Model 204 notation conventions, see [[Notation conventions]].</li>
</ul>

[[Category:SOUL]]

Statement syntax

2020-04-10T19:21:29Z

Dme: /* Loop End */

This page summarizes SOUL syntax and conventions, which are discussed in more detail throughout this wiki. The SOUL statements are listed in alphabetical order. Many of the section titles or syntax blocks contain links to the wiki page describing the statement or syntax phrase. A [[#Other syntax|later section]] provides other SOUL syntax information, including links to [[#tokens|information about the "tokens"]] of SOUL, such as names in SOUL.

All SOUL statements can be used between a <var>[[BEGIN command|Begin]]</var> (or <var>[[MORE command|More]]</var>) command and an <var>[[End statement|End]]</var> statement. 
External Call Facility (ECF) statements are listed under <var>[[#External|External]]</var>.

Various other [[List of Model 204 commands|Model 204 commands]] also have effects on the results of a SOUL request. 

The following notations prefix some of the statements in the presentation of the SOUL syntax: 
<nowiki>*
**
+
++
C
</nowiki>

See the [[#Notation conventions|notation conventions]] section for an explanation of these usages, as well as other general comments about understanding the syntax of SOUL.

  
<div id="User Language statements"></div> 
<div id="SOUL statements"></div> <div id="SOUL syntax"></div>



===[[Add statement|Add]]===
<table class="noBorder">
<tr>
<td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]]</td>
<td>{{Template:Add fieldname statement syntax}}</td></tr>
</table>

<table class="noBorder">
<tr><td style="padding:0em">{{Template:Add lob-fieldname statement syntax}} </td></tr>
</table>

===[[Array statement|Array]]===

Array [arrayname] Occurs {n | Unknown}
Depending On {itemname | %variable}
[After {itemname | arrayname}
| At {position | itemname | imagename1 | arrayname}]


===[[Assert statement|Assert]]===

{{Template:Assert statement syntax}}

===[[Report generation#Audit statement|Audit]]===

Audit [[#Print specification syntax|print-specifications]]


===[[Audit All Fieldgroup Information statement|Audit All Fieldgroup Information]] (AAFGI)===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:AAFGI statement syntax}} </td></tr>
</table>

===[[Report generation#Audit All Information statement|Audit All Information]]===

<table class="noBorder">
<tr><td>{{Template:Audit All Information statement syntax}} </td></tr>
</table>

===Backout===
<table class="noBorder">
<tr><td/>
<td>[[Backout statement|Backout]] </td></tr>
</table>

===BYPASS===

BYPASS [PENDING STATEMENT] 

===CALL===

CALL {label | subname
[([expression | %variable | [LIST] listname] [,...])]}


===[[Data maintenance#Change statement|Change]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:Change fieldname statement syntax (basic)}} </td></tr>
</table>

<table class="noBorder">
<tr>
<td style="padding:0em">{{Template:Change lob-fieldname statement syntax}} </td></tr>
</table>

===[[Global_features#Using_the_CLEAR_statement|CLEAR]]===

{{Template:Clear statement syntax}}

===CLEAR LIST===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>[[Lists#Clearing a list|CLEAR LIST]] listname </td></tr>
</table>

===CLEAR ON===

{{Template:Clear On statement syntax}}

===CLEAR TAG===

CLEAR TAG {screenname | %screenname:inputname}


===[[Close statement (external I/O)|Close]]===

<table class="noBorder">
<tr><td>{{Template:Close statement (external I/O) syntax}} </td></tr>
</table>

===CLOSE PROCESS===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+C)]] </td>
<td>CLOSE PROCESS {cid | processname | %variable} [SYNCLEVEL | FLUSH | %variable] </td></tr>
</table>

CLOSE PROCESS
{cid | processname | %variable}
[SYNCLEVEL | CONFIRM | FLUSH | ERROR | %variable]


===[[Commit statement|Commit]]===

{{Template:Commit statement syntax}}

===[[Horizon SOUL interface#Confirm statement|Confirm]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Confirm statement syntax}} </td></tr>
</table>

===[[Horizon SOUL interface#Confirmed statement|Confirmed]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Confirmed statement syntax}} </td></tr>
</table>

===CONTINUE===

CONTINUE

===COUNT OCCURRENCES OF===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>COUNT OCCURRENCES OF fieldname</td></tr>
</table>

===COUNT RECORDS===

COUNT RECORDS {IN label | ON [LIST] listname}

===[[Declare statement|Declare]]===

[[[Using variables and values in computation#Declaring|Declare]]] declaration



where <var class="term">declaration</var> is one of the following: 

<div style="margin-left: 20px; background-color: #fBfBfB;">
<ul style="font-family: Consolas,monospace; display:table;">
<li>Label labelname [Global | Common]
</li>

<li>[[Lists#DECLARE LIST syntax|List]] listname [In [File | [Perm | Temp] Group]] name] At location [Global | Common]
</li>

<li><var>Image</var> block:
{{Template:Image statement syntax}} </li>

<li>{{Template:Menu statement syntax}} </li>

<li>{{Template:Screen statement syntax}} </li>

<li>%variable [Is] {Fixed [Dp n] | Float} [Array (d1 [,d2 [,d3]])] 
[[[Initial clause in %variable declaration|Initial]](numeric-expression)] [Static] [Common]
</li>

<li>%variable [Is] String [Len n] [Dp {n | *}] [Array (d1 [,d2[,d3]])] 
[No Field Save] [Common] 
[[[Initial clause in %variable declaration|Initial]]('EBCDIC-string' | expression)] [Static]
</li>

<li>[[Subroutines#DECLARE SUBROUTINE statement|Subroutine]] subname [(type [Input | Output | Input Output] [,...])]

where <var class="term">type</var> is one of the following: 
<ul>
<li>Scalar %variable of the following format:
{String [Len] n [DP {n | *}] | [Fixed [Dp n] | Float]} 
</li>

<li>Array %variable of the following format:
{String [Len n] [Dp [n | *}] [Array (* [,*[,*]]) [No Field Save]] 
| [Fixed [Dp n] | Float] [Array (* [,*[,*]])]} 
</li>

<li>A list of records of the following format:
[List] [In {File | [Perm | Temp] Group} name] 
</li></ul>
</ul>

</div> 

===DEFAULT CURSOR===

DEFAULT CURSOR [READ | REREAD | PRINT]
{ITEMID n | itemname | ROW n COLUMN m}


===DEFAULT===

DEFAULT {TITLE
| PROMPT
| INPUT [DEBLANK | NODEBLANK] [PAD WITH 'c'] [LEN m [DP [k | *}]] [UPCASE | NOCASE]
| [TAG [attributes] [WITH 'c']}
[[READ] attributes] [REREAD attributes] [PRINT attributes]

DEFAULT SKIP n POSITIONS[S]
[INITIAL {NULL | character | BLANK}]

DEFAULT [TYPE]
{STRING | BINARY | PACKED | ZONED | FLOAT | EFORMAT}
{LEN {n | UNKNOWN} | BITS n | DIGITS n}
[DP {k | *}] [BP n]
[SIGNED | UNSIGNED] [PAD {BLANK | character | NULL}]
[STRIP | NOSTRIP] [JUSTIFY {LEFT | RIGHT}]
[INITIAL {BLANK | ZERO | NULL | literal}]


===DELETE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Data maintenance#DELETE statement|DELETE]] fieldname [([[Processing_multiply_occurring_fields_and_field_groups#DELETE_statement_rules|subscript]])] [= value | (expression)]
</td></tr>
</table>

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Data maintenance#Deleting a field group|DELETE FIELDGROUP]] [fieldgroupname] [([[Processing_multiply_occurring_fields_and_field_groups#DELETE_statement_rules|subscript]])] [= value | (expression)]
</td></tr>
</table>

===DELETE EACH===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>DELETE EACH fieldname </td></tr>
</table>

===[[Data maintenance#DELETE RECORD statement|DELETE RECORD]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>DELETE RECORD </td></tr>
</table>

===DELETE RECORDS===

DELETE [ALL] RECORDS {IN label | ON [LIST] listname}


===END BLOCK===

END BLOCK label 

===End===

END {FIND | IF | FOR | ON | REPEAT | STORE | SUBROUTINE} [label]

END {ARRAY | IMAGE | MENU | SCREEN}

[[End statement|End]] [MORE | NORUN | USE]...

===END UPDATE===

END UPDATE

===[[External statement|External]]===

{{Template:External statement syntax}}

===FILE RECORDS===

FILE RECORDS {IN label | ON [LIST] listname}
UNDER fieldname = {value | (expression)}


===[[Find Records statement|Find Records]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{FIND [[ALL] RECORDS] | FD } [IN label | ON [LIST] listname] [FOR WHICH | WITH] [[#Retrieval condition syntax|retrieval-conditions]]</td></tr>
</table>

===[[Find And Reserve statement|Find And Reserve]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{FIND AND RESERVE [[ALL] RECORDS] | FDR} [IN label | ON [LIST] listname] [FOR WHICH | WITH] [[#Retrieval condition syntax|retrieval-conditions]] </td></tr>
</table>

===[[Value loops#Find All Values statement|Find Values Of (FDV)]]===
<table class="noBorder">
<tr>
<td style="padding:0em">{{Template: Find Values Of statement syntax}} </td></tr>
</table>

===FIND AND PRINT COUNT===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{Find And Print Count | FPC} [[[#Retrieval condition syntax|retrieval-conditions]]]
</td></tr>
</table>

===[[Find Records statement|Find Without Locks]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{Find Without Locks [[ALL] Records] | FDWOL} [In label | On [LIST] listname]
[For Which | With] [[#Retrieval condition syntax|retrieval-conditions]]</td></tr>
</table>

===FLUSH PROCESS===

FLUSH PROCESS {cid | processname | %variable}

===FOR EACH OCCURRENCE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>FOR {EACH | k} {OCCURRENCE | OCCURRENCES} OF fieldname </td></tr>
</table>

===[[Record loops#For Each Record statement|For Each Record]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{{Template:For Each Record statement syntax}}</td></tr>
</table>
Note: For <var class="term">retrieval-conditions</var>, see [[#Retrieval condition syntax|Retrieval condition syntax]], below. 

===FOR EACH VALUE OF===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>FOR {EACH | k} {VALUE | VALUES} OF fieldname [FROM {value1 | (expression1)}] [TO {value2 | (expression2)}] [[NOT] LIKE pattern] [IN [ASCENDING | DESCENDING] [CHARACTER | NUMERICAL] [RIGHT-ADJUSTED] ORDER]
</td></tr>
</table>

===FOR EACH VALUE IN===

FOR {EACH | k} {VALUE | VALUES} IN label 

===FOR RECORD NUMBER===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>FOR RECORD NUMBER {value | (expression)}
</td></tr>
</table>

===FOR RECORD NUMBER IN===

FOR RECORD NUMBER {value | IN label} [OPTIMIZING FNV]


===[[For %i statement|For %var From %exp1 To %exp2 By %exp3]]===
<table class="noBorder">
<tr>
<td style="padding:0em">{{Template:For %i statement syntax}} </td></tr>
</table>

Note: The <var>By</var> clause, when omitted, defaults to a value of 1. 

===[[Images#Identify statement|Identify]]===

<table class="noBorder" display="table-column">
<tr><td>{{Template:Identify statement syntax}} </td></tr>
</table>

===[[If statement|If]]...Then...ElseIf...Else===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>If expression Then [statement] [statement] ... [ ElseIf expression Then [statement] [statement] ... ] ... [ Else [statement] [statement] ... ] End If
</td></tr>
</table>

===[[Image statement or block|Image]]===
<var>Image</var> block:
<table class="noBorder">
<tr><td style="padding:0em">{{Template:Image statement syntax}}</td></tr>
</table>

===INCLUDE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*, C)]] </td>
<td>INCLUDE procedurename </td></tr>
</table>

===INPUT===

INPUT inputname [AT [COLUMN] n]
[TO [COLUMN] m | [LEN m] DP {k | *}]]
[UPCASE | NOCASE] [DEFAULT 'value']
[DEBLANK | NODEBLANK] [PAD WITH 'c']
[REQUIRED | ALPHA | ALPHANUM | MUSTFILL
| ONEOF literal [, literal]...
| [NUMERIC] [RANGE lo [TO] hi [AND lo [TO] hi] ...]
| VERIFY 'characters']...
[[READ] attributes] [REREAD attributes] [PRINT attributes]
[TAG [attributes] [WITH 'c']] [ITEMID n]


===INSERT===

INSERT fieldname [(subscript)] = {value | (expression)}


===[[Horizon SOUL interface#Invite statement|Invite]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Invite statement syntax}} </td></tr>
</table>

===IS===

itemname IS [TYPE]
{STRING | BINARY | PACKED | ZONED | FLOAT | EFORMAT}
{LEN {n | UNKNOWN} | BITS n | DIGITS n
| TO position}
[DP {k | *}] [BP n] [SIGNED | UNSIGNED]
[PAD {BLANK | character | NULL}] [STRIP | NOSTRIP]
[ALIGN]
[JUSTIFY {LEFT | RIGHT}]
[INITIAL {BLANK | ZERO | NULL | value}]
[AFTER {itemname | arrayname}
| AT {position | itemname | imagename1 | arrayname}]
[OCCURS {n [DEPENDING ON {itemname | %variable}]
| UNKNOWN}]


===JUMP TO===

JUMP TO label

JUMP TO (label1 [, label2] ...) expression

===[[Loop End statement|Loop End]]===

Loop End 

===[[Loop Next statement|Loop Next]]===

Loop Next

===MAX PFKEY===
MAX PFKEY n 

===[[Menu statement or block|Menu]]===
<table class="noBorder">
<tr>
<td>{{Template: Menu statement syntax}} </td></tr>
</table>

===MODIFY===

MODIFY {%menuname:itemname | %screenname:itemname}
[TO] attributes [[FOR] {ALL | READ | REREAD | TAB
| PRINT}]


===MODIFY BUFFER===

MODIFY BUFFER [SIZE=n
| %variable [PRESERVE | NOPRESERVE]]
[FILL [X'nn'] | CLEAR]


===NEW PAGE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>NEW PAGE </td></tr>
</table>

===[[Note statement|Note]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>Note {fieldname [(subscript)]} </td></tr>
</table>
Note 'string'


===[[On statement|On]]===

[[On statement|On]] {Attention | Error | Field Constraint Conflict
| Find Conflict | Missing File | Missing Member
| Record Locking Conflict}
statements
End On [label]


===Open===

{{Template:Open (External I/O) statement syntax}}

 
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>{{Template:Open and OpenC statements syntax}} </td></tr>
</table>

===OPEN PROCESS===

OPEN PROCESS {processname | %variable}
[CID {name | %variable}] 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>OPEN PROCESS {processname | %variable} [CID {name | %variable}] {outbound-options | inbound-options}
</td></tr>
</table>

<div style="margin-left: 30px; background-color: #fBfBfB;">

where <var class="term">outbound-options</var> are:
<ul style="font-family: Consolas,monospace">
<li>[AT DESTINATION] [WITH] [USERID {%variable | 'string'}]

<li>[PASSWORD {%variable | 'string'}]

<li>[{ACCOUNT | PROFILE {%%variable | 'string'}]

<li>[INITIAL {DATA 'string' | DATA %variable | IMAGE imagename] ...]
</ul>

and <var class="term">inbound-options</var> are:

<ul style="font-family: Consolas,monospace">
<li>ACCEPT [INITIAL {DATA %variable | IMAGE image} ...] </li>
</ul>

</div> 

===[[Pause statement|Pause]]===

{{Template:Pause statement syntax}}

===PLACE RECORD ON===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Lists#PLACE RECORD and REMOVE RECORD statements|PLACE RECORD ON]] [LIST] listname
</td></tr>
</table>

===PLACE RECORDS===

PLACE RECORDS {IN label | ON [LIST] listname1} ON [LIST] listname2


===Position===

POSITION {FOUNDSET foundsortset_name | LIST list_name} [AT] position_name

Note: Use the above form of the <var>Position</var> statement with <var>For</var> loop processing; see [[Global features#Position statement|Position statement]].

POSITION {ext-filename | %variable}
AT KEY operator{value | %variable}

Note: Use the above form of the <var>Position</var> statement with external file processing using images; see [[Images#Position statement|Position statement]].

===[[Full-screen feature|PREPARE]]===

PREPARE
{[[[Images#PrepareStmtImage|IMAGE]]] imagename | [[[Full-screen feature#PrepareStmtMenu|MENU]]] menuname
| [[[Full-screen feature#PrepareStmtScrn|SCREEN]]] screenname}


===Print===

Print [[#Print specification syntax|printSpecifications]] 

===Print All Fieldgroup Information (PAFGI)===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:PAFGI statement syntax}} </td></tr>
</table>

===[[Print All Information statement|Print All Information]] or [[PAI statement|PAI]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:PAI statement syntax}} </td></tr>
</table>

===PRINT MENU===

PRINT [MENU] menuname [ALERT]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===PRINT SCREEN===

PRINT SCREEN screenname [ALERT] [[WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===[[Horizon SOUL interface#Query Process statement|Query Process]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Query Process statement syntax}} </td></tr>
</table>

===[[Read Image statement|Read Image]]===

{{Template:Read Image statement syntax}}

===READ menuname===

READ [MENU] menuname [ALERT]
[TITLE ['text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===READ screenname===

READ [SCREEN] screenname [ALERT] [NO REREAD] [ [WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===RECEIVE IMAGE===

RECEIVE {IMAGE imagename | %variable}
FROM {cid | processname | %variable} [RESULT %variable] 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>RECEIVE {IMAGE imagename | %variable} FROM {cid | processname | %variable} RESULT %variable
</td></tr>
</table>

===[[Release All Records statement|Release All Records]]===

{{Template:Release All Records statement syntax}}

===[[Release Position statement|Release Position]]===

<table class="noBorder">
<tr><td>{{Template:Release Position statement syntax}} </td></tr>
</table>

===[[Release Records statement|Release Records]]===

{{Template:Release Records statement syntax}}

===[[Remember statement|Remember]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:Remember statement syntax}}</td></tr>
</table>

===REMOVE RECORD FROM===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Lists#PLACE RECORD and REMOVE RECORD statements|REMOVE RECORD FROM]] [LIST] listname
</td></tr>
</table>

===REMOVE RECORDS===

REMOVE RECORDS {IN label | ON [LIST] listname}
FROM [LIST] listname2


===REPEAT===

REPEAT [FOREVER | n TIMES | WHILE expression]


===REREAD===

REREAD [SCREEN] screenname [ALERT] [[WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===RESET===

RESET {HEADER | TRAILER} m


===[[Exceptions#Rethrow statement|Rethrow]]===

{{Template:Rethrow statement syntax}}

===RETRY===

RETRY [PENDING STATEMENT]


===RETURN===

RETURN


===[[Screen statement or block|Screen]]===

{{Template:Screen statement syntax}}

===SEND===

SEND {IMAGE imagename | 'string' | %variable}
TO {cid | processname | %variable}
[REQSEND %variable]
[FLUSH]

(+)SEND {IMAGE imagename | 'string' | %variable}
TO {cid | processname | %variable}
[FLUSH | CONFIRM]
[REQSEND %variable]


===[[Horizon SOUL interface#Send Error statement|Send Error]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Send Error statement syntax}} </td></tr>
</table>

===SET===

SET {HEADER | TRAILER} m [[#Print specification syntax|print-specifications]]


===[[SetText statement|SetText]]===

{{Template:SetText statement syntax}}

===SIGNAL PROCESS===

SIGNAL PROCESS
{cid | [processname | %variable} {nnn | %variable} 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>SIGNAL PROCESS {cid | [processname | %variable}
</td></tr>
</table>

===[[Sirius Case statement|Sirius Case]] directive===

<table class="noBorder">
<tr><td style="font-family:monoface; padding:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>{{Template:Sirius Case statement syntax}} </td></tr>
</table>

===SKIP LINES===

SKIP n LINE[S]


===[[Skip Position statement|Skip Position]]===

<table class="noBorder">
<tr><td>{{Template:Skip Position statement syntax}} </td></tr>
</table>

===SORT RECORDS===

SORT [k] RECORDS {IN label | ON [LIST] listname}
BY key [AND key] ...


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">key</var> is:
<ul style="font-family: Consolas,monospace">
<li>key = fieldname 
[VALUE {[ASCENDING | DESCENDING] 
[CHARACTER | NUMERICAL] | RIGHT-ADJUSTED]} ...] </li>
</ul>

</div> 

===SORT RECORD KEYS===

SORT [k] RECORD KEYS
{IN label | ON [LIST] listname}
BY key [AND key] ...


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">key</var> is:
<ul style="font-family: Consolas,monospace">
<li>key = fieldname 
[VALUE {[ASCENDING | DESCENDING] 
[CHARACTER | NUMERICAL] | [RIGHT-ADJUSTED]} ...] </li>
</ul>

</div>

===SORT VALUE IN===

SORT VALUE IN label [IN [ASCENDING | DESCENDING]
[CHARACTER | NUMERICAL] | [RIGHT-ADJUSTED] ORDER]


===STOP===

<table class="noBorder">
<tr>
<td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]]</td>
<td>STOP [IF COUNT IN label EXCEEDS n]
</td></tr>
</table>

===STORE RECORD===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>STORE RECORD [sort or hash key value] fieldname1=[value1 | (expression1)] [fieldname2=(expression)] ... [THEN CONTINUE statement statement ...] END STORE
</td></tr>
</table>

===SUBROUTINE===

SUBROUTINE

SUBROUTINE subname
[(formal-parameter [INPUT | OUTPUT | INPUT OUTPUT] [,...])]


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">formal-parameter</var> is one of the following:
<ul style="font-family: Consolas,monospace">
<li>%variable [IS STRING [LEN n] [DP {n | *}] [ARRAY (*[,*[,*]]) [NO FS]] 
| IS {FIXED [DP n] | FLOAT} [ARRAY (*[,*[,*]])]]

<li>LIST listname [IN [FILE | [PERM | TEMP] GROUP] name]
</ul>
</div>

===TAG===

TAG %screenname:inputname [attributes] [WITH 'c']


===[[Horizon SOUL interface#Test Receipt statement|Test Receipt]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Test Receipt statement syntax}} </td></tr>
</table>

===TITLE===

TITLE {'text' | promptname}
[AT [COLUMN] n] [TO [COLUMN] m | [LEN m]
[DP {k | *}]]
[DEFAULT 'value']
[[READ] attributes] [REREAD attributes] [PRINT attributes]


===[[Trace statement|Trace]]===

{{Template:Trace statement syntax}}

Note: The output of the <var>Trace</var> statement is controlled by the <var>[[ULTRACE parameter|ULTRACE]]</var> parameter.

===[[Program Communication facilities#TRANSFER statement format and execution|TRANSFER]]===

TRANSFER [CONTROL] TO PROCESS {processname | %variable}
[WITH] [USERID {string | '%variable'}]
[PASSWORD {variable | 'string'}]
[ACCOUNT {%variable | 'string'}]
[PASSING {IMAGE imagename | 'string' | %variable}]


===UPDATE RECORD===

UPDATE RECORD

===VARIABLES ARE===

VARIABLES ARE
{FIXED [DP n] | FLOAT
| STRING [LEN n] [DP {n | *}]
| UNDEFINED}


===Declare %variable===

[DECLARE] %variable [IS]
{FIXED [DP n] | FLOAT} [ARRAY (d1[,d2[,d3]])]
[COMMON]

[DECLARE] %variable [IS]
STRING [LEN n] [DP {n | *}] [ARRAY (d1[,d2[d3]])]
[NO FIELD SAVE] [COMMON]
%variable [(subscript)] = expression


===WAIT===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>WAIT [{n | %variable} SEC[S]] [FOR] {ANY RECEIPT RETURN %variable | RECEIPT {cid | processname | %variable}}
</td></tr>
</table>

===[[Write Image statement|Write Image]]===

<table class="noBorder">
<tr><td>{{Template:Write Image statement syntax}} </td></tr>
</table>

==Other syntax==

===Names, numbers, literals, comments===

<ul>
<li>Names (for example, %variables, labels): see [[Model 204 naming conventions]]
<li>Other constructs: see [[Basic request structure]] (which also discusses some rules for statement labels)
</ul>

===Value specification syntax===

For all User Language statements and retrieval conditions, wherever the term <var class="term">value</var> appears in the syntax, it can be any of these:
<ul>
<li>Literal number or string </li>
<li><var>VALUE IN</var> clause of the form:
VALUE [IN] label

</li>
<li>%variable</li>
</ul>

===Retrieval condition syntax===

A <var>Find</var> or <var>For Each Record Where</var> statement can be followed by any number of retrieval conditions separated by an end of line or [[LINEND parameter]] character.

Conditions can be constructed as a series of phrases that are combined "in the usual way" with <var>And</var>, <var>Or</var>, <var>Not</var>, and parentheses (()):

[Not] phrase [{And | Or | Nor} [Not] phrase] ...


Where: 

<var class="term">phrase</var> can be constructed from these options: 
<ul style="font-family: Consolas,monospace">
<li><var class="term">fieldname</var> = [Not] value </li>

<li><var class="term">fieldname</var> Like pattern </li>

<li><var class="term">fieldname</var> Is [Not] {Present | Like 'pattern'} </li>

<li><var class="term">fieldname</var> Is [Not] {[Numerically | Alphabetically] 
[Eq | = | Ne | ¬= | Greater Than | Gt | > | Less Than | Lt | < | Le | <= | Ge | >= | Before | After] value} </li>

<li><var class="term">fieldname</var> Is [Not] {[Numerically | Alphabetically] 
{In Range [From | After] value1 {To | [And] Before} 
value2 | Between value1 And value2} </li>

<li>[[Record retrievals#FILE$ condition|File$]] {filename | =} </li>

<li>Find$ <var class="term">label</var> </li>

<li>[[Lists#Using the LIST$ condition|List$]] listname </li>

<li>[[Record retrievals#LOCATION$ condition|Location$]] {location | =} </li>

<li>[[#Point$|Point$]] <var class="term">value</var> </li>

<li>[[#Sfl$ and Sfge$|Sfge$]] <var class="term">value</var> </li>

<li>[[#Sfl$ and Sfge$|Sfl$]] <var class="term">value</var> </li>
</ul>

where <var class="term">value</var> can be: 
<ul>
<li>A literal number or string</li>

<li>A %variable </li>

<li><var>Value</var> {([[#Use of expressions|expression]]) | [<var>In</var>] label}

<var class="term">label</var> points to an existing value set. If an <var>Eq Value In value_set</var> clause, value set values are treated as Boolean OR, for example:

field = value1 OR field = value2 OR.... 

If an <var>Ne Value In value_set</var> clause, values are treated as Boolean AND: 
field <> value1 AND field <> value2 AND.... 

See also [[Basic SOUL statements and commands#Processing a VALUE IN clause|Processing a VALUE IN clause]].</li>
</ul>

Notes:
<ul>
<li>The first character (<code>¬</code>) of the "not-equal" test (<code>¬=</code>) in the fourth of the items in the list of <var class="term">phrase</var> options above is the EBCDIC "not sign," which has the hexadecimal value <code>5f</code>. </li>

<li>For a description of the pattern in the <var>[Is] Like</var> and <var>Is Not</var> clauses, see the syntax of [[Is Like pattern matching#likeSyntax|Is Like patterns]]. </li>

<li>In addition to the discussions in the subsections that follow, see [[Record retrievals]] for a comprehensive description of retrieval conditions. </li>
</ul>

====Omitting repeated first words====

If a sequence of phrases in a particular retrieval condition all have the same first word, that word can be omitted from the latter phrases. For example:
List$ A And Not List$ B


can be written:
List$ A And Not B


And:
x Is 13 Or x Is Less Than 7


can be written:
x Is 13 Or Is Less Than 7


====Omitting duplicated equal signs====

Duplicated equal signs can be omitted. For example, the expression:
a = 3 Or a = 5 Or a = 40


is equivalent to:
a = 3 Or 5 Or 40


====Use of parentheses====

Parentheses can be placed around any sequence of phrases to clarify the condition or force the evaluation to occur in a particular order. For example:
Not (a = 2 Or List$ y)
a = 1 And (b = 2 OR c = 3)


====Use of expressions====

[[Using variables and values in computation#Expressions|Expressions]] can be used in <var>Find</var> and <var>For Each Record</var> statements to provide the retrieval condition for the <var>Point$</var>, <var>Sfl$</var>, and <var>Sfge$</var> conditions, as well as for the <var>Eq Value</var> clause: 

=====Point$=====
Point$ Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. It is preceded by the keyword <var>Value</var>. 

Example: 

This example finds the first <code>MA</code> record on file, and then counts the number of records from this point in the file:
FD1:

IN ICSCUST FPC STATE = MA
END FIND
FOR 1 RECORD IN FD1
PRINT 'CURREC = ' WITH $CURREC
PRINT '>= POINT$'
FD2:
IN ICSCUST FPC POINT$ VALUE($CURREC)
END FIND
END FOR


=====Sfl$ and Sfge$=====
Sfl$ Value(expression)


Or:
Sfge$ Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. It is preceded by the keyword <var>Value</var>. 

Example:

FOR %CT FROM 1 TO 10
IN EXPRESS STORE RECORD ($EDITN(%CT,'999'))
ORD1 = (%REC WITH %CT)
ORD2 = (%CT * 2)
ORD4 = (%CT * 4)
END STORE
END FOR
COMMIT
FOR %CT FROM 1 TO 5
PRINT 'LESS THAN ' WITH %CT
FD1:
IN EXPRESS FPC SFL$ VALUE($EDITN(%CT,'999'))
END FIND
PRINT 'GREATER THAN OR EQUAL TO ' WITH %CT
FD2:
IN EXPRESS FPC SFGE$ VALUE($EDITN(%CT,'999'))
END FIND
END FOR


=====Eq Value=====
fieldname Eq Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. 

Example:

FD: IN FILE PEOPLE FD
LAST EQ VALUE($READ('LAST NAME?') )
END FIND


===Print specification syntax===

A <var>Print</var>, <var>Set</var>, <var>Audit</var>, or <var>Trace</var> statement contains print specifications of the following form:

[term] [And | Tab | With]...[[term] [And | Tab | With] ...] ... [...]

Where:

<var class="term">term</var> can be constructed as follows:
{'string' | %variable | Count In label | Occurrence In label | Value in term | function}
[At [Column] m] [To [Column] n] 

Or, if the statement is within a record loop:

{{Each | term} fieldname | *Record | *Id}
[At [Column] m] [To [Column] n}


Note: For additional <var>Print</var> statement details regarding multiply occurring fields and field groups, see [[Processing multiply occurring fields and field groups#PRINT and PRINT n statements|Print and Print n]] statements for fields. 

===Expression syntax===

The following syntax can be used in: 
<ul>
<li>Assignment statements </li>
<li>Conditional <var>If</var> statements and <var>ElseIf</var> clauses

In the simplified syntax for an <var>If</var> statement, which is:
If condition Then statements


<var class="term">condition</var> expands to the syntax described in this section. </li>

<li>Computed <var>Jump To</var> statements </li>

<li>Subscripts </li>

<li>Function arguments </li>

<li>A value in parenthesis in SOUL "DML" statements, for example:
Add <var class="term">fieldname</var> = (<var class="term">expression</var>)
</ul>

=====Syntax=====
{operand | (expression)} [operator {operand | (expression)}] ...

Where:
<ul>
<li><var class="term">operand</var> can be constructed as follows:
[+ | - | Not]
{'string' | %variable | number
| fieldname [(subscript)] Is [Not] Present
| Count In label | Occurrence In label
| Value In label
| function}
</li>

<li><var class="term">expression</var> (Note: enclosed by parentheses) is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. For further details, see [[Using variables and values in computation#Expressions|Expressions]]. </li>

<li><var class="term">operator</var> may be one of the following:
<table style="table-layout: fixed">
<tr>
<td>+   </td>
<td>=</td>
<td>EQ</td>
<td>And</td>
</tr>

<tr>
<td>-</td>
<td>,=   </td>
<td>NE  </td>
<td>AndIf</td>
</tr>

<tr>
<td>*</td>
<td>></td>
<td>GT</td>
<td>Or</td>
</tr>

<tr>
<td>/</td>
<td><</td>
<td>LT</td>
<td>OrIf</td>
</tr>

<tr>
<td> </td>
<td>>=</td>
<td>GE</td>
<td>With (Note: this can also be achieved via [[Implicit concatenation]])</td>
</tr>

<tr>
<td> </td>
<td><=</td>
<td>LE</td>
<td>Is [Not] Present (Note: applied either to a field or to an [[Methods#optionalParams|optional or default method parameter]])</td>
</tr>

<tr>
<td> </td>
<td> </td>
<td> </td>
<td>Is [Not] Like</td>
</tr>
</table>
<blockquote class="note">Notes:
<ul>
<li>The first character (<code>,</code>) of the inequality test above is the EBCDIC "not sign," which has the hexadecimal value <code>5f</code>. </li>

<li>For a description of the <code>Is Like</code> and <code>Is Not</code> clauses, see the syntax of [[Is Like pattern matching|Is Like patterns]]. </li>

<li>The <var>AndIf</var> and <var>OrIf</var> operators are called "short circuit", because, at a given precedence level, if the value of the conditional expression has been fully determined, the remainder at that level is not evaluated. For example:
%sex eq 'M' and (%ht lt 5.2 orIf %ht gt 6.5)
If the value of <code>%ht</code> is less than 5.2, the final comparison -- <code>%ht gt 6.5</code> -- is never evaluated (that holds regardless of what had been coded as the final comparison).
With the same value of <code>%ht</code>, if the <code>Or</code> operator had been used, then that final comparison is always evaluated.
</li>
<li>For more information about operators, see [[Using variables and values in computation#Operators|Operators]]. </li>
</ul>
</blockquote ></li>
</ul>

===In clause syntax===

The SOUL statements on this page whose syntax display is preceded by an asterisk (<tt>*</tt>) support an <var>In</var> clause. 

The three basic forms of the <var>In</var> clause are: 

In [Permanent | Temporary ] Group groupname
Member [%member | [filename [At {location | =}]]

In file1 [,file2] ...

In {$Curfile | $Update}

The form <var>In $Curfile</var> can be used only within a record loop.

====In Group Member limitations====

In addition to the three basic forms of the In clause shown above, the <var>In Group Member</var> clause restricts the following statements to one member file in a group context:
<ul>
<li><var>Clear List</var></li>

<li><var>Find All Records</var> (and its variants)</li>

<li><var>Find All Values</var></li>

<li><var>For Record Number</var> (or <var>FRN</var>)</li>

<li><var>Store Record</var> </li>
</ul>

You cannot use an <var>In Group Member</var> clause with a <var>For Each Record</var> statement or with an <var>Add</var>, <var>Change</var>, or <var>Delete Record</var> statement. Only the previously listed statements call accept an <var>In Group Member</var> clause.

====Using an In clause in a Begin...End block====

The file name in the <var>In</var> clause used within a <var>Begin...End</var> block is resolved by the compiler. You can hard-code a file name or use some type of dummy string for the file name. Using a %variable for the file name is not allowed. 

===Subscript syntax===

A subscript has the format: 

=====Syntax=====
(subscript1 [,subscript2 [,subscript3]] )

Where:

<var class="term">subscript1</var>, <var class="term">subscript2</var>, and <var class="term">subscript3</var> can be any expression. 

==SOUL macros==
There are [[SOUL macro facility|additional facilities]] supporting <var class="product">SOUL</var>
macro statements. Macro statements allow code to be conditionally compiled.

As an example, in the following SOUL fragment, the <var>Recordset</var> object declaration would be for the file <code>AVEBURY</code>:
!def henge avebury
...
%sites is object recordset in file ?!HENGE


==Terminal display attributes==

One or more of the following terminal display attributes can replace the term attribute in a full-screen formatting statement, if the display attribute is supported by the installation:

<table>
<caption>List of attributes</caption>
<tr>
<td>BLINK</td>
</tr>
<tr>
<td>BLUE</td>
</tr>
<tr>
<td>BRIGHT</td>
</tr>
<tr>
<td>DIM</td>
</tr>
<tr>
<td>GREEN</td>
</tr>
<tr>
<td>INV[IS[BLE]] </td>
</tr>
<tr>
<td>NOBLINK</td>
</tr>
<tr>
<td>NOREV[ERSE]</td>
</tr>
<tr>
<td>NOU[NDER]SCORE</td>
</tr>
<tr>
<td>PINK</td>
</tr>
<tr>
<td>PROT[ECTED]</td>
</tr>
<tr>
<td>RED</td>
</tr>
<tr>
<td>REV[ERSE]</td>
</tr>
<tr>
<td>TURQUOISE</td>
</tr>
<tr>
<td>[UNDER]SCORE</td>
</tr>
<tr>
<td>UNPROT[ECTED]</td>
</tr>
<tr>
<td>VIS[IBLE]</td>
</tr>
<tr>
<td>WHITE</td>
</tr>
<tr>
<td>YELLOW </td>
</tr>
</table>

==Notation conventions==

This page uses the following syntax notation conventions: 

<table>
<tr class="head">
<th>Syntax notation </th>
<th>Indicates that...</th>
</tr>

<tr>
<td>Single asterisk (*) </td>
<td>Statements can be preceded by an IN clause, if there is no reference to a previous set (label or list). See [[#IN clause syntax|IN clause syntax]] for more discussion.</td>
</tr>

<tr>
<td>Two asterisks (**) </td>
<td>Construct can appear only within a record loop.</td>
</tr>

<tr>
<td>Plus sign (+) </td>
<td>Construct requires the optional [[Horizon]] feature.</td>
</tr>

<tr>
<td nowrap>Two plus signs (++) </td>
<td>Construct requires the optional User Language to Database 2 feature.</td>
</tr>

<tr>
<td>C</td>
<td>The (first) keyword of the statement is also a <var class="product">Model 204</var> command; the command's wiki page will be, for example, 'OPEN command'.

<var class="product">Model 204</var> commands are listed alphabetically and documented in [[List of Model 204 commands]]. </td>
</tr>

<tr>
<td>Lowercase italic </td>
<td>Constructs are replaced with variable information.</td>
</tr>
</table>

<ul>
<li>A field name (%%) variable can be used anywhere fieldname appears. The %%variable can contain its own subscript, separate from the field name subscript.
Note: 
The subscript of an array element must be specified before a field name subscript. </li>

<li>The lowercase constructs — retrieval-conditions, print-specifications, expression, subscript, attribute, and type — are discussed separately following the syntax summaries, beginning with [[#Value specification syntax|Value specification syntax]]. </li>

<li>For more Model 204 notation conventions, see [[Notation conventions]].</li>
</ul>

[[Category:SOUL]]

Loop End statement

2020-04-10T19:20:30Z

Dme: Redirected page to Flow of control in SOUL#loopEnd

#REDIRECT[[Flow of control in SOUL#loopEnd]]

Flow of control in SOUL

2020-04-10T19:15:48Z

Dme: /* LOOP END statement */

<div class="toclimit-3">
==Overview==

===Transferring control to another point===

SOUL statements are normally executed in the sequence in which they are written. The following statements can be used to transfer control to another point in the request:
<ul>
<li><var>[[#if|If]]</var> statement</li>
<li>JUMP TO statement</li>
<li>STOP statement</li>
<li>STOP IF COUNT statement</li>
<li>LOOP END statement</li>
</ul>

===Index loops and repeat loops===
<ul>
<li>[[#indexLoops|Index loops]] allow a series of statements to be repeated using an "index" or "counter" variable which is incremented or decremented over a specified range. </li>

<li><var>[[#repeat|Repeat]]</var> loops allow a series of statements to be repeated any number of times, with termination of the loop controlled by arbitrary conditions specified in the loop. </li>
</ul>

===Subroutines===

SOUL lets you treat a single set of statements as a simple or complex subroutine which can be called from different locations within a request.

Subroutines, common elements, and ON units are discussed in [[Subroutines#Subroutines|Subroutines]].

==If statement==

During request execution, you can direct <var class="product">Model 204</var> as to what actions it should take based on the current values of %variables or expressions. You specify a course of action in an <var>If</var> statement. 

The <var>If</var> statement introduces a block. Immediately following the <var>If</var> statement within the block is a set of one or more <var class="product">SOUL</var> statements to execute if the specified conditions are true. The block is ended by an <var>End If</var> or <var>End Block</var> statement.

====Syntax====

The basic format of the IF statement is: 
IF expression THEN statements


where <var class="term">expression</var> specifies an expression in the form described in [[Using variables and values in computation#Expressions|Expressions]] and <var class="term">statements</var> can be any User Language statements. 

===Ending an IF statement===

You must terminate the IF statement with an END IF statement or an END BLOCK statement. 

===Specifying multiple conditions===

You can specify a number of conditions to satisfy in the IF clause by placing them on separate lines. 

You must use a hyphen to indicate line continuation; do not use parentheses. Without the hyphen, starting a new input line within the IF statement implies an AND. The precedence of the implied AND is lower than all other operators. See [[Using variables and values in computation#Operator order of precedence|Operator order of precedence]] for a list of operators and order of precedence.

===Using the THEN clause===

You can place the keyword THEN at the end of the last condition or on a new line. Although the THEN keyword is not required, you should always provide it to avoid confusion and the possibility of unexpected results. The statement or statements included in the THEN clause can be any SOUL statements, as shown in the following example. 
IF POLICY NO EQ 100340
FULLNAME EQ 'ABBOTT, FRANKLIN G'
THEN PRINT DATE OF BIRTH
END IF


The THEN clause is executed only if all conditions are true. If one or more of the conditions are false, the THEN clause is not executed; execution moves to the next statement with a nesting level no deeper than that of the IF statement. In the following example, if the conditional expression is true, the FIND.RECS, PRINT.NAME, and END.PRINT statement are executed. If the expression is false, execution moves to PRINT.MSG.
 .
.
.
CHECK.VAR.A: IF NOT %A LIKE 'JACK*' THEN
FIND.RECS: FIND ALL RECORDS FOR WHICH
AGENT = %A
END FIND
PRINT.NAME: FOR EACH RECORD IN FIND.RECS
PRINT AGENT WITH POLICY NO AT COLUMN 30
END FOR
END.PRINT: JUMP TO PRINT.DONE
END IF
PRINT.MSG: PRINT 'VARIABLES NOT EQUAL'
PRINT.DONE: PRINT 'ALL DONE'


====Example====

If a conditional expression is the last statement within a loop, a false condition continues execution of the loop with the next record or value. 

In the following example, if the condition TOTAL PREMIUM > 300 is true, a second test is performed. If AGENT EQ 'CASOLA' also is true, the birth date is printed. If the first condition is not true, the second test is not performed and execution returns to the top of the FOR loop with the next record. 
FIND.RECS: FIND ALL RECORDS
END FIND
PRINT.DOB: FOR EACH RECORD IN FIND.RECS
IF TOTAL PREMIUM > 300 THEN
IF AGENT EQ 'CASOLA' THEN
PRINT POLICY NO -
WITH DATE OF BIRTH AT COLUMN 30
END IF
END IF
END FOR
SORT.RECS: SORT RECORDS IN FIND.RECS BY POLICY NO
.
.
.


==ELSE clause and ELSEIF clause==

===ELSE clause===

The ELSE clause lets you specify one or more statements to execute when the condition specified in the IF statement is false. For example: 
COMPUTE.A: IF %DIV LE 0 THEN
%X = %X + 1
ELSE
%A = %B / %DIV
END IF


An ELSE clause terminates the THEN clause and must begin on a new line. 

===Nesting IF statements===

A THEN or an ELSE clause can contain an IF statement. When IF statements are embedded, an ELSE clause without a statement label is executed when the condition of the immediately preceding IF is false. 

====Example 1====

In the following example, the ELSE clause is executed when the conditions %W EQ '1' and %X EQ 'A' are true and the condition %Y EQ 'B' is false.
SET.Z.VAR: IF %W EQ '1' THEN
IF %X EQ 'A' THEN
IF %Y EQ 'B' THEN
%Z = 'CASE1'
ELSE
%Z = 'CASE2'
END IF
END IF
END IF


====Example 2====

You can specify an ELSE clause for an IF statement that does not immediately precede the ELSE. The following example illustrates how to use an ELSE clause without a statement to pair each ELSE with the correct IF. In this example, the statement %Z = 'CASE3' is executed whenever the condition %W EQ '1' is true and the condition %X EQ 'A' is false. 
SET.Z.VAR: IF %W EQ '1' THEN
IF %X EQ 'A' THEN
IF %Y EQ 'B' THEN
%Z = 'CASE1'
END IF
ELSE
%Z = 'CASE3'
END IF
END IF


===Using the ELSEIF clause===

The ELSEIF clause provides a convenient way of specifying embedded IF statements when a series of tests are to be made, only one of which will be satisfied. 

The following examples illustrate how to specify a statement using ELSEIF instead of ELSE. 

====Example using ELSE====
IF %X EQ 'A' THEN %I = 1
ELSE
IF %X EQ 'B' THEN %I = 2
ELSE
IF %X EQ 'C' THEN %I = 3
END IF
END IF
END IF


====Example using ELSEIF====
IF %X EQ 'A' THEN %I = 1
ELSEIF %X EQ 'B' THEN %I = 2
ELSEIF %X EQ 'C' THEN %I = 3
END IF


==Using operators with the IF statement==

This section discusses how the following operators are used with IF statements:
<ul>
<li>Comparison </li>
<li>Boolean</li>
<li>IS PRESENT and IS NOT PRESENT</li>
</ul>

[[Using variables and values in computation]] also discusses the use of expressions, operators, and operands.

===Comparison operators===

Comparison operators are used with the assignment or conditional statement to return a value of 1 if the stated relation between operands is true, and a value of 0 if false. If the operands are both numbers or are both character strings, the obvious algebraic or string comparison is made. In conditional clauses, values of non-FLOAT fields and string %variables are treated as character strings whether or not they contain numbers. 

====Conversion====

If one operand is a character string and the other is a number, the character string is converted to a number before the comparison is made. A value of 0 results from the conversion if the string does not follow the rules for numbers used in expressions. Thus:
'+3.0' EQ 3


is true, but:
'THREE' EQ 3


is false.

====Literal number operands====

If one of the operands is a literal number, it should be the second operand. For example:
IF AGE > 3


is acceptable. However:
IF 3 AGE


results in an error message.

====Numeric comparison of string values====

If two operands that normally are strings are to be compared numerically, you must force at least one of the operands to be converted to a number. This is done by preceding the quantity with a unary plus sign. 

====Example 1====

Suppose a request includes these statements:
SET.VAR.A: %A = 21
FOR EACH RECORD IN FIND.RECS


and the user wishes to mark those records where the AGE field is numerically less than the STRING variable %A. If the AGE field for the current record is 9, the comparison:
AGE < %A


is false because both are treated as strings and "9" is greater than "21". Either
+AGE < %A


or
AGE < +%A


produces the desired result. 

====Example 2====

The statement:
IF AGE = 0 THEN
.
.
.


is true if AGE is algebraically equivalent to 0 (0.00, 0, and so on) or if AGE is not a number ('FIVE', ",and so on)
IF AGE = '0' THEN
.
.
.


is true only if AGE is equal to the character "0" (zero).

===Boolean operators===

The power of the IF clause can be expanded by means of the Boolean operators NOT, AND, and OR, which can be used to modify or link together comparison expressions. 

====Examples====
IF AGE > 3 AND AGE < 15 THEN
PRINT AGE


The value of the field AGE is printed if it falls between 3 and 15 inclusively. If the value of AGE is 20, it is not printed because the comparison subclauses are not both true. 

In the following example, the value of the field is printed if either or both of the comparison subclauses are true. Any value greater than 45 is printed as will any value equal to 28. 
IF AGE GT 45 OR AGE EQ 28 THEN
PRINT AGE


====Do not abbreviate conditions====

When the Boolean operators AND, OR, and NOT are used in an IF statement, the conditions they connect cannot be abbreviated as can the conditions in a FIND statement. In a FIND statement, the following are equivalent:
FIND.RECS: FIND ALL RECORDS FOR WHICH
AGE = 24 OR 25 OR 26
END FIND

FIND.RECS: FIND ALL RECORDS FOR WHICH
AGE = 24 OR AGE = 25 OR AGE = 26
END FIND


In an IF statement, the following expressions are not equivalent:
FOR EACH RECORD IN FIND.RECS
IF FIELD EQ 24 OR FIELD EQ 25 -
OR FIELD EQ 26 THEN -
.
.
.

FOR EACH RECORD IN FIND.RECS
IF FIELD EQ 24 OR 25 OR 26 THEN
.
.
.


The first statement is true if the value of FIELD is algebraically equivalent to 24, 25, or 26. The second statement is always true. FIELD EQ 24 is considered to be the first expression. The numbers 25 and 26 are stand-alone expressions that have no algebraic operator. <var class="product">Model 204</var> considers a literal number other than 0 a true value. Character strings are true if they contain nonzero numerical values. 

===ANDIF and ORIF short-circuit operators===

The operators ANDIF and ORIF provide short-circuit logical operations.

The purpose of short-circuit operators is to enable the compiled code to bypass the evaluation of a second expression, depending on the result of the previous expression(s). If the result of the first expression can determine the final result of the operation, there is no need to continue evaluating subsequent expressions since they will not change the outcome.

Consider using short-circuit operators to improve performance if your code can skip evaluation of other expressions, especially if they are complex expressions. Any advantages of using short-circuit operators instead of nested IFs will depend on your code. In most cases, standard nested IF processing will provide better performance.

====Using the ANDIF operator====

Consider the following code that must evaluate each EQ expression before taking action:
IF LASTNAME EQ 'SMITH' AND -
FIRSTNAME EQ 'SAM' AND -
BIRTH.YEAR EQ 1963 THEN
* do something
END IF


You could rewrite the previous code to prevent evaluation of some conditions if the higher level conditions are false. For example, if LASTNAME is not equal to 'SMITH', the subsequent conditions on FIRSTNAME and BIRTH.YEAR are not evaluated:
IF LASTNAME EQ 'SMITH' THEN
IF FIRSTNAME EQ 'SAM' THEN
IF BIRTH.YEAR EQ 1963 THEN
* do something
END IF
END IF
END IF


You could also accomplish the same thing without nested IF statements by using ANDIF. For example, if LASTNAME is not equal to 'SMITH', the subsequent conditions are not evaluated:
IF LASTNAME EQ 'SMITH' ANDIF -
FIRSTNAME EQ 'SAM' ANDIF -
BIRTH.YEAR EQ 1963 THEN
* do something
END IF


====Comparing ANDIF evaluation sequence====

[[#ANDIF and ORIF short-circuit operators|ANDIF and ORIF short-circuit operators]] illustrates how sequential expressions are evaluated when using the ANDIF operator and the result of the operations:
<table>
<caption>Comparing ANDIF evaluation sequence</caption>
<tr class="head">
<th>Expression 1 </th>
<th>Expression 2 </th>
<th>Expression 3 </th>
<th>Result</th>
</tr>

<tr>
<td>TRUE</td>
<td>TRUE</td>
<td>TRUE</td>
<td>TRUE</td>
</tr>

<tr>
<td>TRUE</td>
<td>FALSE</td>
<td>(Not evaluated) </td>
<td>FALSE</td>
</tr>

<tr>
<td>FALSE</td>
<td>(Not evaluated) </td>
<td>(Not evaluated) </td>
<td>FALSE</td>
</tr>
</table>

====Using the ORIF operator====

Similarly, with the ORIF operator:
IF LASTNAME EQ 'SMITH' ORIF -
LASTNAME EQ 'JONES' ORIF -
FIRSTNAME EQ 'FRED' THEN
* do something
END IF


====Comparing ORIF evaluation sequence====

[[#ANDIF and ORIF short-circuit operators|ANDIF and ORIF short-circuit operators]] illustrates how subsequent expressions are evaluated using the ORIF operator and the result of the operations:
<table>
<caption>Comparing ORIF evaluation essence</caption>
<tr class="head">
<th>Expression 1 </th>
<th>Expression 2 </th>
<th>Expression 3 </th>
<th>Result</th>
</tr>

<tr>
<td>TRUE</td>
<td>(Not evaluated) </td>
<td>(Not evaluated) </td>
<td>TRUE</td>
</tr>

<tr>
<td>FALSE</td>
<td>TRUE</td>
<td>(Not evaluated) </td>
<td>TRUE</td>
</tr>

<tr>
<td>FALSE</td>
<td>FALSE</td>
<td>TRUE</td>
<td>TRUE</td>
</tr>

<tr>
<td>FALSE</td>
<td>FALSE</td>
<td>FALSE</td>
<td>FALSE</td>
</tr>
</table>
Note: You can freely intersperse ANDIF evaluations and ORIF evaluations with AND evaluations and OR evaluations.

===IS PRESENT and IS NOT PRESENT operators===

The IS PRESENT and the IS NOT PRESENT operators can be used in expressions within record loops to determine whether or not a field is present on the current record of the loop.

The IS PRESENT operator returns a value of 1 if the specified field is present in a record, and a value of 0 if the specified field is missing. Fields with null values ('') are considered to be present. Conversely, the IS NOT PRESENT operator returns a value of 1 if the specified field is missing in a record, and a value of 0 if the field is present.

The expression: 
fieldname IS NOT PRESENT


is equivalent to:
NOT fieldname IS PRESENT


====Order of precedence====

The IS PRESENT and IS NOT PRESENT operators have higher precedence than any other operators.

====Syntax requirements====
<ul>
<li>The operand must be a field (field name); it cannot be the result of another operator.</li>

<li>You must include the IS keyword as part of the IS PRESENT and IS NOT PRESENT operators.</li>

<li>The IS PRESENT operator cannot be followed by a value. </li>
</ul>

===True and false values===

The final result of a series of comparisons has a numeric value: true equals one and false equals zero. This value can be used in assignment statements. For example:
%CONDITION1 = AGE > 3 AND AGE < 15
%CONDITION2 = NAME EQ 'SMITH' OR NAME EQ 'JONES'
IF %CONDITION1 AND %CONDITION2 THEN
.
.
.


Setting switches equal to 0 or 1, and then testing them in more than one IF statement, is an efficient comparison technique. The condition tested by IF need not contain a comparison operator.

Consider a file containing two record types. If TYPE is a field to be tested in an IF statement, the values assigned to TYPE could be 0 and 1. For example:
BEGIN
FIND.RECS: FIND ALL RECORDS FOR WHICH
NAME = SMITH
END FIND
FOR EACH RECORD IN FIND.RECS
IF TYPE THEN
.
.
.


If TYPE were equal to 1, then the expression is true and the statements following THEN are executed.

==Sample request using IF statements==

The following request demonstrates the use of conditionals. The request finds the average temperature during January, 1999, at each weather station. The CHECK.TEMP statement tests the value of the TEMP field in the current record. If the TEMP field is missing from the record, <var class="product">Model 204</var> assigns it the value of a zero length string (the null string) in expressions. 
BEGIN
NEW PAGE
VARIABLES ARE FLOAT
GET.VALUE: FOR EACH VALUE OF STATION
%TEMP = 0
%NO = 0
FIND.RECS: FIND ALL RECORDS FOR WHICH
TYPE = WEATHER
DATE IS BETWEEN 990100 AND 990132
STATION = VALUE IN GET.VALUE
END FIND
FOR EACH RECORD IN FIND.RECS
CHECK.TEMP: IF TEMP NE " THEN
%NO = %NO + 1
%TEMP = %TEMP + TEMP
END IF
END FOR
IF %NO EQ 0 THEN
PRINT VALUE IN GET.VALUE TAB -
'NO TEMP OBS.-JAN 1999'
JUMP TO SKIP.ONE
END IF
%AVTEMP = %TEMP/%NO
CT.RECS: COUNT RECORDS IN FIND.RECS
%MISS = COUNT IN CT.RECS - %NO
PRINT VALUE IN GET.VALUE TAB %NO WITH -
' TEMP OBS., ' WITH %MISS WITH
' MISSING TEMPERATURE OBSERVATION FOR -
JANUARY 1990' -
TAB %AVTEMP WITH ' MEAN TEMP FOR JAN 1999'
SKIP.ONE: SKIP 1 LINE
END FOR
END


==Branching statements==

The following statements can transfer control and terminate the execution of a loop or request:
<ul>
<li>JUMP TO</li>
<li>STOP</li>
<li>STOP IF COUNT</li>
<li>LOOP END </li>
</ul>

Although these statements typically are used in conjunction with the IF statement, they can be used in other contexts as well.

See [[#Usage with branching statements|Usage with branching statements]] for a discussion of branching statements with repeat loops.

===JUMP TO statement===

The JUMP TO statement transfers control to another statement in the request. 

====Syntax====

The format of the JUMP TO statement is: 
JUMP TO label


where <var class="term">label</var> is the label of the next statement to be processed. 

====Example 1====
 .
.
.
CHECK.DATE: IF DATE OF BIRTH > 19700101 THEN
JUMP TO END.REQUEST
ELSE
%A = TOTAL PREMIUM
END IF
FIND.RECS: FIND ALL RECORDS FOR WHICH
DATE OF BIRTH IS > 19630618
END FIND
FOR EACH RECORD IN FIND.RECS
.
.
.
END FOR
END.REQUEST: PRINT 'INVALID DATE ON FILE'
.
.
.


====Computed JUMP TO====

A more complex form of the JUMP TO statement, called the computed JUMP TO, selects the next statement to be processed based on the current value of some expression. The format of the computed JUMP TO is as follows: 
JUMP TO (label1 [, label2] ...) expression

Where:
<ul>
<li><var class="term">label1</var>, <var class="term">label2</var>, and so on are statement labels</li>

<li><var class="term">expression</var> is any valid arithmetic expression (see the discussion on expressions in [[Using variables and values in computation#Arithmetic operations|Arithmetic operations]]). </li>
</ul>

When the JUMP TO is processed, the expression is evaluated as a number and rounded to an integer (for example, <var class="term">k</var>). A jump is then performed to the <var class="term">k</var>th statement label in the list. 

====Example 2====

For example, if the user enters:
BRANCH: JUMP TO (PRINT.VIN, ACCUM.TOT, ACCUM.GRAND.TOT) -
%A-3
SKIP 1 LINE


then %A-3 is evaluated and rounded to an integer. The next statement processed after BRANCH is PRINT.VIN if %A-3 = 1, ACCUM.TOT if %A-3 = 2, ACCUM.GRAND.TOT if %A-3 = 3, or the SKIP statement if
%A-3 = anything else.

If k is less than one or larger than the number of entries in the list, or if the expression is not a number, no jump occurs. Processing continues with the next sequential statement.

====JUMP TO branching====

Both forms of the JUMP TO statement can branch outside a FOR EACH RECORD loop or refer to other statements within the same loop, but neither form can jump into a loop from outside that loop. 

===STOP statement===

The STOP statement terminates the execution of a request. However, the STOP statement does not cancel compilation and evaluation of a continuation if the terminated request ends with END MORE. 

===STOP IF COUNT statement===

The STOP IF COUNT statement limits the amount of output. 

====Syntax====

The format of the STOP IF COUNT statement is: 
STOP IF COUNT IN label EXCEEDS n


This statement ends a request if the number obtained by a COUNT RECORDS statement is larger than the integer <var class="term">n</var>. STOP IF COUNT must be used outside a loop.

====Example====
BEGIN
DRIVER: FIND ALL RECORDS FOR WHICH
RECTYPE = DRIVER
STATE = VIRGINIA
END FIND
NO.OF.DRIVERS: COUNT RECORDS IN DRIVER
PRINT COUNT IN NO.OF.DRIVERS
STOP IF COUNT IN NO.OF.DRIVERS EXCEEDS 100
FOR EACH RECORD IN DRIVER
PRINT FULLNAME
END FOR
END


If there are 100 or fewer Virginia drivers in the file, <var class="product">Model 204</var> prints the number of drivers and then print the name of each driver. If there are more than 100 drivers in the file, <var class="product">Model 204</var> prints only the number of drivers. 

===Loop End statement===

The <var>Loop End</var> statement transfers control to the statement immediately following the loop that contains the <var>Loop End</var> statement. This, in effect, is a jump outside a loop to just beyond its end. 

====Example:====
BEGIN
FIND.RECS: FIND ALL RECORDS FOR WHICH
RECTYPE = DRIVER
END FIND
LOOP: FOR EACH RECORD IN FIND.RECS
IF DATE OF BIRTH GT 19700101 THEN
LOOP END
END IF
SET.VAR: %AGE = 19900901 - DATE OF BIRTH
.
.
.
END FOR LOOP
PRINT.MSG: PRINT 'MESSAGE'
.
.
.

In the preceding request, if the date of birth is found to be greater than January 1, 1970, the LOOP statement is immediately ended and processing continues beginning with the PRINT.MSG statement.

===Using branching statements to control processing===

Sometimes different sets of records require identical processing. Lists can be used to eliminate the coding of duplicate sets of processing statements and branching statements can be used to control processing, as shown in the following procedure.
BEGIN
MA.POL.HLDR: FIND ALL RECORDS FOR WHICH
RECTYPE = POLICYHOLDER
STATE = MASSACHUSETTS
END FIND
MAKE.LIST: PLACE RECORDS IN MA.POL.HLDR ON LIST GENERAL
SORT.LIST: SORT RECORDS ON LIST GENERAL BY CITY
PRINT.INFO: FOR EACH RECORD IN SORT.LIST
PRINT POLICY NO AND FULLNAME -
WITH CITY AT COLUMN 30
END FOR
ACCUM.CT: %CT = %CT + 1
IF %CT = 2 THEN
JUMP TO STOP
END IF
CLEAR LIST GENERAL
CAL.GOODRICH: FIND ALL RECORDS FOR WHICH
STATE = CALIFORNIA
AGENT = GOODRICH
END FIND
NEW.LIST: PLACE RECORDS IN CAL.GOODRICH ON
LIST GENERAL
JUMP TO SORT.LIST
STOP: END


In the preceding request, the MA.POL.HLDR and MAKE.LIST statements select a set of records that are processed with the SORT.LIST and PRINT.INFO statements. The CAL.GOODRICH and NEW.LIST statements select a second set of records. The request then jumps back to the SORT.LIST statement and the SORT.LIST and PRINT.INFO statements process the second set of records. The ACCUM.CT statement tests a variable and terminates the request after the second set has been processed.

===Using branching statements to continue loops===

====Issue====

It is often necessary to branch around statements in a FOR loop and continue the loop with the next record or value. 

A jump to the FOR EACH RECORD statement or a jump to the first statement in the loop does not accomplish this. If a jump to the FOR EACH RECORD statement is performed within the loop, <var class="product">Model 204</var> starts again with the first record in the set being processed. If a jump to the first statement in the loop is performed, <var class="product">Model 204</var> starts processing the current record again. 

====Solution====

A jump to a comment statement placed at the end of the loop can resolve this problem and allow <var class="product">Model 204</var> to process the next record. For example:
BEGIN
FIND.RECS: FIND ALL RECORDS FOR WHICH
TYPE = PAYROLL
END FIND
FOR EACH RECORD IN FIND.RECS
IF DEPT EQ 'ACCT' THEN
%TIME = %TIME + 40
JUMP TO JUMP.COMM
END IF
IF DEPT EQ 'PAY' THEN
%TIMEP = %TIMEP + 37
END IF
JUMP.COMM: *COMMENTS
END FOR
PRINT %TIME AND %TIMEP
END


==Index loops - For %var From .. To .. By ..==

The index loop statement executes a series of statements for each element of an array, for particular dimensions of the array, or for particular elements of the array. In addition to being used with arrays, index loops can be used any place wherever a set of statements is to be executed a number of times. If the loop is controlled by a number rather than by a value or a FOR loop, an index loop can be used. 

====Syntax====

The format of the index loop statement is:
{{Template:For %i statement syntax}}
Where:
<ul>
<li><var class="term">exp1</var> indicates the first element to be processed by the index loop. Exp1 is not allowed to change during processing.</li>

<li><var class="term">exp2</var> indicates the last element to be processed by the index loop. Exp2 is not allowed to change during processing.</li>

<li><var class="term">exp3</var> indicates the number by which the element number is to be incremented each time the loop is performed. For example, <code>BY 2</code> might be used to process every other array element.

The TO and BY phrases can appear in any order. If BY is omitted, the default increment is 1.
</li>
</ul>

===Index loop processing===

The expressions specified in the index loop are evaluated only once before the first pass through the loop. Exp1 and exp2 are evaluated before the loop, so changes will not affect the loop. However, exp3 can change within the loop.

<var class="product">Model 204</var> performs the test for index loop completion before the loop body. The increment is performed before each pass of the loop except the first. A branch is allowed out of the loop, but not into it.

For all types of variables that represent expr2 and expr3, '''except the FLOAT type''' (see following note), expr2 and expr3 are both evaluated only once. Changing the values of the variable in expr2 and/or expr3 in the body of the FOR loop will not affect the number of times that the loop is run. 
Note: FLOAT variables that represent expr2 and expr3 in a FOR loop are evaluated each time through the FOR loop. You may expand or contract the scope of the loop as well as change the BY SKIP value during the body of the FOR loop each time it is evaluated, so using this type of variable for the expr2 and expr3 expressions can affect the number of times that the loop is run. However, if the expr3 expression evaluates to a negative value, then the loop will terminate. 

====Example====

The following example of an index loop reads inventory items from records and stores them in an array named %PRODUCT. It then reads account numbers and stores them in the array named %ACCTNO. GET.ENTRY processes the array %ACCTNO. It accesses an account number, prints it, sets corresponding items from the %PRODUCT array, and prints them. It then returns to access the next account number, and continues processing.

The following records are used as input to the index loop:
TYPE = ITEM TYPE = ITEM TYPE = ITEM
ACCOUNT = 100 ACCOUNT = 200 ACCOUNT = 300
ITEM = TISSUES ITEM = CORN FLAKES ITEM = WHITE BREAD
ITEM = TOOTHPOWDER ITEM = BRAN FLAKES ITEM = WHOLE WHEAT
ITEM = TOOTHPASTE ITEM = PUFFED WHEAT ITEM = CORN BREAD
ITEM = SOAP ITEM = PUFFED RICE ITEM = HONEY WHEAT
ITEM = TOOTHBRUSH ITEM = SHREDDED WHEAT ITEM = SYRIAN BREAD


The request to process the records is as follows:
BEGIN
%PRODUCT IS STRING LEN 15 ARRAY(3,5)
DECLARE %ACCTNO FLOAT ARRAY(3)
VARIABLES ARE FIXED
%ACCT = 0
FIND.RECS: FIND ALL RECORDS FOR WHICH
TYPE = ITEM
END FIND
GET.ENTRY: FOR EACH RECORD IN FIND.RECS
%ACCT = %ACCT+1
%ACCTNO(%ACCT) = ACCOUNT
FOR %INDEX FROM 1 TO 5
%PRODUCT(%ACCT,%INDEX) = ITEM(%INDEX)
END FOR
END FOR
FOR %ACCT FROM 1 TO 3
PRINT 'CUSTOMER ACCOUNT = ' WITH -
%ACCTNO(%ACCT)
SKIP 1 LINE
FOR %INDEX FROM 1 TO 5
PRINT 'ITEM = ' AT COLUMN 15
WITH %PRODUCT(%ACCT,%INDEX)
END FOR
SKIP 1 LINE
END FOR
END


Output appears as shown below:
CUSTOMER ACCOUNT = 100

ITEM = TISSUES
ITEM = TOOTHPOWDER
ITEM = TOOTHPASTE
ITEM = SOAP
ITEM = TOOTHBRUSH

CUSTOMER ACCOUNT = 200

ITEM = CORN FLAKES
ITEM = BRAN FLAKES
ITEM = PUFFED WHEAT
ITEM = PUFFED RICE
ITEM = SHREDDED WHEAT

CUSTOMER ACCOUNT = 300

ITEM = WHITE BREAD
ITEM = WHOLE WHEAT
ITEM = CORN BREAD
ITEM = HONEY WHEAT
ITEM = SYRIAN BREAD


==Repeat loops==

As discussed previously, you can use the index loop wherever you want to execute a set of statements a specific number of times. However, if the series of statements to be executed either does not need a number specification or if the times of execution occur in a non-uniform manner, you can use a repeat loop. 

===Initiating a repeat loop===

A repeat loop is initiated by using one of the following REPEAT statements. A repeat loop terminates with an END REPEAT statement. You can also end a REPEAT loop with an END BLOCK statement. 
<table>
<tr class="head">
<th>REPEAT... </th>
<th>This statement executes a series of statements...</th>
</tr>

<tr>
<td><var>WHILE </var></td>
<td>As long as a specified condition is true.</td>
</tr>

<tr>
<td><var>UNTIL </var></td>
<td>Until a specified condition is true.</td>
</tr>

<tr>
<td><var class="term">n</var> <var>TIMES </var></td>
<td>A specified number of times.</td>
</tr>

<tr>
<td><var>FOREVER </var></td>
<td>Repeatedly until the loop is exited with a STOP, JUMP, or LOOP END statement. </td>
</tr>
</table>

===Usage with branching statements===

The following rules govern branching into and out of repeat loops:
<table>
<tr class="head">
<th>Statement </th>
<th>Can be used to...</th>
</tr>

<tr>
<td>JUMP TO </td>
<td>Jump out of the repeat loop. However, jumping to a statement within a repeat loop from a statement outside the repeat loop is not allowed. </td>
</tr>

<tr>
<td nowrap>LOOP END </td>
<td>Transfer control to the statement immediately following the repeat loop that contains the LOOP END statement. </td>
</tr>

<tr>

<td>STOP </td>
<td>Terminate processing within repeat loops; however, the STOP IF COUNT statement is not permitted. </td>
</tr>
</table>

Refer to [[#Branching statements|Branching statements]] for a discussion.

===REPEAT WHILE statement===

The REPEAT WHILE statement executes a series of statements, as long as the specified condition is true. The condition is evaluated before each execution of the body of the loop. If the condition is false when the REPEAT WHILE statement is first executed, the statements inside the loop are never executed. 

====Syntax====

The format of the REPEAT WHILE statement is:
REPEAT WHILE condition


where <var class="term">condition</var> can specify one or more conditions. The conditions must be specified on one logical line. A hyphen is used to note the continuation of the set of conditions (with a logical AND implied at each end-of-line) for a logical line. 

====Example 1====

This statement is considered one logical line.
REPEAT WHILE POLICY NO EQ 100340 OR -
(STATE EQ FLORIDA
CITY EQ ORLANDO) OR INCIDENT EQ T3


====Example 2====

This example illustrates the use of the REPEAT WHILE statement: 
 .
.
.
READ IMAGE ACCTPROC
REPEAT WHILE $STATUS = 0
CALL SUB1
READ IMAGE ACCTPROC
END REPEAT
.
.
.


===REPEAT UNTIL statement===

The REPEAT UNTIL statement executes a series of statements until the specified condition is true. The REPEAT UNTIL statement begins executing the body of the loop before evaluating the condition.

====Syntax====

The format of the REPEAT UNTIL statement is:
REPEAT UNTIL condition


where condition can specify one or more conditions. The conditions must be specified on one logical line. A hyphen is used to note the continuation of the set of conditions (with a logical AND implied at each end-of-line) for a logical line. 

====Examples of REPEAT WHILE and REPEAT UNTIL====

Example 1:

The following REPEAT WHILE program results in output of '1':
BEGIN
REPEAT WHILE %I EQ 0
%I = %I + 1
PRINT %I
END


Whereas the following REPEAT UNTIL program results in an endless print loop:
BEGIN
REPEAT UNTIL %I EQ 0
%I = %I + 1
PRINT %I
END


Example 2:
BEGIN
%X IS FLOAT
%TRUE IS BOOLEAN INITIAL(TRUE)
REPEAT UNTIL NOT %TRUE
PRINT 'INSIDE' AND %X AND %TRUE
IF %X = 0 THEN
%TRUE = 'TRUE'
END IF
%X = %X + 1
END REPEAT
PRINT 'OUTSIDE' AND %X AND %TRUE
END
results in:
INSIDE 0 True
OUTSIDE 1 False

But changing REPEAT UNTIL to REPEAT WHILE in the Example 2 code results in:
OUTSIDE 0 True

===REPEAT n TIMES statement===

The <var>REPEAT n TIMES</var> statement executes a series of statements exactly n times. 

====Syntax====

The format of the REPEAT n TIMES statement is:
REPEAT n TIMES


where <var class="term">n</var> (the iteration count) must be either a positive integer literal, for example, 3, 100, 101, or a %variable, for example, %A, %B(%A+1). If the value of <var class="term">n</var> is negative, 0, or a character string when the REPEAT statement is first executed, the statements inside the loop are not executed.

If the value of the %variable is a floating point number, it is converted to an integer before the statement is executed. For example, if REPEAT %I TIMES is specified and the value of %I is 5.9, then the statement is executed five times.

====Example====
 .
.
.
REPEAT 10 TIMES
PRINT '***************'
END REPEAT
.
.
.


You can have a statement within the body of the loop to change the value of a %variable specified as the iteration count. However, such a change has no effect on the number of times the loop is executed because the iteration count is examined only once, prior to the first iteration. 

===REPEAT FOREVER statement===

The REPEAT FOREVER statement executes a series of statements repeatedly until the loop is exited with a STOP, JUMP, or LOOP END statement. 

====Syntax====

The format of the REPEAT FOREVER statement is:
REPEAT [FOREVER]


where the FOREVER keyword is optional. 

====Example====
 .
.
.
REPEAT FOREVER
READ IMAGE ACCTPROC
IF $STATUS = 0 THEN
CALL SUB1
ELSE
LOOP END
END IF
END REPEAT
.
.
.


</div> 

[[Category:SOUL]]

Exceptions

2020-03-23T21:58:53Z

Dme: /* Rethrow */

Exceptions are a technique for handling unusual occurrences in the execution of a method call. This page discusses <var class="product">SOUL</var> exception handling.

==Background==
A wide variety of errors can occur inside a program.
Many of these, such as syntax errors, or invalid variable or member
names, can be caught at compile-time, so they produce compile-time errors.
Other errors can only be caught at run-time, so they produce run-time errors.

For example, a reference to a member of a null object variable will
produce a request cancelling “reference to null object” error.
Generally, such an error is indicative of a logic error in the program
— most likely the program forgot to create an instance of the
object, forgot to assign it to the object variable being used, or is
mistakenly using the wrong object variable.

In any case, since such an error is indicative of a program logic
error, the request cancellation is a benefit: it stops the
program at the earliest point that the error was detected so that
the program does not do damage because of the error.
In addition, if <var class="product">[[SirFact]]</var> is being used, the request cancelling error
will produce a <var class="product">SirFact</var> dump at the time the error was first detected
(or at the very least, indicate the procedure and line number where the error was first detected).
Such early detection of error greatly simplifies problem diagnosis.

Still other errors are actually quite common and might not even be considered errors in most contexts in which they occur.
For example, the <var>Stringlist</var> class <var>[[Locate (Stringlist function)|Locate]]</var> method might not locate any
items that match the search criterion.
Since this is likely not to be a true error, the <var>Locate</var> method simply
returns a 0 in such a case.
The <var>Locate</var> method caller can then check for a zero value and do
processing appropriate to the no-matching-item-found case.

If the <var>Locate</var> method caller assumes that the <var>Locate</var> always finds a
matching item, it is likely to use the zero returned by the <var>Locate</var>
method to reference a matched item, then get a request cancelling
error when item zero is requested.
This illustrates a general principle that methods that can produce
unusual results or, at least, results that are significantly different
from others, should try to set the unusual or result values to something
that is likely to cause a request cancelling error if misused.

For example, a method that returns an object instance might return a
<var>Null</var> object under certain error conditions that are not necessarily indicative
of a programming error.
This allows the calling program to check for a <var>Null</var> and perform
appropriate processing if a <var>Null</var> is returned.
If the program doesn't expect this error case, it might not check for a <var>Null</var>.
If the program is correct, and the error case cannot happen in the
given context, the program behaves correctly with no unnecessary error checking.
If, however, it is incorrect, and a <var>Null</var> can be returned, it is likely
to get a <var>Null</var>-object request-cancelling error when it attempts to
use the <var>Null</var> as an object reference.

This is the best of all worlds — no error checking is required
if the error is known not to occur in a context, but if that knowledge
is incorrect, a request canceling error will quickly stop the program
before any damage is done.

Unfortunately, there are some cases where the return value cannot be
used to indicate an unusual situation:
<ul>
<li>There is no return value.
For example, an error happens inside a subroutine or inside the <var>Set</var>
method of a property.

<li>The return value has no invalid values available to be used to indicate an unusual situation.
For example, if a function returns a string, and a null value is sometimes
a valid output, there might be no reasonable string value that can be used
to indicate the error.

<li>Even if there is a reasonable value (such as a null string, <var>Null</var> object
reference, or zero or negative numeric value), such a value might not provide
enough information about the nature of the error for the calling program to deal with the error.
Obviously, a single string or numeric value, or a <var>Null</var> object reference, cannot
provide a lot of information.
This is especially important if a method might encounter more than one unusual
situation, and the unusual situations are different enough that one might
be expected in a particular context, and the other not; or the unusual situations
require very different corrective action.

For example, a method places an order for a product, and given a product number,
it wants to indicate an error if the product number is invalid.
The number might be invalid because the product number doesn't exist or because the product is out of stock.
Obviously, these are two very different errors, the former possibly being
indicative of a programming error, the latter less likely to be.
</ul>

One solution to such cases is to have an output parameter on the method calls.
Unfortunately, this has several problems:
<ul>
<li>Output parameters can be confusing in code.
There's nothing that marks them as output parameters, so it's not obvious that's
what they are.
Also, someone looking for how a variable used as an output parameter was
or might be set, might only think to look for assignment statements with
the variable on the left side of the assignment.
Certainly, life would be easier if that is all one needed to look for.

<li>Just because a variable is used for the output parameter, there is no
guarantee that the program actually examines the output parameter value.
This could mean that where it is incorrectly believed that a
certain error situation can't occur, the code might not bother to check the variable
used as an output parameter and continue on, oblivious to an error.

<li>Output parameters cannot (currently) be optional.
This means that a variable has to be specified for the output parameter,
even if the unusual situations indicated by the output parameter couldn't
happen in a given context.
This can be annoying, at best, and confusing, at worst.
</ul>

An alternative to output parameters to handle unusual
cases in method calls is called '''exception handling'''.

==Errors unsuitable for exception handling==
Exception handling consists of three parts:
<ol>
<li>The ability to define classes of exceptions and the information available for these classes.
Unsurprisingly, classes of exceptions are defined in almost the same way as other classes.

<li>The ability to indicate an unusual or exception situation.
This is referred to as ''throwing'' an exception.

<li>The ability to detect a thrown exception and to perform special processing
for the exception. This is known as ''catching'' an exception.
</ol>

Exception handling in <var class="product">SOUL</var>
is very similar to many other
object-oriented programming languages, such as Java or VB.Net.
However, each language's implementation of exception handling is unique, each
with subtle or not so subtle differences from others.
<var class="product">SOUL</var> is no exception (no pun intended), and significant departures from the way
other languages support exceptions is indicated where applicable.

A philosophical departure from the support of most other languages for exceptions is worth noting:
while many object-oriented languages make all (or almost all) errors exceptions,
<var class="product">SOUL</var> does not.
This is partially because many object-oriented languages are not, strictly speaking,
application languages — in addition
to writing applications in some other object-oriented languages,
one might write programming environments or even operating systems.
As such, a programming environment or operating system must be able to
intercept all errors and try to deal with them, so the object-oriented languages
facilitate this by making all errors catchable.

<var class="product">SOUL</var> is an application development language.
While it is theoretically possible to build a program environment in <var class="product">SOUL</var>,
or even an operating system, this is not really the focus of <var class="product">SOUL</var>, and it is
not likely anyone would ever do this.
The <var class="product">SOUL</var> programming environment (<var class="product">Model 204</var>, which is not itself written in <var class="product">SOUL</var>)
is responsible both for the ultimate catching of errors and the providing of information about the nature of the errors so that they can be corrected.

The kinds of errors that <var class="product">SOUL</var> does ''not'' turn into exceptions,
and thus are not trappable, fall into two broad categories:

<ol>
<li>Pernicious environmental errors from which it would generally be
almost impossible to recover gracefully on an application level.

For example, if <var>CCATEMP</var> fills up, it is exceedingly unlikely that a
request could recover gracefully.
Since <var>CCATEMP</var> is used for so many different things (including record
sets for finds, stringlists, collections, internal storage of objects
swapped out of a server, transaction backout logs, and so on), it would
be very difficult for an application to anticipate all the places that
<var>CCATEMP</var> could fill.
And even if it could anticipate the places, it would be very difficult to avoid
doing anything that might also require <var>CCATEMP</var>.

Similarly, a <var>PDL</var> (push-down-list) overflow can be detected at almost any
method call, not to mention dozens of internal <var>PDL</var>-intensive routines (such as, say, journal output).
As such, it would be almost impossible for an application to anticipate
all the places where a <var>PDL</var> overflow might be detected.
And even if it could anticipate the places, any method calls to handle the situation
would likely also encounter a <var>PDL</var> overflow.

<li>Errors that are indicative of logic errors in a program.

For example, a class member reference via a <var>Null</var> object variable is usually indicative of a programming error.
Similarly, a reference to an invalid collection item number is also generally
indicative of a programming error.

While there might be error-causing cases of "sloppy" references to
object variables or collection items that you would want to simply catch
when they happen:
<ul>
<li>Most of these are handled well by existing facilities such as <var>[[Classes and Objects#Allow Auto and constructors|Auto New]]</var>
and also <var>[[UseDefault (GenericNamedArraylist property)|UseDefault]]</var> processing for collections.

<li>In the odd cases where such sloppy references are useful, it is trivial
and efficient to check for the sloppy references (<var>Null</var> object variable,
invalid collection item number), so an exception-handling paradigm adds little value.

Of course, there are always border-line cases where an error that is nearly
always indicative of a programming error, might not be in certain
contexts.
Since the initial <var class="product">Sirius Mods</var> support for exceptions was not accompanied by
a complete survey of all error returns by all system methods, it is quite
likely that many request cancelling errors in system methods will gradually
be converted into catchable exceptions over time.
This is also quite likely to be the case for many errors in user-written methods.
</ul>
</ol>

Note that <var class="product">Model 204</var> '''does''' provide <var class="product">SOUL</var> facilities to catch even
these types of untrappable errors.
These facilities include <var>On</var> units, especially <var>On Error</var> units, and <var>APSY</var>
error procedures.
These facilities make it possible for <var class="product">SOUL</var> programs to, at least,
provide nicer notification of an error to a client (web browser, 3270
user, SOAP client) than a broken connection or a <var class="product">Model 204</var> error message.

Even these facilities, however, are limited by severe environmental resource
constraints.
For example, if a <var>CCATEMP</var> or record-locking-table full error drives
an <var>APSY</var> error procedure or an <var>On Error</var> unit, there might be little these
error routines can do without bumping into the very same resource
constraints that caused the problem in the first place.
This problem is not unique to <var class="product">Model 204</var> — severe environmental
constraints can wreak havoc with the best laid error recovery plans in any environment.

==Exception class definitions==
Most error conditions have information associated with them.
This information can be useful for correcting or recovering from the problem.
For example, if an invalid character is detected in a stream of
data, it might be useful to know the character offset in the stream,
the actual invalid character, and some indication of why the character is invalid.
It might also be useful to have a text description of the nature of the error.

The collection of data describing an error situation might be used
immediately after the error is detected, or it might be examined elsewhere.
As such, this error data should be able to persist indefinitely.
Given this requirement, it is clear that the logical place to
hold error information is inside an object.
And the description of the data associated with a particular error
would, of course, be a class.

Classes that describe trappable error situations are called '''exception classes'''.
To a large degree, exception classes are no different from any other class:
<ul>
<li>They can have <var>Public</var>, <var>Private</var>, and <var>Shared</var> blocks; they
can have variables, methods, and the same <var>Allow</var> and <var>Disallow</var> rules
as any other class.
<li>There can be [[List of system exception classes|system exception classes]],
which are provided as part of the <var class="product">Model 204</var> installation, and there can be
exception classes which are defined and maintained by <var class="product">SOUL</var> code.

<li>Exception classes can be used wherever non-exception classes are used,
although the reverse is not true.
That is, there are certain statements that require an exception class or
an object of an exception class.
This is largely to prevent accidental misuse of a non-exception class
in an exception class context.
</ul>

User-defined exception classes are denoted by using the <var>Exception</var>
keyword in the class header:
class tackyColor exception


In many object-oriented languages, a class is indicated as an exception class
by extending some special base class, often called "Exception."
One can think of the Exception keyword on the Class declaration
as indicating that the class extends some hidden base class.
This neither adds nor detracts from an understanding of the basic concept of
an exception class.

If you want, you can put the <var>Exception</var> keyword on almost all class declarations;
specifying it removes no capabilities from the class.
Doing so, however, is misleading, since most classes are likely never to be used
to indicate error situations.
In this regard, you can view the <var>Exception</var> keyword on a class declaration as
documentation that a class can be used as an exception class.
While the compiler ''cannot'' ensure that a class with an <var>Exception</var>
declaration will be used as an exception, it ''does'' ensure that a
class not declared as <var>Exception</var> is not used in exception contexts.

The one case where the <var>Exception</var> keyword is not allowed on class declarations
is in declarations that extend non-exception classes — exception classes
can only extend other exception classes.

Some examples of system exception classes are:
<dl>
<dt><var>[[InvalidHexData class|InvalidHexData]]</var>
<dd>Describes an error in converting hexadecimal data to some other datatype.
<dt><var>[[InvalidRegex class|InvalidRegex]]</var>
<dd>Describes an error processing a regular expression.
<dt><var>[[DaemonLost class|DaemonLost]]</var>
<dd>Describes a situation where the thread doing processing for a <var>Daemon</var> object was lost (logged off).
</dl>

This list is far from exhaustive, but it illustrates that system exception classes
might be associated with a specific system class.
For example, the <var>DaemonLost</var> class is clearly associated with the <var>Daemon</var> class.
On the other hand, an exception class might be associated with a facility that's
used by many different classes.
For example, the <var>InvalidRegex</var> class is not associated with any specific class,
because regular expressions are used in <var>Stringlist</var> and <var>Intrinsic</var> methods.

For links to the descriptions of the individual system exception classes, see the
[[Lists of classes and methods#except|"Lists of classes and methods"]].

==Throwing exceptions==
When an error situation occurs, the code that detects the situation can do
one of two things:
<ul>
<li>It can cancel the request.
In <var class="product">SOUL</var> this is done with an <var>Assert</var> statement.
In system code, this is done by some equivalent of the <var>Assert</var> statement.
This is the correct response to an error if the error is clearly indicative
of a programming error or a severe environmental constraint that is likely
to make request continuation unproductive.

<li>It can ''throw'' an exception.
In <var class="product">SOUL</var> this is done with a <var>Throw</var> statement.
In system code, this is done by some equivalent of the <var>Throw</var> statement.
This is the correct response to an error if the error might occur in the
normal course of processing and the code that called the method might be
able to recover from the error.
'''Note:'''
In the <var class="product">SOUL</var> implementation of exceptions, exceptions can only
be thrown by methods. 
</ul>

In both system and user-written methods, a thrown exception can only be handled
(caught) by the code that called the method.
This is different from many other languages' implementations of exceptions
where exceptions can be handled locally, that is, inside the same method
that threw the exception.
Like many other languages, the exceptions that might be thrown by a method
must be documented in the method header.
This is because a method's exceptions are part of the method's interface to
its callers, as much as any input and output parameters, as much as output values.

===Specifying a Throws clause===
The exceptions thrown by a method are indicated by the <var>Throws</var>
clause in the method declaration and definition header.
For example, if the method <code>Paint</code> might throw a <code>TackyColor</code> and <code>InvalidHexData</code>
exception, it should be declared and defined as:
subroutine paint(%hexColor is string len 6) -
throws tackyColor and invalidHexData


Of course, while the keyword <var>And</var> is used to separate the exceptions
that might be thrown by a method, the method can only ever throw one exception
at a time, and in most cases, it will not throw an exception at all.

The list of exceptions after a <var>Throws</var> keyword is the list of exception class names.
These class names could be user-defined exception class names, or they could be system
exception class names.
If the class is a system class name, it could be fully qualified with the <code>System:</code> namespace indicator.
For instance, the previous example could be written as
subroutine paint(%hexColor is string len 6) -
throws tackyColor and system:invalidHexData


This would only be necessary if there was a user-defined class name with the same
name as the system class name.
Of course, it is best to avoid such a situation as much as possible.

As with most method descriptions, the <var>Throws</var> clause on a method declaration
and definition must match exactly.
That is, the mismatch in the following definition and declaration is invalid:
class house
public
...
subroutine paint(%color is string len 6) -
throws tackyColor and outOfPaint
...
end public
...
**** The following produces a compile error ****
subroutine paint(%color is string len 6) -
throws tackyColor
...
end subroutine
...
end class


It is also invalid if, in the method definition, the list
of thrown exceptions contains the same exceptions as the method
declaration, but in a different order.

Methods that implement an overridable method cannot throw any
exceptions not thrown by the implemented method; however, they do not
necessarily have to throw all the exceptions thrown by the implemented method.
That is, the exceptions in a <var>Throws</var> list on an <var>Implements</var> method
must be a subset of the <var>Throws</var> list on the corresponding
<var>Overridable</var> (or <var>Abstract</var>) method.
For example, if an overridable method in class <code>Products</code> indicates:
subroutine buy(%productCode is string len 8) -
overridable -
throws tooExpensive and outOfStock


then it is valid for an implementing method to indicate:
subroutine buy(%productCode is string len 8) -
implements buy in products -
throws tooExpensive


or even:
subroutine buy(%productCode is string len 8) -
implements buy in products


However, it is '''not''' valid for the implementing method to throw an
exception other than <code>TooExpensive</code> or <code>OutOfStock</code>.
This is because a caller of the base class only expects the <code>Buy</code>
method to throw one of these two exceptions.
It would be surprising, indeed, if the method threw some different
exception, simply because it had been overridden.

===Using the Throw statement===
Once a method declaration indicates the exceptions it might throw,
that method could then throw the exception with the <var>Throw</var> statement.
The <var>Throw</var> statement must be followed by an instance of the exception
class being thrown.
For example, if the method header contains
subroutine paint(%color is string len 6) throws tackyColor


and there is a variable declaration in the method:
%tacky is object tackyColor


The method could do this:
throw %tacky


Of course, the <var>Throw</var> statement is likely to be inside an <var>If</var> clause, since
exceptions are generally thrown in unusual situations, not common ones:
if %color eq %yuckyGreen or -
%color eq %grottyOrange then
throw %tacky
auditText Threw an exception
end if


Note that in the above example, the <var>AuditText</var> statement after the <var>Throw</var>
will '''never''' be executed.
This is because the <var>Throw</var> either returns immediately to the method caller
(if the method caller catches the exception), or it cancels the request immediately.

Another problem with the above example is that <code>%tacky</code> was likely to never have
been set to reference a <code>TackyColor</code> instance.
So, more correct would be something like:
if %color eq %yuckyGreen or -
%color eq %grottyOrange then
%tacky = new
throw %tacky
end if


But, even this is not quite right.
Usually, the exception objects will contain information to aid in problem determination and recovery:
if %color eq %yuckyGreen then
%tacky = new
%tacky:reason = 'Yucky'
%tacky:alternative = '00FF00'
throw %tacky
end if
if %color eq %grottyOrange then
%tacky = new
%tacky:reason = 'Grotty'
%tacky:alternative = 'FFA500'
throw %tacky
end if


This example illustrates the point that it is common for any <var>Throw</var> of a
particular exception class to always return more or less the same information.
As such, exception classes often have [[Notation conventions for methods|constructors]] that can specify all
the information provided by the class.
Then, no variables of the exception class need to be defined; the
result of the constructor call can simply be thrown:
if %color eq %yuckyGreen then
throw %(tackyColor):new('Yucky', '00FF00')
end if
if %color eq %grottyOrange then
throw %(tackyColor):new('Grotty', 'FFA500')
end if


Of course, for code readability, named parameters are preferable on such constructors:
if %color eq %yuckyGreen then
throw %(tackyColor):new(reason='Yucky', alternative='00FF00')
end if
if %color eq %grottyOrange then
throw %(tackyColor):new(reason='Grotty', alternative='FFA500')
end if


An attempt to throw an exception object whose class does not match one
of the classes listed in the method declaration's <var>Throws</var> clause results
in a compilation error.

===Exception classes extending other exception classes===
Exception classes can extend other exception classes.
As such, the class of an object specified in a <var>Throw</var> statement does not
have to match any class in the method's <var>Throws</var> list exactly —
it can be of an extension class of one of the <var>Throws</var> list classes.
Because an extension class can, itself, be extended, and because of
multiple inheritance, this means that a <var>Thrown</var> exception object might
match multiple classes in a method's <var>Throws</var> list.

The thrown (and therefore catchable) class is the first class in the <var>Throws</var>
list that matches the object in the <var>Throw</var>.
That is, the first class in the <var>Throws</var> list that exactly matches the thrown
object's class or that is a base class of the thrown object is used as the thrown class for the method caller.
Because of this, a <var>Throws</var> list must always specify extension classes before
base classes.
Otherwise, the base class in the <var>Throws</var> list would always match any object
that would match an extension class, so the extension class would never be used as the thrown class.

For example, if exception class <code>ReallyNastyColor</code> extended exception class
<code>TackyColor</code>, and method <code>Paint</code> had this header:
subroutine paint(%color is string len 6) throws tackyColor


And if the following statement appeared inside the <code>Paint</code> method;
throw %(reallyNastyColor):new(reason='Awful')


The new <code>ReallyNastyColor</code> exception object would be thrown as a <code>TackyColor</code> object.
That is, the callers of <code>Paint</code> would not be able to assign the thrown
exception to a <code>ReallyNastyColor</code> object without the use of a narrowing assignment.

==Try and Catch==
Without any action on a method caller's part, a thrown exception is,
for all intents and purposes, a request cancelling error.
To prevent the request cancellation, an exception must be "caught."
This is achieved by the use of a '''Try/Catch block'''.

A <var>Try/Catch</var> block consists of two parts.
The first, the <var>Try</var> section, contains one or more <var class="product">SOUL</var> statements that
might result in an exception.
The <var>Try</var> section is then followed by one or more <var>Catch</var> sections, each
one of them handling (catching) a particular class of exception.

The following fragment shows the use of a <var>Try/Catch</var> block to trap
an exception caused by invalid hexadecimal data:
try
%binary = %input:hexToString
catch invalidHexData
%binary = '???'
catch invalidBase64Data
%binary = '???'
end try


This example illustrates a few points:
<ul>
<li>The end of the statements whose exceptions are being caught is indicated
by the first <var>Catch</var> block.
<li>The class of exceptions being caught follows the <var>Catch</var> statement.
<li>A catch block is terminated by another <var>Catch</var> statement or an <var>End Try</var>.
<li>One can catch multiple exception types, each within its own <var>Catch</var> block.
<li>There is no validation that the type of exception being caught might
actually be thrown inside the <var>Try</var> block.

In the preceding example, there would be no chance for an <var>[[InvalidBase64Data class|InvalidBase64Data]]</var>
exception inside the <var>Try</var> block since the <var>[[HexToString (String function)|HexToString]]</var> method will not throw such an exception.
Having a block to catch an exception that's not possible is no different
from having an <var>If/Else</var> <var>If</var> block for an impossible condition — it
simply adds some dead code to a request.
</ul>

===Try block syntax===
Try
tStmt1 ; * Exceptions can
[ tStmt2 ] ; * be caught in
[ ... ] ; * these statements

[ Rethrow rethClassA [And rethClassB ] ... ]

<nowiki>...</nowiki> any number of <var>Rethrow</var> statements

[ Catch catClassC [To %objC] [And catClassD [To %objD]] ...
[ cStmtW ] ; * These are executed if any
[ cStmtX ] ; * of the execptions on the
[ ... ] ; * <var>Catch</var> statement are thrown
]

<nowiki>...</nowiki> any number of <var>Catch</var> blocks

[ Success
[ sStmtY ] ; * These are executed
[ sStmtZ ] ; * if no execptions
[ ... ] ; * are thrown
]

End Try


====Syntax terms====
The <var>Try</var> block is divided into two or more sections, which are separated by
<var>[[#Rethrow|Rethrow]]</var>, <var>Catch</var>, and <var>[[#Success blocks|Success]]</var> statements. Multiple
<var>Rethrow</var> and <var>Catch</var> statements can be mixed
with each other and with the <var>Success</var> statement, in any order.

There must be either one <var>Rethrow</var> or <var>Catch</var> statement in a <var>Try</var> block.

<table>
<tr><th>tStmt1 [tStmt2...]</th>
<td>The first section in the <var>Try</var> block must contain one or more <var class="product">SOUL</var> statements. These statements are executed in turn, and if an exception is thrown within them, execution resumes at the <var>Rethrow</var> or <var>Catch</var> statement specifying that exception; if there are none, the request is cancelled. If no exceptions are thrown, execution resumes with the <var>Success</var> block statements, if any, and then after the <var>End Try</var> statement.</td></tr>

<tr><th nowrap><var>Rethrow</var> rethClassA ...</th>
<td>The <var>Rethrow</var> statement (not block) specifies one or more exception classes; if one of them is thrown, then the method containing the <var>Try</var> block throws that exception. Hence a <var>Rethrow</var> statement can only occur within a method which declares all of the <var class="term">rethClass</var> exceptions in its <var>Throws</var> clause.

Each <var class="term">rethClass</var> may not be the same as, nor an extension of, any exception class preceding it on the statement or on preceding <var>Rethrow</var> and <var>Catch</var> statements in the <var>Try</var> block.</td></tr>

<tr><th><var>Catch</var> catClassC ...</th>
<td>The <var>Catch</var> statement specifies one or more exception classes; if one of them is thrown, then the (optional) <var class="term">cStmt</var> statements in the <var>Catch</var> block are executed in turn, and then execution resumes after the <var>End Try</var> statement.

Each <var class="term">catClass</var> may not be the same as, nor an extension of, any exception class preceding it on the statement or on preceding <var>Rethrow</var> and <var>Catch</var> statements in the <var>Try</var> block.</td></tr>

<tr><th><var>Success</var></th>
<td>If no exceptions are thrown in the <var class="term">tStmt</var> statements, the (optional) <var class="term">sStmt</var> statements in the <var>Success</var> block are executed in turn, and then execution resumes after the <var>End Try</var> statement.</td></tr>
</table>

===Try block considerations===
A <var>Try</var> block can contain more than one statement:
try
%binary = %input:hexToString
%bin = %input64:base64ToString
%key = %inputKey:hexToString
%foo:process(%binary, %bin, %key)
catch invalidHexData
%binary = '???'
catch invalidBase64Data
%bin = '???'
end try


While valid, this example is intended to show that it might not
be a good idea to put a lot of statements inside a <var>Try</var> block:
<ul>
<li>It obscures which statements might be throwing which exceptions,
and this makes the code harder to read.
<li>The more statements you have inside a <var>Try</var> block, the more
likely it is that you will accidentally catch an exception in a
statement in which you were not expecting an exception.

For example, in the above code, the <code>InvalidHexData Catch</code>
block is clearly fixing a problem with invalid hexadecimal data in <code>%input</code>.
But, it will also catch an exception thrown by invalid hexadecimal
data in <code>%inputKey</code>, and in this case, probably it will do the wrong thing.
<li>All the code in the <var>Try</var> block after the method that threw
the exception will not be executed.

While, in some cases, this is what would be intended, there are many
cases where this would not be intended.
In the above example, it is likely that one would want to try to
execute the <var>[[Base64ToString (String function)|Base64ToString]]</var> method on <code>%input64</code> after "correcting"
errors in executing <var>HexToString</var> on <code>%input</code>.
</ul>

As a general rule of thumb, place as few statements inside
a <var>Try</var> block as possible.
To facilitate this, you can follow the <var>Try</var> statement by a <var class="product">SOUL</var>
statement on the same line, as in:
try %binary = %input:hexToString
catch invalidHexData
%binary = '???'
end try


===Referencing a thrown exception object===
As noted in [[#Using the Throw statement|"Using the Throw statement"]], what gets thrown with an exception is
an exception object that contains information about the nature of the exception.
In the <var>Try/Catch</var> examples to this point, the thrown objects were ignored —
only the class of the thrown exception was used.
If you want to reference the thrown exception object, you must specify a
<var>To</var> clause, followed by an object variable of the exception class being caught.

For example, if <code>%daemon</code> is a <var>[[Daemon class|Daemon]]</var> object and <code>%daemonLost</code>
is an object of the <var>[[DaemonLost class|DaemonLost]]</var> exception class, the following block
catches the exception thrown if the daemon thread was logged
off for some reason, and it displays the output of the last command up to the point where it logged off:
try %daemon:run('INCLUDE NASTY')
catch daemonLost to %daemonLost
printText Daemon died! Its last words were:
%daemonLost:daemonOutput:print
end try


Presumably, this block would be useful in diagnosing the problem or even correcting it.

===Rethrow===
====Syntax====
{{template:Rethrow statement syntax}}
====Description====
<var class="product">Sirius Mods</var> 8.1 introduced the <var>Rethrow</var> clause in a <var>Try</var> block. <var>Rethrow</var> lets you propagate an exception without having to assign it to a local variable, probably eliminating the need to declare a local exception class object for the sole purpose of propagating an exception.

The <var>Rethrow</var> clause must occur at the same level as a <var>Catch</var> clause in a <var>Try</var> block. But, unlike the <var>Catch</var> clause, no code is allowed "inside" the <var>Rethrow</var> "block." Because <var>Rethrow</var> causes control to pass immediately out of the current method, no code after <var>Rethrow</var> would ever be executed.

A <var>Rethrow</var> clause can only be followed by an <var>End Try</var>, a <var>Catch</var> clause, or a <var>Success</var> block. Like the <var>Throw</var> statement:
<ul>
<li>The <var>Rethrow</var> clause must be invoked inside a method.
<li>The class or classes specified on a <var>Rethrow</var> clause must be declared as being thrown by that method.
</ul>
====Example====
The following local subroutine illustrates a <var>Rethrow</var> of an <var>InvalidHexdata</var> exception. This subroutine sends a string converted from hex to binary on a socket.
local subroutine (socket):sendHex(%hexdata is longstring) throws invalidHexData
%sendData is longstring

try %sendData = %hexdata:hexToString
rethrow invalidHexdata
end try

%this:send(%sendData)
end subroutine



===Mutiple classes on a Catch or Rethrow statement===
<var class="product">Sirius Mods</var> 8.0 introduced the ability to specify multiple exception classes on a single <var>Catch</var> statement. The class names are separated from each other by the <var>And</var> keyword. However, in <var class="product">Sirius Mods</var> 8.0, no <var>To</var> clause could be specified on a <var>Catch</var> statement with multiple classes.

<var class="product">Sirius Mods</var> 8.1 added support for <var>To</var> clauses on a <var>Catch</var> statement with multiple classes as well as including support for multiple classes on the <var>[[#Rethrow|Rethrow]]</var> statememt.

The following illustrates a <var>Catch</var> statement with multiple classes:
try %foo:doSomethingCrazy
catch invalidHexdata to %ivhexData and tooCrazy and notCrazyEnough to %notCrazyEnough
end try


If the above were inside a method, the exceptions could be rethrown:
try %foo:doSomethingCrazy
rethrow invalidHexdata and tooCrazy and notCrazyEnough
end try


Of course, if a <var>Catch</var> block catches multiple class exceptions, it might be important to determine which exception was actually thrown. In that case, a null test can be performed on the target objects:
try %foo:doSomethingCrazy
catch invalidHexdata to %ivhexData and and tooCrazy and notCrazyEnough to %notCrazyEnough
...
if %ivhexData is not null then
...
elseIf %notCrazyEnough is not null then
...
end if
...
end try


For this to work, one must be sure that the target catch objects are null before the <var>Try</var> block. And, unless there is a lot of common code for the classes in the <var>Catch</var> block, it probably makes more sense to just have a separate <var>Catch</var> block for each exception.

There is no difference between rethrowing exceptions in a single <var>Rethrow</var> statement and multiple <var>Rethrow</var> statements, so it is largely a matter of style as to which approach is used.

===Success blocks===
In cases where a <var>Try</var> block contains multiple statements, a
<var>Success</var> block makes it clear in the code which statement is expected to produce the exceptions that are being caught.
These blocks also protect you from an inadvertent exception thrown in an unexpected context.

For example, consider the following scenario.
You want to try statement <code><a></code> and, if no exceptions get Thrown,
you want to do statements <code><nowiki></nowiki></code>, <code><c></code>, <code><d></code>, and <code><e></code>.
Otherwise, if statement <code><a></code> throws an exception,
you want to do statements <code><x></code>, <code><y></code>, or <code><z></code>, depending on the exception.

You code your <var>Try</var>/<var>Catch</var> block like this:
try
<a>...
...
<c>...
<d>...
<e>...
catch foo
<x>...
catch bar
<y>...
catch another
<z>...
end try


If statement <code><a></code> does indeed throw an exception, statements <code><nowiki></nowiki></code> through <code><e></code> do not run, and the appropriate <var>Catch</var> statement takes effect.
However, if statement <code><a></code> does not throw an exception,
there might be no way to know that statement <code><nowiki></nowiki></code>, <code><c></code>, <code><d></code>, or <code><e></code> might
throw an exception that is one of the exceptions in the subsequent <var>Catch</var> statements.
Or you might be aware of their capacity to do so,
but you might not expect an exception from any of them in this context. Prior to
Version 7.8 of the <var class="product">Sirius Mods</var>, there was
no good way of preventing the catches to also be in effect for these statements
as well as for statement <code><a></code>.

As of <var class="product">Sirius Mods</var> 7.8, a <var>Success</var> block inside the <var>Try</var> block
resolves the problem by making it clear that the <var>Catch</var> statements do '''not''' apply to
statements <code><nowiki></nowiki></code>, <code><c></code>, <code><d></code>, and <code><e></code>:
try
<a>...
success
...
<c>...
<d>...
<e>...
catch foo
<x>...
catch bar
<y>...
catch another
<z>...
end try


The principle benefits of the <var>Success</var> statement are:
<ul>
<li>It makes it clear in the code which statement is expected to produce the exceptions being caught.
<li>It prevents a catch from accidentally catching an exception from a statement that didn't really expect that exception.
</ul>

You can also reverse the order of the the <var>Success</var> and catches:

try
<a>...
catch foo
<x>...
catch bar
<y>...
catch another
<z>...
success
...
<c>...
<d>...
<e>...
end try


===Some differences with other languages===
This section describes some differences between the <var class="product">SOUL</var> implementation
of <var>Try/Catch</var> and implementations in other languages.
Outside of these differences, <var>Try/Catch</var>
support in <var class="product">SOUL</var> is very similar to that in other languages.
<ul>
<li>Unlike Java, it is not necessary to provide a <var>Catch</var> for all exceptions
that a method might throw.
This seems antithetical to the idea that exceptions are unusual conditions
and, in many instances, are known to be impossible.
It seems unnecessary to add code to deal with (or ignore) an error that
cannot occur in a context.

<li>Unlike many other languages, uncaught exceptions are not automatically
propagated to higher level callers.
Partially, this is because the <var class="product">SOUL</var> environment is not written in <var class="product">SOUL</var>, so
there is no need to propagate exceptions to some outer <var class="product">SOUL</var> environment
which, presumably, would clean up the failing request and possibly provide
diagnostics about the error.
Instead, clean-up and diagnostics are provided by the assembler environment.

Automatic propagation of errors is also a grand opportunity for bugs.
Since an automatically propagated error can happen anywhere in a method,
there is no indication that the writer of a method considered the possibility
of the propagated error.
Updates to data-structures, including transactions that update files, might
be half-done at the time of the occurrence of an exception that gets
automatically propagated.

While languages that provide automatic exception propagation usually also
provide a <code>Finally</code> clause to "ensure" that the method
doesn't leave things in a half-done state, there is nothing in a Finally
clause that indicates whether the programmer anticipated the particular
error being propagated.
And the absence of a Finally clause does not prevent error propagation, anyway.

If you want to propagate an exception in <var class="product">SOUL</var>, you can simply catch it
and re-<var>Throw</var> it:
catch tackyColor to %yuck
* let caller deal with this
throw %yuck


This makes it clear which error is being propagated and under what circumstances.

<li>The absence of automatic exception propagation eliminates the utility of a
Finally clause, so no Finally clause is available in <var>Try/Catch</var> blocks in <var class="product">SOUL</var>.

<li><var>Catch</var> statements cannot catch locally thrown exceptions.
That is, a <var>Throw</var> statement always results in immediate exit from the current
method, regardless of whether or not the <var>Throw</var> is inside of a <var>Try</var> block and
whether or not there are <var>Catch</var> statements that correspond to the thrown exception.
The <var class="product">SOUL</var> view of exceptions is that they are part of the interface between
a method and its callers, so they have no place in controlling local program flow.
</ul>

===Nesting Try/Catch blocks===
Like in other languages, <var>Try/Catch</var> blocks can be nested.
That is, a <var>Try/Catch</var> block can be inside the try or catch clause of another
<var>Try/Catch</var> block:
try
%dmn:run('I STEP1')
try
%str = %hex:hexToString
%dmn:run('I STEP2 ' with %str)
catch invalidHexdata
%dmn:run('I STEP2 ???')
end try
catch daemonLost
auditText My daemon's gone!
try %str = %hex:hexToString
catch invalidHexdata
%str = '???'
end try
return %str
end try


The <var>Catch</var> that applies to a particular thrown exception is the first <var>Catch</var>
that either exactly matches the class of the thrown exception, or that is a base
class of the thrown exception.
Because of this, it is possible to catch many different exceptions with a single
<var>Catch</var> if all the exceptions are extensions of a specified base class.
For this reason, too, it is invalid to specify a <var>Catch</var> for an exception class
after a <var>Catch</var> for a base class of that exception class, since the base class
<var>Catch</var> will always catch the exception class exception before the exception
class <var>Catch</var> is processed.
If separate <var>Catch</var> statements are required for base and extension classes, specify the
extension class <var>Catch</var> statements first.

Because there is no single base exception class for all exceptions
(as there is in many other languages), however, it is not possible to
generically catch any and all exceptions with a single <var>Catch</var>.
While this ability might be convenient, it is also likely to encourage sloppy
programming, where generic <var>Catch</var> statements obscure the possible errors in a context,
and make it all too easy to catch unanticipated errors and do the wrong thing.

For <var>Try</var> blocks nested inside of other <var>Try</var> blocks, if no <var>Catch</var> statements that correspond
to a thrown exception are found for the inner-most <var>Try</var> block, then the outer-most
<var>Try</var> block's <var>Catch</var> statements are checked for a match, and they are used if a match is found.
That is, when <var>Try</var> blocks are nested, all <var>Try</var> blocks are in effect for statements
inside the inner-most <var>Try</var> block.
Note, however, that other <var>Catch</var> statements for a <var>Try</var> block are no longer in effect
inside any of the <var>Catch</var> blocks for the <var>Try</var>.
For example, if a request had a <var>Daemon</var> object <code>%dmn</code>, and if <code>%errorhex</code> had invalid hexadecimal data in it in the following block:
try
%dmn:run('NASTY')
%str = %hex:hexToString
catch daemonLost
%str = %errorhex:hexToString
catch invalidHexdata
%str = '???'
end try

The <code>Catch InvalidHexData</code> above would '''not''' catch the conversion error, because the conversion is not
inside the <var>Try</var> block associated with that <var>Catch</var> — it is in a <var>Catch</var> block.

==OnThrow and OnUncaught==
An exception class might want to perform special processing at the time an exception is thrown:
<ul>
<li>It might want to make sure the exception object has valid data.

<li>It might want to record diagnostic information, perhaps to the audit
trail or perhaps to some <var class="product">Model 204</var> file.

<li>It might want to derive some variable values that might not necessarily
have been derivable in the <var>Constructor</var>.
</ul>

To provide this capability, <var class="product">SOUL</var> special-cases two method names in a
user-defined exception class: <var>OnThrow</var> and <var>OnUncaught</var>.
Both of these methods must be <var>Subroutines</var> (as opposed to <var>Functions</var> or
<var>Properties</var>) and cannot have parameters.

The <var>OnUncaught</var> subroutine is automatically called whenever an exception
of the containing class is thrown, and the exception will not be caught.
The <var>OnThrow</var> subroutine is automatically called whenever an exception
of the containing class is thrown, and either the exception will not be
caught and there is no <var>OnUncaught</var> method in the class, or the exception will be caught.

These two method names have no meaning in non-exception classes.

These methods can be called explicitly, and they can be either <var>Private</var>
or <var>Public</var> (though whether they are <var>Public</var> or <var>Private</var> is irrelevant for
implicit calls when an exception is thrown).

The following illustrates an <var>OnThrow</var> subroutine that makes sure the
exception data is valid at the time an exception is thrown:
class pratfall exception
public
variable sound is string len 32
subroutine onThrow
end public
subroutine onThrow
assert %this:sound eq 'splat' or -
%this:sound eq 'boing'
end subroutine
end class


The following illustrates an <var>OnUncaught</var> subroutine that logs information
from the exception to the audit trail before allowing the request to be cancelled:
class pratfall exception
public
variable sound is string len 32
subroutine onUncaught
end public
subroutine OnUncaught
auditText Taking a pratfall -- {%this:sound}
end subroutine
end class


If <var class="product">SirFact</var> is available and capturing dumps for requesting cancelling
errors, all the information one would need is likely to be in the dump,
so there is probably little need to collect extra data in an <var>OnUncaught</var> subroutine.

There is no way for an <var>OnUncaught</var> or <var>OnThrow</var> subroutine to undo the
effect of the exception, that is, to prevent a request cancellation
if the exception is uncaught.
Both routines, however, '''can''' force a request cancellation,
perhaps by using an <var>Assert</var> statement, even if the exception would
have been caught.
If a request cancellation occurs inside on <var>OnThrow</var> subroutine for
an exception that's about to be caught, the catching statements
are not executed, because the request is cancelled before the
<var>OnThrow</var> subroutine returns.

The <var>Throws</var> clause is invalid on an exception class's <var>OnThrow</var> and
<var>OnUncaught</var> subroutines, so these subroutines cannot, themselves,
throw an exception (for, hopefully, obvious reasons).

The <var>Overridable</var> and <var>Implements</var> clauses are also not valid in
an exception class's <var>OnThrow</var> and <var>OnUncaught</var> subroutine declarations.
However, their behavior is similar to overridable routines:
<ul>
<li>If an extension exception class contains an <var>OnUncaught</var> or
<var>OnThrow</var> routine, that routine will be called, when appropriate,
rather than the base class routine.
<li>The extension class routine can call the corresponding
base class routines as it deems fit.

It does this, however, by using the subroutine name (qualified
with the class name) rather than with the superclass method (since
no overriding is involved):
subroutine onThrow
auditText Calling base class OnThrow
%this:(fooError)onThrow
auditText returned from base class OnThrow
end subroutine


In this example, the extension exception class's base class is called <code>FooError</code>.
Of course, an <var>OnUncaught</var> in an extension class can also call an
<var>OnThrow</var> for a base class (or even for its own class).
</ul>

If an <var>OnUncaught</var> subroutine exists in a base class, but the extension
class contains only an <var>OnThrow</var> subroutine, the base class <var>OnUncaught</var>
routine will be called if an extension class object is thrown as an
exception and the exception will not be caught.
That is, an <var>OnUncaught</var> subroutine will always be called for uncaught
exceptions if one is available in the exception's class or any base
class, regardless of whether there are any <var>OnThrow</var> subroutines in the
exception class or any of its base classes.

[[Category:SOUL object-oriented programming topics]]

Statement syntax

2020-03-23T21:44:43Z

Dme: /* RESET */

This page summarizes SOUL syntax and conventions, which are discussed in more detail throughout this wiki. The SOUL statements are listed in alphabetical order. Many of the section titles or syntax blocks contain links to the wiki page describing the statement or syntax phrase. A [[#Other syntax|later section]] provides other SOUL syntax information, including links to [[#tokens|information about the "tokens"]] of SOUL, such as names in SOUL.

All SOUL statements can be used between a <var>[[BEGIN command|Begin]]</var> (or <var>[[MORE command|More]]</var>) command and an <var>[[End statement|End]]</var> statement. 
External Call Facility (ECF) statements are listed under <var>[[#External|External]]</var>.

Various other [[List of Model 204 commands|Model 204 commands]] also have effects on the results of a SOUL request. 

The following notations prefix some of the statements in the presentation of the SOUL syntax: 
<nowiki>*
**
+
++
C
</nowiki>

See the [[#Notation conventions|notation conventions]] section for an explanation of these usages, as well as other general comments about understanding the syntax of SOUL.

  
<div id="User Language statements"></div> 
<div id="SOUL statements"></div> <div id="SOUL syntax"></div>



===[[Add statement|Add]]===
<table class="noBorder">
<tr>
<td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]]</td>
<td>{{Template:Add fieldname statement syntax}}</td></tr>
</table>

<table class="noBorder">
<tr><td style="padding:0em">{{Template:Add lob-fieldname statement syntax}} </td></tr>
</table>

===[[Array statement|Array]]===

Array [arrayname] Occurs {n | Unknown}
Depending On {itemname | %variable}
[After {itemname | arrayname}
| At {position | itemname | imagename1 | arrayname}]


===[[Assert statement|Assert]]===

{{Template:Assert statement syntax}}

===[[Report generation#Audit statement|Audit]]===

Audit [[#Print specification syntax|print-specifications]]


===[[Audit All Fieldgroup Information statement|Audit All Fieldgroup Information]] (AAFGI)===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:AAFGI statement syntax}} </td></tr>
</table>

===[[Report generation#Audit All Information statement|Audit All Information]]===

<table class="noBorder">
<tr><td>{{Template:Audit All Information statement syntax}} </td></tr>
</table>

===Backout===
<table class="noBorder">
<tr><td/>
<td>[[Backout statement|Backout]] </td></tr>
</table>

===BYPASS===

BYPASS [PENDING STATEMENT] 

===CALL===

CALL {label | subname
[([expression | %variable | [LIST] listname] [,...])]}


===[[Data maintenance#Change statement|Change]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:Change fieldname statement syntax (basic)}} </td></tr>
</table>

<table class="noBorder">
<tr>
<td style="padding:0em">{{Template:Change lob-fieldname statement syntax}} </td></tr>
</table>

===[[Global_features#Using_the_CLEAR_statement|CLEAR]]===

{{Template:Clear statement syntax}}

===CLEAR LIST===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>[[Lists#Clearing a list|CLEAR LIST]] listname </td></tr>
</table>

===CLEAR ON===

{{Template:Clear On statement syntax}}

===CLEAR TAG===

CLEAR TAG {screenname | %screenname:inputname}


===[[Close statement (external I/O)|Close]]===

<table class="noBorder">
<tr><td>{{Template:Close statement (external I/O) syntax}} </td></tr>
</table>

===CLOSE PROCESS===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+C)]] </td>
<td>CLOSE PROCESS {cid | processname | %variable} [SYNCLEVEL | FLUSH | %variable] </td></tr>
</table>

CLOSE PROCESS
{cid | processname | %variable}
[SYNCLEVEL | CONFIRM | FLUSH | ERROR | %variable]


===[[Commit statement|Commit]]===

{{Template:Commit statement syntax}}

===[[Horizon SOUL interface#Confirm statement|Confirm]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Confirm statement syntax}} </td></tr>
</table>

===[[Horizon SOUL interface#Confirmed statement|Confirmed]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Confirmed statement syntax}} </td></tr>
</table>

===CONTINUE===

CONTINUE

===COUNT OCCURRENCES OF===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>COUNT OCCURRENCES OF fieldname</td></tr>
</table>

===COUNT RECORDS===

COUNT RECORDS {IN label | ON [LIST] listname}

===[[Declare statement|Declare]]===

[[[Using variables and values in computation#Declaring|Declare]]] declaration



where <var class="term">declaration</var> is one of the following: 

<div style="margin-left: 20px; background-color: #fBfBfB;">
<ul style="font-family: Consolas,monospace; display:table;">
<li>Label labelname [Global | Common]
</li>

<li>[[Lists#DECLARE LIST syntax|List]] listname [In [File | [Perm | Temp] Group]] name] At location [Global | Common]
</li>

<li><var>Image</var> block:
{{Template:Image statement syntax}} </li>

<li>{{Template:Menu statement syntax}} </li>

<li>{{Template:Screen statement syntax}} </li>

<li>%variable [Is] {Fixed [Dp n] | Float} [Array (d1 [,d2 [,d3]])] 
[[[Initial clause in %variable declaration|Initial]](numeric-expression)] [Static] [Common]
</li>

<li>%variable [Is] String [Len n] [Dp {n | *}] [Array (d1 [,d2[,d3]])] 
[No Field Save] [Common] 
[[[Initial clause in %variable declaration|Initial]]('EBCDIC-string' | expression)] [Static]
</li>

<li>[[Subroutines#DECLARE SUBROUTINE statement|Subroutine]] subname [(type [Input | Output | Input Output] [,...])]

where <var class="term">type</var> is one of the following: 
<ul>
<li>Scalar %variable of the following format:
{String [Len] n [DP {n | *}] | [Fixed [Dp n] | Float]} 
</li>

<li>Array %variable of the following format:
{String [Len n] [Dp [n | *}] [Array (* [,*[,*]]) [No Field Save]] 
| [Fixed [Dp n] | Float] [Array (* [,*[,*]])]} 
</li>

<li>A list of records of the following format:
[List] [In {File | [Perm | Temp] Group} name] 
</li></ul>
</ul>

</div> 

===DEFAULT CURSOR===

DEFAULT CURSOR [READ | REREAD | PRINT]
{ITEMID n | itemname | ROW n COLUMN m}


===DEFAULT===

DEFAULT {TITLE
| PROMPT
| INPUT [DEBLANK | NODEBLANK] [PAD WITH 'c'] [LEN m [DP [k | *}]] [UPCASE | NOCASE]
| [TAG [attributes] [WITH 'c']}
[[READ] attributes] [REREAD attributes] [PRINT attributes]

DEFAULT SKIP n POSITIONS[S]
[INITIAL {NULL | character | BLANK}]

DEFAULT [TYPE]
{STRING | BINARY | PACKED | ZONED | FLOAT | EFORMAT}
{LEN {n | UNKNOWN} | BITS n | DIGITS n}
[DP {k | *}] [BP n]
[SIGNED | UNSIGNED] [PAD {BLANK | character | NULL}]
[STRIP | NOSTRIP] [JUSTIFY {LEFT | RIGHT}]
[INITIAL {BLANK | ZERO | NULL | literal}]


===DELETE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Data maintenance#DELETE statement|DELETE]] fieldname [([[Processing_multiply_occurring_fields_and_field_groups#DELETE_statement_rules|subscript]])] [= value | (expression)]
</td></tr>
</table>

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Data maintenance#Deleting a field group|DELETE FIELDGROUP]] [fieldgroupname] [([[Processing_multiply_occurring_fields_and_field_groups#DELETE_statement_rules|subscript]])] [= value | (expression)]
</td></tr>
</table>

===DELETE EACH===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>DELETE EACH fieldname </td></tr>
</table>

===[[Data maintenance#DELETE RECORD statement|DELETE RECORD]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>DELETE RECORD </td></tr>
</table>

===DELETE RECORDS===

DELETE [ALL] RECORDS {IN label | ON [LIST] listname}


===END BLOCK===

END BLOCK label 

===End===

END {FIND | IF | FOR | ON | REPEAT | STORE | SUBROUTINE} [label]

END {ARRAY | IMAGE | MENU | SCREEN}

[[End statement|End]] [MORE | NORUN | USE]...

===END UPDATE===

END UPDATE

===[[External statement|External]]===

{{Template:External statement syntax}}

===FILE RECORDS===

FILE RECORDS {IN label | ON [LIST] listname}
UNDER fieldname = {value | (expression)}


===[[Find Records statement|Find Records]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{FIND [[ALL] RECORDS] | FD } [IN label | ON [LIST] listname] [FOR WHICH | WITH] [[#Retrieval condition syntax|retrieval-conditions]]</td></tr>
</table>

===[[Find And Reserve statement|Find And Reserve]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{FIND AND RESERVE [[ALL] RECORDS] | FDR} [IN label | ON [LIST] listname] [FOR WHICH | WITH] [[#Retrieval condition syntax|retrieval-conditions]] </td></tr>
</table>

===[[Value loops#Find All Values statement|Find Values Of (FDV)]]===
<table class="noBorder">
<tr>
<td style="padding:0em">{{Template: Find Values Of statement syntax}} </td></tr>
</table>

===FIND AND PRINT COUNT===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{Find And Print Count | FPC} [[[#Retrieval condition syntax|retrieval-conditions]]]
</td></tr>
</table>

===[[Find Records statement|Find Without Locks]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{Find Without Locks [[ALL] Records] | FDWOL} [In label | On [LIST] listname]
[For Which | With] [[#Retrieval condition syntax|retrieval-conditions]]</td></tr>
</table>

===FLUSH PROCESS===

FLUSH PROCESS {cid | processname | %variable}

===FOR EACH OCCURRENCE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>FOR {EACH | k} {OCCURRENCE | OCCURRENCES} OF fieldname </td></tr>
</table>

===[[Record loops#For Each Record statement|For Each Record]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>{{Template:For Each Record statement syntax}}</td></tr>
</table>
Note: For <var class="term">retrieval-conditions</var>, see [[#Retrieval condition syntax|Retrieval condition syntax]], below. 

===FOR EACH VALUE OF===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>FOR {EACH | k} {VALUE | VALUES} OF fieldname [FROM {value1 | (expression1)}] [TO {value2 | (expression2)}] [[NOT] LIKE pattern] [IN [ASCENDING | DESCENDING] [CHARACTER | NUMERICAL] [RIGHT-ADJUSTED] ORDER]
</td></tr>
</table>

===FOR EACH VALUE IN===

FOR {EACH | k} {VALUE | VALUES} IN label 

===FOR RECORD NUMBER===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>FOR RECORD NUMBER {value | (expression)}
</td></tr>
</table>

===FOR RECORD NUMBER IN===

FOR RECORD NUMBER {value | IN label} [OPTIMIZING FNV]


===[[For %i statement|For %var From %exp1 To %exp2 By %exp3]]===
<table class="noBorder">
<tr>
<td style="padding:0em">{{Template:For %i statement syntax}} </td></tr>
</table>

Note: The <var>By</var> clause, when omitted, defaults to a value of 1. 

===[[Images#Identify statement|Identify]]===

<table class="noBorder" display="table-column">
<tr><td>{{Template:Identify statement syntax}} </td></tr>
</table>

===[[If statement|If]]...Then...ElseIf...Else===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>If expression Then [statement] [statement] ... [ ElseIf expression Then [statement] [statement] ... ] ... [ Else [statement] [statement] ... ] End If
</td></tr>
</table>

===[[Image statement or block|Image]]===
<var>Image</var> block:
<table class="noBorder">
<tr><td style="padding:0em">{{Template:Image statement syntax}}</td></tr>
</table>

===INCLUDE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*, C)]] </td>
<td>INCLUDE procedurename </td></tr>
</table>

===INPUT===

INPUT inputname [AT [COLUMN] n]
[TO [COLUMN] m | [LEN m] DP {k | *}]]
[UPCASE | NOCASE] [DEFAULT 'value']
[DEBLANK | NODEBLANK] [PAD WITH 'c']
[REQUIRED | ALPHA | ALPHANUM | MUSTFILL
| ONEOF literal [, literal]...
| [NUMERIC] [RANGE lo [TO] hi [AND lo [TO] hi] ...]
| VERIFY 'characters']...
[[READ] attributes] [REREAD attributes] [PRINT attributes]
[TAG [attributes] [WITH 'c']] [ITEMID n]


===INSERT===

INSERT fieldname [(subscript)] = {value | (expression)}


===[[Horizon SOUL interface#Invite statement|Invite]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Invite statement syntax}} </td></tr>
</table>

===IS===

itemname IS [TYPE]
{STRING | BINARY | PACKED | ZONED | FLOAT | EFORMAT}
{LEN {n | UNKNOWN} | BITS n | DIGITS n
| TO position}
[DP {k | *}] [BP n] [SIGNED | UNSIGNED]
[PAD {BLANK | character | NULL}] [STRIP | NOSTRIP]
[ALIGN]
[JUSTIFY {LEFT | RIGHT}]
[INITIAL {BLANK | ZERO | NULL | value}]
[AFTER {itemname | arrayname}
| AT {position | itemname | imagename1 | arrayname}]
[OCCURS {n [DEPENDING ON {itemname | %variable}]
| UNKNOWN}]


===JUMP TO===

JUMP TO label

JUMP TO (label1 [, label2] ...) expression

===[[Flow of control in User Language#LOOP END statement|Loop End]]===

Loop End 

===[[Loop Next statement|Loop Next]]===

Loop Next

===MAX PFKEY===
MAX PFKEY n 

===[[Menu statement or block|Menu]]===
<table class="noBorder">
<tr>
<td>{{Template: Menu statement syntax}} </td></tr>
</table>

===MODIFY===

MODIFY {%menuname:itemname | %screenname:itemname}
[TO] attributes [[FOR] {ALL | READ | REREAD | TAB
| PRINT}]


===MODIFY BUFFER===

MODIFY BUFFER [SIZE=n
| %variable [PRESERVE | NOPRESERVE]]
[FILL [X'nn'] | CLEAR]


===NEW PAGE===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>NEW PAGE </td></tr>
</table>

===[[Note statement|Note]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>Note {fieldname [(subscript)]} </td></tr>
</table>
Note 'string'


===[[On statement|On]]===

[[On statement|On]] {Attention | Error | Field Constraint Conflict
| Find Conflict | Missing File | Missing Member
| Record Locking Conflict}
statements
End On [label]


===Open===

{{Template:Open (External I/O) statement syntax}}

 
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>{{Template:Open and OpenC statements syntax}} </td></tr>
</table>

===OPEN PROCESS===

OPEN PROCESS {processname | %variable}
[CID {name | %variable}] 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>OPEN PROCESS {processname | %variable} [CID {name | %variable}] {outbound-options | inbound-options}
</td></tr>
</table>

<div style="margin-left: 30px; background-color: #fBfBfB;">

where <var class="term">outbound-options</var> are:
<ul style="font-family: Consolas,monospace">
<li>[AT DESTINATION] [WITH] [USERID {%variable | 'string'}]

<li>[PASSWORD {%variable | 'string'}]

<li>[{ACCOUNT | PROFILE {%%variable | 'string'}]

<li>[INITIAL {DATA 'string' | DATA %variable | IMAGE imagename] ...]
</ul>

and <var class="term">inbound-options</var> are:

<ul style="font-family: Consolas,monospace">
<li>ACCEPT [INITIAL {DATA %variable | IMAGE image} ...] </li>
</ul>

</div> 

===[[Pause statement|Pause]]===

{{Template:Pause statement syntax}}

===PLACE RECORD ON===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Lists#PLACE RECORD and REMOVE RECORD statements|PLACE RECORD ON]] [LIST] listname
</td></tr>
</table>

===PLACE RECORDS===

PLACE RECORDS {IN label | ON [LIST] listname1} ON [LIST] listname2


===Position===

POSITION {FOUNDSET foundsortset_name | LIST list_name} [AT] position_name

Note: Use the above form of the <var>Position</var> statement with <var>For</var> loop processing; see [[Global features#Position statement|Position statement]].

POSITION {ext-filename | %variable}
AT KEY operator{value | %variable}

Note: Use the above form of the <var>Position</var> statement with external file processing using images; see [[Images#Position statement|Position statement]].

===[[Full-screen feature|PREPARE]]===

PREPARE
{[[[Images#PrepareStmtImage|IMAGE]]] imagename | [[[Full-screen feature#PrepareStmtMenu|MENU]]] menuname
| [[[Full-screen feature#PrepareStmtScrn|SCREEN]]] screenname}


===Print===

Print [[#Print specification syntax|printSpecifications]] 

===Print All Fieldgroup Information (PAFGI)===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:PAFGI statement syntax}} </td></tr>
</table>

===[[Print All Information statement|Print All Information]] or [[PAI statement|PAI]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:PAI statement syntax}} </td></tr>
</table>

===PRINT MENU===

PRINT [MENU] menuname [ALERT]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===PRINT SCREEN===

PRINT SCREEN screenname [ALERT] [[WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===[[Horizon SOUL interface#Query Process statement|Query Process]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Query Process statement syntax}} </td></tr>
</table>

===[[Read Image statement|Read Image]]===

{{Template:Read Image statement syntax}}

===READ menuname===

READ [MENU] menuname [ALERT]
[TITLE ['text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===READ screenname===

READ [SCREEN] screenname [ALERT] [NO REREAD] [ [WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===RECEIVE IMAGE===

RECEIVE {IMAGE imagename | %variable}
FROM {cid | processname | %variable} [RESULT %variable] 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>RECEIVE {IMAGE imagename | %variable} FROM {cid | processname | %variable} RESULT %variable
</td></tr>
</table>

===[[Release All Records statement|Release All Records]]===

{{Template:Release All Records statement syntax}}

===[[Release Position statement|Release Position]]===

<table class="noBorder">
<tr><td>{{Template:Release Position statement syntax}} </td></tr>
</table>

===[[Release Records statement|Release Records]]===

{{Template:Release Records statement syntax}}

===[[Remember statement|Remember]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>{{Template:Remember statement syntax}}</td></tr>
</table>

===REMOVE RECORD FROM===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(**)]] </td>
<td>[[Lists#PLACE RECORD and REMOVE RECORD statements|REMOVE RECORD FROM]] [LIST] listname
</td></tr>
</table>

===REMOVE RECORDS===

REMOVE RECORDS {IN label | ON [LIST] listname}
FROM [LIST] listname2


===REPEAT===

REPEAT [FOREVER | n TIMES | WHILE expression]


===REREAD===

REREAD [SCREEN] screenname [ALERT] [[WITH] CURSOR]
[TITLE {'text' | %variable} [AT [COLUMN] n]
[TO [COLUMN] m | LEN m] [attributes]]


===RESET===

RESET {HEADER | TRAILER} m


===[[Exceptions#Rethrow statement|Rethrow]]===

{{Template:Rethrow statement syntax}}

===RETRY===

RETRY [PENDING STATEMENT]


===RETURN===

RETURN


===[[Screen statement or block|Screen]]===

{{Template:Screen statement syntax}}

===SEND===

SEND {IMAGE imagename | 'string' | %variable}
TO {cid | processname | %variable}
[REQSEND %variable]
[FLUSH]

(+)SEND {IMAGE imagename | 'string' | %variable}
TO {cid | processname | %variable}
[FLUSH | CONFIRM]
[REQSEND %variable]


===[[Horizon SOUL interface#Send Error statement|Send Error]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Send Error statement syntax}} </td></tr>
</table>

===SET===

SET {HEADER | TRAILER} m [[#Print specification syntax|print-specifications]]


===[[SetText statement|SetText]]===

{{Template:SetText statement syntax}}

===SIGNAL PROCESS===

SIGNAL PROCESS
{cid | [processname | %variable} {nnn | %variable} 

<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>SIGNAL PROCESS {cid | [processname | %variable}
</td></tr>
</table>

===[[Sirius Case statement|Sirius Case]] directive===

<table class="noBorder">
<tr><td style="font-family:monoface; padding:0px">[[Statement syntax#Notation conventions|(C)]] </td>
<td>{{Template:Sirius Case statement syntax}} </td></tr>
</table>

===SKIP LINES===

SKIP n LINE[S]


===[[Skip Position statement|Skip Position]]===

<table class="noBorder">
<tr><td>{{Template:Skip Position statement syntax}} </td></tr>
</table>

===SORT RECORDS===

SORT [k] RECORDS {IN label | ON [LIST] listname}
BY key [AND key] ...


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">key</var> is:
<ul style="font-family: Consolas,monospace">
<li>key = fieldname 
[VALUE {[ASCENDING | DESCENDING] 
[CHARACTER | NUMERICAL] | RIGHT-ADJUSTED]} ...] </li>
</ul>

</div> 

===SORT RECORD KEYS===

SORT [k] RECORD KEYS
{IN label | ON [LIST] listname}
BY key [AND key] ...


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">key</var> is:
<ul style="font-family: Consolas,monospace">
<li>key = fieldname 
[VALUE {[ASCENDING | DESCENDING] 
[CHARACTER | NUMERICAL] | [RIGHT-ADJUSTED]} ...] </li>
</ul>

</div>

===SORT VALUE IN===

SORT VALUE IN label [IN [ASCENDING | DESCENDING]
[CHARACTER | NUMERICAL] | [RIGHT-ADJUSTED] ORDER]


===STOP===

<table class="noBorder">
<tr>
<td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(C)]]</td>
<td>STOP [IF COUNT IN label EXCEEDS n]
</td></tr>
</table>

===STORE RECORD===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(*)]] </td>
<td>STORE RECORD [sort or hash key value] fieldname1=[value1 | (expression1)] [fieldname2=(expression)] ... [THEN CONTINUE statement statement ...] END STORE
</td></tr>
</table>

===SUBROUTINE===

SUBROUTINE

SUBROUTINE subname
[(formal-parameter [INPUT | OUTPUT | INPUT OUTPUT] [,...])]


<div style="margin-left: 20px; background-color: #fBfBfB;">

where <var class="term">formal-parameter</var> is one of the following:
<ul style="font-family: Consolas,monospace">
<li>%variable [IS STRING [LEN n] [DP {n | *}] [ARRAY (*[,*[,*]]) [NO FS]] 
| IS {FIXED [DP n] | FLOAT} [ARRAY (*[,*[,*]])]]

<li>LIST listname [IN [FILE | [PERM | TEMP] GROUP] name]
</ul>
</div>

===TAG===

TAG %screenname:inputname [attributes] [WITH 'c']


===[[Horizon SOUL interface#Test Receipt statement|Test Receipt]]===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>{{Template:Test Receipt statement syntax}} </td></tr>
</table>

===TITLE===

TITLE {'text' | promptname}
[AT [COLUMN] n] [TO [COLUMN] m | [LEN m]
[DP {k | *}]]
[DEFAULT 'value']
[[READ] attributes] [REREAD attributes] [PRINT attributes]


===[[Trace statement|Trace]]===

{{Template:Trace statement syntax}}

Note: The output of the <var>Trace</var> statement is controlled by the <var>[[ULTRACE parameter|ULTRACE]]</var> parameter.

===[[Program Communication facilities#TRANSFER statement format and execution|TRANSFER]]===

TRANSFER [CONTROL] TO PROCESS {processname | %variable}
[WITH] [USERID {string | '%variable'}]
[PASSWORD {variable | 'string'}]
[ACCOUNT {%variable | 'string'}]
[PASSING {IMAGE imagename | 'string' | %variable}]


===UPDATE RECORD===

UPDATE RECORD

===VARIABLES ARE===

VARIABLES ARE
{FIXED [DP n] | FLOAT
| STRING [LEN n] [DP {n | *}]
| UNDEFINED}


===Declare %variable===

[DECLARE] %variable [IS]
{FIXED [DP n] | FLOAT} [ARRAY (d1[,d2[,d3]])]
[COMMON]

[DECLARE] %variable [IS]
STRING [LEN n] [DP {n | *}] [ARRAY (d1[,d2[d3]])]
[NO FIELD SAVE] [COMMON]
%variable [(subscript)] = expression


===WAIT===
<table class="noBorder">
<tr><td style="font-family:monoface; padding-right:0px">[[Statement syntax#Notation conventions|(+)]] </td>
<td>WAIT [{n | %variable} SEC[S]] [FOR] {ANY RECEIPT RETURN %variable | RECEIPT {cid | processname | %variable}}
</td></tr>
</table>

===[[Write Image statement|Write Image]]===

<table class="noBorder">
<tr><td>{{Template:Write Image statement syntax}} </td></tr>
</table>

==Other syntax==

===Names, numbers, literals, comments===

<ul>
<li>Names (for example, %variables, labels): see [[Model 204 naming conventions]]
<li>Other constructs: see [[Basic request structure]] (which also discusses some rules for statement labels)
</ul>

===Value specification syntax===

For all User Language statements and retrieval conditions, wherever the term <var class="term">value</var> appears in the syntax, it can be any of these:
<ul>
<li>Literal number or string </li>
<li><var>VALUE IN</var> clause of the form:
VALUE [IN] label

</li>
<li>%variable</li>
</ul>

===Retrieval condition syntax===

A <var>Find</var> or <var>For Each Record Where</var> statement can be followed by any number of retrieval conditions separated by an end of line or [[LINEND parameter]] character.

Conditions can be constructed as a series of phrases that are combined "in the usual way" with <var>And</var>, <var>Or</var>, <var>Not</var>, and parentheses (()):

[Not] phrase [{And | Or | Nor} [Not] phrase] ...


Where: 

<var class="term">phrase</var> can be constructed from these options: 
<ul style="font-family: Consolas,monospace">
<li><var class="term">fieldname</var> = [Not] value </li>

<li><var class="term">fieldname</var> Like pattern </li>

<li><var class="term">fieldname</var> Is [Not] {Present | Like 'pattern'} </li>

<li><var class="term">fieldname</var> Is [Not] {[Numerically | Alphabetically] 
[Eq | = | Ne | ¬= | Greater Than | Gt | > | Less Than | Lt | < | Le | <= | Ge | >= | Before | After] value} </li>

<li><var class="term">fieldname</var> Is [Not] {[Numerically | Alphabetically] 
{In Range [From | After] value1 {To | [And] Before} 
value2 | Between value1 And value2} </li>

<li>[[Record retrievals#FILE$ condition|File$]] {filename | =} </li>

<li>Find$ <var class="term">label</var> </li>

<li>[[Lists#Using the LIST$ condition|List$]] listname </li>

<li>[[Record retrievals#LOCATION$ condition|Location$]] {location | =} </li>

<li>[[#Point$|Point$]] <var class="term">value</var> </li>

<li>[[#Sfl$ and Sfge$|Sfge$]] <var class="term">value</var> </li>

<li>[[#Sfl$ and Sfge$|Sfl$]] <var class="term">value</var> </li>
</ul>

where <var class="term">value</var> can be: 
<ul>
<li>A literal number or string</li>

<li>A %variable </li>

<li><var>Value</var> {([[#Use of expressions|expression]]) | [<var>In</var>] label}

<var class="term">label</var> points to an existing value set. If an <var>Eq Value In value_set</var> clause, value set values are treated as Boolean OR, for example:

field = value1 OR field = value2 OR.... 

If an <var>Ne Value In value_set</var> clause, values are treated as Boolean AND: 
field <> value1 AND field <> value2 AND.... 

See also [[Basic SOUL statements and commands#Processing a VALUE IN clause|Processing a VALUE IN clause]].</li>
</ul>

Notes:
<ul>
<li>The first character (<code>¬</code>) of the "not-equal" test (<code>¬=</code>) in the fourth of the items in the list of <var class="term">phrase</var> options above is the EBCDIC "not sign," which has the hexadecimal value <code>5f</code>. </li>

<li>For a description of the pattern in the <var>[Is] Like</var> and <var>Is Not</var> clauses, see the syntax of [[Is Like pattern matching#likeSyntax|Is Like patterns]]. </li>

<li>In addition to the discussions in the subsections that follow, see [[Record retrievals]] for a comprehensive description of retrieval conditions. </li>
</ul>

====Omitting repeated first words====

If a sequence of phrases in a particular retrieval condition all have the same first word, that word can be omitted from the latter phrases. For example:
List$ A And Not List$ B


can be written:
List$ A And Not B


And:
x Is 13 Or x Is Less Than 7


can be written:
x Is 13 Or Is Less Than 7


====Omitting duplicated equal signs====

Duplicated equal signs can be omitted. For example, the expression:
a = 3 Or a = 5 Or a = 40


is equivalent to:
a = 3 Or 5 Or 40


====Use of parentheses====

Parentheses can be placed around any sequence of phrases to clarify the condition or force the evaluation to occur in a particular order. For example:
Not (a = 2 Or List$ y)
a = 1 And (b = 2 OR c = 3)


====Use of expressions====

[[Using variables and values in computation#Expressions|Expressions]] can be used in <var>Find</var> and <var>For Each Record</var> statements to provide the retrieval condition for the <var>Point$</var>, <var>Sfl$</var>, and <var>Sfge$</var> conditions, as well as for the <var>Eq Value</var> clause: 

=====Point$=====
Point$ Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. It is preceded by the keyword <var>Value</var>. 

Example: 

This example finds the first <code>MA</code> record on file, and then counts the number of records from this point in the file:
FD1:

IN ICSCUST FPC STATE = MA
END FIND
FOR 1 RECORD IN FD1
PRINT 'CURREC = ' WITH $CURREC
PRINT '>= POINT$'
FD2:
IN ICSCUST FPC POINT$ VALUE($CURREC)
END FIND
END FOR


=====Sfl$ and Sfge$=====
Sfl$ Value(expression)


Or:
Sfge$ Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. It is preceded by the keyword <var>Value</var>. 

Example:

FOR %CT FROM 1 TO 10
IN EXPRESS STORE RECORD ($EDITN(%CT,'999'))
ORD1 = (%REC WITH %CT)
ORD2 = (%CT * 2)
ORD4 = (%CT * 4)
END STORE
END FOR
COMMIT
FOR %CT FROM 1 TO 5
PRINT 'LESS THAN ' WITH %CT
FD1:
IN EXPRESS FPC SFL$ VALUE($EDITN(%CT,'999'))
END FIND
PRINT 'GREATER THAN OR EQUAL TO ' WITH %CT
FD2:
IN EXPRESS FPC SFGE$ VALUE($EDITN(%CT,'999'))
END FIND
END FOR


=====Eq Value=====
fieldname Eq Value(expression)

Where:

<var class="term">expression</var> is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. 

Example:

FD: IN FILE PEOPLE FD
LAST EQ VALUE($READ('LAST NAME?') )
END FIND


===Print specification syntax===

A <var>Print</var>, <var>Set</var>, <var>Audit</var>, or <var>Trace</var> statement contains print specifications of the following form:

[term] [And | Tab | With]...[[term] [And | Tab | With] ...] ... [...]

Where:

<var class="term">term</var> can be constructed as follows:
{'string' | %variable | Count In label | Occurrence In label | Value in term | function}
[At [Column] m] [To [Column] n] 

Or, if the statement is within a record loop:

{{Each | term} fieldname | *Record | *Id}
[At [Column] m] [To [Column] n}


Note: For additional <var>Print</var> statement details regarding multiply occurring fields and field groups, see [[Processing multiply occurring fields and field groups#PRINT and PRINT n statements|Print and Print n]] statements for fields. 

===Expression syntax===

The following syntax can be used in: 
<ul>
<li>Assignment statements </li>
<li>Conditional <var>If</var> statements and <var>ElseIf</var> clauses

In the simplified syntax for an <var>If</var> statement, which is:
If condition Then statements


<var class="term">condition</var> expands to the syntax described in this section. </li>

<li>Computed <var>Jump To</var> statements </li>

<li>Subscripts </li>

<li>Function arguments </li>

<li>A value in parenthesis in SOUL "DML" statements, for example:
Add <var class="term">fieldname</var> = (<var class="term">expression</var>)
</ul>

=====Syntax=====
{operand | (expression)} [operator {operand | (expression)}] ...

Where:
<ul>
<li><var class="term">operand</var> can be constructed as follows:
[+ | - | Not]
{'string' | %variable | number
| fieldname [(subscript)] Is [Not] Present
| Count In label | Occurrence In label
| Value In label
| function}
</li>

<li><var class="term">expression</var> (Note: enclosed by parentheses) is a function call, string concatenation, arithmetic operation, SOUL construct, or Boolean expression. For further details, see [[Using variables and values in computation#Expressions|Expressions]]. </li>

<li><var class="term">operator</var> may be one of the following:
<table style="table-layout: fixed">
<tr>
<td>+   </td>
<td>=</td>
<td>EQ</td>
<td>And</td>
</tr>

<tr>
<td>-</td>
<td>,=   </td>
<td>NE  </td>
<td>AndIf</td>
</tr>

<tr>
<td>*</td>
<td>></td>
<td>GT</td>
<td>Or</td>
</tr>

<tr>
<td>/</td>
<td><</td>
<td>LT</td>
<td>OrIf</td>
</tr>

<tr>
<td> </td>
<td>>=</td>
<td>GE</td>
<td>With (Note: this can also be achieved via [[Implicit concatenation]])</td>
</tr>

<tr>
<td> </td>
<td><=</td>
<td>LE</td>
<td>Is [Not] Present (Note: applied either to a field or to an [[Methods#optionalParams|optional or default method parameter]])</td>
</tr>

<tr>
<td> </td>
<td> </td>
<td> </td>
<td>Is [Not] Like</td>
</tr>
</table>
<blockquote class="note">Notes:
<ul>
<li>The first character (<code>,</code>) of the inequality test above is the EBCDIC "not sign," which has the hexadecimal value <code>5f</code>. </li>

<li>For a description of the <code>Is Like</code> and <code>Is Not</code> clauses, see the syntax of [[Is Like pattern matching|Is Like patterns]]. </li>

<li>The <var>AndIf</var> and <var>OrIf</var> operators are called "short circuit", because, at a given precedence level, if the value of the conditional expression has been fully determined, the remainder at that level is not evaluated. For example:
%sex eq 'M' and (%ht lt 5.2 orIf %ht gt 6.5)
If the value of <code>%ht</code> is less than 5.2, the final comparison -- <code>%ht gt 6.5</code> -- is never evaluated (that holds regardless of what had been coded as the final comparison).
With the same value of <code>%ht</code>, if the <code>Or</code> operator had been used, then that final comparison is always evaluated.
</li>
<li>For more information about operators, see [[Using variables and values in computation#Operators|Operators]]. </li>
</ul>
</blockquote ></li>
</ul>

===In clause syntax===

The SOUL statements on this page whose syntax display is preceded by an asterisk (<tt>*</tt>) support an <var>In</var> clause. 

The three basic forms of the <var>In</var> clause are: 

In [Permanent | Temporary ] Group groupname
Member [%member | [filename [At {location | =}]]

In file1 [,file2] ...

In {$Curfile | $Update}

The form <var>In $Curfile</var> can be used only within a record loop.

====In Group Member limitations====

In addition to the three basic forms of the In clause shown above, the <var>In Group Member</var> clause restricts the following statements to one member file in a group context:
<ul>
<li><var>Clear List</var></li>

<li><var>Find All Records</var> (and its variants)</li>

<li><var>Find All Values</var></li>

<li><var>For Record Number</var> (or <var>FRN</var>)</li>

<li><var>Store Record</var> </li>
</ul>

You cannot use an <var>In Group Member</var> clause with a <var>For Each Record</var> statement or with an <var>Add</var>, <var>Change</var>, or <var>Delete Record</var> statement. Only the previously listed statements call accept an <var>In Group Member</var> clause.

====Using an In clause in a Begin...End block====

The file name in the <var>In</var> clause used within a <var>Begin...End</var> block is resolved by the compiler. You can hard-code a file name or use some type of dummy string for the file name. Using a %variable for the file name is not allowed. 

===Subscript syntax===

A subscript has the format: 

=====Syntax=====
(subscript1 [,subscript2 [,subscript3]] )

Where:

<var class="term">subscript1</var>, <var class="term">subscript2</var>, and <var class="term">subscript3</var> can be any expression. 

==SOUL macros==
There are [[SOUL macro facility|additional facilities]] supporting <var class="product">SOUL</var>
macro statements. Macro statements allow code to be conditionally compiled.

As an example, in the following SOUL fragment, the <var>Recordset</var> object declaration would be for the file <code>AVEBURY</code>:
!def henge avebury
...
%sites is object recordset in file ?!HENGE


==Terminal display attributes==

One or more of the following terminal display attributes can replace the term attribute in a full-screen formatting statement, if the display attribute is supported by the installation:

<table>
<caption>List of attributes</caption>
<tr>
<td>BLINK</td>
</tr>
<tr>
<td>BLUE</td>
</tr>
<tr>
<td>BRIGHT</td>
</tr>
<tr>
<td>DIM</td>
</tr>
<tr>
<td>GREEN</td>
</tr>
<tr>
<td>INV[IS[BLE]] </td>
</tr>
<tr>
<td>NOBLINK</td>
</tr>
<tr>
<td>NOREV[ERSE]</td>
</tr>
<tr>
<td>NOU[NDER]SCORE</td>
</tr>
<tr>
<td>PINK</td>
</tr>
<tr>
<td>PROT[ECTED]</td>
</tr>
<tr>
<td>RED</td>
</tr>
<tr>
<td>REV[ERSE]</td>
</tr>
<tr>
<td>TURQUOISE</td>
</tr>
<tr>
<td>[UNDER]SCORE</td>
</tr>
<tr>
<td>UNPROT[ECTED]</td>
</tr>
<tr>
<td>VIS[IBLE]</td>
</tr>
<tr>
<td>WHITE</td>
</tr>
<tr>
<td>YELLOW </td>
</tr>
</table>

==Notation conventions==

This page uses the following syntax notation conventions: 

<table>
<tr class="head">
<th>Syntax notation </th>
<th>Indicates that...</th>
</tr>

<tr>
<td>Single asterisk (*) </td>
<td>Statements can be preceded by an IN clause, if there is no reference to a previous set (label or list). See [[#IN clause syntax|IN clause syntax]] for more discussion.</td>
</tr>

<tr>
<td>Two asterisks (**) </td>
<td>Construct can appear only within a record loop.</td>
</tr>

<tr>
<td>Plus sign (+) </td>
<td>Construct requires the optional [[Horizon]] feature.</td>
</tr>

<tr>
<td nowrap>Two plus signs (++) </td>
<td>Construct requires the optional User Language to Database 2 feature.</td>
</tr>

<tr>
<td>C</td>
<td>The (first) keyword of the statement is also a <var class="product">Model 204</var> command; the command's wiki page will be, for example, 'OPEN command'.

<var class="product">Model 204</var> commands are listed alphabetically and documented in [[List of Model 204 commands]]. </td>
</tr>

<tr>
<td>Lowercase italic </td>
<td>Constructs are replaced with variable information.</td>
</tr>
</table>

<ul>
<li>A field name (%%) variable can be used anywhere fieldname appears. The %%variable can contain its own subscript, separate from the field name subscript.
Note: 
The subscript of an array element must be specified before a field name subscript. </li>

<li>The lowercase constructs — retrieval-conditions, print-specifications, expression, subscript, attribute, and type — are discussed separately following the syntax summaries, beginning with [[#Value specification syntax|Value specification syntax]]. </li>

<li>For more Model 204 notation conventions, see [[Notation conventions]].</li>
</ul>

[[Category:SOUL]]

Template:Rethrow statement syntax

2020-03-23T21:43:17Z

Dme: Created page with "Rethrow exceptionName ... "

[[Exceptions#Rethrow statement|Rethrow]] exceptionName ...

Exceptions

2020-03-23T21:42:59Z

Dme: /* Rethrow */

Exceptions are a technique for handling unusual occurrences in the execution of a method call. This page discusses <var class="product">SOUL</var> exception handling.

==Background==
A wide variety of errors can occur inside a program.
Many of these, such as syntax errors, or invalid variable or member
names, can be caught at compile-time, so they produce compile-time errors.
Other errors can only be caught at run-time, so they produce run-time errors.

For example, a reference to a member of a null object variable will
produce a request cancelling “reference to null object” error.
Generally, such an error is indicative of a logic error in the program
— most likely the program forgot to create an instance of the
object, forgot to assign it to the object variable being used, or is
mistakenly using the wrong object variable.

In any case, since such an error is indicative of a program logic
error, the request cancellation is a benefit: it stops the
program at the earliest point that the error was detected so that
the program does not do damage because of the error.
In addition, if <var class="product">[[SirFact]]</var> is being used, the request cancelling error
will produce a <var class="product">SirFact</var> dump at the time the error was first detected
(or at the very least, indicate the procedure and line number where the error was first detected).
Such early detection of error greatly simplifies problem diagnosis.

Still other errors are actually quite common and might not even be considered errors in most contexts in which they occur.
For example, the <var>Stringlist</var> class <var>[[Locate (Stringlist function)|Locate]]</var> method might not locate any
items that match the search criterion.
Since this is likely not to be a true error, the <var>Locate</var> method simply
returns a 0 in such a case.
The <var>Locate</var> method caller can then check for a zero value and do
processing appropriate to the no-matching-item-found case.

If the <var>Locate</var> method caller assumes that the <var>Locate</var> always finds a
matching item, it is likely to use the zero returned by the <var>Locate</var>
method to reference a matched item, then get a request cancelling
error when item zero is requested.
This illustrates a general principle that methods that can produce
unusual results or, at least, results that are significantly different
from others, should try to set the unusual or result values to something
that is likely to cause a request cancelling error if misused.

For example, a method that returns an object instance might return a
<var>Null</var> object under certain error conditions that are not necessarily indicative
of a programming error.
This allows the calling program to check for a <var>Null</var> and perform
appropriate processing if a <var>Null</var> is returned.
If the program doesn't expect this error case, it might not check for a <var>Null</var>.
If the program is correct, and the error case cannot happen in the
given context, the program behaves correctly with no unnecessary error checking.
If, however, it is incorrect, and a <var>Null</var> can be returned, it is likely
to get a <var>Null</var>-object request-cancelling error when it attempts to
use the <var>Null</var> as an object reference.

This is the best of all worlds — no error checking is required
if the error is known not to occur in a context, but if that knowledge
is incorrect, a request canceling error will quickly stop the program
before any damage is done.

Unfortunately, there are some cases where the return value cannot be
used to indicate an unusual situation:
<ul>
<li>There is no return value.
For example, an error happens inside a subroutine or inside the <var>Set</var>
method of a property.

<li>The return value has no invalid values available to be used to indicate an unusual situation.
For example, if a function returns a string, and a null value is sometimes
a valid output, there might be no reasonable string value that can be used
to indicate the error.

<li>Even if there is a reasonable value (such as a null string, <var>Null</var> object
reference, or zero or negative numeric value), such a value might not provide
enough information about the nature of the error for the calling program to deal with the error.
Obviously, a single string or numeric value, or a <var>Null</var> object reference, cannot
provide a lot of information.
This is especially important if a method might encounter more than one unusual
situation, and the unusual situations are different enough that one might
be expected in a particular context, and the other not; or the unusual situations
require very different corrective action.

For example, a method places an order for a product, and given a product number,
it wants to indicate an error if the product number is invalid.
The number might be invalid because the product number doesn't exist or because the product is out of stock.
Obviously, these are two very different errors, the former possibly being
indicative of a programming error, the latter less likely to be.
</ul>

One solution to such cases is to have an output parameter on the method calls.
Unfortunately, this has several problems:
<ul>
<li>Output parameters can be confusing in code.
There's nothing that marks them as output parameters, so it's not obvious that's
what they are.
Also, someone looking for how a variable used as an output parameter was
or might be set, might only think to look for assignment statements with
the variable on the left side of the assignment.
Certainly, life would be easier if that is all one needed to look for.

<li>Just because a variable is used for the output parameter, there is no
guarantee that the program actually examines the output parameter value.
This could mean that where it is incorrectly believed that a
certain error situation can't occur, the code might not bother to check the variable
used as an output parameter and continue on, oblivious to an error.

<li>Output parameters cannot (currently) be optional.
This means that a variable has to be specified for the output parameter,
even if the unusual situations indicated by the output parameter couldn't
happen in a given context.
This can be annoying, at best, and confusing, at worst.
</ul>

An alternative to output parameters to handle unusual
cases in method calls is called '''exception handling'''.

==Errors unsuitable for exception handling==
Exception handling consists of three parts:
<ol>
<li>The ability to define classes of exceptions and the information available for these classes.
Unsurprisingly, classes of exceptions are defined in almost the same way as other classes.

<li>The ability to indicate an unusual or exception situation.
This is referred to as ''throwing'' an exception.

<li>The ability to detect a thrown exception and to perform special processing
for the exception. This is known as ''catching'' an exception.
</ol>

Exception handling in <var class="product">SOUL</var>
is very similar to many other
object-oriented programming languages, such as Java or VB.Net.
However, each language's implementation of exception handling is unique, each
with subtle or not so subtle differences from others.
<var class="product">SOUL</var> is no exception (no pun intended), and significant departures from the way
other languages support exceptions is indicated where applicable.

A philosophical departure from the support of most other languages for exceptions is worth noting:
while many object-oriented languages make all (or almost all) errors exceptions,
<var class="product">SOUL</var> does not.
This is partially because many object-oriented languages are not, strictly speaking,
application languages — in addition
to writing applications in some other object-oriented languages,
one might write programming environments or even operating systems.
As such, a programming environment or operating system must be able to
intercept all errors and try to deal with them, so the object-oriented languages
facilitate this by making all errors catchable.

<var class="product">SOUL</var> is an application development language.
While it is theoretically possible to build a program environment in <var class="product">SOUL</var>,
or even an operating system, this is not really the focus of <var class="product">SOUL</var>, and it is
not likely anyone would ever do this.
The <var class="product">SOUL</var> programming environment (<var class="product">Model 204</var>, which is not itself written in <var class="product">SOUL</var>)
is responsible both for the ultimate catching of errors and the providing of information about the nature of the errors so that they can be corrected.

The kinds of errors that <var class="product">SOUL</var> does ''not'' turn into exceptions,
and thus are not trappable, fall into two broad categories:

<ol>
<li>Pernicious environmental errors from which it would generally be
almost impossible to recover gracefully on an application level.

For example, if <var>CCATEMP</var> fills up, it is exceedingly unlikely that a
request could recover gracefully.
Since <var>CCATEMP</var> is used for so many different things (including record
sets for finds, stringlists, collections, internal storage of objects
swapped out of a server, transaction backout logs, and so on), it would
be very difficult for an application to anticipate all the places that
<var>CCATEMP</var> could fill.
And even if it could anticipate the places, it would be very difficult to avoid
doing anything that might also require <var>CCATEMP</var>.

Similarly, a <var>PDL</var> (push-down-list) overflow can be detected at almost any
method call, not to mention dozens of internal <var>PDL</var>-intensive routines (such as, say, journal output).
As such, it would be almost impossible for an application to anticipate
all the places where a <var>PDL</var> overflow might be detected.
And even if it could anticipate the places, any method calls to handle the situation
would likely also encounter a <var>PDL</var> overflow.

<li>Errors that are indicative of logic errors in a program.

For example, a class member reference via a <var>Null</var> object variable is usually indicative of a programming error.
Similarly, a reference to an invalid collection item number is also generally
indicative of a programming error.

While there might be error-causing cases of "sloppy" references to
object variables or collection items that you would want to simply catch
when they happen:
<ul>
<li>Most of these are handled well by existing facilities such as <var>[[Classes and Objects#Allow Auto and constructors|Auto New]]</var>
and also <var>[[UseDefault (GenericNamedArraylist property)|UseDefault]]</var> processing for collections.

<li>In the odd cases where such sloppy references are useful, it is trivial
and efficient to check for the sloppy references (<var>Null</var> object variable,
invalid collection item number), so an exception-handling paradigm adds little value.

Of course, there are always border-line cases where an error that is nearly
always indicative of a programming error, might not be in certain
contexts.
Since the initial <var class="product">Sirius Mods</var> support for exceptions was not accompanied by
a complete survey of all error returns by all system methods, it is quite
likely that many request cancelling errors in system methods will gradually
be converted into catchable exceptions over time.
This is also quite likely to be the case for many errors in user-written methods.
</ul>
</ol>

Note that <var class="product">Model 204</var> '''does''' provide <var class="product">SOUL</var> facilities to catch even
these types of untrappable errors.
These facilities include <var>On</var> units, especially <var>On Error</var> units, and <var>APSY</var>
error procedures.
These facilities make it possible for <var class="product">SOUL</var> programs to, at least,
provide nicer notification of an error to a client (web browser, 3270
user, SOAP client) than a broken connection or a <var class="product">Model 204</var> error message.

Even these facilities, however, are limited by severe environmental resource
constraints.
For example, if a <var>CCATEMP</var> or record-locking-table full error drives
an <var>APSY</var> error procedure or an <var>On Error</var> unit, there might be little these
error routines can do without bumping into the very same resource
constraints that caused the problem in the first place.
This problem is not unique to <var class="product">Model 204</var> — severe environmental
constraints can wreak havoc with the best laid error recovery plans in any environment.

==Exception class definitions==
Most error conditions have information associated with them.
This information can be useful for correcting or recovering from the problem.
For example, if an invalid character is detected in a stream of
data, it might be useful to know the character offset in the stream,
the actual invalid character, and some indication of why the character is invalid.
It might also be useful to have a text description of the nature of the error.

The collection of data describing an error situation might be used
immediately after the error is detected, or it might be examined elsewhere.
As such, this error data should be able to persist indefinitely.
Given this requirement, it is clear that the logical place to
hold error information is inside an object.
And the description of the data associated with a particular error
would, of course, be a class.

Classes that describe trappable error situations are called '''exception classes'''.
To a large degree, exception classes are no different from any other class:
<ul>
<li>They can have <var>Public</var>, <var>Private</var>, and <var>Shared</var> blocks; they
can have variables, methods, and the same <var>Allow</var> and <var>Disallow</var> rules
as any other class.
<li>There can be [[List of system exception classes|system exception classes]],
which are provided as part of the <var class="product">Model 204</var> installation, and there can be
exception classes which are defined and maintained by <var class="product">SOUL</var> code.

<li>Exception classes can be used wherever non-exception classes are used,
although the reverse is not true.
That is, there are certain statements that require an exception class or
an object of an exception class.
This is largely to prevent accidental misuse of a non-exception class
in an exception class context.
</ul>

User-defined exception classes are denoted by using the <var>Exception</var>
keyword in the class header:
class tackyColor exception


In many object-oriented languages, a class is indicated as an exception class
by extending some special base class, often called "Exception."
One can think of the Exception keyword on the Class declaration
as indicating that the class extends some hidden base class.
This neither adds nor detracts from an understanding of the basic concept of
an exception class.

If you want, you can put the <var>Exception</var> keyword on almost all class declarations;
specifying it removes no capabilities from the class.
Doing so, however, is misleading, since most classes are likely never to be used
to indicate error situations.
In this regard, you can view the <var>Exception</var> keyword on a class declaration as
documentation that a class can be used as an exception class.
While the compiler ''cannot'' ensure that a class with an <var>Exception</var>
declaration will be used as an exception, it ''does'' ensure that a
class not declared as <var>Exception</var> is not used in exception contexts.

The one case where the <var>Exception</var> keyword is not allowed on class declarations
is in declarations that extend non-exception classes — exception classes
can only extend other exception classes.

Some examples of system exception classes are:
<dl>
<dt><var>[[InvalidHexData class|InvalidHexData]]</var>
<dd>Describes an error in converting hexadecimal data to some other datatype.
<dt><var>[[InvalidRegex class|InvalidRegex]]</var>
<dd>Describes an error processing a regular expression.
<dt><var>[[DaemonLost class|DaemonLost]]</var>
<dd>Describes a situation where the thread doing processing for a <var>Daemon</var> object was lost (logged off).
</dl>

This list is far from exhaustive, but it illustrates that system exception classes
might be associated with a specific system class.
For example, the <var>DaemonLost</var> class is clearly associated with the <var>Daemon</var> class.
On the other hand, an exception class might be associated with a facility that's
used by many different classes.
For example, the <var>InvalidRegex</var> class is not associated with any specific class,
because regular expressions are used in <var>Stringlist</var> and <var>Intrinsic</var> methods.

For links to the descriptions of the individual system exception classes, see the
[[Lists of classes and methods#except|"Lists of classes and methods"]].

==Throwing exceptions==
When an error situation occurs, the code that detects the situation can do
one of two things:
<ul>
<li>It can cancel the request.
In <var class="product">SOUL</var> this is done with an <var>Assert</var> statement.
In system code, this is done by some equivalent of the <var>Assert</var> statement.
This is the correct response to an error if the error is clearly indicative
of a programming error or a severe environmental constraint that is likely
to make request continuation unproductive.

<li>It can ''throw'' an exception.
In <var class="product">SOUL</var> this is done with a <var>Throw</var> statement.
In system code, this is done by some equivalent of the <var>Throw</var> statement.
This is the correct response to an error if the error might occur in the
normal course of processing and the code that called the method might be
able to recover from the error.
'''Note:'''
In the <var class="product">SOUL</var> implementation of exceptions, exceptions can only
be thrown by methods. 
</ul>

In both system and user-written methods, a thrown exception can only be handled
(caught) by the code that called the method.
This is different from many other languages' implementations of exceptions
where exceptions can be handled locally, that is, inside the same method
that threw the exception.
Like many other languages, the exceptions that might be thrown by a method
must be documented in the method header.
This is because a method's exceptions are part of the method's interface to
its callers, as much as any input and output parameters, as much as output values.

===Specifying a Throws clause===
The exceptions thrown by a method are indicated by the <var>Throws</var>
clause in the method declaration and definition header.
For example, if the method <code>Paint</code> might throw a <code>TackyColor</code> and <code>InvalidHexData</code>
exception, it should be declared and defined as:
subroutine paint(%hexColor is string len 6) -
throws tackyColor and invalidHexData


Of course, while the keyword <var>And</var> is used to separate the exceptions
that might be thrown by a method, the method can only ever throw one exception
at a time, and in most cases, it will not throw an exception at all.

The list of exceptions after a <var>Throws</var> keyword is the list of exception class names.
These class names could be user-defined exception class names, or they could be system
exception class names.
If the class is a system class name, it could be fully qualified with the <code>System:</code> namespace indicator.
For instance, the previous example could be written as
subroutine paint(%hexColor is string len 6) -
throws tackyColor and system:invalidHexData


This would only be necessary if there was a user-defined class name with the same
name as the system class name.
Of course, it is best to avoid such a situation as much as possible.

As with most method descriptions, the <var>Throws</var> clause on a method declaration
and definition must match exactly.
That is, the mismatch in the following definition and declaration is invalid:
class house
public
...
subroutine paint(%color is string len 6) -
throws tackyColor and outOfPaint
...
end public
...
**** The following produces a compile error ****
subroutine paint(%color is string len 6) -
throws tackyColor
...
end subroutine
...
end class


It is also invalid if, in the method definition, the list
of thrown exceptions contains the same exceptions as the method
declaration, but in a different order.

Methods that implement an overridable method cannot throw any
exceptions not thrown by the implemented method; however, they do not
necessarily have to throw all the exceptions thrown by the implemented method.
That is, the exceptions in a <var>Throws</var> list on an <var>Implements</var> method
must be a subset of the <var>Throws</var> list on the corresponding
<var>Overridable</var> (or <var>Abstract</var>) method.
For example, if an overridable method in class <code>Products</code> indicates:
subroutine buy(%productCode is string len 8) -
overridable -
throws tooExpensive and outOfStock


then it is valid for an implementing method to indicate:
subroutine buy(%productCode is string len 8) -
implements buy in products -
throws tooExpensive


or even:
subroutine buy(%productCode is string len 8) -
implements buy in products


However, it is '''not''' valid for the implementing method to throw an
exception other than <code>TooExpensive</code> or <code>OutOfStock</code>.
This is because a caller of the base class only expects the <code>Buy</code>
method to throw one of these two exceptions.
It would be surprising, indeed, if the method threw some different
exception, simply because it had been overridden.

===Using the Throw statement===
Once a method declaration indicates the exceptions it might throw,
that method could then throw the exception with the <var>Throw</var> statement.
The <var>Throw</var> statement must be followed by an instance of the exception
class being thrown.
For example, if the method header contains
subroutine paint(%color is string len 6) throws tackyColor


and there is a variable declaration in the method:
%tacky is object tackyColor


The method could do this:
throw %tacky


Of course, the <var>Throw</var> statement is likely to be inside an <var>If</var> clause, since
exceptions are generally thrown in unusual situations, not common ones:
if %color eq %yuckyGreen or -
%color eq %grottyOrange then
throw %tacky
auditText Threw an exception
end if


Note that in the above example, the <var>AuditText</var> statement after the <var>Throw</var>
will '''never''' be executed.
This is because the <var>Throw</var> either returns immediately to the method caller
(if the method caller catches the exception), or it cancels the request immediately.

Another problem with the above example is that <code>%tacky</code> was likely to never have
been set to reference a <code>TackyColor</code> instance.
So, more correct would be something like:
if %color eq %yuckyGreen or -
%color eq %grottyOrange then
%tacky = new
throw %tacky
end if


But, even this is not quite right.
Usually, the exception objects will contain information to aid in problem determination and recovery:
if %color eq %yuckyGreen then
%tacky = new
%tacky:reason = 'Yucky'
%tacky:alternative = '00FF00'
throw %tacky
end if
if %color eq %grottyOrange then
%tacky = new
%tacky:reason = 'Grotty'
%tacky:alternative = 'FFA500'
throw %tacky
end if


This example illustrates the point that it is common for any <var>Throw</var> of a
particular exception class to always return more or less the same information.
As such, exception classes often have [[Notation conventions for methods|constructors]] that can specify all
the information provided by the class.
Then, no variables of the exception class need to be defined; the
result of the constructor call can simply be thrown:
if %color eq %yuckyGreen then
throw %(tackyColor):new('Yucky', '00FF00')
end if
if %color eq %grottyOrange then
throw %(tackyColor):new('Grotty', 'FFA500')
end if


Of course, for code readability, named parameters are preferable on such constructors:
if %color eq %yuckyGreen then
throw %(tackyColor):new(reason='Yucky', alternative='00FF00')
end if
if %color eq %grottyOrange then
throw %(tackyColor):new(reason='Grotty', alternative='FFA500')
end if


An attempt to throw an exception object whose class does not match one
of the classes listed in the method declaration's <var>Throws</var> clause results
in a compilation error.

===Exception classes extending other exception classes===
Exception classes can extend other exception classes.
As such, the class of an object specified in a <var>Throw</var> statement does not
have to match any class in the method's <var>Throws</var> list exactly —
it can be of an extension class of one of the <var>Throws</var> list classes.
Because an extension class can, itself, be extended, and because of
multiple inheritance, this means that a <var>Thrown</var> exception object might
match multiple classes in a method's <var>Throws</var> list.

The thrown (and therefore catchable) class is the first class in the <var>Throws</var>
list that matches the object in the <var>Throw</var>.
That is, the first class in the <var>Throws</var> list that exactly matches the thrown
object's class or that is a base class of the thrown object is used as the thrown class for the method caller.
Because of this, a <var>Throws</var> list must always specify extension classes before
base classes.
Otherwise, the base class in the <var>Throws</var> list would always match any object
that would match an extension class, so the extension class would never be used as the thrown class.

For example, if exception class <code>ReallyNastyColor</code> extended exception class
<code>TackyColor</code>, and method <code>Paint</code> had this header:
subroutine paint(%color is string len 6) throws tackyColor


And if the following statement appeared inside the <code>Paint</code> method;
throw %(reallyNastyColor):new(reason='Awful')


The new <code>ReallyNastyColor</code> exception object would be thrown as a <code>TackyColor</code> object.
That is, the callers of <code>Paint</code> would not be able to assign the thrown
exception to a <code>ReallyNastyColor</code> object without the use of a narrowing assignment.

==Try and Catch==
Without any action on a method caller's part, a thrown exception is,
for all intents and purposes, a request cancelling error.
To prevent the request cancellation, an exception must be "caught."
This is achieved by the use of a '''Try/Catch block'''.

A <var>Try/Catch</var> block consists of two parts.
The first, the <var>Try</var> section, contains one or more <var class="product">SOUL</var> statements that
might result in an exception.
The <var>Try</var> section is then followed by one or more <var>Catch</var> sections, each
one of them handling (catching) a particular class of exception.

The following fragment shows the use of a <var>Try/Catch</var> block to trap
an exception caused by invalid hexadecimal data:
try
%binary = %input:hexToString
catch invalidHexData
%binary = '???'
catch invalidBase64Data
%binary = '???'
end try


This example illustrates a few points:
<ul>
<li>The end of the statements whose exceptions are being caught is indicated
by the first <var>Catch</var> block.
<li>The class of exceptions being caught follows the <var>Catch</var> statement.
<li>A catch block is terminated by another <var>Catch</var> statement or an <var>End Try</var>.
<li>One can catch multiple exception types, each within its own <var>Catch</var> block.
<li>There is no validation that the type of exception being caught might
actually be thrown inside the <var>Try</var> block.

In the preceding example, there would be no chance for an <var>[[InvalidBase64Data class|InvalidBase64Data]]</var>
exception inside the <var>Try</var> block since the <var>[[HexToString (String function)|HexToString]]</var> method will not throw such an exception.
Having a block to catch an exception that's not possible is no different
from having an <var>If/Else</var> <var>If</var> block for an impossible condition — it
simply adds some dead code to a request.
</ul>

===Try block syntax===
Try
tStmt1 ; * Exceptions can
[ tStmt2 ] ; * be caught in
[ ... ] ; * these statements

[ Rethrow rethClassA [And rethClassB ] ... ]

<nowiki>...</nowiki> any number of <var>Rethrow</var> statements

[ Catch catClassC [To %objC] [And catClassD [To %objD]] ...
[ cStmtW ] ; * These are executed if any
[ cStmtX ] ; * of the execptions on the
[ ... ] ; * <var>Catch</var> statement are thrown
]

<nowiki>...</nowiki> any number of <var>Catch</var> blocks

[ Success
[ sStmtY ] ; * These are executed
[ sStmtZ ] ; * if no execptions
[ ... ] ; * are thrown
]

End Try


====Syntax terms====
The <var>Try</var> block is divided into two or more sections, which are separated by
<var>[[#Rethrow|Rethrow]]</var>, <var>Catch</var>, and <var>[[#Success blocks|Success]]</var> statements. Multiple
<var>Rethrow</var> and <var>Catch</var> statements can be mixed
with each other and with the <var>Success</var> statement, in any order.

There must be either one <var>Rethrow</var> or <var>Catch</var> statement in a <var>Try</var> block.

<table>
<tr><th>tStmt1 [tStmt2...]</th>
<td>The first section in the <var>Try</var> block must contain one or more <var class="product">SOUL</var> statements. These statements are executed in turn, and if an exception is thrown within them, execution resumes at the <var>Rethrow</var> or <var>Catch</var> statement specifying that exception; if there are none, the request is cancelled. If no exceptions are thrown, execution resumes with the <var>Success</var> block statements, if any, and then after the <var>End Try</var> statement.</td></tr>

<tr><th nowrap><var>Rethrow</var> rethClassA ...</th>
<td>The <var>Rethrow</var> statement (not block) specifies one or more exception classes; if one of them is thrown, then the method containing the <var>Try</var> block throws that exception. Hence a <var>Rethrow</var> statement can only occur within a method which declares all of the <var class="term">rethClass</var> exceptions in its <var>Throws</var> clause.

Each <var class="term">rethClass</var> may not be the same as, nor an extension of, any exception class preceding it on the statement or on preceding <var>Rethrow</var> and <var>Catch</var> statements in the <var>Try</var> block.</td></tr>

<tr><th><var>Catch</var> catClassC ...</th>
<td>The <var>Catch</var> statement specifies one or more exception classes; if one of them is thrown, then the (optional) <var class="term">cStmt</var> statements in the <var>Catch</var> block are executed in turn, and then execution resumes after the <var>End Try</var> statement.

Each <var class="term">catClass</var> may not be the same as, nor an extension of, any exception class preceding it on the statement or on preceding <var>Rethrow</var> and <var>Catch</var> statements in the <var>Try</var> block.</td></tr>

<tr><th><var>Success</var></th>
<td>If no exceptions are thrown in the <var class="term">tStmt</var> statements, the (optional) <var class="term">sStmt</var> statements in the <var>Success</var> block are executed in turn, and then execution resumes after the <var>End Try</var> statement.</td></tr>
</table>

===Try block considerations===
A <var>Try</var> block can contain more than one statement:
try
%binary = %input:hexToString
%bin = %input64:base64ToString
%key = %inputKey:hexToString
%foo:process(%binary, %bin, %key)
catch invalidHexData
%binary = '???'
catch invalidBase64Data
%bin = '???'
end try


While valid, this example is intended to show that it might not
be a good idea to put a lot of statements inside a <var>Try</var> block:
<ul>
<li>It obscures which statements might be throwing which exceptions,
and this makes the code harder to read.
<li>The more statements you have inside a <var>Try</var> block, the more
likely it is that you will accidentally catch an exception in a
statement in which you were not expecting an exception.

For example, in the above code, the <code>InvalidHexData Catch</code>
block is clearly fixing a problem with invalid hexadecimal data in <code>%input</code>.
But, it will also catch an exception thrown by invalid hexadecimal
data in <code>%inputKey</code>, and in this case, probably it will do the wrong thing.
<li>All the code in the <var>Try</var> block after the method that threw
the exception will not be executed.

While, in some cases, this is what would be intended, there are many
cases where this would not be intended.
In the above example, it is likely that one would want to try to
execute the <var>[[Base64ToString (String function)|Base64ToString]]</var> method on <code>%input64</code> after "correcting"
errors in executing <var>HexToString</var> on <code>%input</code>.
</ul>

As a general rule of thumb, place as few statements inside
a <var>Try</var> block as possible.
To facilitate this, you can follow the <var>Try</var> statement by a <var class="product">SOUL</var>
statement on the same line, as in:
try %binary = %input:hexToString
catch invalidHexData
%binary = '???'
end try


===Referencing a thrown exception object===
As noted in [[#Using the Throw statement|"Using the Throw statement"]], what gets thrown with an exception is
an exception object that contains information about the nature of the exception.
In the <var>Try/Catch</var> examples to this point, the thrown objects were ignored —
only the class of the thrown exception was used.
If you want to reference the thrown exception object, you must specify a
<var>To</var> clause, followed by an object variable of the exception class being caught.

For example, if <code>%daemon</code> is a <var>[[Daemon class|Daemon]]</var> object and <code>%daemonLost</code>
is an object of the <var>[[DaemonLost class|DaemonLost]]</var> exception class, the following block
catches the exception thrown if the daemon thread was logged
off for some reason, and it displays the output of the last command up to the point where it logged off:
try %daemon:run('INCLUDE NASTY')
catch daemonLost to %daemonLost
printText Daemon died! Its last words were:
%daemonLost:daemonOutput:print
end try


Presumably, this block would be useful in diagnosing the problem or even correcting it.

===Rethrow===
<var class="product">Sirius Mods</var> 8.1 introduced the <var>Rethrow</var> clause in a <var>Try</var> block. <var>Rethrow</var> lets you propagate an exception without having to assign it to a local variable, probably eliminating the need to declare a local exception class object for the sole purpose of propagating an exception.

The <var>Rethrow</var> clause must occur at the same level as a <var>Catch</var> clause in a <var>Try</var> block. But, unlike the <var>Catch</var> clause, no code is allowed "inside" the <var>Rethrow</var> "block." Because <var>Rethrow</var> causes control to pass immediately out of the current method, no code after <var>Rethrow</var> would ever be executed.

A <var>Rethrow</var> clause can only be followed by an <var>End Try</var>, a <var>Catch</var> clause, or a <var>Success</var> block. Like the <var>Throw</var> statement:
<ul>
<li>The <var>Rethrow</var> clause must be invoked inside a method.
<li>The class or classes specified on a <var>Rethrow</var> clause must be declared as being thrown by that method.
</ul>

The following local subroutine illustrates a <var>Rethrow</var> of an <var>InvalidHexdata</var> exception. This subroutine sends a string converted from hex to binary on a socket.
local subroutine (socket):sendHex(%hexdata is longstring) throws invalidHexData
%sendData is longstring

try %sendData = %hexdata:hexToString
rethrow invalidHexdata
end try

%this:send(%sendData)
end subroutine


===Mutiple classes on a Catch or Rethrow statement===
<var class="product">Sirius Mods</var> 8.0 introduced the ability to specify multiple exception classes on a single <var>Catch</var> statement. The class names are separated from each other by the <var>And</var> keyword. However, in <var class="product">Sirius Mods</var> 8.0, no <var>To</var> clause could be specified on a <var>Catch</var> statement with multiple classes.

<var class="product">Sirius Mods</var> 8.1 added support for <var>To</var> clauses on a <var>Catch</var> statement with multiple classes as well as including support for multiple classes on the <var>[[#Rethrow|Rethrow]]</var> statememt.

The following illustrates a <var>Catch</var> statement with multiple classes:
try %foo:doSomethingCrazy
catch invalidHexdata to %ivhexData and tooCrazy and notCrazyEnough to %notCrazyEnough
end try


If the above were inside a method, the exceptions could be rethrown:
try %foo:doSomethingCrazy
rethrow invalidHexdata and tooCrazy and notCrazyEnough
end try


Of course, if a <var>Catch</var> block catches multiple class exceptions, it might be important to determine which exception was actually thrown. In that case, a null test can be performed on the target objects:
try %foo:doSomethingCrazy
catch invalidHexdata to %ivhexData and and tooCrazy and notCrazyEnough to %notCrazyEnough
...
if %ivhexData is not null then
...
elseIf %notCrazyEnough is not null then
...
end if
...
end try


For this to work, one must be sure that the target catch objects are null before the <var>Try</var> block. And, unless there is a lot of common code for the classes in the <var>Catch</var> block, it probably makes more sense to just have a separate <var>Catch</var> block for each exception.

There is no difference between rethrowing exceptions in a single <var>Rethrow</var> statement and multiple <var>Rethrow</var> statements, so it is largely a matter of style as to which approach is used.

===Success blocks===
In cases where a <var>Try</var> block contains multiple statements, a
<var>Success</var> block makes it clear in the code which statement is expected to produce the exceptions that are being caught.
These blocks also protect you from an inadvertent exception thrown in an unexpected context.

For example, consider the following scenario.
You want to try statement <code><a></code> and, if no exceptions get Thrown,
you want to do statements <code><nowiki></nowiki></code>, <code><c></code>, <code><d></code>, and <code><e></code>.
Otherwise, if statement <code><a></code> throws an exception,
you want to do statements <code><x></code>, <code><y></code>, or <code><z></code>, depending on the exception.

You code your <var>Try</var>/<var>Catch</var> block like this:
try
<a>...
...
<c>...
<d>...
<e>...
catch foo
<x>...
catch bar
<y>...
catch another
<z>...
end try


If statement <code><a></code> does indeed throw an exception, statements <code><nowiki></nowiki></code> through <code><e></code> do not run, and the appropriate <var>Catch</var> statement takes effect.
However, if statement <code><a></code> does not throw an exception,
there might be no way to know that statement <code><nowiki></nowiki></code>, <code><c></code>, <code><d></code>, or <code><e></code> might
throw an exception that is one of the exceptions in the subsequent <var>Catch</var> statements.
Or you might be aware of their capacity to do so,
but you might not expect an exception from any of them in this context. Prior to
Version 7.8 of the <var class="product">Sirius Mods</var>, there was
no good way of preventing the catches to also be in effect for these statements
as well as for statement <code><a></code>.

As of <var class="product">Sirius Mods</var> 7.8, a <var>Success</var> block inside the <var>Try</var> block
resolves the problem by making it clear that the <var>Catch</var> statements do '''not''' apply to
statements <code><nowiki></nowiki></code>, <code><c></code>, <code><d></code>, and <code><e></code>:
try
<a>...
success
...
<c>...
<d>...
<e>...
catch foo
<x>...
catch bar
<y>...
catch another
<z>...
end try


The principle benefits of the <var>Success</var> statement are:
<ul>
<li>It makes it clear in the code which statement is expected to produce the exceptions being caught.
<li>It prevents a catch from accidentally catching an exception from a statement that didn't really expect that exception.
</ul>

You can also reverse the order of the the <var>Success</var> and catches:

try
<a>...
catch foo
<x>...
catch bar
<y>...
catch another
<z>...
success
...
<c>...
<d>...
<e>...
end try


===Some differences with other languages===
This section describes some differences between the <var class="product">SOUL</var> implementation
of <var>Try/Catch</var> and implementations in other languages.
Outside of these differences, <var>Try/Catch</var>
support in <var class="product">SOUL</var> is very similar to that in other languages.
<ul>
<li>Unlike Java, it is not necessary to provide a <var>Catch</var> for all exceptions
that a method might throw.
This seems antithetical to the idea that exceptions are unusual conditions
and, in many instances, are known to be impossible.
It seems unnecessary to add code to deal with (or ignore) an error that
cannot occur in a context.

<li>Unlike many other languages, uncaught exceptions are not automatically
propagated to higher level callers.
Partially, this is because the <var class="product">SOUL</var> environment is not written in <var class="product">SOUL</var>, so
there is no need to propagate exceptions to some outer <var class="product">SOUL</var> environment
which, presumably, would clean up the failing request and possibly provide
diagnostics about the error.
Instead, clean-up and diagnostics are provided by the assembler environment.

Automatic propagation of errors is also a grand opportunity for bugs.
Since an automatically propagated error can happen anywhere in a method,
there is no indication that the writer of a method considered the possibility
of the propagated error.
Updates to data-structures, including transactions that update files, might
be half-done at the time of the occurrence of an exception that gets
automatically propagated.

While languages that provide automatic exception propagation usually also
provide a <code>Finally</code> clause to "ensure" that the method
doesn't leave things in a half-done state, there is nothing in a Finally
clause that indicates whether the programmer anticipated the particular
error being propagated.
And the absence of a Finally clause does not prevent error propagation, anyway.

If you want to propagate an exception in <var class="product">SOUL</var>, you can simply catch it
and re-<var>Throw</var> it:
catch tackyColor to %yuck
* let caller deal with this
throw %yuck


This makes it clear which error is being propagated and under what circumstances.

<li>The absence of automatic exception propagation eliminates the utility of a
Finally clause, so no Finally clause is available in <var>Try/Catch</var> blocks in <var class="product">SOUL</var>.

<li><var>Catch</var> statements cannot catch locally thrown exceptions.
That is, a <var>Throw</var> statement always results in immediate exit from the current
method, regardless of whether or not the <var>Throw</var> is inside of a <var>Try</var> block and
whether or not there are <var>Catch</var> statements that correspond to the thrown exception.
The <var class="product">SOUL</var> view of exceptions is that they are part of the interface between
a method and its callers, so they have no place in controlling local program flow.
</ul>

===Nesting Try/Catch blocks===
Like in other languages, <var>Try/Catch</var> blocks can be nested.
That is, a <var>Try/Catch</var> block can be inside the try or catch clause of another
<var>Try/Catch</var> block:
try
%dmn:run('I STEP1')
try
%str = %hex:hexToString
%dmn:run('I STEP2 ' with %str)
catch invalidHexdata
%dmn:run('I STEP2 ???')
end try
catch daemonLost
auditText My daemon's gone!
try %str = %hex:hexToString
catch invalidHexdata
%str = '???'
end try
return %str
end try


The <var>Catch</var> that applies to a particular thrown exception is the first <var>Catch</var>
that either exactly matches the class of the thrown exception, or that is a base
class of the thrown exception.
Because of this, it is possible to catch many different exceptions with a single
<var>Catch</var> if all the exceptions are extensions of a specified base class.
For this reason, too, it is invalid to specify a <var>Catch</var> for an exception class
after a <var>Catch</var> for a base class of that exception class, since the base class
<var>Catch</var> will always catch the exception class exception before the exception
class <var>Catch</var> is processed.
If separate <var>Catch</var> statements are required for base and extension classes, specify the
extension class <var>Catch</var> statements first.

Because there is no single base exception class for all exceptions
(as there is in many other languages), however, it is not possible to
generically catch any and all exceptions with a single <var>Catch</var>.
While this ability might be convenient, it is also likely to encourage sloppy
programming, where generic <var>Catch</var> statements obscure the possible errors in a context,
and make it all too easy to catch unanticipated errors and do the wrong thing.

For <var>Try</var> blocks nested inside of other <var>Try</var> blocks, if no <var>Catch</var> statements that correspond
to a thrown exception are found for the inner-most <var>Try</var> block, then the outer-most
<var>Try</var> block's <var>Catch</var> statements are checked for a match, and they are used if a match is found.
That is, when <var>Try</var> blocks are nested, all <var>Try</var> blocks are in effect for statements
inside the inner-most <var>Try</var> block.
Note, however, that other <var>Catch</var> statements for a <var>Try</var> block are no longer in effect
inside any of the <var>Catch</var> blocks for the <var>Try</var>.
For example, if a request had a <var>Daemon</var> object <code>%dmn</code>, and if <code>%errorhex</code> had invalid hexadecimal data in it in the following block:
try
%dmn:run('NASTY')
%str = %hex:hexToString
catch daemonLost
%str = %errorhex:hexToString
catch invalidHexdata
%str = '???'
end try

The <code>Catch InvalidHexData</code> above would '''not''' catch the conversion error, because the conversion is not
inside the <var>Try</var> block associated with that <var>Catch</var> — it is in a <var>Catch</var> block.

==OnThrow and OnUncaught==
An exception class might want to perform special processing at the time an exception is thrown:
<ul>
<li>It might want to make sure the exception object has valid data.

<li>It might want to record diagnostic information, perhaps to the audit
trail or perhaps to some <var class="product">Model 204</var> file.

<li>It might want to derive some variable values that might not necessarily
have been derivable in the <var>Constructor</var>.
</ul>

To provide this capability, <var class="product">SOUL</var> special-cases two method names in a
user-defined exception class: <var>OnThrow</var> and <var>OnUncaught</var>.
Both of these methods must be <var>Subroutines</var> (as opposed to <var>Functions</var> or
<var>Properties</var>) and cannot have parameters.

The <var>OnUncaught</var> subroutine is automatically called whenever an exception
of the containing class is thrown, and the exception will not be caught.
The <var>OnThrow</var> subroutine is automatically called whenever an exception
of the containing class is thrown, and either the exception will not be
caught and there is no <var>OnUncaught</var> method in the class, or the exception will be caught.

These two method names have no meaning in non-exception classes.

These methods can be called explicitly, and they can be either <var>Private</var>
or <var>Public</var> (though whether they are <var>Public</var> or <var>Private</var> is irrelevant for
implicit calls when an exception is thrown).

The following illustrates an <var>OnThrow</var> subroutine that makes sure the
exception data is valid at the time an exception is thrown:
class pratfall exception
public
variable sound is string len 32
subroutine onThrow
end public
subroutine onThrow
assert %this:sound eq 'splat' or -
%this:sound eq 'boing'
end subroutine
end class


The following illustrates an <var>OnUncaught</var> subroutine that logs information
from the exception to the audit trail before allowing the request to be cancelled:
class pratfall exception
public
variable sound is string len 32
subroutine onUncaught
end public
subroutine OnUncaught
auditText Taking a pratfall -- {%this:sound}
end subroutine
end class


If <var class="product">SirFact</var> is available and capturing dumps for requesting cancelling
errors, all the information one would need is likely to be in the dump,
so there is probably little need to collect extra data in an <var>OnUncaught</var> subroutine.

There is no way for an <var>OnUncaught</var> or <var>OnThrow</var> subroutine to undo the
effect of the exception, that is, to prevent a request cancellation
if the exception is uncaught.
Both routines, however, '''can''' force a request cancellation,
perhaps by using an <var>Assert</var> statement, even if the exception would
have been caught.
If a request cancellation occurs inside on <var>OnThrow</var> subroutine for
an exception that's about to be caught, the catching statements
are not executed, because the request is cancelled before the
<var>OnThrow</var> subroutine returns.

The <var>Throws</var> clause is invalid on an exception class's <var>OnThrow</var> and
<var>OnUncaught</var> subroutines, so these subroutines cannot, themselves,
throw an exception (for, hopefully, obvious reasons).

The <var>Overridable</var> and <var>Implements</var> clauses are also not valid in
an exception class's <var>OnThrow</var> and <var>OnUncaught</var> subroutine declarations.
However, their behavior is similar to overridable routines:
<ul>
<li>If an extension exception class contains an <var>OnUncaught</var> or
<var>OnThrow</var> routine, that routine will be called, when appropriate,
rather than the base class routine.
<li>The extension class routine can call the corresponding
base class routines as it deems fit.

It does this, however, by using the subroutine name (qualified
with the class name) rather than with the superclass method (since
no overriding is involved):
subroutine onThrow
auditText Calling base class OnThrow
%this:(fooError)onThrow
auditText returned from base class OnThrow
end subroutine


In this example, the extension exception class's base class is called <code>FooError</code>.
Of course, an <var>OnUncaught</var> in an extension class can also call an
<var>OnThrow</var> for a base class (or even for its own class).
</ul>

If an <var>OnUncaught</var> subroutine exists in a base class, but the extension
class contains only an <var>OnThrow</var> subroutine, the base class <var>OnUncaught</var>
routine will be called if an extension class object is thrown as an
exception and the exception will not be caught.
That is, an <var>OnUncaught</var> subroutine will always be called for uncaught
exceptions if one is available in the exception's class or any base
class, regardless of whether there are any <var>OnThrow</var> subroutines in the
exception class or any of its base classes.

[[Category:SOUL object-oriented programming topics]]

$FunLoad

2020-02-28T02:32:04Z

Dme:

{{DISPLAYTITLE:$FunLoad}}
Fast/Unload records in Model 204 list or found set

Note: Many $functions have been deprecated in favor of Object Oriented methods. The OO equivalent for the $Funload function is the <var>[[FastUnload (Recordset function)|FastUnload]]</var> function in the <var>Recordset</var> class

This function requests an unload of the data in a <var class="product">Model 204</var> list or found set using <var class="product">[[Fast/Unload]]</var>. If <var class="product">Fast/Unload</var> is not installed at your site, this function returns a <code>-1</code> error code.

<var>$FunLoad</var> accepts six arguments, as explained below.

==Syntax==
%result = $FunLoad(found_set, funin, funprint, funout, [parms], [timelimit])


<table>
<tr><th>%result</th>
<td>This numeric variable is set to the [[#Return codes and error messages|return code]] from Fast Unload, to the positive request number for asynchronous requests, or to a negative number if <var class="product">Fast/Unload</var> is unable to process the request.</td></tr>

<tr><th>found_set</th>
<td>A string that identifies a found set or a list. This is a required parameter. If you want to unload records in a found set created with a FIND statement, pass the label of the found set as the <var class="term">found_set</var> argument. To unload the records in a list, specify the name of the list as the <var class="term">found_set</var> argument.

If you have a <var>FIND</var> statement label and a list with the same name, <var>$FunLoad</var> will use the <var>FIND</var> statement label, unless you explicitly specify that you want to unload a list by preceding the name of the list with the word <code>LIST</code>. For example, in the following program the unload at label <code>FUN1</code> unloads all records found in the <var>FIND</var> statement at label <code>DATA</code>, while the unload at label <code>FUN2</code> unloadsthe records on list <code>DATA</code>: 

declare list data in bigfile

data: in bigfile find all records for which
. . .
end find

fun1: %rc = $funload('DATA',...)
fun2: %rc = $funload('LIST DATA',..)


<var class="product">Model 204</var> <var>FIND</var> statement record locking protects the record sets you are unloading. For jobs where data consistency is critical, reorganizing a file, for example, this record locking is essential. For jobs that can tolerate some inconsistent data, like certain report creation, unlocked record sets (<var>FIND WITHOUT LOCKS</var>) may be suitable. 

You cannot unload records that are not in a found set or a list. For example, you cannot unload a sorted record set (although you can use sorted output in the FUEL program that <var>$FunLoad</var> runs, as described in [[Fast/Unload Extraction Language (FUEL)]]). </td></tr>

<tr><th>funin</th>
<td>The identifier of a [[$lists|$list]], or it is the DDname of an input program. This argument corresponds to FUNIN in batch mode <var class="product">Fast/Unload</var>. This is a required parameter. </td></tr>

<tr><th>funprint</th>
<td>The identifier of the $list that is to receive the <var class="product">Fast/Unload</var> report data, or it is the DDname of a file that is to receive the <var class="product">Fast/Unload</var> report data. Note that if you specify the ASYNCH parameter, you cannot specify a $list identifier for this argument. This argument corresponds to FUNPRINT in batch mode <var class="product">Fast/Unload</var>.

If this parameter is not specified, all report data will go to the <var class="product">Fast/Unload</var> audit trail. </td></tr>

<tr><th>funout</th>
<td>Corresponds to FUNOUT in batch mode <var class="product">Fast/Unload</var>; specifies the destination for the output data. This argument is required, and it may be one of the following:
<ul>
<li>A %variable that identifies the $list that is to receive the unloaded data. If you use a $list for output, you are allowed only one output stream in the FUEL program you are invoking. The $list you specify will be the sole output destination, and any destination names specified in the FUEL program are ignored.</li>

<li>An asterisk (<tt>*</tt>), indicating that the unloaded data will be processed with <var>$FunImg</var>, <var>$FunSkip</var>, and/or <var>$FunsStr</var>. Specifying an asterisk for the <var class="term">funout</var> argument implies that the unload is asynchronous, whether or not the ASYNCH parameter is actually specified. </li>

<li>A string (eight characters at most), which indicates that the output data is to be sent to the one or more data sets specified in the FUEL program.

Formerly, multiple output data sets were not supported by the <var class="product">[[Fast/Unload SOUL Interface]]</var>, and this <var class="term">funout</var> argument had to be the DDname of the destination file for the single output stream specified or implied in the FUEL program. <var>$FunLoad</var> validated the existence and attempted to obtain an exclusive enqueue on the output data set. </li>
</ul>

Processing of this argument depends on the <var class="product">Fast/Unload</var> version: 
<ul>
<li>For <var class="product">Fast/Unload</var> versions prior to 4.2, only a single output stream is supported, and processing is as described above. </li>

<li>For <var class="product">Fast/Unload</var> 4.2 and higher, multiple output data sets are supported, and this argument string serves as a placeholder only, indicating that the output data is to be sent to the one or more data sets specified in the FUEL program. <var class="product">Fast/Unload</var> will validate the existence and attempt to obtain an exclusive enqueue on all output data sets specified or implied in the FUEL program. </li>
</ul></td></tr>

<tr><th>parms</th>
<td>A string that specifies the <var class="product">Fast/Unload</var> parameters. This string can contain any of the parameters allowed on the PARM option on the EXEC card for batch mode <var class="product">Fast/Unload</var>
and can, in addition, contain the parameters ASYNCH, ALLMSG and NOTIFY. The description of parameters in [[Fast/Unload program parameters]] shows the default parameter values, showing any differences when invoked via the <var class="product">Fast/Unload SOUL Interface</var>. </td></tr>

<tr><th>timelimit</th>
<td>A number indicating the maximum amount of time in seconds that the request is to be allowed to complete. If the <var>$FunLoad</var> request does not complete within this time, the <var>$FunLoad</var> request is immediately cancelled. The SOUL request is not cancelled in such a case, but, for synchronous requests, <var>$FunLoad</var> returns a 32. This is an optional argument and, if not specified, defaults to the <var>FUNMAXT</var> system parameter setting.

An explicit or default value of 0 means that there will be no time limit placed on the request. 

Note: The time limit includes the time waiting for the request to actually be run by a <var class="product">Fast/Unload</var> task, so a request could time out because of other long-running requests tying up the <var class="product">Fast/Unload</var> tasks. </td></tr>
</table>

==Return codes and error messages==
These are the return codes:
 -1 - <var class="product">Fast/Unload</var> PST not available
-2 - Input/report/output DDname in use
-3 - Ran out of CCATEMP or free storage
-4 - Input/report/output DDname not found
-5 - Required parameter not specified
-11 - Invalid found set specified
-12 - Invalid input/report/output descriptor specified
-13 - Conflicting parameters


In addition to the above error codes, if <var>$FunLoad</var> discovers that a required capability is not supported by the version of <var class="product">Fast/Unload</var> in use, the SOUL request is cancelled with an error message indicating the missing capability. If any missing capabilities that would prevent successful <var>$FunLoad</var> operation are discovered during <var class="product">Model 204</var> initialization, an operator warning is issued and saved in the <code>VIEW ERRORS</code> table, so that corrective action may be taken in advance.

If the X'01' bit is set in the system <var>FUNPARM</var> parameter, the request is cancelled if a <var>$FunLoad</var> is issued in the middle of an updating transaction. Whether or not <var>FUNPARM</var> X'01' is set, it is generally best to avoid <var>$FunLoad</var> calls in the middle of an updating transaction, since <var>$FunLoad</var> calls can take a long time to run, even if the specific <var>$FunLoad</var> request is relatively small. This is so because all <var>$FunLoad</var> requests share the same <var>FUNTSKN</var> subtasks, and if these are tied up with relatively long-running requests, all other requests must wait for access to a <var class="product">Fast/Unload</var> task.

To make it easier to diagnose problems where <var class="product">Fast/Unload SOUL Interface</var> is involved, messages are also sent to the <var class="product">Model 204</var> journal/audit trail at each <var class="product">Fast/Unload</var> request made and at each completed by the <var class="product">Fast/Unload SOUL Interface</var>.
The message when the requests are started look like:
MSIR.0890: Asynchronous request 2 made by $FunLoad


And the message when the requests are completed look like:
MSIR.0891: Asynchronous request 2 completed, RC = 0


==Examples==
In the following example, the <var class="product">Fast/Unload</var> input data is in DDname <code>FUNIN</code>, the report is to go to DDname <code>FUNPRINT</code>, and the data is to be unloaded to DDname <code>FUNOUT</code>.
begin
find1: find all records in comics for which
name = 'SIMPSON'
end find

%rc = $funload('FIND1', 'FUNIN', 'FUNPRINT', 'FUNOUT', 'NOBUFF=6')

if %rc ne 0 then
print 'Error performing Fast/Unload... RC =' and %rc
end if
end


In the following example, we dynamically build the unload input program, have the report data simply go to the <var class="product">Fast/Unload</var>
audit trail, and have the data unloaded to a $list.
begin
%list1 = $listNew
%list2 = $listNew

%rc = $listAdd( %list1, 'FOR EACH RECORD' )
%rc = $listAdd( %list1, ' PUT ''*''' )
%rc = $listAdd( %list1, ' OUTPUT' )
%rc = $listAdd( %list1, ' PAI' )
%rc = $listAdd( %list1, 'END FOR' )

find1: in clowns find all records for which
trademark = 'PRATFALL'
end find

%rc = $funload( 'FIND1', %list1, , %list2)
. . .
end


In the following example, the input FUEL program is contained in procedure <code>UNLOAD1</code> in the <var class="product">Model 204</var> procedure file called <code>FUELPROC</code>. The data is processed with <var>$FunImg</var> calls (not shown).

begin
declare list hoho in bigfile
. . .
%replist = $listNew
%records = 'LIST HOHO'

%inlist = $listNew

%rc = $procOpn('UNLOAD1','FUELPROC')
%rc = $procDat(%inlist)

%options = 'NEBUFF=4,NBBUFF=2,UPPER,ALLMSG'
%rc = $funload( %records, %inlist, , '*', %options )
. . .
end


The following is an example of an asynchronous unload request. The input program is in DDname <code>FUNIN</code>, the report data is to go to the <var class="product">Fast/Unload</var>
audit trail, and the data is to be dumped to DDname <code>OUTFILE</code>.

begin
findx: in movies find all records for which
director = 'HITCHCOCK'
end find

%options = 'ASYNCH ALLMSG NOBUFF=8'

%rc = $funload( 'FINDX', 'FUNIN', , 'OUTFILE', %OPTIONS )

if %rc > 0 then
print 'Fast/Unload request accepted,' and 'request number =' with %rc
else
Print 'Fast/Unload request rejected,' and 'error code =' and %rc
end if
end


==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[Fast/Unload SOUL Interface]] </li>
</ul>

[[Category:$Functions|$FunLoad]]
[[Category:Fast/Unload SOUL Interface]]

Regex lookbehind

2020-02-23T19:09:55Z

Dme: Redirected page to Regex processing#lookbehind

#REDIRECT[[Regex processing#lookbehind]]

Regex lookahead

2020-02-23T19:08:32Z

Dme: Redirected page to Regex processing#lookahead

#REDIRECT[[Regex processing#lookahead]]

Regex processing

2020-02-23T19:07:53Z

Dme: /* Look-around subexpressions */

<var class="product">SOUL</var> includes support for '''regular expression'''
("regex") processing in multiple $functions and O-O methods.
This support is modeled closely on Perl's regular expression implementation.

==Overview==
SOUL $functions and methods offer the following variety of tasks you
can accomplish using a regex.
<ul>
<li>Simple matching:
<ul>
<li>You can determine whether and where a single regex pattern
matches within a single input string.
See the <var>[[RegexMatch (String function)|RegexMatch]]</var> and <var>[[UnicodeRegexMatch (Unicode function)|UnicodeRegexMatch]]</var> intrinsic functions. </li>

<li>You can apply a single regex to a <var>Stringlist</var> to find one item. See the <var>[[RegexLocate and RegexLocateUp (Stringlist functions)|RegexLocate]]</var> and
<var>[[RegexLocate and RegexLocateUp (Stringlist functions)|RegexLocateUp]]</var> <var>Stringlist</var> functions. </li>

<li>You can apply a single regex to a <var>Stringlist</var> to find all
matching items and place them on a <var>Stringlist</var>.
See the <var>[[RegexSubset (Stringlist function)|RegexSubset]]</var> <var>Stringlist</var> function. </li>
</ul></li>

<li>Capturing:
<ul>
<li>You can append to a <var>Stringlist</var> the characters in an input string that are matched by regex capturing groups.
See the <var>[[RegexCapture (Stringlist function)|RegexCapture]]</var> <var>Stringlist</var> function. </li>
</ul></li>

<li>Searching and replacing:
<ul>
<li>You can replace the matched characters in a single
input string with a specified string, one or many times.
See the <var>[[RegexReplace (String function)|RegexReplace]]</var> and <var>[[UnicodeRegexReplace (Unicode function)|UnicodeRegexReplace]]</var> intrinsic functions. </li>

<li>You can find the characters in a single string
that are matched by one of a set (<var>Stringlist</var>) of regexes, and replace
the matched characters with a string from a corresponding set (<var>Stringlist</var>).
See the <var>[[RegexReplaceCorresponding (Stringlist function)|RegexReplaceCorresponding]]</var> <var>Stringlist</var> function. </li>
</ul></li>

<li>Splitting:
<ul>
<li>You can use a regex repeatedly to separate a given input string
into the substrings that are
matched by the regex and the substrings that are not matched, and
append to a Stringlist either or both of these sets of substrings
(in combination or not with the subset of matched substrings
that are captured.
See the <var>[[RegexSplit (Stringlist function)|RegexSplit]]</var> <var>Stringlist</var> function.
and <var>[[RegexSplit (String function)|RegexSplit]]</var> intrinsic <var>String</var> function. </li>
</ul></li>
</ul>

Many tools implement regular expressions, each with its own variation
of supported features.
The following sections describe the SOUL regex support.
<ul>
<li>[[#Regex rules|Regex rules]] discusses the symbols and grammar of SOUL regex. </li>

<li>[[#Common regex options|Common regex options]] and [[#XML Schema mode|XML Schema mode]] discuss options that modify the
interpretation of a specified regex, which are available to some or all of the SOUL regex $functions and methods. </li>

<li>[[#SOUL programming considerations|SOUL programming considerations]] discusses aspects of using regex in SOUL programs. </li>
</ul>

===Distinction from SOUL Is Like pattern matching===
The use of regex processing conforms to the common matching processing provided in contemporary languages such as Perl, PHP, Python, Java, and so on. In addition to this, several constructs in SOUL, such as the <var>Find</var> and <var>If</var> statements, provide a pattern matching construct using an <var>Is Like</var> clause. The rules for <var>Is Like</var> are discussed in the syntax for [[Is Like pattern matching#likeSyntax|Is like patterns]].

==Regex rules==
When a regular expression is said to "match a string," what is meant is
that a substring of characters within the string
fit (are matched by) the pattern specified by the regex.
The "rules" observed by SOUL for regex formation and matching
are primarily those followed
by the Perl programing language (as described, for example, in
''Programming Perl'', by Larry Wall et al,
published by O'Reilly Media, Inc.; 3rd edition, July 14, 2000).
An additional reference is
''Mastering Regular Expressions'', by Jeffrey E. F. Friedl,
published by O'Reilly Media, Inc. (2nd edition, July 15, 2002).
In terms of the type of regex engine described in this book, the Model 204
regex processing is considered NFA (not DFA, and not POSIX NFA).

Highlights of the SOUL regex support are discussed in the following
subsections, especially noting where SOUL rules differ from Perl's.
If a regex feature is not mentioned below, you should assume it is supported by SOUL to the extent that it is supported in Perl.

===Online web resources; regex character set===
A Google search of 'regex' will yield many pages, and you will find some that are well suited to your task; it is difficult to provide a "one size fits all" recommendation.

However, here is one link that provides a one-page illustration of regex features, with extremely brief indications of their purpose:

http://web.mit.edu/hackl/www/lab/turkshop/slides/regex-cheatsheet.pdf

And here is a clip from that page (as of January 24, 2019) listing the characters which have special meaning in regex (any other character in a regex matches the character itself):

Special characters
<ul>
<li>The following 6 characters
{}[]()
<li>and the following 8 characters
^$.|*+?\
<li>and <code>-</code> inside <code>[</code>...<code>]</code>
</ul>
have special meaning in regex, so they
must be "escaped" with <code>\</code> to match them.
Ex: <code>\.</code> matches the period <code>.</code> and
<code>\\</code>
matches the
backslash <code>\</code>


The above 15 metacharacters are those that can be escaped in Model 204 regex, as described in the [[#esc|table below]].

===Expression constituents===
This section describes elements that constitute the actual expression pattern.
The next section describes features that modify or affect a specified pattern.
These sections describe the default case where the optional
[[#XML Schema mode|XML Schema mode]] processing is ''not'' in effect.

These features are discussed:
<ul>
<li>[[#Escape sequences|Escape sequences]]
<li>[[#Character classes|Character classes]]
<li>[[#Greedy and non-greedy quantifiers|Greedy and non-greedy quantifiers]]
<li>[[#Capturing groups|Capturing groups]]
<li>[[#Look-around subexpressions|Look-around subexpressions]]
<li>[[#Alternatives|Alternatives]]
</ul>

====Escape sequences====
The only escape sequences allowed in a Model 204 regex are those
for metacharacters
and those that are "shorthands" for special characters or character classes, as specified below.

These metacharacter escapes are allowed in regex arguments:

<table class="thJustBold">
<tr>
<th valign="top">\ .</th>
<td>Period (or dot); see [[#Mode modifiers|Mode modifiers]] for difference from Perl on what is matched by an un-escaped period
</td></tr>

<tr>
<th>\ [</th>
<td>Left square bracket
</td></tr>

<tr>
<th>\ ]</th>
<td>Right square bracket
</td></tr>

<tr>
<th>\ (</th>
<td>Left, or opening, parenthesis
</td></tr>

<tr>
<th>\ )</th>
<td>Right, or closing, parenthesis
</td></tr>

<tr>
<th>\*</th>
<td>Star, or asterisk
</td></tr>

<tr>
<th>\ -</th>
<td>Hyphen
</td></tr>

<tr>
<th>\ {</th>
<td>Left curly bracket
</td></tr>

<tr>
<th nowrap>\ }</th>
<td>Right curly bracket
</td></tr>

<tr>
<th>\ |</th>
<td>Vertical bar
</td></tr>

<tr>
<th>\\</th>
<td>Backslash
</td></tr>

<tr>
<th>\+</th>
<td>Plus sign
</td></tr>

<tr>
<th>\?</th>
<td>Question mark
</td></tr>

<tr>
<th>\$</th>
<td>Dollar sign
</td></tr>

<tr>
<th valign="top">\^</th>
<td>Caret, or circumflex
'''Note:''' A caret is used in this documentation to represent the character that the keyboard program translates to X'5F'; this may be a not sign (<tt>¬</tt>) on your system.</td></tr>
</table>

These character shorthands are allowed:
<table class="thJustBold">
<tr><th>\n</th>
<td>Linefeed (X'25')
</td></tr>

<tr><th>\r</th>
<td>Carriage return (X'0D')
</td></tr>

<tr><th>\t</th>
<td>Horizontal tab (X'05')
</table>

These class shorthands are allowed:
<table class="thJustBold">
<tr><th valign="top">\b</th>
<td>Word boundary anchor (a position between a \w character and a non-\w character) — but not supported as a backspace character or within a character class.</td></tr>

<tr><th valign="top">\B</th>
<td>The inverse of \b: any position that is not a word boundary anchor.
</td></tr>

<tr><th valign="top">\c</th>
<td>Legal name character; equivalent to <code>[\-_:.A-Za-z0-9]</code>
</td></tr>

<tr><th valign="top">\C</th>
<td>Non-legal name character; equivalent to <code>[^\-_:.A-Za-z0-9]</code>
</td></tr>

<tr><th valign="top">\d</th>
<td>Digit; equivalent to <code>[0-9]</code>
</td></tr>

<tr><th valign="top">\D</th>
<td>Non-digit; equivalent to <code>[^0-9]</code>
</td></tr>

<tr><th valign="top">\i</th>
<td>Legal start-of-name character; equivalent to <code>[_:A-Za-z]</code>
</td></tr>

<tr><th valign="top">\I</th>
<td>Non-legal start-of-name character; equivalent to <code>[^_:A-Za-z]</code>
</td></tr>

<tr><th valign="top">\s</th>
<td>Whitespace character; equivalent to <code>[ \r\n\t]</code>
</td></tr>

<tr><th valign="top">\S</th>
<td>Non-whitespace; equivalent to <code>[^ \r\n\t]</code>
</td></tr>

<tr><th valign="top">\w</th>
<td>Any letter (uppercase or lowercase), any digit, or the underscore.
</td></tr>

<tr><th valign="top">\W</th>
<td>The inverse of \w: any non-letter or non-digit except the underscore.
</td></tr>
</table>

====Character classes====
In character classes (which "match any character in the square
brackets"):
<ul>
<li>The only ranges allowed are subsets of uppercase letters,
lowcase letters, or digits.
For example, <code>[A-z]</code> is
'''not''' legal; <code>[A-Za-z]</code> '''is''' legal; <code>[a-9]</code>
is '''not''' legal.

Because of the gaps in the EBCDIC encoding, you can specify <code>[A-Z]</code>,
but internally that is converted to <code>[A-IJ-RS-Z]</code>;
and similarly for <code>[a-z]</code>. </li>

<li>Multi-character escape sequences
(for example, <code>\s</code>, <code>\c</code>)
are allowed within character classes.
However, they are '''not''' allowed as either side in a range. </li>

<li>An unescaped hyphen (<code>-</code>) is allowed
if it occurs as the first character (or the second, if the first
is <code>^</code>) or as the last character in a character class expression.
An escaped hyphen (<code>\-</code>) is allowed in all positions.

All the following are allowed: 
[-A-Z158]
[^-A-Z158]
[158A-Z-]
[158A-Z0-]


But <code>[A-F-K]</code> is '''not''' allowed.
And a hyphen is not allowed as the left or right character
in the range expression itself
(<code>["--]</code>, for example, is '''not''' allowed). </li>

<li>Some bracket characters (<code>[</code> or <code>]</code>,
from any of the several character codes that produce a left or right square bracket in EBCDIC) do not have to be escaped.
A bracket character does ''not'' require a preceding escape character if it is:
<ul>
<li>A right bracket (<code>]</code>) that is outside of, not part of,
a character class expression.
So, <code>(1]9)</code> matches <code>0001]9zzz</code>. </li>

<li>A right bracket that is the first character — or
the second, if the first is a caret (<code>^</code>) —
in a character class expression.
So, <code>[]xxx]</code> and <code>[^]xxx]</code> are legal. </li>

<li>A left bracket that occurs anywhere in a character class expression.
So, <code>[abc[]</code> is legal and matches any of these four
characters: <code>a b c [</code>

A left bracket that occurs outside of a character class expression must always be escaped. </li>
</ul></li>

Although not required, escape characters may be used in the cases cited above.
</ul>

====Greedy and non-greedy quantifiers====
Both greedy and non-greedy matching are supported.
That is, if there is more than one plausible match for a greedy quantifier
(<code>*</code>, <code>+</code>, <code>?</code>, <code>{min,max}</code>),
which govern how many input string characters the
preceding regex item may try to match), the longest one is selected.
In contrast, the non-greedy (aka "lazy")
quantifiers (<code>*?</code>, <code>+?</code>, <code>??</code>, <code>{min,max}?</code>)
select the minimum number of characters needed to satisfy a match.

For example, in SOUL methods and $functions, the regex <code><.+></code>
greedily matches
the entire input string <code><tag1 att=x><tag2 att=y><tag3 att=z></code>, although its set of plausible matches
also includes <code><tag1 att=x></code> and <code><tag2 att=y></code>.

The regex <code><.+?></code>, however, lazily matches just <code><tag1 att=x></code>,
the shortest of the plausible matches.
'''Note:'''
Since <code>??</code> is a <var class="product">Model 204</var> dummy string signifier,
you may need to use a SOUL expression such as
<code>'?' With '?'</code> if you want to use the <code>??</code> quantifier. 

Understanding greediness becomes more important when the string
that a regex matches is being replaced by another string. See the [[RegexReplace (String function)#greedy|greedy example]] for the <var>RegexReplace</var> function.

====Capturing groups====
<ul>
<li>Extraction of repeating capture groups from a string is
different in Perl and SOUL.
If there are multiple matches by a repeated group, Perl replaces each capture with the next one, ending up with only the final capture.
SOUL saves each capture and concatenates them when finished.

For example, if this is the ''regex'': 
9([A-Z])*9


And this is the input string: 
xxx9ABCDEF9yyy


In both the <var class="product">SOUL</var> and Perl,
the "greedy quantifier" <code>*</code> matches as many times as it can,
stopping at the second <code>9</code>.
The resulting capture in SOUL $functions and methods is <code>ABCDEF</code>,
the concatenation of six one-character matches.
In Perl, the resulting capture is <code>F</code>. </li>

<li>A subexpression that is a validly formed capturing group
that is nested within a
non-capturing subexpression is still a capturing group.
The regex <code>(?:[1-9]*(a+))</code> matches <code>123aa</code> and
captures <code>aa</code>. </li>
</ul>

====Look-around subexpressions====
Although look-ahead subexpressions in a regex are supported,
look-behind subexpressions are '''not''' supported.
Look-behind specifications begin with <code>(?<=</code> or <code>(?<!</code>.

The only supported parenthesized subexpression sequences that begin
with a question mark are the following, which are all non-capturing:
<table>
<tr><td>(?:</td>
<td>Denotes a non-capturing group</td></tr>

<tr><td>(?=</td>
<td>Denotes a positive look-ahead</td></tr>

<tr><td>(?!</td>
<td>Denotes a negative look-ahead</td></tr>
</table>

====Alternatives====
Alternatives (indicated by <code>|</code>) are evaluated from
left to right,
and evaluation is "short-circuited" (that is, it stops as soon as it finds a match).

Empty expressions, for example, empty alternatives, are supported.
The following regex matches <code>A9</code>, <code>B9</code>, and <code>9</code>,
capturing respectively <code>A</code>, <code>B</code>, and the null string:
(A|B|)9

An empty alternative (like the <code>|</code>, above, that is followed only by the closing parenthesis) is always True.
<blockquote class="note">
'''Note:'''
SOUL and Perl make a special case of a regex that has
an empty alternative on the left (or anywhere but at the right end).
You might think that such an "always true" alternative gets selected
before, and thereby prevents the evaluation of, the alternatives to its right.
However, in such a regex, this empty alternative is evaluated as the last
alternative instead of according to its actual position. 

For example, the regex <code>(|A|B)9</code> matches each of the
strings <code>A9</code>, <code>B9</code>, and <code>9</code>.
However, since the evaluation of the empty alternative is
implicitly postponed until the other alternatives are tried,
the <code>(|A|B)</code> group captures,
respectively, <code>A</code>, <code>B</code>, and the null string.
</blockquote>

===Features that affect the whole expression===

====Unicode====
Unicode is supported by the <var>[[UnicodeRegexMatch (Unicode function)|UnicodeRegexMatch]]</var> and <var>[[UnicodeRegexReplace (Unicode function)|UnicodeRegexReplace]]</var> functions.

====Locales====
Locales are not supported.

====Mode modifiers====
Mode modifiers are settings that influence how a regex is applied.
SOUL mode modifiers apply to the entire regex; none can be applied to
part of a regex.
<ul>
<li>In SOUL regex, the dot (<code>.</code>) metacharacter matches any character except for a carriage return or linefeed.
'''Note:'''
In Perl, which does not consider a carriage return an end-of-line character,
a dot always matches a carriage return as well. 

To initiate dot-matches-all mode, in which dot matches '''any'''
character, Perl uses an <code>s</code> character after the regex-ending <code>/</code>.
SOUL regex $functions and methods have an "options" argument
that can initiate this mode (value <code>S</code>), as described
in [[#Common regex options|Common regex options]]. </li>

<li>Perl supports a case-insensitive matching mode
that you can apply globally (<code>i</code> after the regex-ending <code>/</code>) or partially
(started by <code>(?i)</code> and ended by <code>(?-i)</code>)) to a regex.
SOUL provides only a global case-insensitivity switch, which does
'''not''' use the Perl signifier.
Instead, SOUL uses an "options" argument
to initiate case-insensitive matching (value <code>I</code>), as described, below, in [[#Common regex options|Common regex options]]. </li>

<li>In multi-line mode, the caret (<code>^</code>) and
dollar sign (<code>$</code>) anchor characters may match a position wherever
a newline character occurs in the target string — they are not
restricted to matching only at the beginning and end of the string.
To enter this mode, Perl uses an <code>m</code> after the regex-ending <code>/</code>.
SOUL uses an "options" argument to initiate this mode (value <code>M</code>), as described, below,
in [[#Common regex options|Common regex options]]. </li>

<li>In Perl, comments may be included in a regex between the number sign (<code>#</code>) and a newline.
SOUL does not recognize this convention, and the number-sign character
is '''not''' a metacharacter. </li>
</ul>

==Common regex options==
SOUL regex $functions and methods have an optional "options" argument that
lets you invoke one or more operating modes that modify how the regex is applied.
In most cases, the functionality provided by the option is similar to
what Perl provides, but Perl uses a different notation to invoke it.

The options argument is a string of one or more of the following single-letter options.
Not all options are available to all regex $functions and methods.
— the individual $function and method descriptions list the
options available to that function or method.
<table class="thJustBold">
<tr><th>I</th>
<td>Do case-insensitive matching between the input string(s) and the regex. Treat the uppercase and lowercase variants of letters as equivalent. </td></tr>

<tr><th>S</th>
<td>Dot-All mode. If this mode is '''not''' specified, a dot (<code>.</code>), also called a point, matches any single character except X'0D' (carriage return) and X'25' (linefeed). In Dot-All mode, a dot also matches carriage return and linefeed characters. </td></tr>

<tr><th>M</th>
<td>Multi-line mode. If this mode is '''not''' specified, a caret (<code>^</code>) or a not sign (<code>¬</code>) — whichever key your keyboard program translates to X'5F' — matches only the position at the very start of the string, and dollar sign (<code>$</code>) matches only the position at the very end. (This documentation uses the caret.)

The caret and dollar sign are position-identifying characters known
as "anchors," which match the beginning and end, respectively,
of a line or string. They do not match any text. 

In M mode, a caret '''also''' matches the position immediately
after any end-of-line indicator
(carriage return, linefeed, carriage-return/linefeed),
and a dollar sign '''also'''
matches the position immediately before any end-of-line indicator. 

M mode is ignored if option C (XML Schema mode) is also specified, since
caret and dollar sign are not metacharacters in C mode. </td></tr>

<tr><th>C</th>
<td>XML Schema mode. See, below, [[#XML Schema mode|XML Schema mode]]. </td></tr>

<tr><th>G</th>
<td>Global replacement of matched substrings (for methods and $functions that provide replacement substrings for matched substrings).

If this mode is '''not''' specified, a replacement string replaces the first matched substring only.
In G mode, every occurrence of the match is replaced. </td></tr>

<tr><th>A</th>
<td>Replace as is (for methods and $functions that provide replacement substrings for matched substrings.

If this mode is specified, the replacement string is copied as is.
No escapes are recognized; a <code>$n</code> combination
is interpreted as a literal and '''not''' as a special marker;
and so on. </td></tr>
</table>

==XML Schema mode==
An optional "options" argument lets you invoke XML Schema mode.
In this mode (not available in Perl),
the regex matching is done according to the rules for
regular expressions in the W3C XML Schema language specification
(the [http://www.w3.org/TR/xmlschema-2/#regexs Regular Expressions appendix] in Part 2 of the XML Schema recommenation).

This mode is designed for testing regexes for suitability for
validating strings in a schema document
(an XML document that constitutes an XML schema).
Although it is available in most of the SOUL regex $functions
and methods, it is intended primarily for matching and not for capturing
or replacing.

The SOUL regex rules described in [[#Regex rules|Regex rules]]
still apply in XML Schema mode, except:
<ul>
<li>In a regex, no characters are recognized as anchors, and
any regex is treated as if it is anchored at both ends.
The entire regex must match the entire target string (although
you can construct an unanchored match, as described in the
"Regular Expressions" appendix).

The regex <code>ABC</code> in XML Schema mode is equivalent
to <code>^(?:ABC)$</code> in non-XML Schema mode, where
the <code>(?:</code> indicates a "non-capturing" group.

Related to this, or as a consequence of this implicit anchoring:
<ul>
<li>The usual anchoring-atoms, <code>^</code> and <code>$</code>, are
treated as ordinary characters in a regex, and you may ''not'' escape them. </li>

<li>If the multi-line mode option (see [[#Common regex options|Common regex options]]) is specified along with XML Schema mode,
multi-line mode is ignored. </li>
</ul></li>

<li>The two-character sequence <code>(?</code> is not valid in a regex.
You can use a pair of parentheses for grouping, but capturing is not part of the
XML Schema regex specification, nor are non-capturing and look-aheads, whose indicators begin with a <code>(?</code> sequence.

If you specify the XML Schema mode option in a $function or method
that makes use of capturing (or replacing), however, any capturing groups
you use in the regex or replacement string(s) '''do''' perform
their usual operation.</li>

<li>A bracket character (<code>[</code> or <code>]</code>
requires a preceding escape character if it is:
<ul>
<li>A right bracket (<code>]</code>) that is outside of, not part of,
a character class expression.
So, <code>(1\]9)</code> matches <code>0001]9zzz</code>, but <code>(1]9)</code> is ''not'' allowed. </li>

<li>A right bracket that is the first character — or
the second, if the first is a caret (<code>^</code>) —
in a character class expression.
So, <code>[\]xxx]</code> and <code>[^\]xxx]</code> are allowed.</li>

<li>A left bracket that occurs anywhere in a character class expression.
So, <code>[abc\[]</code> is allowed.

A left bracket that
occurs outside of a character class expression must always be escaped.</li>
</ul>

These cases are compiler errors unless the cited bracket characters are escaped.</li>

<li>Character class subtraction is supported.
You can exclude a subset of characters from the characters
already designated to be in the class.
This is only allowed in XML Schema mode, and it is ''not'' allowed in Perl.

This feature lets you specify a character class like the following,
which matches anything from A to Z except D, I, O, Q, U, or V: 
[A-Z-[DIOQUV]]


You can also nest subtractions, as in:
[\w-[A-Z-[DIOQUV]]]


Characters immediately after the right bracket of a subtracted character
class are '''not''' allowed.
<code>[A-Z-[DIOQUV]abc]</code> is an ''invalid'' character class. 

You can also subtract a negated character class:
<code>[A-Z-[^DIOQUV]]</code> is ''valid''. </li>

<li>If the Dot-All mode or case-insensitive mode option (see [[#Common regex options|Common regex options]])
is specified along with XML Schema mode, Dot-All mode or case-insensitive mode works as usual. </li>
</ul>

==SOUL programming considerations==
These are issues of note when writing regex requests:
<ul>
<li>SOUL regex processing can use considerable user stack (PDL) space and STBL space:
<ul>
<li>A program running with a relatively small (less than 3000) setting of the
<var class="product">Model 204</var> <var>LPDLST</var> parameter is subject to a user restart due to PDL overflow,
even with relatively simple regular expressions.
Regular expression compilation and evaluation can sometimes be recursive, with each level of
recursion using a certain amount of PDL space.
For certain complex regular expressions, a large amount of PDL space may be used.

To reset <var>LPDLST</var>, you can use, for example, <code>UTABLE LPDLST 3000</code>.</li>

<li>In general, there must be at least 8500 bytes available in STBL (some
routines use less).
Using <code>UTABLE LSTBL 9000</code> is sufficient if the rest of the
User Language program requires almost no STBL space. </li>
</ul></li>

<li>A question mark character (<code>?</code>) is a reserved character, or metacharacter, in a regex expression.
As pointed out in a preceding subsection, the <code>??</code> character
combination in a SOUL regex is ambiguous, meaning either a regex quantifier or a SOUL dummy string.
In that case, the dummy string interpretation prevails, and you must
use an expression like <code>'?' With '?'</code> to code the regex quantifier.

Similarly, the SOUL dummy-string signifiers <code>?$</code> and <code>?&</code>
take precedence if those character sequences occur in a regex.
To use <code>?$</code> or <code>?&</code>
in a regex, you must use one or two escape characters,
respectively, after the question mark. </li>

<li>A caret (<code>^</code>) is used in this documentation to represent
the character that the keyboard program translates to X'5F'; this may be
a not sign (<code>¬</code>) on your system.</li>
</ul>

[[Category:Overviews]]

$ResetN

2019-11-11T00:16:14Z

Dme:

{{DISPLAYTITLE:$ResetN}}
Reset or view M204 parameter

Note: Many $functions have been deprecated in favor of Object Oriented methods. There is no OO equivalent for the <var>$ResetN</var> function.

This [[Calling Sirius Mods $functions|callable]] function retrieves the current value of a <var class="product">Model 204</var> parameter, and it can also change the value of that parameter. Not all parameters are resettable by $ResetN: the supported subset includes only parameters considered useful to change as well as safe to change during evaluation of a <var class="product">SOUL</var> request.

<var>$ResetN</var> accepts one required and two optional arguments, and it returns a numeric value.

==Syntax==
[%oldval =] $ResetN(parameter, newval, %rc_variable)


===Syntax terms===
<table class="syntaxTable">
<tr><th>%oldval</th>
<td>The returned value is the current value of <var class="term">parameter</var> (before <var>$ResetN</var> changes it). If the <var class="term">parameter</var> is not the name of a parameter supported by <var>$ResetN</var>, the returned value is 0 (if <var class="term">%rc_variable</var> is supplied; otherwise this and all errors cause request cancellation).</td></tr>

<tr><th>parameter</th>
<td>A string that is the name of the parameter to retrieve (and optionally reset). See the list of allowed parameters in [[#Parameters resettable by $ResetN|Parameters resettable by $ResetN]]. </td></tr>

<tr><th>newval</th>
<td>An optional numeric value. If specified, the parameter is reset to this value. </td></tr>

<tr><th>%rc_variable</th>
<td>An optional %variable that is the target for the <var>$ResetN</var> return code. If specified, this %variable is set to one of the return codes shown [[#Return codes|below]]. If this argument is omitted and a condition occurs that is associated with a non-zero return code value, the request is cancelled.

This %variable may '''not''' be a <var class="product">SOUL</var> [[Classes_and_Objects#Variable_declarations|class variable]]. </td></tr>
</table>

==Return codes==
-1 — Invalid value for parameter
0 — Successful completion
1 — Invalid parameter name


==Examples==
For example, the following fragment will to prevent the <code>M204.0620 FILE OPENED</code> and <code>M204.1203 FILE WAS LAST UPDATED</code> messages from going to the user's terminal:

%VAL = $ResetN('MSGCTL', 2)
OPEN 'MYFILE' PASSWORD 'UPDATE'
%VAL = $ResetN('MSGCTL', %VAL)


==Parameters resettable by $ResetN==
In the following list of parameters, the minimum and maximum value is shown. Note that these values may be more strict than the corresponding minimums and maximums allowed by the <var class="product">Model 204</var> <var>[[RESET command|RESET]]</var> command. For example, the <code>RESET ERMX -2</code> command changes <var>[[ERMX parameter|ERMX]]</var> to a value, as shown by the response to the command, of 65534. However, the value of -2 is not "meaningful" for <var>ERMX</var>. To avoid this, an attempt to invoke <code>$ResetN('ERMX',-2)</code> is rejected, because -2 is outside the legal range for <var>ERMX</var>.

'''Note: ''' This situation is even more pointed for <var>UDDLPP</var>, which is currently not supported for <var>$ResetN
</var> because there is little reason to change it from within a <var class="product">SOUL</var> request.

The <code>RESET UDDLPP -1</code> command changes <var>[[UDDLPP parameter|UDDLPP]]</var> to a value of 65535, as shown by the response to the command or as returned by <var>$VIEW</var>. However, the <code>RESET UDDLPP 65535</code> command issues an error message and changes <var>UDDLPP</var> to the value of 32767, which is very different from the meaning of -1 for <var>UDDLPP</var>.

The valid parameter names which may be supplied as the <var class="term">parameter</var> argument to <var>$ResetN</var> are shown in the following list, along with the minimum and maximum values and a terse description.
<table>
<tr><th><var>[[ENQRETRY parameter|ENQRETRY]]</var></th>
<td>0..255: Record-locking retry count</td></tr>

<tr><th><var>[[ENQTIME parameter|ENQTIME]]</var></th>
<td>1..60000: Record-locking retry wait time, milliseconds (new in version 7.8, or in 7.7 with zap 77Z299)</td></tr>

<tr><th><var>[[ERCNT parameter|ERCNT]]</var></th>
<td>0..65,535: Error count (provided by the <var class="product">Sirius Mods</var>). (Note that the you can also increment or clear this using <var>[[$ErrSet]]</var>.)</td></tr>

<tr><th><var>[[ERMX parameter|ERMX]]</var></th>
<td>-1..65,534: Maximum number of errors</td></tr>

<tr><th><var>[[FSOUTPUT parameter|FSOUTPUT]]</var></th>
<td>0..2: Full screen color and highlighting</td></tr>

<tr><th><var>[[HDRCTL parameter|HDRCTL]]</var></th>
<td>0..255: Header control</td></tr>

<tr><th><var>[[MBSCAN parameter|MBSCAN]]</var></th>
<td>-2,147,483,647..2,147,483,647: Maximum table B to records scan</td></tr>

<tr><th><var>[[MCNCT parameter|MCNCT]]</var></th>
<td>-2,147,483,647..2,147,483,647: Maximum connect time</td></tr>

<tr><th><var>[[MCPU parameter|MCPU]]</var></th>
<td>-2,147,483,647..2,147,483,647: Maximum CPU time</td></tr>

<tr><th><var>[[MDKRD parameter|MDKRD]]</var></th>
<td>-2,147,483,647..2,147,483,647: Maximum disk reads</td></tr>

<tr><th><var>[[MDKWR parameter|MDKWR]]</var></th>
<td>-2,147,483,647..2,147,483,647: Maximum disk writes</td></tr>

<tr><th><var>[[MOUT parameter|MOUT]]</var></th>
<td>-2,147,483,647..2,147,483,647: Maximum output lines</td></tr>

<tr><th><var>[[MSGCTL parameter|MSGCTL]]</var></th>
<td>0..255: Message printing options</td></tr>

<tr><th><var>[[MUDD parameter|MUDD]]</var></th>
<td>-2,147,483,647..2,147,483,647: Maximum USE dataset lines
</td></tr></table>

Some of the parameters supported by <var>$ResetN</var> are treated as "hexadecimal" parameters by the <var class="product">Model 204</var> <var>RESET</var> command. For example, the <code>VIEW HDRCTL</code> command displays a result such as <code>X'01'</code>. It so happens that this is a moot point with any of these "hex" parameters currently supported by <var>$ResetN</var>, because the maximum value they may have is 7, which is the same in base 10 and base 16.

However, if <var>$ResetN</var> is extended to support, for example, <var>UDDRFM</var>, you might wish to supply an argument to <var>$ResetN</var> expressed in hex. This could be easily accomplished using the <var>$X2D</var> function. Again, assuming <var>$ResetN</var> were extended to support <var>UDDRFM</var>, you could set the USE dataset record format to variable length records with ASA carriage control with the following statement:

%VAL = $ResetN('UDDRFM', $X2D('12'))


==See also==
<ul>
<li><var>[[$SirParm]]</var>
</ul>

==Products authorizing {{PAGENAMEE}}==
<ul class="smallAndTightList">
<li>[[Sirius Functions]]</li>
<li>[[Fast/Unload User Language Interface]]</li>
<li>[[Media:JoclrNew.pdf|Janus Open Client]]</li>
<li>[[Media:JosrvrNew.pdf|Janus Open Server]]</li>
<li>[[Janus Sockets]]</li>
<li>[[Janus Web Server]]</li>
<li>Japanese functions</li>
<li>[[Media:SirfieldNew.pdf|Sir2000 Field Migration Facility]]</li>
</ul>

[[Category:$Functions|$ResetN]]

SOUL $functions

2019-11-11T00:05:00Z

Dme:

Some operations are inefficient or impossible to code in a high-level programming language like <var class="product">SOUL</var>. To overcome this difficulty, <var class="product">SOUL</var> provides a variety of $functions. Many of these functions are deprecated in favor of an OO API method. When that is the case, the $function page notes the matching method.

<div id="otherLists"></div>
The mathematical $functions, and those $functions central to a <var class="product">Model 204</var> product (and which require authorization of that product) are listed separately; you can find links to those sets of $functions in the following table:
<div class="showVisit">
<table class="wikitable">
<tr class="head"><th>$Function set</th><th>Description</th></tr>

<tr><td>[[List of mathematical $functions|$xxxmath]]</td><td>Mathematical $functions</td></tr>
<tr><td>[[SirFact $functions|$Fact_xxx]]</td><td>SirFact $functions</td></tr>
<tr><td>[[List of Janus FTP Server $functions|$Ftp_xxx]]</td><td>Janus FTP Server $functions</td></tr>
<tr><td>[[List of Janus Sockets $functions|$Sock_xxx]]</td><td>Janus Sockets $functions</td></tr>
<tr><td>[[List of Janus Web Server $functions|$Web_xxx]]</td><td>Janus Web Server $functions</td></tr>
<tr><td>[[List of Sir2000 User Language Tools $functions|Sir2000]]</td><td>Sir2000 User Language Tools $functions</td></tr>

</table>
</div>

==List of standard $functions==
The following table lists available <var class="product">SOUL</var> $functions, in alphabetical order. The list is not exhaustive (see the [[#otherLists|table of other $function sets]], above).

Note: Some of the $functions listed below are only available with the purchase of a Model 204 add-on product. The individual page containing such a $function's full description has an itemized list of the add-on products that authorize the use of the $function.

See also: 
<ul>
<li>[[#Using_functions|Using functions]], which reviews coding in <var class="product">SOUL</var> with $functions </li>

<li>[[Notation conventions]], which provides a description of the conventions used in syntax on individual $function pages. </li>
</ul>

<div class="showVisit">
<table class="wikitable">
<tr class="head"><th>$Function</th><th>Description</th></tr>



<tr><td>[[$Abbrev]]</td><td>Determine if string is abbreviation within list of words</td></tr>
<tr><td>[[$Account]]</td><td>Account under which the user is logged in.</td></tr>
<tr><td>[[$Acct]]</td><td>User ID under which the user is logged in.</td></tr>
<tr><td>[[$Alpha]]</td><td>Whether a string is composed of only the letters A through Z.</td></tr>
<tr><td>[[$AlphNum]]</td><td>Whether a string is composed of only the letters A through Z and digits 0 through 9.</td></tr>
<tr><td>[[$Arr_Find]]</td><td>Find value within array</td></tr>
<tr><td>[[$Arr_Init]]</td><td>Initialize every element of array to specific value</td></tr>
<tr><td>[[$Arr_Max]]</td><td>Find maximum value in array</td></tr>
<tr><td>[[$Arr_Min]]</td><td>Find minimum value in array</td></tr>
<tr><td>[[$ArrSize]]</td><td>Number of elements in a particular dimension of an array.</td></tr>
<tr><td>[[$Ascii]]</td><td>Input string, converted from EBCDIC to ASCII.</td></tr>
<tr><td>[[$A2E]]</td><td>Translate ASCII to EBCDIC</td></tr>
<tr><td>[[$Base64_Decode]]</td><td>Convert from base 64 to byte string</td></tr>
<tr><td>[[$Base64_Encode]]</td><td>Convert byte string to base 64</td></tr>
<tr><td>[[$BgPurge]]</td><td>Cancel "long" sdaemon request initiated with $CommBg</td></tr>
<tr><td>[[$BgQuery]]</td><td>List of "long" sdaemon requests initiated via $CommBg</td></tr>
<tr><td>[[$Binary]]</td><td>A number converted into fixed-point binary.</td></tr>
<tr><td>[[$Bind_List]]</td><td>Return list of bound semaphores onto a $list</td></tr>
<tr><td>[[$Bind]]</td><td>Fast, easy synchronization of system wide resource</td></tr>
<tr><td>[[$BitAnd]]</td><td>Bitwise AND of two integers</td></tr>
<tr><td>[[$BitOr]]</td><td>Bitwise OR of two integers</td></tr>
<tr><td>[[$BldProc]]</td><td>Enables a request to build a temporary procedure.</td></tr>
<tr><td>[[$Buffer_Position]]</td><td>Current Universal Buffer position.</td></tr>
<tr><td>[[$Buffer_Size]]</td><td>Size of user's Universal Buffer.</td></tr>
<tr><td>[[$Buffer_Used]]</td><td>Amount of data currently in Universal Buffer</td></tr>
<tr><td>[[$Bump]]</td><td>Bump a user</td></tr>
<tr><td>[[$CenqCt]]</td><td>Number of unused entries within the resource enqueuing table.</td></tr>
<tr><td>[[$Center]]</td><td>Center string</td></tr>
<tr><td>[[$CfStatL]]</td><td>List of statistics for users holding critical file resources</td></tr>
<tr><td>[[$ChkMod]]</td><td>Whether the terminal operator entered data in any full-screen input field.</td></tr>
<tr><td>[[$ChkPat]]</td><td>Syntax of a pattern.</td></tr>
<tr><td>[[$ChkpInf]]</td><td>Information about checkpoints</td></tr>
<tr><td>[[$ChkTag]]</td><td>Whether any erroneous full-screen input has been entered by the end user.</td></tr>
<tr><td>[[$Close]]</td><td>Close file or group in User Language request</td></tr>
<tr><td>[[$Cms]]</td><td>Determine if online is running under CMS</td></tr>
<tr><td>[[$Code]]</td><td>Encoding facility.</td></tr>
<tr><td>[[$Command]]</td><td>Execute Model 204 command on sdaemon, results to image</td></tr>
<tr><td>[[$CommBg]]</td><td>Execute Model 204 commands on sdaemon</td></tr>
<tr><td>[[$CommndL]]</td><td>Execute Model 204 command on sdaemon, results to $list</td></tr>
<tr><td>[[$Context]]</td><td>Determine if string is name of open file or group</td></tr>
<tr><td>[[$Curfile]]</td><td>Name of the file from which the current record has been selected.</td></tr>
<tr><td>[[$Currec]]</td><td>Integer equal to the internal number of the current record.</td></tr>
<tr><td>[[$C2D]]</td><td>Convert binary byte string to integer</td></tr>
<tr><td>[[$C2X]]</td><td>A translation of each byte within a character string to its two-byte hexadecimal representation.</td></tr>
<tr><td>[[$DaemonMasterNumber]]</td><td>Get user number of master thread</td></tr>
<tr><td>[[$DaemonParentNumber]]</td><td>Get user number of parent thread</td></tr>
<tr><td><div id="datex"></div>[[$Date]]</td><td>Current date in yy-mm-dd format.</td></tr>
<tr><td>[[$DateChg]]</td><td>Specified number of days, added to or subtracted from a given date.</td></tr>
<tr><td>[[$DateChk]]</td><td>Whether a given date is valid.</td></tr>
<tr><td>[[$DateCnv]]</td><td>Date converted to a format specified by the user.</td></tr>
<tr><td>[[$DateDif]]</td><td>Difference in days between two dates.</td></tr>
<tr><td>[[$DateP]]</td><td>Current date in "dd mon yy" format.</td></tr>
<tr><td>[[$DAY]]</td><td>Day name of the input day-number.</td></tr>
<tr><td>[[$DayI]]</td><td>Number reflecting current day of the week.</td></tr>
<tr><td>[[$Deblank]]</td><td>Substring of a string, with leading and trailing blanks removed.</td></tr>
<tr><td>[[$Decode]]</td><td>Decoding facility.</td></tr>
<tr><td>[[$Deflate]]</td><td>Compress a longstring with Deflate</td></tr>
<tr><td>[[$DelCh]]</td><td>Remove characters from string, compress and strip blanks</td></tr>
<tr><td>[[$Delg_Subsys]]</td><td>Delete subsystem-wide global</td></tr>
<tr><td>[[$Delg_Sys]]</td><td>Delete system-wide global</td></tr>
<tr><td>[[$Delimr]]</td><td>Insert delimiter string into input string at regular positions</td></tr>
<tr><td>[[$Dscr]]</td><td>Decoding facility.</td></tr>
<tr><td>[[$Dsn]]</td><td>Data set name when you specify a file's DD name and the ordinal number.</td></tr>
<tr><td>[[$DsnNum]]</td><td>Total number of data sets defined for a file when you specify the file's DD name.</td></tr>
<tr><td>[[$D2C]]</td><td>Binary byte representation of integer</td></tr>
<tr><td>[[$D2X]]</td><td>Hex representation of integer</td></tr>
<tr><td>[[$Ebcdic]]</td><td>Convert input string from ASCII to EBCDIC</td></tr>
<tr><td>[[$EcbDGet]]</td><td>Get string data associated with an Event Control Block (ECB)</td></tr>
<tr><td>[[$EcbDSet]]</td><td>Set string data associated with an Event Control Block (ECB)</td></tr>
<tr><td>[[$EcbTest]]</td><td>Check an Event Control Block (ECB) to see if it is posted</td></tr>
<tr><td>[[$EcfStat]]</td><td>Returns the detailed completion code from the previous EXTERNAL statement.</td></tr>
<tr><td>[[$Edit]]</td><td>Edited numeric and alphanumeric text</td></tr>
<tr><td>[[$EdScan]]</td><td>Scan list of entities in online</td></tr>
<tr><td>[[$Eformat]]</td><td>Exponent notations from converted numeric values</td></tr>
<tr><td>[[$Encrypt]]</td><td>A one-way encryption of a character string.</td></tr>
<tr><td>[[$Ent_Print]]</td><td>Set automatic character entity substitution</td></tr>
<tr><td>[[$Ent_Tab]]</td><td>retrieve/modify character entity substitution table</td></tr>
<tr><td>[[$Ent]]</td><td>Do character entity substitution</td></tr>
<tr><td>[[$Enter]]</td><td>Efficient terminal dialogue with users of data entry applications.</td></tr>
<tr><td>[[$ErrClr]]</td><td>Clears the error message text returned by the $ErrMsg and $Fsterr functions.</td></tr>
<tr><td>[[$ErrMsg]]</td><td>Prefix and text of the last counting error or request cancellation message received.</td></tr>
<tr><td>[[$ErrSet]]</td><td>Increment or clear number of counting errors, set $ErrMsg</td></tr>
<tr><td>[[$E2A]]</td><td>Translate EBCDIC to ASCII</td></tr>
<tr><td>[[$FakeEnt]]</td><td>Prepare fake ENTER to automatically satisfy next full screen read</td></tr>
<tr><td>[[$FDef]]</td><td>String that describes the attributes of a field in a <var class="product">Model 204</var> file.</td></tr>
<tr><td>[[$Field_Image]]</td><td>Return field values into an image</td></tr>
<tr><td>[[$Field_List]]</td><td>Return field values into a $list</td></tr>
<tr><td>[[$Field_ListI]]</td><td>Return field values into a $list mapped to an image</td></tr>
<tr><td>[[$FieldgroupId]]</td><td>The ID of the current field group. (Available as of Model 204 version 7.5.)</td></tr>
<tr><td>[[$FieldgroupOccurrence]]</td><td>The current occurrence number of the field group. (Available as of Model 204 version 7.5.)</td></tr>
<tr><td>[[$FIniTim]]</td><td>File initialization YYDDDMMHHSSTH</td></tr>
<tr><td>[[$FiStat]]</td><td>Retrieve file's statistics into string</td></tr>
<tr><td>[[$FiStatL]]</td><td>Retrieve set of files' statistics into list</td></tr>
<tr><td>[[$FldLen]]</td><td>Length of a field.</td></tr>
<tr><td>[[$Float]]</td><td>Floating-point to a 4-byte string without conversion (4-byte floating point number to a 4-byte string).</td></tr>
<tr><td>[[$FloatD]]</td><td>Floating-point to a 4-byte string without conversion (8-byte floating point number to an 8-byte string). </td></tr>
<tr><td>[[$FlsAcc]]</td><td>User's access rights to a particular field.</td></tr>
<tr><td>[[$FlsChk]]</td><td>Whether a given set of field level security accesses is valid for a field.</td></tr>
<tr><td>[[$FreeOpt]]</td><td>Free optional file or group from subsystem</td></tr>
<tr><td>[[$Fsterr]]</td><td>Variable-length string containing the prefix and the first counting error message or request cancellation message received by the user since the last time the count was reset to zero.</td></tr>
<tr><td>[[$FunForc]]</td><td>Cancel running or waiting Fast/Unload request</td></tr>
<tr><td>[[$FunImg]]</td><td>Retrieve data from active Fast/Unload request into image</td></tr>
<tr><td>[[$FunList]]</td><td>$list of active and enqueued Fast/Unload requests</td></tr>
<tr><td>[[$FunLoad]]</td><td>Fast/Unload records in Model 204 list or found set</td></tr>
<tr><td>[[$FunPurg]]</td><td>Purge running or waiting Fast/Unload request</td></tr>
<tr><td>[[$FunSkip]]</td><td>Skip to next output record for $FunImg, $FunsStr</td></tr>
<tr><td>[[$FunsStr]]</td><td>Retrieve data from active Fast/Unload request into string</td></tr>
<tr><td>[[$FunWait]]</td><td>Wait until asynchronous Fast/Unload request completes</td></tr>
<tr><td>[[$Getg]]</td><td>Information stored by a $SETG function.</td></tr>
<tr><td>[[$GetL]]</td><td>Line number of the current line on the page on the user's terminal or on the output data set specified by a USE command.</td></tr>
<tr><td>[[$GetP]]</td><td>Page number currently on the user's terminal or on the output data set specified by a USE command.</td></tr>
<tr><td>[[$GrmLoc]]</td><td>Location of a missing member.</td></tr>
<tr><td>[[$GrmName]]</td><td>File name of a missing member.</td></tr>
<tr><td>[[$GrnLeft]]</td><td>Number of optional files that may fail before MAXFAIL is exceeded.</td></tr>
<tr><td>[[$GrnMiss]]</td><td>Number of missing members.</td></tr>
<tr><td>[[$GunZip]]</td><td>Decompress a longstring with GUNZIP</td></tr>
<tr><td>[[$GZip]]</td><td>Compress a longstring with GZip</td></tr>
<tr><td>[[$HexA]]</td><td>Convert hexadecimal string to EBCDIC equivalent</td></tr>
<tr><td>[[$HPage]]</td><td>String of special characters whose length is equal to the value specified as the $HPage argument.</td></tr>
<tr><td>[[$Hsh]]</td><td>A hash value from a converted string value. A hash value is a distinct numeric representation of a given string value.</td></tr>
<tr><td>[[$IHexA]]</td><td>Convert EBCDIC string to hexadecimal equivalent</td></tr>
<tr><td>[[$ImgInf]]</td><td>Retrieve image item by variable name</td></tr>
<tr><td>[[$ImgOvl]]</td><td>Replace image item value</td></tr>
<tr><td>[[$Incrg]]</td><td>Performs simple arithmetic on global variables.</td></tr>
<tr><td>[[$IncStat]]</td><td>Increment local system statistic</td></tr>
<tr><td>[[$Index]]</td><td>After comparing two strings, a number equal to the first position within the first string at which the second string appears; the same function as $SCAN.</td></tr>
<tr><td>[[$Inflate]]</td><td>Decompress a longstring with inflate</td></tr>
<tr><td>[[$ItsOpen]]</td><td>Whether or not a file is open.</td></tr>
<tr><td>[[$ItsRemote]]</td><td>Whether the current file or group is remote or scattered.</td></tr>
<tr><td>[[$JobAuth]]</td><td>Determine if user has authorization for USE $JOB</td></tr>
<tr><td>[[$Jobcode]]</td><td>Allows a request that is part of one step of a <var class="product">Model 204</var> batch run to communicate with a subsequent step.</td></tr>
<tr><td>[[$JpStat]]</td><td>Retrieve Janus port's statistics into string</td></tr>
<tr><td>[[$JpStatL]]</td><td>Retrieve statistics for set of Janus pors into $list</td></tr>
<tr><td>[[$LangSpc]]</td><td>String containing the binary value of a character in a specified language.</td></tr>
<tr><td>[[$LangSrt]]</td><td>A binary string translated to sort according to the NLSORT macro for the specified language.</td></tr>
<tr><td>[[$LangUst]]</td><td>Previously $LangSrt'ed string translated back to its original form.</td></tr>
<tr><td>[[$Len]]</td><td>Length of a value in a field.</td></tr>
<tr><td>[[$List_Add_Ordered]]</td><td>Add an item to an ordered $list</td></tr>
<tr><td>[[$List_Add_Unique_Ordered]]</td><td>Conditionally add an item to an ordered $list</td></tr>
<tr><td>[[$List_Add_Unique]]</td><td>Conditionally add an item to a $list</td></tr>
<tr><td>[[$List_Capture]]</td><td>Capture print data to $list</td></tr>
<tr><td>[[$List_Conv_Item]]</td><td>Convert $list to single delimited $list item</td></tr>
<tr><td>[[$List_Copy_Items]]</td><td>Copy items between $lists</td></tr>
<tr><td>[[$List_Diff_Item]]</td><td>Differences between $list and delimited $list item</td></tr>
<tr><td>[[$List_Global and $List_Session]]</td><td>Access/create global/session $list</td></tr>
<tr><td>[[$List_Global_Del and $List_Session_Del]]</td><td>Delete global/session $lists</td></tr>
<tr><td>[[$List_Global_List and $List_Session_List]]</td><td>List global/session $lists</td></tr>
<tr><td>[[$List_MaxIL]]</td><td>Return maximum $list item length</td></tr>
<tr><td>[[$List_Print]]</td><td>Display contents of a $list</td></tr>
<tr><td>[[$ListAdd_Lstr]]</td><td>Add longstring as new $list item</td></tr>
<tr><td>[[$ListAdd]]</td><td>Add string as new $list item</td></tr>
<tr><td>[[$ListAddI]]</td><td>Add image as new $list item</td></tr>
<tr><td>[[$ListAdj]]</td><td>Adjust length of $list item</td></tr>
<tr><td>[[$ListChk]]</td><td>Validate a $list identifier</td></tr>
<tr><td>[[$ListCmp]]</td><td>Compare two $lists and produce $list describing differences</td></tr>
<tr><td>[[$ListCnt]]</td><td>Number of items in $list</td></tr>
<tr><td>[[$ListCpy]]</td><td>Copy $list</td></tr>
<tr><td>[[$ListDel]]</td><td>Release CCATEMP storage used for $list</td></tr>
<tr><td>[[$ListFind]]</td><td>Find string in $list</td></tr>
<tr><td>[[$ListFindI and $ListFindI_Up]]</td><td>Find image item in $list</td></tr>
<tr><td>[[$ListFindI_Sub]]</td><td>Build $list subset based on image item</td></tr>
<tr><td>[[$ListILn]]</td><td>Length of $list item</td></tr>
<tr><td>[[$Listimg_Copy]]</td><td>Copy a $list's image association</td></tr>
<tr><td>[[$ListImg]]</td><td>Associate an image with a $list</td></tr>
<tr><td>[[$ListInf_Lstr]]</td><td>Retrieve $list item into longstring</td></tr>
<tr><td>[[$ListInf]]</td><td>Retrieve $list item into string</td></tr>
<tr><td>[[$ListInfI]]</td><td>Retrieve $list item into image</td></tr>
<tr><td>[[$ListIns_Lstr]]</td><td>Insert string into a $list</td></tr>
<tr><td>[[$ListIns]]</td><td>Insert string into a $list</td></tr>
<tr><td>[[$ListInsI]]</td><td>Insert image into a $list</td></tr>
<tr><td>[[$ListLoc]]</td><td>Locate string in $list</td></tr>
<tr><td>[[$ListLup]]</td><td>Locate string in $list, searching backwards</td></tr>
<tr><td>[[$ListMove]]</td><td>Move a $list</td></tr>
<tr><td>[[$ListNew]]</td><td>Create empty $list</td></tr>
<tr><td>[[$ListNewA]]</td><td>Create array of empty $lists</td></tr>
<tr><td>[[$ListNewAI]]</td><td>Create array of empty $lists associated with image</td></tr>
<tr><td>[[$ListNewI]]</td><td>Create empty $list associated with image</td></tr>
<tr><td>[[$ListOvl]]</td><td>Overlay part of $list item with string</td></tr>
<tr><td>[[$ListOvlI]]</td><td>Overlay part of $list item with image item</td></tr>
<tr><td>[[$ListRem]]</td><td>Remove item from $list</td></tr>
<tr><td>[[$ListRep_Lstr]]</td><td>Replace a $list item with a longstring</td></tr>
<tr><td>[[$ListRep]]</td><td>Replace a $list item with a string</td></tr>
<tr><td>[[$ListRepI]]</td><td>Replace $list item with an image</td></tr>
<tr><td>[[$ListRst]]</td><td>Restore global $list</td></tr>
<tr><td>[[$ListSav and $ListSave]]</td><td>Save global $list</td></tr>
<tr><td>[[$ListSavL]]</td><td>Count and names of available global $lists</td></tr>
<tr><td>[[$ListSort and $ListSrt]]</td><td>Sort $list</td></tr>
<tr><td>[[$ListSub]]</td><td>Create $list that is subset of input $list</td></tr>
<tr><td>[[$ListUpd]]</td><td>Produce $list from input $list using $list of updates</td></tr>
<tr><td>[[$Lowcase]]</td><td>A lower case string translated from an uppercase or mixed case string</td></tr>
<tr><td>[[$LstFld]]</td><td>Field names in a file, along with their field descriptions, into an image.</td></tr>
<tr><td>[[$LstProc]]</td><td>Information that is stored for a procedure.</td></tr>
<tr><td>[[$Lstr_Add_UserBuffer]]</td><td>Add longstring to user buffer</td></tr>
<tr><td>[[$Lstr_Base64_Decode]]</td><td>Convert from base 64 to byte string</td></tr>
<tr><td>[[$Lstr_Base64_Encode]]</td><td>Convert byte string to base 64</td></tr>
<tr><td>[[$Lstr_C2X]]</td><td>Convert byte string to hexadecimal</td></tr>
<tr><td>[[$Lstr_Get_Image and $Lstr_Set_Image]]</td><td>Longstring to/from image</td></tr>
<tr><td>[[$Lstr_Get_Userbuffer]]</td><td>Get user buffer contents to a longstring</td></tr>
<tr><td>[[$Lstr_Global and $Lstr_Session]]</td><td>Bind to global/session longstring</td></tr>
<tr><td>[[$Lstr_Global_Del and $Lstr_Session_Del]]</td><td>Delete global or session longstring</td></tr>
<tr><td>[[$Lstr_Global_Get and $Lstr_Session_Get]]</td><td>Get global or session longstring</td></tr>
<tr><td>[[$Lstr_Global_Set and $Lstr_Session_Set]]</td><td>Set global or session longstring</td></tr>
<tr><td>[[$Lstr_Index]]</td><td>Find a string inside a longstring</td></tr>
<tr><td>[[$Lstr_Left]]</td><td>Leftmost characters of a longstring</td></tr>
<tr><td>[[$Lstr_Len]]</td><td>Length of a longstring</td></tr>
<tr><td>[[$Lstr_Parse]]</td><td>Part of longstring preceding character in delimiter set</td></tr>
<tr><td>[[$Lstr_ParseX]]</td><td>Part of longstring following character in delimiter set</td></tr>
<tr><td>[[$Lstr_Right]]</td><td>Rightmost characters of a longstring</td></tr>
<tr><td>[[$Lstr_Set_UserBuffer]]</td><td>Set user buffer to longstring value</td></tr>
<tr><td>[[$Lstr_Substr]]</td><td>Substring of a longstring</td></tr>
<tr><td>[[$Lstr_SubWord]]</td><td>Substring of a longstring using word counts</td></tr>
<tr><td>[[$Lstr_Translate]]</td><td>Translate longstring</td></tr>
<tr><td>[[$Lstr_Unblank]]</td><td>Remove extraneous blanks from longstring</td></tr>
<tr><td>[[$Lstr_Windex]]</td><td>Return the position of a word within a long string</td></tr>
<tr><td>[[$Lstr_Word]]</td><td>Return a word from a long string</td></tr>
<tr><td>[[$Lstr_Words]]</td><td>Return the number of words in a long string</td></tr>
<tr><td>[[$Lstr_X2C]]</td><td>Convert from hexadecimal to byte string</td></tr>
<tr><td>[[$Lstr]]</td><td>Treat a string as longstring</td></tr>
<tr><td>[[$MisGrup]]</td><td>Group name if the error occurred in group context, null if in file context.</td></tr>
<tr><td>[[$MisLoc]]</td><td>Location of a missing member or file.</td></tr>
<tr><td>[[$MisName]]</td><td>File name of a missing member or file.</td></tr>
<tr><td>[[$MisNum]]</td><td>Number of files that failed in a group.</td></tr>
<tr><td>[[$MisStmt]]</td><td>Statement that caused the ON unit to be entered.</td></tr>
<tr><td>[[$Mod]]</td><td>Remainder that results when one argument is divided by the another argument.</td></tr>
<tr><td>[[$Occurs]]</td><td>Whether a field has the OCCURS attribute.</td></tr>
<tr><td>[[$Oneof]]</td><td>Table lookup that can replace a series of IF conditions.</td></tr>
<tr><td>[[$Pack]]</td><td>Packed decimal representation of a string.</td></tr>
<tr><td>[[$Pad]]</td><td>Designated character padded to the left.</td></tr>
<tr><td>[[$PadR]]</td><td>Designated character padded to the right</td></tr>
<tr><td>[[$Parse]]</td><td>Part of string preceding character in delimiter set</td></tr>
<tr><td>[[$ParseX]]</td><td>Part of string following character in delimiter set</td></tr>
<tr><td>[[$Post]]</td><td>Indicates that an event has occurred; the thread waiting on an ECB can resume processing.</td></tr>
<tr><td>[[$PrcLEx]]</td><td>$list of information about procedures in file</td></tr>
<tr><td>[[$PrcLExG]]</td><td>$list of information about procedures in group or file</td></tr>
<tr><td>[[$Priorty]]</td><td>Change a user's priority</td></tr>
<tr><td>[[$Proc_List]]</td><td>$list of information about procedures in file</td></tr>
<tr><td>[[$Proc_ListG]]</td><td>$list of information about procedures in group or file</td></tr>
<tr><td>[[$Proc_Touch]]</td><td>Change a procedure's last-update date and user</td></tr>
<tr><td>[[$ProcCls]]</td><td>Close procedure before reaching end</td></tr>
<tr><td>[[$ProcDat]]</td><td>Add lines from procedure to $list</td></tr>
<tr><td>[[$ProcGet]]</td><td>Next line of procedure</td></tr>
<tr><td>[[$ProcLoc]]</td><td>Locate any of set of strings in procedure</td></tr>
<tr><td>[[$ProcOpn]]</td><td>Open procedure for $ProcDat, $ProcGet, $ProcLoc</td></tr>
<tr><td>[[$Random_Seed]]</td><td>Build seed specifying series of $Random results</td></tr>
<tr><td>[[$Random]]</td><td>Get next random number</td></tr>
<tr><td>[[$RdProc]]</td><td>Lines of a User Language procedure, retrieved in sequential order, that is stored in a <var class="product">Model 204</var> file.</td></tr>
<tr><td>[[$Read]]</td><td>An echo of the data a user enters as a request is evaluated</td></tr>
<tr><td>[[$ReadInv]]</td><td>Performs the same function as $READ, except that input from the terminal is not echoed.</td></tr>
<tr><td>[[$ReadLc]]</td><td>An echo of the data a user enters as a request is evaluated, except that case translation is deactivated, regardless of the current *UPPER or *LOWER setting.</td></tr>
<tr><td>[[$RegexMatch]]</td><td>Whether string matches regex</td></tr>
<tr><td>[[$RegexReplace]]</td><td>Replace matching strings</td></tr>
<tr><td>[[$Remote]]</td><td>VTAMNAME value of the originating <var class="product">Model 204</var> region when using SNA Communications Server (formerly VTAM) TRANSFER to transfer between <var class="product">Model 204</var> regions.</td></tr>
<tr><td>[[$ResetN]]</td><td>Reset or view M204 parameter</td></tr>
<tr><td>[[$Reverse]]</td><td>Reversed order of a string.</td></tr>
<tr><td>[[$RlcFile]]</td><td>Name of the file in which the last record locking conflict occurred.</td></tr>
<tr><td>[[$RlcRec]]</td><td>Internal record number for which the last record locking conflict occurred.</td></tr>
<tr><td>[[$RlcUid]]</td><td>ID of the user who caused an ON FIND CONFICT or ON RECORD LOCKING CONFLICT. If the conflicting user is on a remote node, $RLCUID also returns the name of the node.</td></tr>
<tr><td>[[$RlcUsr]]</td><td>User number of the user with which the request conflicted when the last record locking conflict occurred.</td></tr>
<tr><td>[[$Round]]</td><td>Number, rounded to a specified number of decimal places.</td></tr>
<tr><td>[[$Scan]]</td><td>After comparing two strings, a number equal to the first position within the first string at which the second string appears; the same function as $INDEX.</td></tr>
<tr><td>[[$Sclass]]</td><td>Current user's subsystem user class.</td></tr>
<tr><td>[[$Screen_attr]]</td><td>Get screen item attributes as a blank-delimited string</td></tr>
<tr><td>[[$Screen_clear]]</td><td>Clear tagged and/or modified attributes in a screen</td></tr>
<tr><td>[[$Screen_mod]]</td><td>Set modified attribute for a screen item</td></tr>
<tr><td>[[$ScrHide]]</td><td>Hide lines in SCREEN</td></tr>
<tr><td>[[$ScrSize]]</td><td>Change size of field on SCREEN</td></tr>
<tr><td>[[$ScrWide]]</td><td>Allow SCREEN to accept fields wider than 79</td></tr>
<tr><td>[[$Session_$Session_Id_$Session_Owner_and_$Session_Timeout|$Session, $Session_Id, $Session_Owner,    and $Session_Timeout]]</td><td>Return values for currently open session</td></tr>
<tr><td>[[$Session_Close]]</td><td>Close an open session</td></tr>
<tr><td>[[$Session_Create]]</td><td>Create a new session</td></tr>
<tr><td>[[$Session_Delete]]</td><td>Delete a session</td></tr>
<tr><td>[[$Session_List]]</td><td>Get list of sessions</td></tr>
<tr><td>[[$Session_Open]]</td><td>Open a session</td></tr>
<tr><td>[[$Setg_Subsys_List]]</td><td>Get list of subsystem-wide globals</td></tr>
<tr><td>[[$Setg_Subsys]]</td><td>Set subsystem-wide global</td></tr>
<tr><td>[[$Setg_Sys_List]]</td><td>Get list of system-wide globals</td></tr>
<tr><td>[[$Setg_Sys]]</td><td>Set system-wide global</td></tr>
<tr><td>[[$Setg]]</td><td>A created or changed entry in the global variable section of GTBL.</td></tr>
<tr><td>[[$SetL]]</td><td>Sets the current line counter for the output device currently in effect.</td></tr>
<tr><td>[[$SetP]]</td><td>Sets the current page number for the output device currently in effect.</td></tr>
<tr><td>[[$SetStat]]</td><td>Set local system statistic</td></tr>
<tr><td><div id="datetime"></div>[[$Sir_Date]]</td><td>Get current datetime</td></tr>
<tr><td>[[$Sir_DateFmt]]</td><td>Validate datetime format</td></tr>
<tr><td><div id="daten"></div>[[$Sir_DateN]]</td><td>Current date and time as number of seconds/300</td></tr>
<tr><td>[[$Sir_DateND]]</td><td>Current date as number of days</td></tr>
<tr><td>[[$Sir_DateNM]]</td><td>Current date and time as number of milliseconds</td></tr>
<tr><td>[[$Sir_DateNS]]</td><td>Current date and time as number of seconds</td></tr>
<tr><td>[[$Sir_Date2N]]</td><td>Convert datetime string to number of seconds/300</td></tr>
<tr><td>[[$Sir_Date2ND]]</td><td>Convert datetime string to number of days</td></tr>
<tr><td>[[$Sir_Date2NM]]</td><td>Convert datetime string to number of milliseconds</td></tr>
<tr><td>[[$Sir_Date2NS]]</td><td>Convert datetime string to number of seconds</td></tr>
<tr><td>[[$Sir_Login]]</td><td>Perform secured web or sockets login</td></tr>
<tr><td>[[$Sir_ND2Date]]</td><td>Convert datetime number of days to string</td></tr>
<tr><td>[[$Sir_NM2Date]]</td><td>Convert datetime number of milliseconds to string</td></tr>
<tr><td>[[$Sir_NS2Date]]</td><td>Convert datetime number of seconds to string</td></tr>
<tr><td>[[$Sir_N2Date]]</td><td>Convert datetime number of seconds/300 to string</td></tr>
<tr><td>[[$Sir_Wild]]</td><td>Test string against a wildcard string</td></tr>
<tr><td>[[$SirJGet]]</td><td>Place audit trail data on $list</td></tr>
<tr><td>[[$SirMsg]]</td><td>Line of current $SirMsgP procedure</td></tr>
<tr><td>[[$SirMsgP]]</td><td>Load procedure for retrieval via $SirMsg</td></tr>
<tr><td>[[$SirParm]]</td><td>Set user-specific value, controlling Sirius products</td></tr>
<tr><td>[[$SirProd]]</td><td>Determine availability of Sirius product or capability</td></tr>
<tr><td>[[$SirSite]]</td><td>Current Sirius customer site ID</td></tr>
<tr><td>[[$SirTime]]</td><td>Current time as YYDDDHHMISSXX</td></tr>
<tr><td>[[$SirVer]]</td><td>Current version number of Sirius product</td></tr>
<tr><td>[[$SirWarn]]</td><td>Send warning or message to user(s)</td></tr>
<tr><td>[[$Slstats]]</td><td>Resets the recording of since-last statistics anywhere within a request.</td></tr>
<tr><td>[[$SndMail]]</td><td>Send an email message</td></tr>
<tr><td>[[$Sndx]]</td><td>SOUNDEX code of an argument.</td></tr>
<tr><td>[[$Square]]</td><td>A number multiplied by itself.</td></tr>
<tr><td>[[$SsStat]]</td><td>Retrieve subsystem's statistics into string</td></tr>
<tr><td>[[$SsStatL]]</td><td>Retrieve statistics for set of subsystems into $list</td></tr>
<tr><td>[[$Stat]]</td><td>Current value of any user statistic.</td></tr>
<tr><td>[[$StatD]]</td><td>Calculate differences and rates for statistics strings</td></tr>
<tr><td>[[$StatLD]]</td><td>Calculate differences and rates for statistics $lists</td></tr>
<tr><td>[[$Status]]</td><td>The success or failure of the last executed external I/O or program communication statement.</td></tr>
<tr><td>[[$StatusD]]</td><td>More detailed description of a condition returned by $STATUS.</td></tr>
<tr><td>[[$Str]]</td><td>Treat a longstring as string</td></tr>
<tr><td>[[$StrAnd]]</td><td>Bit-wise AND two strings</td></tr>
<tr><td>[[$Strip]]</td><td>A number with suppressed leading zeros.</td></tr>
<tr><td>[[$StrOr]]</td><td>Bit-wise OR two strings</td></tr>
<tr><td>[[$StrXor]]</td><td>Bit-wise exclusive OR two strings</td></tr>
<tr><td>[[$SubCnt]]</td><td>Count occurrences of one string in another</td></tr>
<tr><td>[[$SubErs]]</td><td>Remove occurrence of one string from another</td></tr>
<tr><td>[[$SubIns]]</td><td>Insert string inside another string</td></tr>
<tr><td>[[$SubRep]]</td><td>Replace occurrences of string</td></tr>
<tr><td>[[$Substr]]</td><td>Substring of a string.</td></tr>
<tr><td>[[$Subsys]]</td><td>Status of an APSY subsystem.</td></tr>
<tr><td>[[$SyStat]]</td><td>Retrieve system statistics into string</td></tr>
<tr><td>[[$TableC]]</td><td>Information provided by TABLEC command</td></tr>
<tr><td>[[$TermId]]</td><td>Terminal ID of current user thread</td></tr>
<tr><td>[[$Time]]</td><td>Current time in hh:mm:ss format.</td></tr>
<tr><td>[[$TkStat]]</td><td>Retrieve task's statistics into string</td></tr>
<tr><td>[[$TkStatL]]</td><td>Retrieve statistics for all tasks into $list</td></tr>
<tr><td>[[$TsoAtt]]</td><td>Attach program in user's TSO address space</td></tr>
<tr><td>[[$TsoCall]]</td><td>Call program in user's TSO address space</td></tr>
<tr><td>[[$TsoCan]]</td><td>Cancel program invoked via $TsoAtt</td></tr>
<tr><td>[[$TsoCmd]]</td><td>Invoke command in user's TSO address space</td></tr>
<tr><td>[[$TsoExec]]</td><td>Invoke CLIST in user's TSO address space</td></tr>
<tr><td>[[$TsoExit]]</td><td>Terminate TSO full screen interface session, stack command</td></tr>
<tr><td>[[$TSOId]]</td><td>TSO userid user's thread</td></tr>
<tr><td>[[$TSOStat]]</td><td>Status of program invoked via $TsoAtt</td></tr>
<tr><td>[[$TSOWait]]</td><td>Wait for program invoked via $TsoAtt to complete</td></tr>
<tr><td>[[$Unbin]]</td><td>Value converted from binary to string representation.</td></tr>
<tr><td>[[$Unbind_and_$UnbindW]]</td><td>$Unbind and $UnbindW: Unbind resource previously bound via $Bind</td></tr>
<tr><td>[[$Unblank]]</td><td>Contents of an argument, removing leading and trailing blanks, and compressing multiple embedded blanks to one blank character.</td></tr>
<tr><td>[[$Unfloat]]</td><td>Character string that represents a numeric counted string of 4 or 8 bytes, which contains a floating point.</td></tr>
<tr><td>[[$Unpack]]</td><td>Unpacked decimal data </td></tr>
<tr><td>[[$UnPost]]</td><td>Resets a specified Event Control Block (ECB) to an unposted state.</td></tr>
<tr><td>[[$UnqRec]]</td><td>In the case of a uniqueness violation, returns the file-relative record number of the record that already contains the field name = value pairIf no uniqueness violation occurred. returns -1.</td></tr>
<tr><td>[[$UnSpace]]</td><td>Normalize spaces and quotes</td></tr>
<tr><td>[[$Upcase]]</td><td>An uppercase string converted from a lower or mixed case string.</td></tr>
<tr><td>[[$Update]]</td><td>Name of the group update file or the current file.</td></tr>
<tr><td>[[$UpdFile]]</td><td>Name of the file in which a field level constraint violation has occurred, or a blank if no violation occurred.</td></tr>
<tr><td>[[$UpdFld]]</td><td>Name of the field for which a field level constraint violation has occurred, or a blank if no violation occurred.</td></tr>
<tr><td>[[$UpdLoc]]</td><td>Location name (node name) of the current update unit (Parallel Query Option/204 only).</td></tr>
<tr><td>[[$UpdOval]]</td><td>Value of the original field occurrence causing a constraint violation, when invoked from an ON FCC unit following the detection of an AT-MOST-ONE field-level constraint conflict. </td></tr>
<tr><td>[[$UpdRec]]</td><td>File-relative record number of the record whose update caused a field level constraint violation, or -1 if no violation occurred.</td></tr>
<tr><td>[[$UpdStat]]</td><td>Numeric value denoting the type of field level constraint violation that has occurred, or 0 if no violation occurred.</td></tr>
<tr><td>[[$UpdStmt]]</td><td>Type of User Language updating statement causing a field level constraint violation, or a blank if no violation occurred.</td></tr>
<tr><td>[[$UpdVal]]</td><td>Field value causing a field level constraint violation, or a blank if no violation occurred.</td></tr>
<tr><td>[[$UseASA]]</td><td>Prevent carriage control in USE output</td></tr>
<tr><td>[[$User]]</td><td>User's user number.</td></tr>
<tr><td>[[$Userid]]</td><td>User ID under which the user is logged in.</td></tr>
<tr><td>[[$UsrPriv]]</td><td>Whether a user ID has been granted specific <var class="product">Model 204</var> privileges.</td></tr>
<tr><td>[[$UsStat]]</td><td>Retrieve user's statistics into string</td></tr>
<tr><td>[[$UsStatL]]</td><td>Retrieve statistics for set of users into $list</td></tr>
<tr><td>[[$Verify]]</td><td>Whether every character in one string is present in a second string.</td></tr>
<tr><td>[[$View]]</td><td>Value of a parameter.</td></tr>
<tr><td>[[$Vnum]]</td><td>Whether a given argument is in a valid format for a SORT BY VALUE NUMERICAL statement or for any type of mathematical operation.</td></tr>
<tr><td>[[$Wait]]</td><td>Suspend a user until an Event Control Block (ECB) is posted.</td></tr>
<tr><td>[[$WakeUp]]</td><td>Pause user until specified time</td></tr>

<tr><td>[[List of Janus Web Server $functions|$Web_xxx]]</td><td>List of Janus Web Server $functions</td></tr>
<tr><td>[[$Windex]]</td><td>Word number of first occurrence of word in phrase</td></tr>
<tr><td>[[$Word]]</td><td>P word in a specified string, delimited by a blank or optionally specified character.</td></tr>
<tr><td>[[$Words]]</td><td>Number of words in a specified string, delimited by a blank or optionally specified character.</td></tr>
<tr><td>[[$X2C]]</td><td>One-byte EBCDIC characters translated from a string of 2-byte hexadecimal character.</td></tr>
<tr><td>[[$X2D]]</td><td>Convert hex string to integer</td></tr>
</table>
</div>

==Using functions==
You can use functions in several ways, including, as a term in:
<ul>
<li>An expression in a variable assignment statement, for example:</li>
</ul>
%X=$EDIT(2573,'99999')

<ul>
<li>The specifications in a PRINT statement</li>
</ul>

A PRINT statement can include a function call anywhere a field name can be used. For example:
PRINT $EDIT(2573,'99999')

<ul>
<li>An expression in a conditional statement, for example:</li>
</ul>
IF $EDIT(2573,'99999') EQ 02573 THEN...

<ul>
<li>An expression which serves as the argument to another function, for example:</li>
</ul>
%L=$LEN($EDIT(2573,'99999'))


The direct use of function calls in some statements, such as FIND, results in compilation errors. 

====Comparing successful and unsuccessful $function code====

If your request is coded as follows:
BEGIN
$EDIT(2573,'99999')
END


The following error is your result:
*** 1 M204.0229: INVALID STATEMENT $EDIT(2573,'99999')


However, if you code your request as follows, it works properly:
BEGIN
PRINT $EDIT(2573,'99999')
* Or *
* %X=$EDIT(2573,'99999') *
END


===Function return values===

Each function returns a single value to the calling request. For example, this function sets %A equal to the user's login account name:
%a = $account


This function causes the length of the current value of the FULLNAME field to be compared to 10:
IF $LEN(FULLNAME) GT 10 THEN
.
.
.


===Function arguments===

Some functions require one or more arguments which allow you to pass information to the subroutine. Some functions take no arguments. Arguments must be enclosed in parentheses and separated by commas. For example:
IF $READ('CONTINUE?') EQ 'YES' THEN
.
.
.
%X = $mod(COUNT IN CT, %BASE)


====Rules for function arguments====

Function arguments follow the normal rules for arithmetic expressions. Arguments can include other function calls and can perform any type of computation. See the section [[Using variables and values in computation#Expressions|Expressions]] for detailed information on expression syntax.

====Argument evaluation and conversion====

<var class="product">Model 204</var> evaluates each argument to a function as either a string or a number. When this data type conflicts with the data type required by the function, the following rules apply:
<ul>
<li>If an argument is expected to be numeric but is a string, <var class="product">Model 204</var> converts the string to a number according to the conversion rules described in the assignment statement discussion in [[Using variables and values in computation#Relationship between %variable assignment and declaration|Relationship between %variable assignment and declaration]] and [[Using variables and values in computation#Conversion|Conversion]]. </li>
</li>
<li>If an argument is expected to be a string but is numeric, <var class="product">Model 204</var> converts the number to a string. </li>
</li>
<li>If the original number contains decimal places, they are lost during the conversion.</li>
</li>
</ul>

==User-written functions==

In addition to the functions provided by <var class="product">SOUL</var>, some customer sites write their own functions based on their particular needs.
Before using any user-written functions, make sure that your site's FUNU module has been reassembled with the macro library supplied with the current release. Also, please be sure to carefully test your user-written functions before your system goes into production. 

<blockquote class="note">
Notes:
<ul>
<li>It is recommended that all user-written functions use the STMG/LMG Assembly Language instructions to save and restore any registers that are modified.
<li>The RESULT macro does not work in Model 204 Version 5.1 and later. Change any use of the RESULT macro in $functions to use the standard LEAVENUM, LEAVEF0 and LEAVESTR macros.
<li>In addition to the above considerations, see the [[Model 204 installation#FUNU|installation instructions relating to FUNU]].
</ul></blockquote>

Customers are individually responsible for any functions they write. Rocket Software takes no responsibility for user-written functions or their documentation.

[[Category:SOUL]]