The CHECKI tag defines a test of an input value.

Parameters

TYPE=

This attribute specifies the type of check to be performed. The valid types are:

RANGE

This allows you to check for an integer value within a range. The specified range includes the end points. The range delimiters can include 16 digits. The range delimiters can also contain a sign (- or +). If no sign is coded, the value is assumed to be positive.

Important: In ISPF, the VER(variable RANGE,lower,upper) statement limits the length of the specified variable to 16 digits. If you specify the CHECKI TYPE=RANGE on a variable that is longer than 16 positions, the variable may not be correctly validated. For example, assume an application developer defines a data field with a length of 20 and defines this validity check for the field:

<CHECKI TYPE=RANGE PARM1=1 PARM2=9999999999999999>

If the number 12345678901234567890 were entered into the field, only the first 16 digits would be verified and the number would be within the defined range, even though the entire number entered is outside of the defined range.

PARM1=low-bound | %varname

This attribute supplies the low value, if any or the name of a variable that contains the low value. If you do not supply a value, the default is "-" followed by sixteen 9s (that is, -9999...99). Negative values must be coded with the minus sign on the left.

ISPF restrictions on the VER(variable RANGE,lower,upper) apply. The lower value specified in PARM1 can be positive or negative. The length of the lower limit is limited to 16 digits, in addition to the plus or minus sign if used.

PARM2=high-bound | %varname

This attribute supplies the high value, if any or the name of a variable that contains the high value. If you do not supply a value, the default is sixteen 9s (that is, 9999...99). Negative values must be coded with the minus sign on the left.

ISPF restrictions on the VER(variable RANGE,lower,upper) apply. The upper value specified in PARM2 can be positive or negative. The length of the upper limit is limited to 16 digits, in addition to the plus or minus sign if used.

ALPHA

This limits the character set to A-Z, a-z, and #, $, @. The conversion utility builds the VER(variable ALPHA) statement.

CHARS

Specifies the CHARS check of characters allowed within an input string.

The conversion utility uses the TYPE=CHARS check to support ISPF VER(variable BIT), VER(variable HEX) and VER(variable NUM). BIT, HEX, and NUM are the only types of support provided by ISPF for the TYPE=CHARS check.

PARM1=EQ

This attribute contains EQ to specify that PARM2 contains a value that must be matched. If PARM1 contains any other value, the check is ignored and the conversion utility issues a warning message.

PARM2=character-set

This attribute specifies a set of characters to be matched.

• If TYPE=CHARS, PARM1=‘EQ’, and PARM2=‘01’, the conversion utility generates VER(variable BIT).
• If TYPE=CHARS, PARM1=‘EQ’, and PARM2=‘0123456789ABCDEFabcdef’, the conversion utility generates VER(variable HEX).
• If TYPE=CHARS, PARM1=‘EQ’, and PARM2=‘0123456789’, the conversion utility generates VER(variable NUM).

Note: If one of these options is used, the PARM2 value must be exactly as specified. If PARM2 contains any other value, the check is ignored and the conversion utility issues a warning message.

VALUES

Specifies that the value entered must be the same as one of the values specified in PARM2.

The VER LIST statement built by the conversion utility is case-sensitive to the values entered in PARM2 (no folding of PARM2 to uppercase). This means that ISPF looks for an exact match in the verification process. You can specify XLATL FORMAT=UPPER within the variable class definition before the CHECKL tag to convert user input to uppercase before the VALUES check is processed.

PARM1=EQ

This attribute contains EQ to specify that PARM2 contains values that must be matched. If PARM1 contains any other value, the check is ignored and the conversion utility issues a warning message.

PARM2=value-list

This attribute specifies the list of values. If the list contains more than one value, it must be enclosed in quotes. If a value in the list contains blanks, then it must be enclosed in single quotes and the entire list enclosed in double quotes. Each value in the list must be separated by blanks or enclosed quotes. For example:

dog
‘dog cat bird lion’
"parsley onion ‘black pepper’ garlic"

The maximum number of values allowed is 100.

Note: You should surround the entire value for PARM2 with double quotes and then surround any value in the list that contains blanks with single quotes. Double quotes surrounding a list are supported by the conversion utility.

The conversion utility generates VER(variable LIST,value-list) from PARM2.

VALUESX

Specifies that the value entered cannot be any of the values specified in PARM2. This is the opposite of VALUES.

The VER LISTX statement built by the conversion utility is case-sensitive to the values entered in PARM2 (no folding of PARM2 to uppercase). This means that ISPF looks for an exact match in the verification process. You can specify XLATL FORMAT=UPPER within the variable class definition before the CHECKL tag to convert user input to uppercase before the VALUES check is processed.

PARM1=NE

this attribute contains ne to specify that parm2 contains values that cannot be entered. If parm1 contains any other value, the check is ignored and the conversion utility issues a warning message.

PARM2=VALUE-LIST

This attribute specifies the list of values. If the list contains more than one value, it must be enclosed in quotes. If a value in the list contains blanks, then it must be enclosed in single quotes and the entire list enclosed in double quotes. Each value in the list must be separated by blanks or enclosed quotes. For example:

dog
‘dog cat bird lion’
"parsley onion ‘black pepper’ garlic"

The maximum number of values allowed is 100.

Note: You should surround the entire value for PARM2 with double quotes and then surround any value in the list that contains blanks with single quotes. Double quotes surrounding a list are supported by the conversion utility.

The conversion utility generates VER(variable LISTX,value-list) from PARM2.

BIT

Specifies that the variable must be all 0’s and 1’s. The conversion utility builds the VER(variable BIT) statement.

NAME

Specifies that the variable must contain a valid name, following the rules of member names. The conversion utility builds the VER(variable NAME) statement.

NAMEF

Specifies that the variable must contain a valid name filter. The conversion utility builds the VER(variable NAMEF) statement.

PICT

Specifies that the variable must contain characters that match the corresponding type of character in pictstring.

PARM1=EQ

This attribute contains EQ to specify that PARM2 contains values that must be matched. If PARM1 contains any other value, the check is ignored and the conversion utility issues a warning message.

PARM2=pictstring

This ‘pictstring’ parameter must be the actual value to be used in the generated VER statement. ISPF does not support a variable name for this value.

If PARM2 contains invalid characters as defined by ISPF, the check is ignored and the conversion utility issues a warning message.

The conversion utility builds the VER(variable PICT,pictstring) statement.

PICTCN

Specifies that the variable must contain specific constants along with other standard ISPF picture verification characters.

PARM1=mask-character

The mask-character is any special character that represents itself. It cannot be one of the ISPF picture string characters (C,A,N,X,9,c,a,n,x)

PARM2=field-mask

The field-mask provides the required characters for the field. All other field positions must be represented by the mask-character. For example, if the field is to contain a string VnnRnnMnn (for Version, Release, and Modification) and the mask-character is an asterisk (*), the field mask is V**R**M**.

PARM3=string

The string must be the same length as the field-mask. It contains all of the required characters in the same positions as the field-mask. The positions defined with the mask-character in the field-mask contain one of the standard ISPF picture characters (C,A,N,X,9,c,a,n,x). To complete the example provided for PARM2, the string is VnnRnnMnn. The resulting verification statement is:

VER(variable,PICTCN,*,V**R**M**,VnnRnnMnn)

The variable is verified for V in position 1, R in position 4, M in position 7, and numeric characters in positions 2,3,5,6,8, and 9.

The conversion utility builds the VER(variable,PICTCN,mask-character,field-mask,string) statement.

NUM

Specifies that the variable must contain all numeric characters (0-9). The conversion utility builds the VER(variable NUM) statement.

DBCS

Specifies that the variable must contain all valid DBCS characters. The conversion utility builds the VER(variable DBCS) statement.

LISTV

Specifies that the variable must be one of the values provided by varlist.

PARM1=EQ

This attribute contains EQ to specify that PARM2 contains values that must be matched. If PARM1 contains any other value, the check is ignored and the conversion utility issues a warning message.

PARM2=%varlist

This attribute must be a variable name entered with "%" as the first character. The variable contents are provided by the application and must be a list of valid values.

The conversion utility builds the VER(variable LISTV,&varlist) statement.

LISTVX

Specifies that the variable cannot be any of the values provided by varlist. This is the opposite of LISTV.

PARM1=NE

This attribute contains NE to specify that PARM2 contains values that cannot be entered. If PARM1 contains any other value, the check is ignored and the conversion utility issues a warning message.

PARM2=%VARLIST

This attribute must be a variable name entered with "%" as the first character. The variable contents are provided by the application and must be a valid list of excluded values.

The conversion utility builds the VER(variable LISTVX,&varlist) statement.

ALPHAB

Specifies that the variable must be all alphabetic characters (A-Z or a-z). The conversion utility builds the VER(variable ALPHAB) statement.

LEN

Specifies that the variable must satisfy the condition expressed by the relational operator and the expected length.

PARM1=operator | %varname

This attribute can be a relational operator (EQ, LT, GT, LE, GE, NE, NG, or NL) or a variable name that contains a relational operator. If a variable name is entered, it must be preceded by a “%”.

PARM2=length | %varname

The parameter must be either a number or a variable name. If a number is entered, it must be in the range of 1-99999. If a variable name is entered, it must be preceded by a "%".

The conversion utility builds the VER(variable operator,length) statement.

EBCDIC

Specifies that the variable must contain all valid EBCDIC characters. The conversion utility builds the VER(variable EBDIC) statement.

ENUM

Specifies that the variable can contain extended numeric notation. The conversion utility builds the VER(variable ENUM) statement.

DSNAME

Specifies that the variable must contain a valid TSO data set name. The conversion utility builds the VER(variable DSNAME) statement.

DSNAMEF

Specifies that the variable must contain a valid TSO data set name filter. The optional member name cannot be specified as a member pattern. A missing close parentheses and ending quotation mark are automatically added by ISPF. The conversion utility builds the VER(variable DSNAMEF) statement.

DSNAMEFM

Specifies that the variable must contain a valid data set name. The optional member name can be specified as a member pattern. A missing close parentheses and ending quotation mark are automatically added by ISPF. The conversion utility builds the VER(variable DSNAMEFM) statement.

DSNAMEPQ

Specifies that the variable must contain a valid TSO data set name. A missing close parentheses and ending quotation mark are automatically added by ISPF. The conversion utility builds the VER(variable DSNAMEPQ) statement.

DSNAMEQ

Specifies that the variable must contain a valid TSO data set name. A missing ending quotation mark is automatically added by ISPF. The conversion utility builds the VER(variable DSNAMEQ) statement.

MIX

Specifies that the variable must contain all valid DBCS and EBCDIC characters. The conversion utility builds the VER(variable MIX) statement.

HEX

Specifies that the variable must contain all hexadecimal characters (0-9, a-f or A-F). The conversion utility builds the VER(variable HEX) statement.

FILEID

Specifies that the variable must contain a valid file ID in CMS syntax. The conversion utility builds the VER(variable FILEID) statement.

See the z/OS ISPF Dialog Developer's Guide and Reference for additional information concerning panel variable validation.

INCLUDE

Specifies that the variable must contain valid characters from at least one of the ISPF-defined VER groups ALPHA, ALPHAB or NUM.

PARM1=IMBLK

This attribute contains IMBLK to specify that the IMBLK keyword be added to the generated VER statement. If PARM1 contains any other value, it is reset to the value IMBLK.

PARM2=ALPHA | ALPHAB | NUM

This attribute must contain either the value ALPHA, ALPHAB, or NUM. If PARM2 is not specified or contains any other value, the INCLUDE check is ignored and the conversion utility issues a warning message.

PARM3=ALPHA | ALPHAB | NUM

This attribute must contain either the value ALPHA, ALPHAB, or NUM. The value specified for PARM3 should be different than the value specified for PARM2. If the values for PARM2 and PARM3 are the same, the PARM3 value is ignored and the conversion utility issues a warning message.

The conversion utility builds the VER(variable INCLUDE [,IMBLK], parm2 [,parm3]) statement.

IDATE

Specifies that the variable must contain a valid 8 character international date. The conversion utility builds the VER(variable,IDATE) statement.

STDDATE

Specifies that the variable must contain a valid 10 character standard date. The conversion utility builds the VER(variable,STDDATE) statement.

JDATE

Specifies that the variable must contain a valid 6 character Julian date. The conversion utility builds the VER(variable,JDATE) statement.

JSTD

Specifies that the variable must contain a valid 8 character standard Julian date. The conversion utility builds the VER(variable,JSTD) statement.

ITIME

Specifies that the variable must contain a valid 5 character international time. The conversion utility builds the VER(variable,ITIME) statement.

STDTIME

Specifies that the variable must contain a valid 8 character standard time. The conversion utility builds the VER(variable,STDTIME) statement.

IPADDR4

Specifies that the variable must contain a valid 15-position IP address. The conversion utility builds the VER(variable,IPADDR4) statement.

Comments

The CHECKI tag defines a test of an input value. Validity checking occurs only on input.

Restrictions

• You must code the CHECKI tag within a CHECKL definition. The conversion utility supports only one CHECKI within each CHECKL definition. If multiple CHECKI definitions are coded within a single CHECKL definition, the additional CHECKI tags are ignored and are not syntax checked. See CHECKL (Validity Check List) for a complete description of this tag.
• The conversion utility builds a VER statement in the ISPF )PROC section of the panel definition for a CHECKI tag.
• When a "%varname" notation is found on any of the attributes that allow a variable name, the "%varname" entry must follow the standard naming convention described in Rules for “%variable” names.

Processing

None.