*copyc clc$ecc_range
?? FMT (FORMAT := OFF) ??
{
{ CLE$ECC_parsing has the following unused code offsets:
{
{ 2247..2999
{

  CONST

    clc$min_ecc_parsing             = clc$min_ecc + 2000,

{ Application type conformance errors }

    cle$application_name_mismatch   = clc$min_ecc + 2185,
    {E Application type names do not match.}

    cle$balance_brackets_dont_match = clc$min_ecc + 2186,
    {E "BALANCE_BRACKETS" attributes do not match.}

{ Application type specification errors }

    cle$expecting_applic_type_attr  = clc$min_ecc + 2000,
    {E Expecting attribute for APPLICATION type, found +P.}

{ Array type conformance errors }

    cle$array_bounds_dont_match     = clc$min_ecc + 2092,
    {E Array bounds do not match.}

    cle$unknown_array_element_type  = clc$min_ecc + 2191,
    {E Undefined array element type.}

{ Array expression errors }

    cle$too_few_or_many_array_elems = clc$min_ecc + 2001,
    {E +P elements given for array, but the array bounds are +P .. +P.}

    cle$unexpected_empty_array      = clc$min_ecc + 2226,
    {E No elements given for array, but at least one element must be given.}

{ Array type specification errors }

    cle$array_bound_out_of_range    = clc$min_ecc + 2002,
    {E The ARRAY bound +P is out of range.  It must be between +P and +P.}

    cle$array_bounds_required       = clc$min_ecc + 2003,
    {E In the declaration for an ARRAY type, the bounds must be specified ..
    {unless the declaration is for the type of a command (procedure) or ..
    {function parameter.}

    cle$array_elem_type_required    = clc$min_ecc + 2004,
    {E In the declaration for an ARRAY type, the element type must be ..
    {specified unless the declaration is for the type of a command ..
    {(procedure) or function parameter.}

    cle$expecting_of_for_array      = clc$min_ecc + 2005,
    {E Expecting OF in ARRAY type specification, found +P.}

    cle$max_array_bound_omitted     = clc$min_ecc + 2006,
    {E The maximum bound for an array was omitted but must be given when ..
    {the minimum bound is given.}

    cle$min_array_bound_gt_max      = clc$min_ecc + 2007,
    {E The minimum bound for an array may not be greater than the ..
    {corresponding maximum bound.}

{ Boolean expression errors }

    cle$and_operand_not_boolean     = clc$min_ecc + 2008,
    {E The operands of the "AND" operator must be booleans, a +P was found.}

    cle$not_operand_not_boolean     = clc$min_ecc + 2009,
    {E The operand of the "NOT" operator must be a boolean, a +P was found.}

    cle$or_operand_not_boolean      = clc$min_ecc + 2010,
    {E The operands of the "OR" operator must be booleans, a +P was found.}

    cle$xor_operand_not_boolean     = clc$min_ecc + 2011,
    {E The operands of the "XOR" operator must be booleans, a +P was found.}

{ COBOL_name expression errors }

    cle$expecting_cobol_name_expr   = clc$min_ecc + 2012,
    {E Expecting COBOL_name expression, found +P.}

    cle$not_a_cobol_name            = clc$min_ecc + 2013,
    {E +P is not a COBOL_name.  A COBOL name may contain up to 30 letters, ..
    {digits or hyphens. It may not start or end with a hyphen and must ..
    {contain at least one letter.}

{ Comparison (relational expression) errors }

    cle$non_comparable_type         = clc$min_ecc + 2014,
    {E Values of type +P may not be compared.}

    cle$non_comparable_values       = clc$min_ecc + 2015,
    {E Values of types +P and +P may not be compared.}

    cle$only_compare_for_equality   = clc$min_ecc + 2087,
    {E Values of type +P may only be compared for equality or inequality.}

{ Date_Time  type conformance errors }

    cle$date_time_tenses_dont_match = clc$min_ecc + 2189,
    {E Date_Time tenses do not match.}

    cle$date_time_types_dont_match  = clc$min_ecc + 2190,
    {E Date_Time type identifiers do not match.}

{ Date_Time, Date and Time expression errors }

    cle$expecting_date_time_expr    = clc$min_ecc + 2016,
    {E Expecting DATE_TIME expression, found +P.}

    cle$impossible_date_or_time     = clc$min_ecc + 1430,
    {E One or more of the components of a DATE_TIME value is out of ..
    {range, or the components are mutually incompatible: +P.}

    cle$unrecognizable_date_time    = clc$min_ecc + 2018,
    {E Unrecognizable DATE_TIME expression: +P.}

    cle$wrong_date_time_tense       = clc$min_ecc + 2019,
    {E The tense for +P1 "+P4" (+P2) is wrong, it must be: +P3.}

{ Date_Time, Date and Time type specification errors }

    cle$expecting_date_time_tense   = clc$min_ecc + 2020,
    {E Expecting tense (PAST, PRESENT or FUTURE) in DATE/TIME type ..
    {specification, found +P.}

{ Field referencing errors }

    cle$expecting_field_name        = clc$min_ecc + 405,
    {E Expecting field name following "." qualifier of +P, found +P.}

    cle$unaccessible_field          = clc$min_ecc + 2022,
    {E Field +P cannot be accessed because of the values of other ..
    {fields within +P.}

    cle$undefined_field             = clc$min_ecc + 2023,
    {E Field +P within +P has not been assigned a value.}

    cle$unknown_field               = clc$min_ecc + 2024,
    {E +P is not a field within +P.}

{ Function call errors }

    cle$expecting_rparen_of_plist   = clc$min_ecc + 623,
    {E Expecting ")" of parameter list for function +P, found +P.}

    cle$function_is_read_only       = clc$min_ecc + 2017,
    {E Function +P can only be read; it may not be used as a variable or ..
    {parameter.}

    cle$no_function_result          = clc$min_ecc + 2026,
    {E No result was returned by function +P.}

    cle$qual_$value_is_read_only    = clc$min_ecc + 2063,
    {E When the $VALUE function is used to refer to a VAR parameter ..
    {only the parameter name may be given.}

    cle$unknown_function            = clc$min_ecc + 1090,
    {E +P is not a function.}

{ Integer type conformance errors }

    cle$integer_ranges_dont_match   = clc$min_ecc + 2096,
    {E Integer subranges do not match.}

    cle$integer_radices_dont_match  = clc$min_ecc + 2099,
    {E Integer default radices do not match.}

{ Integer type specification errors }

    cle$radix_out_of_range          = clc$min_ecc + 2028,
    {E The radix +P is out of range.  It must be between +P and +P.}

{ Keyword type conformance errors }

    cle$keywords_dont_match         = clc$min_ecc + 2107,
    {E Keywords do not match.}

{ Keyword expression errors }

    cle$unknown_keyword             = clc$min_ecc + 2029,
    {E +P is not a keyword.}

{ Keyword type specification errors }

    cle$duplicate_keyword           = clc$min_ecc + 2030,
    {E Duplicate keyword +P in +P declaration.}

    cle$expecting_key_in_spec       = clc$min_ecc + 2031,
    {E Expecting keyword in KEY type specification, found +P.}

    cle$no_advanced_usage_keywords  = clc$min_ecc + 2032,
    {E No keywords following ADVANCED_KEY in KEY type specification.}

    cle$no_hidden_keywords          = clc$min_ecc + 2033,
    {E No keywords following HIDDEN_KEY in KEY type specification.}

    cle$no_keywords                 = clc$min_ecc + 2034,
    {E No keywords in KEY type specification.}

    cle$no_normal_usage_keywords    = clc$min_ecc + 2035,
    {E No keywords before ADVANCED_KEY or HIDDEN_KEY in KEY type ..
    {specification.}

{ Line_identifier expression errors }

    cle$expecting_sequence_number   = clc$min_ecc + 2088,
    {E Expecting sequence number of line_identifier, found +P.

    cle$modification_name_too_long  = clc$min_ecc + 2036,
    {E The modification name +P is too long. It has more than 9 ..
    {characters.}

    cle$sequence_number_not_integer = clc$min_ecc + 2037,
    {E The line_identifier's sequence number must be an integer, not a ..
    {real number, but +P was given.}

    cle$sequence_num_out_of_range   = clc$min_ecc + 2038,
    {E The line_identifier's sequence number must be between 1 and ..
    {16777215, but +P was given.}

{ List type conformance errors }

    cle$defer_expans_doesnt_match   = clc$min_ecc + 2244,
    {E "DEFER_EXPANSION" qualifiers for the lists do not match.}

    cle$list_rest_doesnt_match      = clc$min_ecc + 2111,
    {E "REST" qualifiers for the lists do not match.}

    cle$list_sizes_dont_match       = clc$min_ecc + 2144,
    {E List size qualifiers do not match.}

    cle$undefined_value_in_list     = clc$min_ecc + 2240,
    {E An uninitialized value may not be the element of a list.}

    cle$unknown_array_to_list_value = clc$min_ecc + 2241,
    {E An uninitialized array element may not be the element of a list.}

    cle$unknown_list_element_type   = clc$min_ecc + 2192,
    {E An undefined type may not be the element of a list.}

{ List expression errors }

    cle$expecting_list_elem_sep     = clc$min_ecc + 2039,
    {E Expecting  space, ','  or ')' after list element, found +P.}

    cle$expecting_rparen_of_list    = clc$min_ecc + 2040,
    {E Expecting ")" of list, found +P.}

    cle$too_few_or_many_list_elems  = clc$min_ecc + 2041,
    {E +P elements given for list, but the number of elements must be ..
    {between +P and +P.}

{ List type specification errors }

    cle$expecting_of_for_list       = clc$min_ecc + 2042,
    {E Expecting OF in LIST type specification, found +P.}

    cle$improper_use_of_list_rest   = clc$min_ecc + 2043,
    {E The REST qualifier for a LIST type may only be specified for the ..
    {last field of a RECORD, or the last parameter of a function ..
    {(provided the parameter does not have the VAR attribute).}

    cle$list_bound_out_of_range     = clc$min_ecc + 2044,
    {E The list bound +P is out of range.  It must be between +P and +P.}

    cle$list_elem_type_required     = clc$min_ecc + 2045,
    {E In the declaration for a LIST type, the element type must be ..
    {specified unless the declaration is for the type of a command ..
    {(procedure) or function parameter.}

    cle$max_list_bound_omitted      = clc$min_ecc + 2046,
    {E The maximum bound for a list was omitted but must be given when ..
    {the minimum bound is given.}

    cle$min_list_bound_gt_max       = clc$min_ecc + 2047,
    {E The minimum bound for a list may not be greater than the ..
    {corresponding maximum bound.}

{ Miscellaneous type conformance errors }

    cle$undefined_type              = clc$min_ecc + 2193,
    {E Type is not defined.}

    cle$undefined_value             = clc$min_ecc + 2194,
    {E Value is not defined.}

    cle$value_not_union_type        = clc$min_ecc + 2195,
    {E Wrong kind of value or value out of range for a union (ANY) type.}

    cle$variable_not_union_type     = clc$min_ecc + 2228,
    {E Wrong kind of variable for a union (ANY) type for parameter +P.}

{ Miscellaneous declaration errors }

    cle$expecting_type_expression   = clc$min_ecc + 2048,
    {E Expecting type expression, found +P.}

{ Miscellaneous expression errors }

    cle$expecting_end_of_expression = clc$min_ecc + 310,
    {E Expecting end of expression, found +P.}

    cle$expecting_operand           = clc$min_ecc + 2050,
    {E Expecting operand of expression, found +P.}

    cle$expecting_rparen_of_subexpr = clc$min_ecc + 2051,
    {E Expecting ")" of subexpression, found +P.}

    cle$expression_not_union_type   = clc$min_ecc + 2052,
    {E Wrong kind of value, value out of range, or improper expression ..
    {for a union (ANY) type: +P.}

    cle$nonevaluable_deferred_value = clc$min_ecc + 2053,
    {E Unable to evaluate deferred value for +P.}

    cle$recursive_deferred_variable = clc$min_ecc + 2245,
    {E Recursive use of deferred variable or parameter +P is not allowed.}

    cle$unexpected_oper_for_unspec  = clc$min_ecc + 2054,
    {E A reference to unspecified (omitted) parameter +P may not be ..
    {the operand of the "+P" operator.}

    cle$unexpected_qual_for_unspec  = clc$min_ecc + 2055,
    {E A reference to unspecified (omitted) parameter +P may not be ..
    {followed by a subscript, substring, field reference or path ..
    {element; a "+P" was found.}

    cle$unspecified_value_for_list  = clc$min_ecc + 2233,
    {E A reference to unspecified (omitted) parameter +P may not be the ..
    {element value of a list or array.}

    cle$unspecified_value_for_range = clc$min_ecc + 2234,
    {E A reference to unspecified (omitted) parameter +P may not be the ..
    {low or high value of a range.}

    cle$unspecified_value_for_req   = clc$min_ecc + 2056,
    {E The +P request resulted in an unspecified value (omitted parameter +P).}

    cle$unspecified_value_for_state = clc$min_ecc + 2057,
    {E A reference to unspecified (omitted) parameter +P may not be given ..
    {as the expression for the +P statement.}

    cle$unrecognizable_data_value   = clc$min_ecc + 2058,
    {F Attempt to use unrecognizable value with the "+P" operator.}

    cle$wrong_kind_of_element_type  = clc$min_ecc + 2059,
    {E Wrong kind of list or array element type, expecting +P, found +P.}

    cle$wrong_kind_of_element_value = clc$min_ecc + 2060,
    {E Wrong kind of list or array element value, expecting +P, found +P ..
    {for element number +P.}

    cle$wrong_kind_of_value         = clc$min_ecc + 265,
    {E Wrong kind of value, expecting +P, found +P.}

{ Name type conformance errors }

    cle$name_sizes_dont_match       = clc$min_ecc + 2150,
    {E Name sizes do not match.}

{ Name expression errors }

    cle$name_value_too_long         = clc$min_ecc + 240,
    {E Name +P3 should not have more than +P1 characters in it but ..
    {it has +P2.}

    cle$name_value_too_short        = clc$min_ecc + 245,
    {E Name +P3 should have at least +P1 characters in it but it has ..
    {only +P2.}

{ Name type specification errors }

    cle$min_name_size_gt_max        = clc$min_ecc + 2064,
    {E The minimum size for a name may not be greater than the ..
    {corresponding maximum size.}

    cle$name_size_out_of_range      = clc$min_ecc + 2065,
    {E The name size +P is out of range.  It must be between +P and +P.}

{ Numeric expression errors }

    cle$arithmetic_operand_not_num  = clc$min_ecc + 2066,
    {E The operands of the "+P" operator must be numbers (integer or real), ..
    {a +P was found.}

    cle$arithmetic_overflow         = clc$min_ecc + 2067,
    {E Arithmetic overflow occurred attempting +P.}

    cle$arithmetic_significance     = clc$min_ecc + 2068,
    {E A loss of significant digits resulted from attempting +P.}

    cle$divide_fault                = clc$min_ecc + 2069,
    {E A divide fault (division by zero) occurred attempting +P.}

    cle$exponent_overflow           = clc$min_ecc + 2070,
    {E Exponent overflow occurred attempting +P.}

    cle$exponent_underflow          = clc$min_ecc + 2071,
    {E Exponent underflow occurred attempting +P.}

    cle$exponentiate_fault          = clc$min_ecc + 2072,
    {E Improper operands were used for exponentiation: +P. ..
    {The left operand may not be negative, and if the left operand is ..
    {zero the right operand may not be zero or negative.}

    cle$fp_indefinite               = clc$min_ecc + 2073,
    {E An indefinite value resulted from attempting +P.}

    cle$fp_significance_loss        = clc$min_ecc + 2074,
    {E A loss of significant digits resulted from attempting +P.}

    cle$integer_out_of_range        = clc$min_ecc + 225,
    {E The integer +P is out of range.  It must be between +P and +P.}

    cle$real_greater_than_integer   = clc$min_ecc + 2076,
    {E The real number +P cannot be converted to an integer because it is ..
    {not within the range of values -(2**63) and (2**63)-1.}

    cle$real_number_out_of_range    = clc$min_ecc + 2077,
    {E The real number +P is out of range.  It must be between +P and +P.}

{ Numeric type specification errors }

    cle$max_of_subrange_omitted     = clc$min_ecc + 2078,
    {E The maximum value for a subrange type may not be omitted .}

    cle$min_of_subrange_not_le_max  = clc$min_ecc + 2079,
    {E The minimum value for a subrange type must be less than or equal to ..
    {the corresponding maximum value.}

{ Parameter evaluation errors }

    cle$default_name_not_string     = clc$min_ecc + 2080,
    {E The default variable +P for parameter +P is not a string variable.}

    cle$defaulted_parameter_unspec  = clc$min_ecc + 2198,
    {E Parameter +P, for which a default value is declared, was specified ..
    {with an omitted procedure parameter.}

    cle$doubly_defined_parameter    = clc$min_ecc + 610,
    {E Parameter +P already given.}

    cle$expecting_default_term      = clc$min_ecc + 615,
    {E Expecting end of default value expression for parameter +P, found +P.}

    cle$expecting_parameter_term    = clc$min_ecc + 620,
    {E Expecting end of parameter +P, found +P.}

    cle$expecting_var_for_param     = clc$min_ecc + 2179,
    {E Expecting variable for parameter +P, found +P.}

    cle$by_name_not_by_name         = clc$min_ecc + 2246,
    {E A parameter with the BY_NAME attribute was given positionally.}

    cle$indeterminate_param_var     = clc$min_ecc + 2081,
    {E +P cannot be validated to conform to +P.}

    cle$omited_param_cant_have_qual = clc$min_ecc + 2236,
    {E A reference to unspecified (omitted) parameter +P may not be ..
    {followed by a subscript, substring, or field reference.

    cle$only_string_literal_for_par = clc$min_ecc + 2084,
    {E Only a literal quoted string is allowed for parameter +P. ..
    {No variables, function or operators may be used.}

    cle$p_application_name_mismatch = clc$min_ecc + 2199,
    {E Application type names do not match for parameter +P.}

    cle$p_array_bounds_dont_match   = clc$min_ecc + 2200,
    {E Array bounds do not match for parameter +P.}

    cle$p_balance_brackets_mismatch = clc$min_ecc + 2201,
    {E "BALANCE_BRACKETS" attributes do not match for parameter +P.}

    cle$p_date_time_tenses_mismatch = clc$min_ecc + 2202,
    {E Date_Time tenses do not match for parameter +P.}

    cle$p_date_time_types_mismatch  = clc$min_ecc + 2203,
    {E Date_Time type identifiers do not match for parameter +P.}

    cle$p_field_names_dont_match    = clc$min_ecc + 2204,
    {E Field names for records do not match for parameter +P.}

    cle$p_field_requiremnt_mismatch = clc$min_ecc + 2205,
    {E Field requirements for records do not match for parameter +P.}

    cle$p_field_types_dont_match    = clc$min_ecc + 2206,
    {E Wrong kind of record field type, expecting +P, found +P ..
    {for field +P for parameter +P.}

    cle$p_integer_radices_mismatch  = clc$min_ecc + 2207,
    {E Integer default radices do not match for parameter +P.}

    cle$p_integer_ranges_dont_match = clc$min_ecc + 2208,
    {E Integer subranges do not match for parameter +P.}

    cle$p_keywords_dont_match       = clc$min_ecc + 2209,
    {E Keywords do not match for parameter +P.}

    cle$p_list_rest_doesnt_match    = clc$min_ecc + 2210,
    {E "REST" qualifiers for the lists do not match for parameter +P.}

    cle$p_list_sizes_dont_match     = clc$min_ecc + 2211,
    {E List size qualifiers do not match for parameter +P.}

    cle$p_name_sizes_dont_match     = clc$min_ecc + 2212,
    {E Name sizes do not match for parameter +P.}

    cle$p_number_of_fields_mismatch = clc$min_ecc + 2213,
    {E Number of fields for records do not match for parameter +P.}

    cle$p_range_types_dont_match    = clc$min_ecc + 2214,
    {E Wrong kind of range type, expecting +P, found +P for parameter +P.}

    cle$p_real_subranges_dont_match = clc$min_ecc + 2215,
    {E Real subranges do not match for parameter +P.}

    cle$p_string_literals_mismatch  = clc$min_ecc + 2216,
    {E "LITERAL" qualifier for strings do not match for parameter +P.}

    cle$p_string_sizes_dont_match   = clc$min_ecc + 2217,
    {E String sizes do not match for parameter +P.}

    cle$p_undefined_type            = clc$min_ecc + 2218,
    {E Type is not defined for parameter +P.}

    cle$p_undefined_value           = clc$min_ecc + 2219,
    {E Value is not defined for parameter +P.}

    cle$p_unexpect_oper_for_unspec  = clc$min_ecc + 2235,
    {E A reference to unspecified (omitted) parameter +P may not be ..
    {the operand of the "+P" operator for parameter +P.}

    cle$p_unknown_array_elem_type   = clc$min_ecc + 2220,
    {E Undefined array element type for parameter +P.}

    cle$p_unknown_list_element_type = clc$min_ecc + 2221,
    {E Undefined list element type for parameter +P.}

    cle$p_unknown_range_elem_type   = clc$min_ecc + 2222,
    {E Undefined range element type for parameter +P.}

    cle$p_value_not_union_type      = clc$min_ecc + 2229,
    {E Wrong kind of value or value out of range for a union (ANY) type ..
    {for parameter +P.}

    cle$p_wrong_kind_of_elem_type   = clc$min_ecc + 2232,
    {E Wrong kind of list or array element type, expecting +P, found +P ..
    {for parameter +P.}

    cle$param_expr_not_union_type   = clc$min_ecc + 2085,
    {E Wrong kind of value, value out of range, or improper expression ..
    {for parameter +P: +P.}

    cle$param_not_spec_by_name      = clc$min_ecc + 648,
    {E Parameter +P must be specified by name but was given positionally ..
    {as: +P.}

    cle$parameter_never_given_value = clc$min_ecc + 2231,
    {E A reference was made to parameter +P, but no value has ever been ..
    {assigned to it.}

    cle$required_parameter_omitted  = clc$min_ecc + 650,
    {E Parameter +P is required but was omitted.}

    cle$required_parameter_unspec   = clc$min_ecc + 2224,
    {E Required parameter +P was specified with omitted procedure ..
    {parameter +P.}

    cle$secure_parameter_incorrect  = clc$min_ecc + 2230,
    {E Value for secure parameter +P is incorrect.}

    cle$too_many_parameters         = clc$min_ecc + 670,
    {E Too many parameters given.}

    cle$unexpected_in_param_list    = clc$min_ecc + 688,
    {E Unexpected +P in parameter list.}

    cle$unknown_parameter_keyword   = clc$min_ecc + 2090,
    {E +P is not a keyword for parameter +P.}

    cle$unknown_parameter_name      = clc$min_ecc + 690,
    {E +P is not a parameter name.}

    cle$value_given_positionally    = clc$min_ecc + 694,
    {E A parameter was given positionally but there is no parameter ..
    {defined for that position; value = +P.}

    cle$wrong_kind_of_param_value   = clc$min_ecc + 2093,
    {E Wrong kind of value, expecting +P, found +P for parameter +P.}

    cle$wrong_kind_of_param_var     = clc$min_ecc + 2180,
    {E Wrong kind of variable, expecting +P2, found +P3 for parameter +P1.}

{ Parameter specification errors }

    cle$advanced_parameter_conflict = clc$min_ecc + 2094,
    {E Specification conflict for parameter +P: a parameter with the ..
    {ADVANCED attribute may not also be a required parameter or have a ..
    {default option of $CONFIRM.}

    cle$by_name_in_function         = clc$min_ecc + 2095,
    {E The BY_NAME attribute, specified for parameter +P, may not be used in ..
    {a function declaration.}

    cle$defer_with_var              = clc$min_ecc + 2097,
    {E Attribute conflict for parameter +P: a parameter with the VAR ..
    {attribute may not also have the DEFER attribute.}

    cle$duplicate_parameter_attr    = clc$min_ecc + 2098,
    {E Duplicate attribute +P for parameter +P.}

    cle$duplicate_parameter_name    = clc$min_ecc + 810,
    {E Duplicate parameter name +P in +P declaration.}

    cle$expecting_parameter_attr    = clc$min_ecc + 2100,
    {E Expecting attribute for parameter +P, found +P.}

    cle$expecting_parameter_name    = clc$min_ecc + 2101,
    {E Expecting parameter name in +P declaration, found +P.

    cle$expecting_end_of_param_spec = clc$min_ecc + 2227,
    {E Expecting semicolon or end of line after specification for parameter ..
    {+P, found +P.}

    cle$expecting_parameter_spec    = clc$min_ecc + 2102,
    {E Expecting parameter specification in +P declaration, found +P.}

    cle$function_parameter_one_name = clc$min_ecc + 2103,
    {E Function parameter +P declared with more than one name.}

    cle$hidden_parameter_conflict   = clc$min_ecc + 2104,
    {E Specification conflict for parameter +P: a parameter with the HIDDEN ..
    {attribute may not also be a required parameter or have a default option ..
    {of $CONFIRM.}

    cle$no_type_for_function_param  = clc$min_ecc + 2105,
    {E Type specification for function parameter +P missing, found +P.}

    cle$secure_param_in_function    = clc$min_ecc + 2178,
    {E The SECURE attribute, specified for parameter +P, may not be used ..
    {in a function declaration.}

    cle$secure_with_var             = clc$min_ecc + 2177,
    {E Attribute conflict for parameter +P: a parameter with the VAR ..
    {attribute may not also have the SECURE attribute.}

    cle$unsupported_parameter_spec  = clc$min_ecc + 692,
    {E "VAR (or ARRAY) OF type" is not supported in combination with ..
    {LIST, RANGE, or KEY specifications (parameter +P).}

    cle$var_param_in_function       = clc$min_ecc + 2176,
    {E The VAR attribute, specified for parameter +P, may not be used in ..
    {a function declaration.}

{ Procedure / Function declaration errors }

    cle$duplicate_proc_attribute    = clc$min_ecc + 2106,
    {E Duplicate +P attribute in +P declaration.}

    cle$duplicate_proc_name         = clc$min_ecc + 815,
    {E Duplicate name +P in +P declaration.}

    cle$expecting_proc_attribute    = clc$min_ecc + 2108,
    {E Expecting +P attribute, found +P.}

    cle$expecting_proc_func_or_type = clc$min_ecc + 2109,
    {E Expecting PROCEDURE, FUNCTION, or TYPE, found +P.}

    cle$expecting_proc_header_term  = clc$min_ecc + 2110,
    {E Expecting ";" or end of line after +P declaration, found +P.

    cle$expecting_proc_name         = clc$min_ecc + 855,
    {E Expecting +P name in declaration, found +P.}

    cle$function_name_needs_$       = clc$min_ecc + 2112,
    {E Function name +P does not begin with a "$" character.}

    cle$proc_scope_attr_conflict    = clc$min_ecc + 2113,
    {E Attribute conflict in +P declaration: LOCAL may not be used with XDCL ..
    {or GATE.}

{ Program_name expression errors }

    cle$null_program_name           = clc$min_ecc + 2114,
    {E A string specified for a program_name may not be null or blank.}

    cle$program_name_too_long       = clc$min_ecc + 2115,
    {E Program name string '+P' is too long. It has more than 31 characters.}

{ Range type conformance errors }

    cle$range_types_dont_match      = clc$min_ecc + 2163,
    {E Wrong kind of range type, expecting +P, found +P.}

    cle$undefined_value_in_range    = clc$min_ecc + 2242,
    {E An uninitialized value may not be the low or high value of a range.}

    cle$unknown_range_element_type  = clc$min_ecc + 2196,
    {E An undefined type may not be the low or high value of a range.}

{ Range referencing errors }

    cle$undefined_range_selector    = clc$min_ecc + 2089,
    {E Range selector +P for +P has not been assigned a value.}

    cle$unknown_range_selector      = clc$min_ecc + 2091,
    {E +P is not a range selector for +P.  It must be 'LOW' or 'HIGH'.}

{ Range type specification errors }

    cle$range_elem_type_required    = clc$min_ecc + 2116,
    {E In the declaration for a RANGE type, the element type must be ..
    {specified unless the declaration is for the type of a command ..
    {(procedure) or function parameter.}

    cle$expecting_of_for_range      = clc$min_ecc + 2117,
    {E Expecting OF in RANGE type specification, found +P.}

{ Real type conformance errors }

    cle$real_subranges_dont_match   = clc$min_ecc + 2164,
    {E Real subranges do not match.}

{ Record type conformance errors }

    cle$field_names_dont_match      = clc$min_ecc + 2173,
    {E Field names for records do not match.}

    cle$field_requirements_mismatch = clc$min_ecc + 2175,
    {E Field requirements for records do not match.}

    cle$field_types_dont_match      = clc$min_ecc + 2181,
    {E Wrong kind of record field type, expecting +P, found +P ..
    {for field +P.}

    cle$number_of_fields_dont_match = clc$min_ecc + 2182,
    {E Number of fields for records do not match.}

{ Record expression errors }

    cle$expecting_rparen_of_flist   = clc$min_ecc + 2118,
    {E Expecting ")" for field list of +P, found +P.}

    cle$field_expr_not_union_type   = clc$min_ecc + 2119,
    {E Wrong kind of value, value out of range, or improper expression ..
    {for field +P: +P.}

    cle$only_string_literal_for_fld = clc$min_ecc + 2120,
    {E Only a literal quoted string is allowed for field +P of +P. ..
    {No variables functions or operators may be used.}

    cle$required_field_omitted      = clc$min_ecc + 2121,
    {E Field +P for +P is required but was omitted.}

    cle$required_field_unspecified  = clc$min_ecc + 2225,
    {E Required field +P1 for +P3 was specified with omitted procedure ..
    {parameter +P2.}

    cle$too_many_fields             = clc$min_ecc + 2122,
    {E Too many fields for +P.}

    cle$unexpected_in_field_list    = clc$min_ecc + 2123,
    {E Unexpected +P in field list for +P.}

    cle$unknown_field_keyword       = clc$min_ecc + 2124,
    {E +P is not a keyword for field +P of +P.}

    cle$wrong_kind_of_field_value   = clc$min_ecc + 2125,
    {E Wrong kind of value, expecting +P, found +P for field +P of +P.}

{ Record type specification errors }

    cle$duplicate_field_name        = clc$min_ecc + 2223,
    {E Duplicate field name +P in RECORD type specification.}

    cle$expecting_after_field_name  = clc$min_ecc + 2126,
    {E Expecting ":" after field name +P in RECORD type specification, ..
    {found +P.}

    cle$expecting_after_field_spec  = clc$min_ecc + 2127,
    {E Expecting "," or ";" or end of line after specification for field +P ..
    {in RECORD type specification, found +P.}

    cle$expecting_field_attribute   = clc$min_ecc + 2128,
    {E Expecting attribute for field +P in RECORD type specification, ..
    {found +P.}

    cle$expecting_field_requirement = clc$min_ecc + 2129,
    {E Expecting $REQUIRED or $OPTIONAL for field +P in RECORD type ..
    {specification, found +P.}

    cle$expecting_record_field_name = clc$min_ecc + 2130,
    {E Expecting field name in RECORD type specification, found +P.}

    cle$no_record_fields            = clc$min_ecc + 2131,
    {E No fields in RECORD type specification.}

{ Statistic_code expression errors }

    cle$statistic_code_out_of_range = clc$min_ecc + 2132,
    {E An integer for a statistic code must be between 0 and ..
    {0ffffffffff(16), but +P was given.}

    cle$unrecognizable_statist_name = clc$min_ecc + 2133,
    {E A statistic code may be specified by a name of the form "xxnnn" ..
    {or "xx_nnn", where xx is the code's 2 character product identifier ..
    {and nnn is an unsigned decimal number between 0 and 16777215. ..
    {The following was specified: +P.}

    cle$unrecognizable_statist_str  = clc$min_ecc + 2134,
    {E A statistic code may be specified by a string of the form "XX nnn", ..
    {where XX is the code's 2 character product identifier and is an ..
    {unsigned decimal number between 0 and 16777215. ..
    {The following was specified: +P.}

{ Status_code expression errors }

    cle$status_code_out_of_range    = clc$min_ecc + 2135,
    {E An integer for a status code must be between 0 and ..
    {0ffffffffff(16), but +P was given.}

    cle$unknown_status_code_name    = clc$min_ecc + 2243,
    {E +P is not a status code name.}

    cle$unrecognizable_status_name  = clc$min_ecc + 2136,
    {E A status code may be specified by a name of the form "xxnnn" ..
    {or "xx_nnn", where xx is the code's 2 character product identifier ..
    {and nnn is an unsigned decimal number between 0 and 16777215. ..
    {The following was specified: +P.}

    cle$unrecognizable_status_str   = clc$min_ecc + 2137,
    {E A status code may be specified by a string of the form "XX nnn", ..
    {where XX is the code's 2 character product identifier and nnn is an ..
    {unsigned decimal number between 0 and 16777215. ..
    {The following was specified: +P.}

{ String type conformance errors }

    cle$string_literals_dont_match  = clc$min_ecc + 2183,
    {E "LITERAL" qualifier for strings do not match.}

    cle$string_sizes_dont_match     = clc$min_ecc + 2184,
    {E String sizes do not match.}

{ String expression errors }

    cle$concat_left_op_not_str      = clc$min_ecc + 2138,
    {E The left operand of the "//" operator must be a string, a +P was found.}

    cle$concat_right_op_not_str     = clc$min_ecc + 2139,
    {E The right operand of the "//" operator must be a string or ..
    {representable as a single string, a +P was found.}

    cle$concatenated_str_too_long   = clc$min_ecc + 2140,
    {E The concatenation of strings via the "//" operator resulted in a ..
    {string that exceeded the maximum string size of 65535 characters.}

    cle$only_string_literal_allowed = clc$min_ecc + 2141,
    {E Only a literal quoted string is allowed.  No variables, function or ..
    {operators may be used.}

    cle$string_value_too_long       = clc$min_ecc + 2142,
    {E String '+P3' should not have more than +P1 characters in it but ..
    {contains +P2.}

    cle$string_value_too_short      = clc$min_ecc + 2143,
    {E String '+P3' should have at least +P1 characters in it but contains ..
    {only +P2.}

{ String type specification errors }

    cle$min_string_size_gt_max      = clc$min_ecc + 2145,
    {E The minimum size for a string may not be greater than the ..
    {corresponding maximum size.}

    cle$string_size_out_of_range    = clc$min_ecc + 2146,
    {E The string size +P is out of range.  It must be between +P and +P.}

{ Subscript referencing errors }

    cle$expecting_rparen_of_subscr  = clc$min_ecc + 2147,
    {E Expecting ")" of subscript qualifier used with +P, found +P.}

    cle$list_subscript_too_large    = clc$min_ecc + 2148,
    {E The subscript +P2 used with +P1 is greater than the current ..
    {number of elements in the list (+P3).}

    cle$list_subscript_too_small    = clc$min_ecc + 2149,
    {E The subscript +P2 used with +P1 is too small to be used with a ..
    {list.  A list subscript must be greater than or equal to 1.}

    cle$max_list_subscript_error    = clc$min_ecc + 2086,
    {E The subscript +P2 used with +P1 is greater than the maximum ..
    {number of allowed elements in the list (+P3).}

    cle$subscript_out_of_max_range  = clc$min_ecc + 2083,
    {E The subscript +P2 used with +P1 is out of range.  It must be ..
    {between the maximum range +P3 and +P4.}

    cle$subscript_out_of_range      = clc$min_ecc + 455,
    {E The subscript +P2 used with +P1 is out of range.  It must be ..
    {between +P3 and +P4.}

    cle$undefined_subscr_element    = clc$min_ecc + 2151,
    {E Element +P2 within +P1 has not been assigned a value.}

{ Substring referencing errors }

    cle$expecting_rparen_of_substr  = clc$min_ecc + 2152,
    {E Expecting ")" of substring qualifier used with +P, found +P.}

    cle$max_substr_index_error      = clc$min_ecc + 2082,
    {E The substring index +P2 used with +P1 is out of range.  It must be ..
    {between 1 and the maximum allowed index of +P3.}

    cle$substr_index_out_of_range   = clc$min_ecc + 2153,
    {E The substring index +P2 used with +P1 is out of range.  It must be ..
    {between 1 and +P3.}

    cle$substr_size_out_of_range    = clc$min_ecc + 2154,
    {E The substring size +P2 used with +P1 is out of range.  It must be ..
    {between 0 and +P3.}

{ Time_Increment expression errors }

    cle$expecting_date_time_operand = clc$min_ecc + 2155,
    {E Expecting DATE_TIME after "-" in TIME_INCREMENT expression, found +P.}

    cle$expecting_date_time_subtrct = clc$min_ecc + 2156,
    {E Expecting "-" after DATE_TIME in TIME_INCREMENT expression, found +P.}

    cle$expecting_time_incr_expr    = clc$min_ecc + 2157,
    {E Expecting TIME_INCREMENT expression, found +P.}

    cle$expecting_time_incr_operand = clc$min_ecc + 2158,
    {E Expecting TIME_INCREMENT variable or function after +P, found +P.}

    cle$expecting_time_zone_operand = clc$min_ecc + 2159,
    {E Expecting TIME_ZONE after "-" in TIME_INCREMENT expression, found +P.}

    cle$expecting_time_zone_subtrct = clc$min_ecc + 2160,
    {E Expecting "-" after TIME_ZONE in TIME_INCREMENT expression, found +P.}

    cle$unrecognizable_time_incr    = clc$min_ecc + 2161,
    {E Unrecognizable TIME_INCREMENT expression: +P.}

{ Time_Zone expression errors }

    cle$expecting_time_zone_expr    = clc$min_ecc + 2162,
    {E Expecting TIME_ZONE expression, found +P.}

    cle$impossible_time_zone        = clc$min_ecc + 275,
    {E One or more of the components of a TIME_ZONE value is out of range, ..
    {or the components are mutually incompatible: +P.}

    cle$unrecognizable_time_zone    = clc$min_ecc + 280,
    {E Unrecognizable TIME_ZONE expression: +P.}

{ Type specification errors }

    cle$expecting_after_type_def    = clc$min_ecc + 2165,
    {E Expecting comma, semicolon or end of line after TYPE definition, ..
    {found +P.}

    cle$expecting_after_type_name   = clc$min_ecc + 2166,
    {E Expecting : or = after TYPE name, found +P.}

    cle$expecting_type_name         = clc$min_ecc + 2167,
    {E Expecting TYPE name, found +P.}

    cle$expecting_typend            = clc$min_ecc + 2168,
    {E Expecting TYPEND, found +P.}

{ Union (Any) type specification errors }

    cle$expecting_after_member_spec = clc$min_ecc + 2169,
    {E Expecting "," or ";" or end of line after member type specification ..
    {in ANY specification, found +P.}

    cle$expecting_of_for_any        = clc$min_ecc + 2170,
    {E Expecting OF in ANY type specification, found +P.}

    cle$inconsistent_radix_in_union = clc$min_ecc + 2171,
    {E Numeric member types of a union type specified different radices. ..
    {If multiple integer types are specified they must have identical ..
    {radices.  If integer and real types are specified, the radix for ..
    {the integer types must be 10.}

    cle$no_union_members            = clc$min_ecc + 2172,
    {E No member types in ANY type specification.}

{ Variable reference and specification errors }

    cle$bad_function_result         = clc$min_ecc + 401,
    {E A bad function result was found for variable +P.}

    cle$bad_value_qualifier         = clc$min_ecc + 402,
    {E Bad value qualifier encountered for variable +P.}

    cle$bad_variable_access_mode    = clc$min_ecc + 400,
    {E Improper access mode specification for variable +P.}

    cle$bad_variable_eval_method    = clc$min_ecc + 414,
    {E Improper evaluation method specification for variable +P.}

    cle$bad_variable_kind           = clc$min_ecc + 403,
    {E Improper kind specification for variable +P.}

    cle$bad_variable_scope          = clc$min_ecc + 407,
    {E Improper scope specification for variable +P.}

    cle$bad_variable_string_size    = clc$min_ecc + 412,
    {E Improper string size specification for variable +P.}

    cle$cannot_assign_to_a_read_var = clc$min_ecc + 404,
    {E Cannot assign a value to a read only variable: +P.}

    cle$cannot_initialize_component = clc$min_ecc + 406,
    {E Can only initialize by component an array or record in variable +P.}

    cle$cannot_push_variable        = clc$min_ecc + 423,
    {E Cannot push variable +P because it is not an environment variable.}

    cle$cannot_read_component       = clc$min_ecc + 408,
    {E Cannot get the component value of variable +P ..
    {because the variable is uninitialized.}

    cle$cannot_read_omitted_param   = clc$min_ecc + 419,
    {E Cannot read an omitted parameter, +P.}

    cle$cannot_write_omitted_param   = clc$min_ecc + 421,
    {E Cannot write to an omitted parameter, +P.}

    cle$duplicate_variable_attr     = clc$min_ecc + 2049,
    {E Duplicate attribute +P for variable +P.}

    cle$expecting_after_var_def     = clc$min_ecc + 2021,
    {E Expecting semicolon or end of line after VAR definition, found +P.}

    cle$expecting_after_var_name    = clc$min_ecc + 2025,
    {E Expecting colon after VAR name, found +P.}

    cle$expecting_variable_attr     = clc$min_ecc + 2061,
    {E Expecting attribute for variable +P, found +P.}

    cle$expecting_variable_name     = clc$min_ecc + 415,
    {E Expecting variable name, found +P.}

    cle$improper_array_bounds       = clc$min_ecc + 426,
    {E Lowerbound must be <= upperbound for variable +P.}

    cle$improper_use_of_$           = clc$min_ecc + 427,
    {E $ improper first character in declaration of +P.}

    cle$improper_use_of_defer_value = clc$min_ecc + 2187,
    {E A deferred value cannot be assigned to a component of ..
    {variable +P.}

    cle$improper_use_of_defer_var   = clc$min_ecc + 2188,
    {E Cannot assign a value to a component of variable +P ..
    {because it has the deferred attribute.}

    cle$improper_var_specification  = clc$min_ecc + 428,
    {E Improper attributes for variable +P.}

    cle$improper_variable_name      = clc$min_ecc + 429,
    {E Improper variable name: +P.}

    cle$improper_variable_requests  = clc$min_ecc + 2237,
    {E Improper access requests for variable +P.}

    cle$improper_variable_value     = clc$min_ecc + 431,
    {E Improper value for variable: +P.}

    cle$incompatible_assignment     = clc$min_ecc + 442,
    {E Wrong kind of value for variable: +P.}

    cle$initial_name_not_string     = clc$min_ecc + 2075,
    {E The "initial variable" +P for variable +P is not a string variable.}

    cle$internal_read_qualifier_err  = clc$min_ecc + 2238,
    {E An internal error was encountered while trying ..
    {to read variable: +P.  An invalid qualifier was ..
    {detected.}

    cle$improper_parameter_value  = clc$min_ecc + 2239,
    {E Value +P is improper for the parameter type.}

    cle$internal_read_variable_err  = clc$min_ecc + 422,
    {E An internal error was encountered while trying ..
    {to read variable: +P.  The type description does not ..
    {match the current value.}

    cle$must_specify_new_data_value = clc$min_ecc + 418,
    {E Must specify new value in order to change the value ..
    {of variable +P.}

    cle$no_space_for_variable       = clc$min_ecc + 444,
    {E Not enough space to hold variable +P.}

    cle$not_a_variable_attribute    = clc$min_ecc + 2062,
    {E "+P" is not a variable attribute.}

    cle$not_a_variable_kind         = clc$min_ecc + 445,
    {E The initial value kind for variable +P is not ..
    {assignable to a variable.

    cle$no_type_spec_specified      = clc$min_ecc + 416,
    {E No type specification given for variable +P.}

    cle$read_var_requires_value     = clc$min_ecc + 2027,
    {E Variable, +P, defined with the read attribute must be ..
    {given an initial value.}

    cle$special_name_use            = clc$min_ecc + 453,
    {E +P identifies a boolean constant and therefore may not be ..
    {used as a variable name.}

    cle$undefined_variable_field    = clc$min_ecc + 465,
    {E Field +P is not meaningful in current value of variable +P.}

    cle$undefined_var_qualifier     = clc$min_ecc + 409,
    {E Component after field +P is not meaningful in current value ..
    {of variable +P.}

    cle$undefined_var_subscript     = clc$min_ecc + 411,
    {E Subscript +P2 is not meaningful in current value of variable +P1.}

    cle$undefined_var_substring     = clc$min_ecc + 413,
    {E Substring is not meaningful in current value of variable +P.}

    cle$variable_never_given_value  = clc$min_ecc + 2174,
    {E A reference was made to variable +P, but no value has ever been ..
    {assigned to it.}

    cle$xref_var_cannot_have_value  = clc$min_ecc + 417,
    {E Cannot create variable +P with an XREF scope and ..
    { an initial value.

    clc$max_ecc_parsing             = clc$min_ecc + 2999;

?? FMT (FORMAT := ON) ??
