13#define PM_DIAGNOSTIC_ID_MAX 322 
   92    [PM_ERR_INVALID_ENCODING_MAGIC_COMMENT]     = { 
"unknown or invalid encoding in the magic comment", 
PM_ERROR_LEVEL_ARGUMENT },
 
   98    [PM_ERR_ALIAS_ARGUMENT]                     = { 
"invalid argument being passed to `alias`; expected a bare word, symbol, constant, or global variable", 
PM_ERROR_LEVEL_SYNTAX },
 
   99    [PM_ERR_ALIAS_ARGUMENT_NUMBERED_REFERENCE]  = { 
"invalid argument being passed to `alias`; can't make alias for the number variables", 
PM_ERROR_LEVEL_SYNTAX },
 
  100    [PM_ERR_AMPAMPEQ_MULTI_ASSIGN]              = { 
"unexpected `&&=` in a multiple assignment", 
PM_ERROR_LEVEL_SYNTAX },
 
  101    [PM_ERR_ARGUMENT_AFTER_BLOCK]               = { 
"unexpected argument after a block argument", 
PM_ERROR_LEVEL_SYNTAX },
 
  102    [PM_ERR_ARGUMENT_AFTER_FORWARDING_ELLIPSES] = { 
"unexpected argument after `...`", 
PM_ERROR_LEVEL_SYNTAX },
 
  104    [PM_ERR_ARGUMENT_BLOCK_MULTI]               = { 
"both block arg and actual block given; only one block is allowed", 
PM_ERROR_LEVEL_SYNTAX },
 
  105    [PM_ERR_ARGUMENT_CONFLICT_AMPERSAND]        = { 
"unexpected `&`; anonymous block parameter is also used within block", 
PM_ERROR_LEVEL_SYNTAX },
 
  106    [PM_ERR_ARGUMENT_CONFLICT_STAR]             = { 
"unexpected `*`; anonymous rest parameter is also used within block", 
PM_ERROR_LEVEL_SYNTAX },
 
  107    [PM_ERR_ARGUMENT_CONFLICT_STAR_STAR]        = { 
"unexpected `**`; anonymous keyword rest parameter is also used within block", 
PM_ERROR_LEVEL_SYNTAX },
 
  108    [PM_ERR_ARGUMENT_FORMAL_CLASS]              = { 
"invalid formal argument; formal argument cannot be a class variable", 
PM_ERROR_LEVEL_SYNTAX },
 
  109    [PM_ERR_ARGUMENT_FORMAL_CONSTANT]           = { 
"invalid formal argument; formal argument cannot be a constant", 
PM_ERROR_LEVEL_SYNTAX },
 
  110    [PM_ERR_ARGUMENT_FORMAL_GLOBAL]             = { 
"invalid formal argument; formal argument cannot be a global variable", 
PM_ERROR_LEVEL_SYNTAX },
 
  111    [PM_ERR_ARGUMENT_FORMAL_IVAR]               = { 
"invalid formal argument; formal argument cannot be an instance variable", 
PM_ERROR_LEVEL_SYNTAX },
 
  112    [PM_ERR_ARGUMENT_FORWARDING_UNBOUND]        = { 
"unexpected `...` in an non-parenthesized call", 
PM_ERROR_LEVEL_SYNTAX },
 
  113    [PM_ERR_ARGUMENT_NO_FORWARDING_AMPERSAND]   = { 
"unexpected `&`; no anonymous block parameter", 
PM_ERROR_LEVEL_SYNTAX },
 
  114    [PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES]    = { 
"unexpected ... when the parent method is not forwarding", 
PM_ERROR_LEVEL_SYNTAX },
 
  115    [PM_ERR_ARGUMENT_NO_FORWARDING_STAR]        = { 
"unexpected `*`; no anonymous rest parameter", 
PM_ERROR_LEVEL_SYNTAX },
 
  116    [PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR]   = { 
"unexpected `**`; no anonymous keyword rest parameter", 
PM_ERROR_LEVEL_SYNTAX },
 
  117    [PM_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT]   = { 
"unexpected `*` splat argument after a `**` keyword splat argument", 
PM_ERROR_LEVEL_SYNTAX },
 
  118    [PM_ERR_ARGUMENT_SPLAT_AFTER_SPLAT]         = { 
"unexpected `*` splat argument after a `*` splat argument", 
PM_ERROR_LEVEL_SYNTAX },
 
  119    [PM_ERR_ARGUMENT_TERM_PAREN]                = { 
"unexpected %s; expected a `)` to close the arguments", 
PM_ERROR_LEVEL_SYNTAX },
 
  120    [PM_ERR_ARGUMENT_UNEXPECTED_BLOCK]          = { 
"unexpected '{' after a method call without parenthesis", 
PM_ERROR_LEVEL_SYNTAX },
 
  122    [PM_ERR_ARRAY_EXPRESSION]                   = { 
"expected an expression for the array element", 
PM_ERROR_LEVEL_SYNTAX },
 
  123    [PM_ERR_ARRAY_EXPRESSION_AFTER_STAR]        = { 
"expected an expression after `*` in the array", 
PM_ERROR_LEVEL_SYNTAX },
 
  124    [PM_ERR_ARRAY_SEPARATOR]                    = { 
"unexpected %s; expected a `,` separator for the array elements", 
PM_ERROR_LEVEL_SYNTAX },
 
  126    [PM_ERR_BEGIN_LONELY_ELSE]                  = { 
"unexpected `else` in `begin` block; else without rescue is useless", 
PM_ERROR_LEVEL_SYNTAX },
 
  129    [PM_ERR_BEGIN_UPCASE_TERM]                  = { 
"expected a `}` to close the `BEGIN` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  131    [PM_ERR_BLOCK_PARAM_LOCAL_VARIABLE]         = { 
"expected a local variable name in the block parameters", 
PM_ERROR_LEVEL_SYNTAX },
 
  132    [PM_ERR_BLOCK_PARAM_PIPE_TERM]              = { 
"expected the block parameters to end with `|`", 
PM_ERROR_LEVEL_SYNTAX },
 
  133    [PM_ERR_BLOCK_TERM_BRACE]                   = { 
"expected a block beginning with `{` to end with `}`", 
PM_ERROR_LEVEL_SYNTAX },
 
  134    [PM_ERR_BLOCK_TERM_END]                     = { 
"expected a block beginning with `do` to end with `end`", 
PM_ERROR_LEVEL_SYNTAX },
 
  136    [PM_ERR_CASE_EXPRESSION_AFTER_CASE]         = { 
"expected an expression after `case`", 
PM_ERROR_LEVEL_SYNTAX },
 
  137    [PM_ERR_CASE_EXPRESSION_AFTER_WHEN]         = { 
"expected an expression after `when`", 
PM_ERROR_LEVEL_SYNTAX },
 
  138    [PM_ERR_CASE_MATCH_MISSING_PREDICATE]       = { 
"expected a predicate for a case matching statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  139    [PM_ERR_CASE_MISSING_CONDITIONS]            = { 
"expected a `when` or `in` clause after `case`", 
PM_ERROR_LEVEL_SYNTAX },
 
  142    [PM_ERR_CLASS_NAME]                         = { 
"unexpected constant path after `class`; class/module name must be CONSTANT", 
PM_ERROR_LEVEL_SYNTAX },
 
  145    [PM_ERR_CLASS_UNEXPECTED_END]               = { 
"unexpected `end`, expecting ';' or '\\n'", 
PM_ERROR_LEVEL_SYNTAX },
 
  146    [PM_ERR_CLASS_VARIABLE_BARE]                = { 
"'@@' without identifiers is not allowed as a class variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  147    [PM_ERR_CONDITIONAL_ELSIF_PREDICATE]        = { 
"expected a predicate expression for the `elsif` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  148    [PM_ERR_CONDITIONAL_IF_PREDICATE]           = { 
"expected a predicate expression for the `if` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  150    [PM_ERR_CONDITIONAL_TERM]                   = { 
"expected an `end` to close the conditional clause", 
PM_ERROR_LEVEL_SYNTAX },
 
  151    [PM_ERR_CONDITIONAL_TERM_ELSE]              = { 
"expected an `end` to close the `else` clause", 
PM_ERROR_LEVEL_SYNTAX },
 
  152    [PM_ERR_CONDITIONAL_UNLESS_PREDICATE]       = { 
"expected a predicate expression for the `unless` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  153    [PM_ERR_CONDITIONAL_UNTIL_PREDICATE]        = { 
"expected a predicate expression for the `until` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  154    [PM_ERR_CONDITIONAL_WHILE_PREDICATE]        = { 
"expected a predicate expression for the `while` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  155    [PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT] = { 
"expected a constant after the `::` operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  157    [PM_ERR_DEF_ENDLESS_PARAMETERS]             = { 
"could not parse the endless method parameters", 
PM_ERROR_LEVEL_SYNTAX },
 
  158    [PM_ERR_DEF_ENDLESS_SETTER]                 = { 
"invalid method name; a setter method cannot be defined in an endless method definition", 
PM_ERROR_LEVEL_SYNTAX },
 
  160    [PM_ERR_DEF_PARAMS_TERM]                    = { 
"expected a delimiter to close the parameters", 
PM_ERROR_LEVEL_SYNTAX },
 
  161    [PM_ERR_DEF_PARAMS_TERM_PAREN]              = { 
"unexpected %s; expected a `)` to close the parameters", 
PM_ERROR_LEVEL_SYNTAX },
 
  163    [PM_ERR_DEF_RECEIVER_TERM]                  = { 
"expected a `.` or `::` after the receiver in a method definition", 
PM_ERROR_LEVEL_SYNTAX },
 
  172    [PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT]      = { 
"invalid control escape sequence; control cannot be repeated", 
PM_ERROR_LEVEL_SYNTAX },
 
  175    [PM_ERR_ESCAPE_INVALID_META_REPEAT]         = { 
"invalid meta escape sequence; meta cannot be repeated", 
PM_ERROR_LEVEL_SYNTAX },
 
  177    [PM_ERR_ESCAPE_INVALID_UNICODE_CM_FLAGS]    = { 
"invalid Unicode escape sequence; Unicode cannot be combined with control or meta flags", 
PM_ERROR_LEVEL_SYNTAX },
 
  179    [PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL]     = { 
"invalid Unicode escape sequence; Multiple codepoints at single character literal are disallowed", 
PM_ERROR_LEVEL_SYNTAX },
 
  180    [PM_ERR_ESCAPE_INVALID_UNICODE_LONG]        = { 
"invalid Unicode escape sequence; maximum length is 6 digits", 
PM_ERROR_LEVEL_SYNTAX },
 
  181    [PM_ERR_ESCAPE_INVALID_UNICODE_SHORT]       = { 
"too short escape sequence: %.*s", 
PM_ERROR_LEVEL_SYNTAX },
 
  184    [PM_ERR_EXPECT_EOL_AFTER_STATEMENT]         = { 
"unexpected %s, expecting end-of-input", 
PM_ERROR_LEVEL_SYNTAX },
 
  185    [PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ]   = { 
"expected an expression after `&&=`", 
PM_ERROR_LEVEL_SYNTAX },
 
  186    [PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ] = { 
"expected an expression after `||=`", 
PM_ERROR_LEVEL_SYNTAX },
 
  187    [PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA]      = { 
"expected an expression after `,`", 
PM_ERROR_LEVEL_SYNTAX },
 
  188    [PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL]      = { 
"expected an expression after `=`", 
PM_ERROR_LEVEL_SYNTAX },
 
  189    [PM_ERR_EXPECT_EXPRESSION_AFTER_LESS_LESS]  = { 
"expected an expression after `<<`", 
PM_ERROR_LEVEL_SYNTAX },
 
  190    [PM_ERR_EXPECT_EXPRESSION_AFTER_LPAREN]     = { 
"expected an expression after `(`", 
PM_ERROR_LEVEL_SYNTAX },
 
  191    [PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR]   = { 
"unexpected %s; expected an expression after the operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  192    [PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT]      = { 
"expected an expression after `*` splat in an argument", 
PM_ERROR_LEVEL_SYNTAX },
 
  193    [PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH] = { 
"expected an expression after `**` in a hash", 
PM_ERROR_LEVEL_SYNTAX },
 
  194    [PM_ERR_EXPECT_EXPRESSION_AFTER_STAR]       = { 
"expected an expression after `*`", 
PM_ERROR_LEVEL_SYNTAX },
 
  195    [PM_ERR_EXPECT_FOR_DELIMITER]               = { 
"unexpected %s; expected a 'do', newline, or ';' after the 'for' loop collection", 
PM_ERROR_LEVEL_SYNTAX },
 
  196    [PM_ERR_EXPECT_IDENT_REQ_PARAMETER]         = { 
"expected an identifier for the required parameter", 
PM_ERROR_LEVEL_SYNTAX },
 
  197    [PM_ERR_EXPECT_IN_DELIMITER]                = { 
"expected a delimiter after the patterns of an `in` clause", 
PM_ERROR_LEVEL_SYNTAX },
 
  198    [PM_ERR_EXPECT_LPAREN_AFTER_NOT_LPAREN]     = { 
"expected a `(` immediately after `not`", 
PM_ERROR_LEVEL_SYNTAX },
 
  200    [PM_ERR_EXPECT_LPAREN_REQ_PARAMETER]        = { 
"expected a `(` to start a required parameter", 
PM_ERROR_LEVEL_SYNTAX },
 
  201    [PM_ERR_EXPECT_MESSAGE]                     = { 
"unexpected %s; expecting a message to send to the receiver", 
PM_ERROR_LEVEL_SYNTAX },
 
  204    [PM_ERR_EXPECT_RPAREN_AFTER_MULTI]          = { 
"expected a `)` after multiple assignment", 
PM_ERROR_LEVEL_SYNTAX },
 
  205    [PM_ERR_EXPECT_RPAREN_REQ_PARAMETER]        = { 
"expected a `)` to end a required parameter", 
PM_ERROR_LEVEL_SYNTAX },
 
  206    [PM_ERR_EXPECT_SINGLETON_CLASS_DELIMITER]   = { 
"unexpected %s; expected a newline or a ';' after the singleton class", 
PM_ERROR_LEVEL_SYNTAX },
 
  207    [PM_ERR_EXPECT_STRING_CONTENT]              = { 
"expected string content after opening string delimiter", 
PM_ERROR_LEVEL_SYNTAX },
 
  208    [PM_ERR_EXPECT_WHEN_DELIMITER]              = { 
"expected a delimiter after the predicates of a `when` clause", 
PM_ERROR_LEVEL_SYNTAX },
 
  210    [PM_ERR_EXPRESSION_NOT_WRITABLE]            = { 
"unexpected '='; target cannot be written", 
PM_ERROR_LEVEL_SYNTAX },
 
  211    [PM_ERR_EXPRESSION_NOT_WRITABLE_ENCODING]   = { 
"Can't assign to __ENCODING__", 
PM_ERROR_LEVEL_SYNTAX },
 
  216    [PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED]   = { 
"Can't assign to numbered parameter %.2s", 
PM_ERROR_LEVEL_SYNTAX },
 
  220    [PM_ERR_FOR_COLLECTION]                     = { 
"expected a collection after the `in` in a `for` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  222    [PM_ERR_FOR_IN]                             = { 
"expected an `in` after the index in a `for` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  224    [PM_ERR_GLOBAL_VARIABLE_BARE]               = { 
"'$' without identifiers is not allowed as a global variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  225    [PM_ERR_HASH_EXPRESSION_AFTER_LABEL]        = { 
"expected an expression after the label in a hash", 
PM_ERROR_LEVEL_SYNTAX },
 
  226    [PM_ERR_HASH_KEY]                           = { 
"unexpected %s, expecting '}' or a key in the hash literal", 
PM_ERROR_LEVEL_SYNTAX },
 
  229    [PM_ERR_HASH_VALUE]                         = { 
"unexpected %s; expected a value in the hash literal", 
PM_ERROR_LEVEL_SYNTAX },
 
  231    [PM_ERR_HEREDOC_TERM]                       = { 
"unterminated heredoc; can't find string \"%.*s\" anywhere before EOF", 
PM_ERROR_LEVEL_SYNTAX },
 
  233    [PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3]      = { 
"`%.*s' is not allowed as a class variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  234    [PM_ERR_INCOMPLETE_VARIABLE_CLASS]          = { 
"'%.*s' is not allowed as a class variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  235    [PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3]   = { 
"`%.*s' is not allowed as an instance variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  236    [PM_ERR_INCOMPLETE_VARIABLE_INSTANCE]       = { 
"'%.*s' is not allowed as an instance variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  237    [PM_ERR_INSTANCE_VARIABLE_BARE]             = { 
"'@' without identifiers is not allowed as an instance variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  242    [PM_ERR_INVALID_LOCAL_VARIABLE_READ]        = { 
"identifier %.*s is not valid to get", 
PM_ERROR_LEVEL_SYNTAX },
 
  243    [PM_ERR_INVALID_LOCAL_VARIABLE_WRITE]       = { 
"identifier %.*s is not valid to set", 
PM_ERROR_LEVEL_SYNTAX },
 
  244    [PM_ERR_INVALID_NUMBER_BINARY]              = { 
"invalid binary number; numeric literal without digits", 
PM_ERROR_LEVEL_SYNTAX },
 
  245    [PM_ERR_INVALID_NUMBER_DECIMAL]             = { 
"invalid decimal number; numeric literal without digits", 
PM_ERROR_LEVEL_SYNTAX },
 
  246    [PM_ERR_INVALID_NUMBER_FRACTION]            = { 
"unexpected fraction part after numeric literal", 
PM_ERROR_LEVEL_SYNTAX },
 
  247    [PM_ERR_INVALID_NUMBER_HEXADECIMAL]         = { 
"invalid hexadecimal number; numeric literal without digits", 
PM_ERROR_LEVEL_SYNTAX },
 
  248    [PM_ERR_INVALID_NUMBER_OCTAL]               = { 
"invalid octal number; numeric literal without digits", 
PM_ERROR_LEVEL_SYNTAX },
 
  249    [PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER]    = { 
"invalid underscore placement in number", 
PM_ERROR_LEVEL_SYNTAX },
 
  253    [PM_ERR_INVALID_MULTIBYTE_CHARACTER]        = { 
"invalid multibyte character 0x%X", 
PM_ERROR_LEVEL_SYNTAX },
 
  257    [PM_ERR_INVALID_PERCENT_EOF]                = { 
"unterminated quoted string meets end of file", 
PM_ERROR_LEVEL_SYNTAX },
 
  262    [PM_ERR_INVALID_VARIABLE_GLOBAL_3_3]        = { 
"`%.*s' is not allowed as a global variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  263    [PM_ERR_INVALID_VARIABLE_GLOBAL]            = { 
"'%.*s' is not allowed as a global variable name", 
PM_ERROR_LEVEL_SYNTAX },
 
  265    [PM_ERR_IT_NOT_ALLOWED_NUMBERED]            = { 
"'it' is not allowed when a numbered parameter is already used", 
PM_ERROR_LEVEL_SYNTAX },
 
  266    [PM_ERR_IT_NOT_ALLOWED_ORDINARY]            = { 
"'it' is not allowed when an ordinary parameter is defined", 
PM_ERROR_LEVEL_SYNTAX },
 
  267    [PM_ERR_LAMBDA_OPEN]                        = { 
"expected a `do` keyword or a `{` to open the lambda block", 
PM_ERROR_LEVEL_SYNTAX },
 
  268    [PM_ERR_LAMBDA_TERM_BRACE]                  = { 
"expected a lambda block beginning with `{` to end with `}`", 
PM_ERROR_LEVEL_SYNTAX },
 
  269    [PM_ERR_LAMBDA_TERM_END]                    = { 
"expected a lambda block beginning with `do` to end with `end`", 
PM_ERROR_LEVEL_SYNTAX },
 
  271    [PM_ERR_LIST_I_LOWER_TERM]                  = { 
"unterminated list; expected a closing delimiter for the `%i`", 
PM_ERROR_LEVEL_SYNTAX },
 
  273    [PM_ERR_LIST_I_UPPER_TERM]                  = { 
"unterminated list; expected a closing delimiter for the `%I`", 
PM_ERROR_LEVEL_SYNTAX },
 
  275    [PM_ERR_LIST_W_LOWER_TERM]                  = { 
"unterminated list; expected a closing delimiter for the `%w`", 
PM_ERROR_LEVEL_SYNTAX },
 
  277    [PM_ERR_LIST_W_UPPER_TERM]                  = { 
"unterminated list; expected a closing delimiter for the `%W`", 
PM_ERROR_LEVEL_SYNTAX },
 
  280    [PM_ERR_MODULE_IN_METHOD]                   = { 
"unexpected module definition in method body", 
PM_ERROR_LEVEL_SYNTAX },
 
  281    [PM_ERR_MODULE_NAME]                        = { 
"unexpected constant path after `module`; class/module name must be CONSTANT", 
PM_ERROR_LEVEL_SYNTAX },
 
  282    [PM_ERR_MODULE_TERM]                        = { 
"expected an `end` to close the `module` statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  283    [PM_ERR_MULTI_ASSIGN_MULTI_SPLATS]          = { 
"multiple splats in multiple assignment", 
PM_ERROR_LEVEL_SYNTAX },
 
  284    [PM_ERR_MULTI_ASSIGN_UNEXPECTED_REST]       = { 
"unexpected '%.*s' resulting in multiple splats in multiple assignment", 
PM_ERROR_LEVEL_SYNTAX },
 
  287    [PM_ERR_NON_ASSOCIATIVE_OPERATOR]           = { 
"unexpected %s; %s is a non-associative operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  290    [PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK]     = { 
"numbered parameter is already used in inner block", 
PM_ERROR_LEVEL_SYNTAX },
 
  291    [PM_ERR_NUMBERED_PARAMETER_IT]              = { 
"numbered parameters are not allowed when 'it' is already used", 
PM_ERROR_LEVEL_SYNTAX },
 
  292    [PM_ERR_NUMBERED_PARAMETER_ORDINARY]        = { 
"numbered parameters are not allowed when an ordinary parameter is defined", 
PM_ERROR_LEVEL_SYNTAX },
 
  293    [PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK]     = { 
"numbered parameter is already used in outer block", 
PM_ERROR_LEVEL_SYNTAX },
 
  294    [PM_ERR_OPERATOR_MULTI_ASSIGN]              = { 
"unexpected operator for a multiple assignment", 
PM_ERROR_LEVEL_SYNTAX },
 
  295    [PM_ERR_OPERATOR_WRITE_ARGUMENTS]           = { 
"unexpected operator after a call with arguments", 
PM_ERROR_LEVEL_SYNTAX },
 
  296    [PM_ERR_OPERATOR_WRITE_BLOCK]               = { 
"unexpected operator after a call with a block", 
PM_ERROR_LEVEL_SYNTAX },
 
  297    [PM_ERR_PARAMETER_ASSOC_SPLAT_MULTI]        = { 
"unexpected multiple `**` splat parameters", 
PM_ERROR_LEVEL_SYNTAX },
 
  298    [PM_ERR_PARAMETER_BLOCK_MULTI]              = { 
"multiple block parameters; only one block is allowed", 
PM_ERROR_LEVEL_SYNTAX },
 
  303    [PM_ERR_PARAMETER_NO_DEFAULT]               = { 
"expected a default value for the parameter", 
PM_ERROR_LEVEL_SYNTAX },
 
  304    [PM_ERR_PARAMETER_NO_DEFAULT_KW]            = { 
"expected a default value for the keyword parameter", 
PM_ERROR_LEVEL_SYNTAX },
 
  305    [PM_ERR_PARAMETER_NUMBERED_RESERVED]        = { 
"%.2s is reserved for numbered parameters", 
PM_ERROR_LEVEL_SYNTAX },
 
  307    [PM_ERR_PARAMETER_SPLAT_MULTI]              = { 
"unexpected multiple `*` splat parameters", 
PM_ERROR_LEVEL_SYNTAX },
 
  311    [PM_ERR_PARAMETER_UNEXPECTED_NO_KW]         = { 
"unexpected **nil; no keywords marker disallowed after keywords", 
PM_ERROR_LEVEL_SYNTAX },
 
  312    [PM_ERR_PATTERN_ARRAY_MULTIPLE_RESTS]       = { 
"unexpected multiple '*' rest patterns in an array pattern", 
PM_ERROR_LEVEL_SYNTAX },
 
  314    [PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET]   = { 
"expected a pattern expression after the `[` operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  315    [PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA]     = { 
"expected a pattern expression after `,`", 
PM_ERROR_LEVEL_SYNTAX },
 
  316    [PM_ERR_PATTERN_EXPRESSION_AFTER_HROCKET]   = { 
"expected a pattern expression after `=>`", 
PM_ERROR_LEVEL_SYNTAX },
 
  317    [PM_ERR_PATTERN_EXPRESSION_AFTER_IN]        = { 
"expected a pattern expression after the `in` keyword", 
PM_ERROR_LEVEL_SYNTAX },
 
  318    [PM_ERR_PATTERN_EXPRESSION_AFTER_KEY]       = { 
"expected a pattern expression after the key", 
PM_ERROR_LEVEL_SYNTAX },
 
  319    [PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN]     = { 
"expected a pattern expression after the `(` operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  320    [PM_ERR_PATTERN_EXPRESSION_AFTER_PIN]       = { 
"expected a pattern expression after the `^` pin operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  321    [PM_ERR_PATTERN_EXPRESSION_AFTER_PIPE]      = { 
"expected a pattern expression after the `|` operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  322    [PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE]     = { 
"expected a pattern expression after the range operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  323    [PM_ERR_PATTERN_EXPRESSION_AFTER_REST]      = { 
"unexpected pattern expression after the `**` expression", 
PM_ERROR_LEVEL_SYNTAX },
 
  324    [PM_ERR_PATTERN_FIND_MISSING_INNER]         = { 
"find patterns need at least one required inner pattern", 
PM_ERROR_LEVEL_SYNTAX },
 
  325    [PM_ERR_PATTERN_HASH_IMPLICIT]              = { 
"unexpected implicit hash in pattern; use '{' to delineate", 
PM_ERROR_LEVEL_SYNTAX },
 
  326    [PM_ERR_PATTERN_HASH_KEY]                   = { 
"unexpected %s; expected a key in the hash pattern", 
PM_ERROR_LEVEL_SYNTAX },
 
  328    [PM_ERR_PATTERN_HASH_KEY_INTERPOLATED]      = { 
"symbol literal with interpolation is not allowed", 
PM_ERROR_LEVEL_SYNTAX },
 
  329    [PM_ERR_PATTERN_HASH_KEY_LABEL]             = { 
"expected a label as the key in the hash pattern", 
PM_ERROR_LEVEL_SYNTAX },
 
  330    [PM_ERR_PATTERN_HASH_KEY_LOCALS]            = { 
"key must be valid as local variables", 
PM_ERROR_LEVEL_SYNTAX },
 
  331    [PM_ERR_PATTERN_IDENT_AFTER_HROCKET]        = { 
"expected an identifier after the `=>` operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  332    [PM_ERR_PATTERN_LABEL_AFTER_COMMA]          = { 
"expected a label after the `,` in the hash pattern", 
PM_ERROR_LEVEL_SYNTAX },
 
  334    [PM_ERR_PATTERN_TERM_BRACE]                 = { 
"expected a `}` to close the pattern expression", 
PM_ERROR_LEVEL_SYNTAX },
 
  335    [PM_ERR_PATTERN_TERM_BRACKET]               = { 
"expected a `]` to close the pattern expression", 
PM_ERROR_LEVEL_SYNTAX },
 
  336    [PM_ERR_PATTERN_TERM_PAREN]                 = { 
"expected a `)` to close the pattern expression", 
PM_ERROR_LEVEL_SYNTAX },
 
  337    [PM_ERR_PIPEPIPEEQ_MULTI_ASSIGN]            = { 
"unexpected `||=` in a multiple assignment", 
PM_ERROR_LEVEL_SYNTAX },
 
  338    [PM_ERR_REGEXP_ENCODING_OPTION_MISMATCH]    = { 
"regexp encoding option '%c' differs from source encoding '%s'", 
PM_ERROR_LEVEL_SYNTAX },
 
  339    [PM_ERR_REGEXP_INCOMPAT_CHAR_ENCODING]      = { 
"incompatible character encoding: /%.*s/", 
PM_ERROR_LEVEL_SYNTAX },
 
  340    [PM_ERR_REGEXP_NON_ESCAPED_MBC]             = { 
"/.../n has a non escaped non ASCII character in non ASCII-8BIT script: /%.*s/", 
PM_ERROR_LEVEL_SYNTAX },
 
  344    [PM_ERR_REGEXP_TERM]                        = { 
"unterminated regexp meets end of file; expected a closing delimiter", 
PM_ERROR_LEVEL_SYNTAX },
 
  345    [PM_ERR_REGEXP_UTF8_CHAR_NON_UTF8_REGEXP]   = { 
"UTF-8 character in non UTF-8 regexp: /%s/", 
PM_ERROR_LEVEL_SYNTAX },
 
  347    [PM_ERR_RESCUE_MODIFIER_VALUE]              = { 
"expected a value after the `rescue` modifier", 
PM_ERROR_LEVEL_SYNTAX },
 
  348    [PM_ERR_RESCUE_TERM]                        = { 
"expected a closing delimiter for the `rescue` clause", 
PM_ERROR_LEVEL_SYNTAX },
 
  349    [PM_ERR_RESCUE_VARIABLE]                    = { 
"expected an exception variable after `=>` in a rescue statement", 
PM_ERROR_LEVEL_SYNTAX },
 
  351    [PM_ERR_SINGLETON_FOR_LITERALS]             = { 
"cannot define singleton method for literals", 
PM_ERROR_LEVEL_SYNTAX },
 
  352    [PM_ERR_STATEMENT_ALIAS]                    = { 
"unexpected an `alias` at a non-statement position", 
PM_ERROR_LEVEL_SYNTAX },
 
  353    [PM_ERR_STATEMENT_POSTEXE_END]              = { 
"unexpected an `END` at a non-statement position", 
PM_ERROR_LEVEL_SYNTAX },
 
  354    [PM_ERR_STATEMENT_PREEXE_BEGIN]             = { 
"unexpected a `BEGIN` at a non-statement position", 
PM_ERROR_LEVEL_SYNTAX },
 
  355    [PM_ERR_STATEMENT_UNDEF]                    = { 
"unexpected an `undef` at a non-statement position", 
PM_ERROR_LEVEL_SYNTAX },
 
  357    [PM_ERR_STRING_INTERPOLATED_TERM]           = { 
"unterminated string; expected a closing delimiter for the interpolated string", 
PM_ERROR_LEVEL_SYNTAX },
 
  359    [PM_ERR_STRING_LITERAL_TERM]                = { 
"unexpected %s, expected a string literal terminator", 
PM_ERROR_LEVEL_SYNTAX },
 
  361    [PM_ERR_SYMBOL_TERM_DYNAMIC]                = { 
"unterminated quoted string; expected a closing delimiter for the dynamic symbol", 
PM_ERROR_LEVEL_SYNTAX },
 
  362    [PM_ERR_SYMBOL_TERM_INTERPOLATED]           = { 
"unterminated symbol; expected a closing delimiter for the interpolated symbol", 
PM_ERROR_LEVEL_SYNTAX },
 
  363    [PM_ERR_TERNARY_COLON]                      = { 
"expected a `:` after the true expression of a ternary operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  364    [PM_ERR_TERNARY_EXPRESSION_FALSE]           = { 
"expected an expression after `:` in the ternary operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  365    [PM_ERR_TERNARY_EXPRESSION_TRUE]            = { 
"expected an expression after `?` in the ternary operator", 
PM_ERROR_LEVEL_SYNTAX },
 
  366    [PM_ERR_UNARY_RECEIVER]                     = { 
"unexpected %s, expected a receiver for unary `%c`", 
PM_ERROR_LEVEL_SYNTAX },
 
  367    [PM_ERR_UNARY_DISALLOWED]                   = { 
"unexpected %s; unary calls are not allowed in this context", 
PM_ERROR_LEVEL_SYNTAX },
 
  368    [PM_ERR_UNDEF_ARGUMENT]                     = { 
"invalid argument being passed to `undef`; expected a bare word, constant, or symbol argument", 
PM_ERROR_LEVEL_SYNTAX },
 
  369    [PM_ERR_UNEXPECTED_BLOCK_ARGUMENT]          = { 
"block argument should not be given", 
PM_ERROR_LEVEL_SYNTAX },
 
  370    [PM_ERR_UNEXPECTED_INDEX_BLOCK]             = { 
"unexpected block arg given in index assignment; blocks are not allowed in index assignment expressions", 
PM_ERROR_LEVEL_SYNTAX },
 
  371    [PM_ERR_UNEXPECTED_INDEX_KEYWORDS]          = { 
"unexpected keyword arg given in index assignment; keywords are not allowed in index assignment expressions", 
PM_ERROR_LEVEL_SYNTAX },
 
  373    [PM_ERR_UNEXPECTED_MULTI_WRITE]             = { 
"unexpected multiple assignment; multiple assignment is not allowed in this context", 
PM_ERROR_LEVEL_SYNTAX },
 
  374    [PM_ERR_UNEXPECTED_RANGE_OPERATOR]          = { 
"unexpected range operator; .. and ... are non-associative and cannot be chained", 
PM_ERROR_LEVEL_SYNTAX },
 
  375    [PM_ERR_UNEXPECTED_SAFE_NAVIGATION]         = { 
"&. inside multiple assignment destination", 
PM_ERROR_LEVEL_SYNTAX },
 
  376    [PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT]     = { 
"unexpected %s, assuming it is closing the parent %s", 
PM_ERROR_LEVEL_SYNTAX },
 
  384    [PM_ERR_XSTRING_TERM]                       = { 
"expected a closing delimiter for the `%x` or backtick string", 
PM_ERROR_LEVEL_SYNTAX },
 
  387    [PM_WARN_AMBIGUOUS_BINARY_OPERATOR]         = { 
"'%s' after local variable or literal is interpreted as binary operator even though it seems like %s", 
PM_WARNING_LEVEL_VERBOSE },
 
  388    [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS]    = { 
"ambiguous first argument; put parentheses or a space even after `-` operator", 
PM_WARNING_LEVEL_VERBOSE },
 
  389    [PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS]     = { 
"ambiguous first argument; put parentheses or a space even after `+` operator", 
PM_WARNING_LEVEL_VERBOSE },
 
  390    [PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND]        = { 
"ambiguous `&` has been interpreted as an argument prefix", 
PM_WARNING_LEVEL_VERBOSE },
 
  391    [PM_WARN_AMBIGUOUS_PREFIX_STAR]             = { 
"ambiguous `*` has been interpreted as an argument prefix", 
PM_WARNING_LEVEL_VERBOSE },
 
  392    [PM_WARN_AMBIGUOUS_PREFIX_STAR_STAR]        = { 
"ambiguous `**` has been interpreted as an argument prefix", 
PM_WARNING_LEVEL_VERBOSE },
 
  393    [PM_WARN_AMBIGUOUS_SLASH]                   = { 
"ambiguous `/`; wrap regexp in parentheses or add a space after `/` operator", 
PM_WARNING_LEVEL_VERBOSE },
 
  396    [PM_WARN_DUPLICATED_HASH_KEY]               = { 
"key %.*s is duplicated and overwritten on line %" PRIi32, 
PM_WARNING_LEVEL_DEFAULT },
 
  397    [PM_WARN_DUPLICATED_WHEN_CLAUSE]            = { 
"'when' clause on line %" PRIi32 
" duplicates 'when' clause on line %" PRIi32 
" and is ignored", 
PM_WARNING_LEVEL_VERBOSE },
 
  398    [PM_WARN_EQUAL_IN_CONDITIONAL_3_3]          = { 
"found `= literal' in conditional, should be ==", 
PM_WARNING_LEVEL_DEFAULT },
 
  402    [PM_WARN_IGNORED_FROZEN_STRING_LITERAL]     = { 
"'frozen_string_literal' is ignored after any tokens", 
PM_WARNING_LEVEL_VERBOSE },
 
  403    [PM_WARN_INDENTATION_MISMATCH]              = { 
"mismatched indentations at '%.*s' with '%.*s' at %" PRIi32, 
PM_WARNING_LEVEL_VERBOSE },
 
  407    [PM_WARN_INVALID_NUMBERED_REFERENCE]        = { 
"'%.*s' is too big for a number variable, always nil", 
PM_WARNING_LEVEL_DEFAULT },
 
  411    [PM_WARN_SHAREABLE_CONSTANT_VALUE_LINE]     = { 
"'shareable_constant_value' is ignored unless in comment-only line", 
PM_WARNING_LEVEL_VERBOSE },
 
  412    [PM_WARN_SHEBANG_CARRIAGE_RETURN]           = { 
"shebang line ending with \\r may cause problems", 
PM_WARNING_LEVEL_DEFAULT },
 
  413    [PM_WARN_UNEXPECTED_CARRIAGE_RETURN]        = { 
"encountered \\r in middle of line, treated as a mere space", 
PM_WARNING_LEVEL_DEFAULT },
 
  425        case PM_ERR_ALIAS_ARGUMENT: 
return "alias_argument";
 
  426        case PM_ERR_ALIAS_ARGUMENT_NUMBERED_REFERENCE: 
return "alias_argument_numbered_reference";
 
  427        case PM_ERR_AMPAMPEQ_MULTI_ASSIGN: 
return "ampampeq_multi_assign";
 
  428        case PM_ERR_ARGUMENT_AFTER_BLOCK: 
return "argument_after_block";
 
  429        case PM_ERR_ARGUMENT_AFTER_FORWARDING_ELLIPSES: 
return "argument_after_forwarding_ellipses";
 
  430        case PM_ERR_ARGUMENT_BARE_HASH: 
return "argument_bare_hash";
 
  431        case PM_ERR_ARGUMENT_BLOCK_FORWARDING: 
return "argument_block_forwarding";
 
  432        case PM_ERR_ARGUMENT_BLOCK_MULTI: 
return "argument_block_multi";
 
  433        case PM_ERR_ARGUMENT_CONFLICT_AMPERSAND: 
return "argument_conflict_ampersand";
 
  434        case PM_ERR_ARGUMENT_CONFLICT_STAR: 
return "argument_conflict_star";
 
  435        case PM_ERR_ARGUMENT_CONFLICT_STAR_STAR: 
return "argument_conflict_star_star";
 
  436        case PM_ERR_ARGUMENT_FORMAL_CLASS: 
return "argument_formal_class";
 
  437        case PM_ERR_ARGUMENT_FORMAL_CONSTANT: 
return "argument_formal_constant";
 
  438        case PM_ERR_ARGUMENT_FORMAL_GLOBAL: 
return "argument_formal_global";
 
  439        case PM_ERR_ARGUMENT_FORMAL_IVAR: 
return "argument_formal_ivar";
 
  440        case PM_ERR_ARGUMENT_FORWARDING_UNBOUND: 
return "argument_forwarding_unbound";
 
  441        case PM_ERR_ARGUMENT_NO_FORWARDING_AMPERSAND: 
return "argument_no_forwarding_ampersand";
 
  442        case PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES: 
return "argument_no_forwarding_ellipses";
 
  443        case PM_ERR_ARGUMENT_NO_FORWARDING_STAR: 
return "argument_no_forwarding_star";
 
  444        case PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR: 
return "argument_no_forwarding_star_star";
 
  445        case PM_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT: 
return "argument_splat_after_assoc_splat";
 
  446        case PM_ERR_ARGUMENT_SPLAT_AFTER_SPLAT: 
return "argument_splat_after_splat";
 
  447        case PM_ERR_ARGUMENT_TERM_PAREN: 
return "argument_term_paren";
 
  448        case PM_ERR_ARGUMENT_UNEXPECTED_BLOCK: 
return "argument_unexpected_block";
 
  449        case PM_ERR_ARRAY_ELEMENT: 
return "array_element";
 
  450        case PM_ERR_ARRAY_EXPRESSION: 
return "array_expression";
 
  451        case PM_ERR_ARRAY_EXPRESSION_AFTER_STAR: 
return "array_expression_after_star";
 
  452        case PM_ERR_ARRAY_SEPARATOR: 
return "array_separator";
 
  453        case PM_ERR_ARRAY_TERM: 
return "array_term";
 
  454        case PM_ERR_BEGIN_LONELY_ELSE: 
return "begin_lonely_else";
 
  455        case PM_ERR_BEGIN_TERM: 
return "begin_term";
 
  456        case PM_ERR_BEGIN_UPCASE_BRACE: 
return "begin_upcase_brace";
 
  457        case PM_ERR_BEGIN_UPCASE_TERM: 
return "begin_upcase_term";
 
  458        case PM_ERR_BEGIN_UPCASE_TOPLEVEL: 
return "begin_upcase_toplevel";
 
  459        case PM_ERR_BLOCK_PARAM_LOCAL_VARIABLE: 
return "block_param_local_variable";
 
  460        case PM_ERR_BLOCK_PARAM_PIPE_TERM: 
return "block_param_pipe_term";
 
  461        case PM_ERR_BLOCK_TERM_BRACE: 
return "block_term_brace";
 
  462        case PM_ERR_BLOCK_TERM_END: 
return "block_term_end";
 
  463        case PM_ERR_CANNOT_PARSE_EXPRESSION: 
return "cannot_parse_expression";
 
  464        case PM_ERR_CANNOT_PARSE_STRING_PART: 
return "cannot_parse_string_part";
 
  465        case PM_ERR_CASE_EXPRESSION_AFTER_CASE: 
return "case_expression_after_case";
 
  466        case PM_ERR_CASE_EXPRESSION_AFTER_WHEN: 
return "case_expression_after_when";
 
  467        case PM_ERR_CASE_MATCH_MISSING_PREDICATE: 
return "case_match_missing_predicate";
 
  468        case PM_ERR_CASE_MISSING_CONDITIONS: 
return "case_missing_conditions";
 
  469        case PM_ERR_CASE_TERM: 
return "case_term";
 
  470        case PM_ERR_CLASS_IN_METHOD: 
return "class_in_method";
 
  471        case PM_ERR_CLASS_NAME: 
return "class_name";
 
  472        case PM_ERR_CLASS_SUPERCLASS: 
return "class_superclass";
 
  473        case PM_ERR_CLASS_TERM: 
return "class_term";
 
  474        case PM_ERR_CLASS_UNEXPECTED_END: 
return "class_unexpected_end";
 
  475        case PM_ERR_CLASS_VARIABLE_BARE: 
return "class_variable_bare";
 
  476        case PM_ERR_CONDITIONAL_ELSIF_PREDICATE: 
return "conditional_elsif_predicate";
 
  477        case PM_ERR_CONDITIONAL_IF_PREDICATE: 
return "conditional_if_predicate";
 
  478        case PM_ERR_CONDITIONAL_PREDICATE_TERM: 
return "conditional_predicate_term";
 
  479        case PM_ERR_CONDITIONAL_TERM: 
return "conditional_term";
 
  480        case PM_ERR_CONDITIONAL_TERM_ELSE: 
return "conditional_term_else";
 
  481        case PM_ERR_CONDITIONAL_UNLESS_PREDICATE: 
return "conditional_unless_predicate";
 
  482        case PM_ERR_CONDITIONAL_UNTIL_PREDICATE: 
return "conditional_until_predicate";
 
  483        case PM_ERR_CONDITIONAL_WHILE_PREDICATE: 
return "conditional_while_predicate";
 
  484        case PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT: 
return "constant_path_colon_colon_constant";
 
  485        case PM_ERR_DEF_ENDLESS: 
return "def_endless";
 
  486        case PM_ERR_DEF_ENDLESS_PARAMETERS: 
return "def_endless_parameters";
 
  487        case PM_ERR_DEF_ENDLESS_SETTER: 
return "def_endless_setter";
 
  488        case PM_ERR_DEF_NAME: 
return "def_name";
 
  489        case PM_ERR_DEF_PARAMS_TERM: 
return "def_params_term";
 
  490        case PM_ERR_DEF_PARAMS_TERM_PAREN: 
return "def_params_term_paren";
 
  491        case PM_ERR_DEF_RECEIVER: 
return "def_receiver";
 
  492        case PM_ERR_DEF_RECEIVER_TERM: 
return "def_receiver_term";
 
  493        case PM_ERR_DEF_TERM: 
return "def_term";
 
  494        case PM_ERR_DEFINED_EXPRESSION: 
return "defined_expression";
 
  495        case PM_ERR_EMBDOC_TERM: 
return "embdoc_term";
 
  496        case PM_ERR_EMBEXPR_END: 
return "embexpr_end";
 
  497        case PM_ERR_EMBVAR_INVALID: 
return "embvar_invalid";
 
  498        case PM_ERR_END_UPCASE_BRACE: 
return "end_upcase_brace";
 
  499        case PM_ERR_END_UPCASE_TERM: 
return "end_upcase_term";
 
  500        case PM_ERR_ESCAPE_INVALID_CONTROL: 
return "escape_invalid_control";
 
  501        case PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT: 
return "escape_invalid_control_repeat";
 
  502        case PM_ERR_ESCAPE_INVALID_HEXADECIMAL: 
return "escape_invalid_hexadecimal";
 
  503        case PM_ERR_ESCAPE_INVALID_META: 
return "escape_invalid_meta";
 
  504        case PM_ERR_ESCAPE_INVALID_META_REPEAT: 
return "escape_invalid_meta_repeat";
 
  505        case PM_ERR_ESCAPE_INVALID_UNICODE: 
return "escape_invalid_unicode";
 
  506        case PM_ERR_ESCAPE_INVALID_UNICODE_CM_FLAGS: 
return "escape_invalid_unicode_cm_flags";
 
  507        case PM_ERR_ESCAPE_INVALID_UNICODE_LIST: 
return "escape_invalid_unicode_list";
 
  508        case PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL: 
return "escape_invalid_unicode_literal";
 
  509        case PM_ERR_ESCAPE_INVALID_UNICODE_LONG: 
return "escape_invalid_unicode_long";
 
  510        case PM_ERR_ESCAPE_INVALID_UNICODE_SHORT: 
return "escape_invalid_unicode_short";
 
  511        case PM_ERR_ESCAPE_INVALID_UNICODE_TERM: 
return "escape_invalid_unicode_term";
 
  512        case PM_ERR_EXPECT_ARGUMENT: 
return "expect_argument";
 
  513        case PM_ERR_EXPECT_EOL_AFTER_STATEMENT: 
return "expect_eol_after_statement";
 
  514        case PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ: 
return "expect_expression_after_ampampeq";
 
  515        case PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA: 
return "expect_expression_after_comma";
 
  516        case PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL: 
return "expect_expression_after_equal";
 
  517        case PM_ERR_EXPECT_EXPRESSION_AFTER_LESS_LESS: 
return "expect_expression_after_less_less";
 
  518        case PM_ERR_EXPECT_EXPRESSION_AFTER_LPAREN: 
return "expect_expression_after_lparen";
 
  519        case PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR: 
return "expect_expression_after_operator";
 
  520        case PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ: 
return "expect_expression_after_pipepipeeq";
 
  521        case PM_ERR_EXPECT_EXPRESSION_AFTER_QUESTION: 
return "expect_expression_after_question";
 
  522        case PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT: 
return "expect_expression_after_splat";
 
  523        case PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH: 
return "expect_expression_after_splat_hash";
 
  524        case PM_ERR_EXPECT_EXPRESSION_AFTER_STAR: 
return "expect_expression_after_star";
 
  525        case PM_ERR_EXPECT_FOR_DELIMITER: 
return "expect_for_delimiter";
 
  526        case PM_ERR_EXPECT_IDENT_REQ_PARAMETER: 
return "expect_ident_req_parameter";
 
  527        case PM_ERR_EXPECT_IN_DELIMITER: 
return "expect_in_delimiter";
 
  528        case PM_ERR_EXPECT_LPAREN_AFTER_NOT_LPAREN: 
return "expect_lparen_after_not_lparen";
 
  529        case PM_ERR_EXPECT_LPAREN_AFTER_NOT_OTHER: 
return "expect_lparen_after_not_other";
 
  530        case PM_ERR_EXPECT_LPAREN_REQ_PARAMETER: 
return "expect_lparen_req_parameter";
 
  531        case PM_ERR_EXPECT_MESSAGE: 
return "expect_message";
 
  532        case PM_ERR_EXPECT_RBRACKET: 
return "expect_rbracket";
 
  533        case PM_ERR_EXPECT_RPAREN: 
return "expect_rparen";
 
  534        case PM_ERR_EXPECT_RPAREN_AFTER_MULTI: 
return "expect_rparen_after_multi";
 
  535        case PM_ERR_EXPECT_RPAREN_REQ_PARAMETER: 
return "expect_rparen_req_parameter";
 
  536        case PM_ERR_EXPECT_SINGLETON_CLASS_DELIMITER: 
return "expect_singleton_class_delimiter";
 
  537        case PM_ERR_EXPECT_STRING_CONTENT: 
return "expect_string_content";
 
  538        case PM_ERR_EXPECT_WHEN_DELIMITER: 
return "expect_when_delimiter";
 
  539        case PM_ERR_EXPRESSION_BARE_HASH: 
return "expression_bare_hash";
 
  540        case PM_ERR_EXPRESSION_NOT_WRITABLE: 
return "expression_not_writable";
 
  541        case PM_ERR_EXPRESSION_NOT_WRITABLE_ENCODING: 
return "expression_not_writable_encoding";
 
  542        case PM_ERR_EXPRESSION_NOT_WRITABLE_FALSE: 
return "expression_not_writable_false";
 
  543        case PM_ERR_EXPRESSION_NOT_WRITABLE_FILE: 
return "expression_not_writable_file";
 
  544        case PM_ERR_EXPRESSION_NOT_WRITABLE_LINE: 
return "expression_not_writable_line";
 
  545        case PM_ERR_EXPRESSION_NOT_WRITABLE_NIL: 
return "expression_not_writable_nil";
 
  546        case PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED: 
return "expression_not_writable_numbered";
 
  547        case PM_ERR_EXPRESSION_NOT_WRITABLE_SELF: 
return "expression_not_writable_self";
 
  548        case PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE: 
return "expression_not_writable_true";
 
  549        case PM_ERR_FLOAT_PARSE: 
return "float_parse";
 
  550        case PM_ERR_FOR_COLLECTION: 
return "for_collection";
 
  551        case PM_ERR_FOR_IN: 
return "for_in";
 
  552        case PM_ERR_FOR_INDEX: 
return "for_index";
 
  553        case PM_ERR_FOR_TERM: 
return "for_term";
 
  554        case PM_ERR_GLOBAL_VARIABLE_BARE: 
return "global_variable_bare";
 
  555        case PM_ERR_HASH_EXPRESSION_AFTER_LABEL: 
return "hash_expression_after_label";
 
  556        case PM_ERR_HASH_KEY: 
return "hash_key";
 
  557        case PM_ERR_HASH_ROCKET: 
return "hash_rocket";
 
  558        case PM_ERR_HASH_TERM: 
return "hash_term";
 
  559        case PM_ERR_HASH_VALUE: 
return "hash_value";
 
  560        case PM_ERR_HEREDOC_IDENTIFIER: 
return "heredoc_identifier";
 
  561        case PM_ERR_HEREDOC_TERM: 
return "heredoc_term";
 
  562        case PM_ERR_INCOMPLETE_QUESTION_MARK: 
return "incomplete_question_mark";
 
  563        case PM_ERR_INCOMPLETE_VARIABLE_CLASS: 
return "incomplete_variable_class";
 
  564        case PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3: 
return "incomplete_variable_class_3_3";
 
  565        case PM_ERR_INCOMPLETE_VARIABLE_INSTANCE: 
return "incomplete_variable_instance";
 
  566        case PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3: 
return "incomplete_variable_instance_3_3";
 
  567        case PM_ERR_INSTANCE_VARIABLE_BARE: 
return "instance_variable_bare";
 
  568        case PM_ERR_INVALID_BLOCK_EXIT: 
return "invalid_block_exit";
 
  569        case PM_ERR_INVALID_CHARACTER: 
return "invalid_character";
 
  570        case PM_ERR_INVALID_COMMA: 
return "invalid_comma";
 
  571        case PM_ERR_INVALID_ENCODING_MAGIC_COMMENT: 
return "invalid_encoding_magic_comment";
 
  572        case PM_ERR_INVALID_ESCAPE_CHARACTER: 
return "invalid_escape_character";
 
  573        case PM_ERR_INVALID_FLOAT_EXPONENT: 
return "invalid_float_exponent";
 
  574        case PM_ERR_INVALID_LOCAL_VARIABLE_READ: 
return "invalid_local_variable_read";
 
  575        case PM_ERR_INVALID_LOCAL_VARIABLE_WRITE: 
return "invalid_local_variable_write";
 
  576        case PM_ERR_INVALID_MULTIBYTE_CHAR: 
return "invalid_multibyte_char";
 
  577        case PM_ERR_INVALID_MULTIBYTE_CHARACTER: 
return "invalid_multibyte_character";
 
  578        case PM_ERR_INVALID_MULTIBYTE_ESCAPE: 
return "invalid_multibyte_escape";
 
  579        case PM_ERR_INVALID_NUMBER_BINARY: 
return "invalid_number_binary";
 
  580        case PM_ERR_INVALID_NUMBER_DECIMAL: 
return "invalid_number_decimal";
 
  581        case PM_ERR_INVALID_NUMBER_FRACTION: 
return "invalid_number_fraction";
 
  582        case PM_ERR_INVALID_NUMBER_HEXADECIMAL: 
return "invalid_number_hexadecimal";
 
  583        case PM_ERR_INVALID_NUMBER_OCTAL: 
return "invalid_number_octal";
 
  584        case PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER: 
return "invalid_number_underscore_inner";
 
  585        case PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING: 
return "invalid_number_underscore_trailing";
 
  586        case PM_ERR_INVALID_PERCENT: 
return "invalid_percent";
 
  587        case PM_ERR_INVALID_PERCENT_EOF: 
return "invalid_percent_eof";
 
  588        case PM_ERR_INVALID_PRINTABLE_CHARACTER: 
return "invalid_printable_character";
 
  589        case PM_ERR_INVALID_RETRY_AFTER_ELSE: 
return "invalid_retry_after_else";
 
  590        case PM_ERR_INVALID_RETRY_AFTER_ENSURE: 
return "invalid_retry_after_ensure";
 
  591        case PM_ERR_INVALID_RETRY_WITHOUT_RESCUE: 
return "invalid_retry_without_rescue";
 
  592        case PM_ERR_INVALID_SYMBOL: 
return "invalid_symbol";
 
  593        case PM_ERR_INVALID_VARIABLE_GLOBAL: 
return "invalid_variable_global";
 
  594        case PM_ERR_INVALID_VARIABLE_GLOBAL_3_3: 
return "invalid_variable_global_3_3";
 
  595        case PM_ERR_INVALID_YIELD: 
return "invalid_yield";
 
  596        case PM_ERR_IT_NOT_ALLOWED_NUMBERED: 
return "it_not_allowed_numbered";
 
  597        case PM_ERR_IT_NOT_ALLOWED_ORDINARY: 
return "it_not_allowed_ordinary";
 
  598        case PM_ERR_LAMBDA_OPEN: 
return "lambda_open";
 
  599        case PM_ERR_LAMBDA_TERM_BRACE: 
return "lambda_term_brace";
 
  600        case PM_ERR_LAMBDA_TERM_END: 
return "lambda_term_end";
 
  601        case PM_ERR_LIST_I_LOWER_ELEMENT: 
return "list_i_lower_element";
 
  602        case PM_ERR_LIST_I_LOWER_TERM: 
return "list_i_lower_term";
 
  603        case PM_ERR_LIST_I_UPPER_ELEMENT: 
return "list_i_upper_element";
 
  604        case PM_ERR_LIST_I_UPPER_TERM: 
return "list_i_upper_term";
 
  605        case PM_ERR_LIST_W_LOWER_ELEMENT: 
return "list_w_lower_element";
 
  606        case PM_ERR_LIST_W_LOWER_TERM: 
return "list_w_lower_term";
 
  607        case PM_ERR_LIST_W_UPPER_ELEMENT: 
return "list_w_upper_element";
 
  608        case PM_ERR_LIST_W_UPPER_TERM: 
return "list_w_upper_term";
 
  609        case PM_ERR_MALLOC_FAILED: 
return "malloc_failed";
 
  610        case PM_ERR_MIXED_ENCODING: 
return "mixed_encoding";
 
  611        case PM_ERR_MODULE_IN_METHOD: 
return "module_in_method";
 
  612        case PM_ERR_MODULE_NAME: 
return "module_name";
 
  613        case PM_ERR_MODULE_TERM: 
return "module_term";
 
  614        case PM_ERR_MULTI_ASSIGN_MULTI_SPLATS: 
return "multi_assign_multi_splats";
 
  615        case PM_ERR_MULTI_ASSIGN_UNEXPECTED_REST: 
return "multi_assign_unexpected_rest";
 
  616        case PM_ERR_NESTING_TOO_DEEP: 
return "nesting_too_deep";
 
  617        case PM_ERR_NO_LOCAL_VARIABLE: 
return "no_local_variable";
 
  618        case PM_ERR_NON_ASSOCIATIVE_OPERATOR: 
return "non_associative_operator";
 
  619        case PM_ERR_NOT_EXPRESSION: 
return "not_expression";
 
  620        case PM_ERR_NUMBER_LITERAL_UNDERSCORE: 
return "number_literal_underscore";
 
  621        case PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK: 
return "numbered_parameter_inner_block";
 
  622        case PM_ERR_NUMBERED_PARAMETER_IT: 
return "numbered_parameter_it";
 
  623        case PM_ERR_NUMBERED_PARAMETER_ORDINARY: 
return "numbered_parameter_ordinary";
 
  624        case PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK: 
return "numbered_parameter_outer_block";
 
  625        case PM_ERR_OPERATOR_MULTI_ASSIGN: 
return "operator_multi_assign";
 
  626        case PM_ERR_OPERATOR_WRITE_ARGUMENTS: 
return "operator_write_arguments";
 
  627        case PM_ERR_OPERATOR_WRITE_BLOCK: 
return "operator_write_block";
 
  628        case PM_ERR_PARAMETER_ASSOC_SPLAT_MULTI: 
return "parameter_assoc_splat_multi";
 
  629        case PM_ERR_PARAMETER_BLOCK_MULTI: 
return "parameter_block_multi";
 
  630        case PM_ERR_PARAMETER_CIRCULAR: 
return "parameter_circular";
 
  631        case PM_ERR_PARAMETER_FORWARDING_AFTER_REST: 
return "parameter_forwarding_after_rest";
 
  632        case PM_ERR_PARAMETER_METHOD_NAME: 
return "parameter_method_name";
 
  633        case PM_ERR_PARAMETER_NAME_DUPLICATED: 
return "parameter_name_duplicated";
 
  634        case PM_ERR_PARAMETER_NO_DEFAULT: 
return "parameter_no_default";
 
  635        case PM_ERR_PARAMETER_NO_DEFAULT_KW: 
return "parameter_no_default_kw";
 
  636        case PM_ERR_PARAMETER_NUMBERED_RESERVED: 
return "parameter_numbered_reserved";
 
  637        case PM_ERR_PARAMETER_ORDER: 
return "parameter_order";
 
  638        case PM_ERR_PARAMETER_SPLAT_MULTI: 
return "parameter_splat_multi";
 
  639        case PM_ERR_PARAMETER_STAR: 
return "parameter_star";
 
  640        case PM_ERR_PARAMETER_UNEXPECTED_FWD: 
return "parameter_unexpected_fwd";
 
  641        case PM_ERR_PARAMETER_UNEXPECTED_NO_KW: 
return "parameter_unexpected_no_kw";
 
  642        case PM_ERR_PARAMETER_WILD_LOOSE_COMMA: 
return "parameter_wild_loose_comma";
 
  643        case PM_ERR_PATTERN_ARRAY_MULTIPLE_RESTS: 
return "pattern_array_multiple_rests";
 
  644        case PM_ERR_PATTERN_CAPTURE_DUPLICATE: 
return "pattern_capture_duplicate";
 
  645        case PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET: 
return "pattern_expression_after_bracket";
 
  646        case PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA: 
return "pattern_expression_after_comma";
 
  647        case PM_ERR_PATTERN_EXPRESSION_AFTER_HROCKET: 
return "pattern_expression_after_hrocket";
 
  648        case PM_ERR_PATTERN_EXPRESSION_AFTER_IN: 
return "pattern_expression_after_in";
 
  649        case PM_ERR_PATTERN_EXPRESSION_AFTER_KEY: 
return "pattern_expression_after_key";
 
  650        case PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN: 
return "pattern_expression_after_paren";
 
  651        case PM_ERR_PATTERN_EXPRESSION_AFTER_PIN: 
return "pattern_expression_after_pin";
 
  652        case PM_ERR_PATTERN_EXPRESSION_AFTER_PIPE: 
return "pattern_expression_after_pipe";
 
  653        case PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE: 
return "pattern_expression_after_range";
 
  654        case PM_ERR_PATTERN_EXPRESSION_AFTER_REST: 
return "pattern_expression_after_rest";
 
  655        case PM_ERR_PATTERN_FIND_MISSING_INNER: 
return "pattern_find_missing_inner";
 
  656        case PM_ERR_PATTERN_HASH_IMPLICIT: 
return "pattern_hash_implicit";
 
  657        case PM_ERR_PATTERN_HASH_KEY: 
return "pattern_hash_key";
 
  658        case PM_ERR_PATTERN_HASH_KEY_DUPLICATE: 
return "pattern_hash_key_duplicate";
 
  659        case PM_ERR_PATTERN_HASH_KEY_INTERPOLATED: 
return "pattern_hash_key_interpolated";
 
  660        case PM_ERR_PATTERN_HASH_KEY_LABEL: 
return "pattern_hash_key_label";
 
  661        case PM_ERR_PATTERN_HASH_KEY_LOCALS: 
return "pattern_hash_key_locals";
 
  662        case PM_ERR_PATTERN_IDENT_AFTER_HROCKET: 
return "pattern_ident_after_hrocket";
 
  663        case PM_ERR_PATTERN_LABEL_AFTER_COMMA: 
return "pattern_label_after_comma";
 
  664        case PM_ERR_PATTERN_REST: 
return "pattern_rest";
 
  665        case PM_ERR_PATTERN_TERM_BRACE: 
return "pattern_term_brace";
 
  666        case PM_ERR_PATTERN_TERM_BRACKET: 
return "pattern_term_bracket";
 
  667        case PM_ERR_PATTERN_TERM_PAREN: 
return "pattern_term_paren";
 
  668        case PM_ERR_PIPEPIPEEQ_MULTI_ASSIGN: 
return "pipepipeeq_multi_assign";
 
  669        case PM_ERR_REGEXP_ENCODING_OPTION_MISMATCH: 
return "regexp_encoding_option_mismatch";
 
  670        case PM_ERR_REGEXP_INCOMPAT_CHAR_ENCODING: 
return "regexp_incompat_char_encoding";
 
  671        case PM_ERR_REGEXP_INVALID_UNICODE_RANGE: 
return "regexp_invalid_unicode_range";
 
  672        case PM_ERR_REGEXP_NON_ESCAPED_MBC: 
return "regexp_non_escaped_mbc";
 
  673        case PM_ERR_REGEXP_PARSE_ERROR: 
return "regexp_parse_error";
 
  674        case PM_ERR_REGEXP_TERM: 
return "regexp_term";
 
  675        case PM_ERR_REGEXP_UNKNOWN_OPTIONS: 
return "regexp_unknown_options";
 
  676        case PM_ERR_REGEXP_UTF8_CHAR_NON_UTF8_REGEXP: 
return "regexp_utf8_char_non_utf8_regexp";
 
  677        case PM_ERR_RESCUE_EXPRESSION: 
return "rescue_expression";
 
  678        case PM_ERR_RESCUE_MODIFIER_VALUE: 
return "rescue_modifier_value";
 
  679        case PM_ERR_RESCUE_TERM: 
return "rescue_term";
 
  680        case PM_ERR_RESCUE_VARIABLE: 
return "rescue_variable";
 
  681        case PM_ERR_RETURN_INVALID: 
return "return_invalid";
 
  682        case PM_ERR_SCRIPT_NOT_FOUND: 
return "script_not_found";
 
  683        case PM_ERR_SINGLETON_FOR_LITERALS: 
return "singleton_for_literals";
 
  684        case PM_ERR_STATEMENT_ALIAS: 
return "statement_alias";
 
  685        case PM_ERR_STATEMENT_POSTEXE_END: 
return "statement_postexe_end";
 
  686        case PM_ERR_STATEMENT_PREEXE_BEGIN: 
return "statement_preexe_begin";
 
  687        case PM_ERR_STATEMENT_UNDEF: 
return "statement_undef";
 
  688        case PM_ERR_STRING_CONCATENATION: 
return "string_concatenation";
 
  689        case PM_ERR_STRING_INTERPOLATED_TERM: 
return "string_interpolated_term";
 
  690        case PM_ERR_STRING_LITERAL_EOF: 
return "string_literal_eof";
 
  691        case PM_ERR_STRING_LITERAL_TERM: 
return "string_literal_term";
 
  692        case PM_ERR_SYMBOL_INVALID: 
return "symbol_invalid";
 
  693        case PM_ERR_SYMBOL_TERM_DYNAMIC: 
return "symbol_term_dynamic";
 
  694        case PM_ERR_SYMBOL_TERM_INTERPOLATED: 
return "symbol_term_interpolated";
 
  695        case PM_ERR_TERNARY_COLON: 
return "ternary_colon";
 
  696        case PM_ERR_TERNARY_EXPRESSION_FALSE: 
return "ternary_expression_false";
 
  697        case PM_ERR_TERNARY_EXPRESSION_TRUE: 
return "ternary_expression_true";
 
  698        case PM_ERR_UNARY_DISALLOWED: 
return "unary_disallowed";
 
  699        case PM_ERR_UNARY_RECEIVER: 
return "unary_receiver";
 
  700        case PM_ERR_UNDEF_ARGUMENT: 
return "undef_argument";
 
  701        case PM_ERR_UNEXPECTED_BLOCK_ARGUMENT: 
return "unexpected_block_argument";
 
  702        case PM_ERR_UNEXPECTED_INDEX_BLOCK: 
return "unexpected_index_block";
 
  703        case PM_ERR_UNEXPECTED_INDEX_KEYWORDS: 
return "unexpected_index_keywords";
 
  704        case PM_ERR_UNEXPECTED_LABEL: 
return "unexpected_label";
 
  705        case PM_ERR_UNEXPECTED_MULTI_WRITE: 
return "unexpected_multi_write";
 
  706        case PM_ERR_UNEXPECTED_RANGE_OPERATOR: 
return "unexpected_range_operator";
 
  707        case PM_ERR_UNEXPECTED_SAFE_NAVIGATION: 
return "unexpected_safe_navigation";
 
  708        case PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT: 
return "unexpected_token_close_context";
 
  709        case PM_ERR_UNEXPECTED_TOKEN_IGNORE: 
return "unexpected_token_ignore";
 
  710        case PM_ERR_UNTIL_TERM: 
return "until_term";
 
  711        case PM_ERR_VOID_EXPRESSION: 
return "void_expression";
 
  712        case PM_ERR_WHILE_TERM: 
return "while_term";
 
  713        case PM_ERR_WRITE_TARGET_IN_METHOD: 
return "write_target_in_method";
 
  714        case PM_ERR_WRITE_TARGET_READONLY: 
return "write_target_readonly";
 
  715        case PM_ERR_WRITE_TARGET_UNEXPECTED: 
return "write_target_unexpected";
 
  716        case PM_ERR_XSTRING_TERM: 
return "xstring_term";
 
  717        case PM_WARN_AMBIGUOUS_BINARY_OPERATOR: 
return "ambiguous_binary_operator";
 
  718        case PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS: 
return "ambiguous_first_argument_minus";
 
  719        case PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS: 
return "ambiguous_first_argument_plus";
 
  720        case PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND: 
return "ambiguous_prefix_ampersand";
 
  721        case PM_WARN_AMBIGUOUS_PREFIX_STAR: 
return "ambiguous_prefix_star";
 
  722        case PM_WARN_AMBIGUOUS_PREFIX_STAR_STAR: 
return "ambiguous_prefix_star_star";
 
  723        case PM_WARN_AMBIGUOUS_SLASH: 
return "ambiguous_slash";
 
  724        case PM_WARN_COMPARISON_AFTER_COMPARISON: 
return "comparison_after_comparison";
 
  725        case PM_WARN_DOT_DOT_DOT_EOL: 
return "dot_dot_dot_eol";
 
  726        case PM_WARN_EQUAL_IN_CONDITIONAL: 
return "equal_in_conditional";
 
  727        case PM_WARN_EQUAL_IN_CONDITIONAL_3_3: 
return "equal_in_conditional_3_3";
 
  728        case PM_WARN_END_IN_METHOD: 
return "end_in_method";
 
  729        case PM_WARN_DUPLICATED_HASH_KEY: 
return "duplicated_hash_key";
 
  730        case PM_WARN_DUPLICATED_WHEN_CLAUSE: 
return "duplicated_when_clause";
 
  731        case PM_WARN_FLOAT_OUT_OF_RANGE: 
return "float_out_of_range";
 
  732        case PM_WARN_IGNORED_FROZEN_STRING_LITERAL: 
return "ignored_frozen_string_literal";
 
  733        case PM_WARN_INDENTATION_MISMATCH: 
return "indentation_mismatch";
 
  734        case PM_WARN_INTEGER_IN_FLIP_FLOP: 
return "integer_in_flip_flop";
 
  735        case PM_WARN_INVALID_CHARACTER: 
return "invalid_character";
 
  736        case PM_WARN_INVALID_MAGIC_COMMENT_VALUE: 
return "invalid_magic_comment_value";
 
  737        case PM_WARN_INVALID_NUMBERED_REFERENCE: 
return "invalid_numbered_reference";
 
  738        case PM_WARN_KEYWORD_EOL: 
return "keyword_eol";
 
  739        case PM_WARN_LITERAL_IN_CONDITION_DEFAULT: 
return "literal_in_condition_default";
 
  740        case PM_WARN_LITERAL_IN_CONDITION_VERBOSE: 
return "literal_in_condition_verbose";
 
  741        case PM_WARN_SHAREABLE_CONSTANT_VALUE_LINE: 
return "shareable_constant_value_line";
 
  742        case PM_WARN_SHEBANG_CARRIAGE_RETURN: 
return "shebang_carriage_return";
 
  743        case PM_WARN_UNEXPECTED_CARRIAGE_RETURN: 
return "unexpected_carriage_return";
 
  744        case PM_WARN_UNREACHABLE_STATEMENT: 
return "unreachable_statement";
 
  745        case PM_WARN_UNUSED_LOCAL_VARIABLE: 
return "unused_local_variable";
 
  746        case PM_WARN_VOID_STATEMENT: 
return "void_statement";
 
  749    assert(
false && 
"unreachable");
 
 
  753static inline const char *
 
  755    assert(diag_id < PM_DIAGNOSTIC_ID_MAX);
 
  757    const char *message = diagnostic_messages[diag_id].
message;
 
  765    assert(diag_id < PM_DIAGNOSTIC_ID_MAX);
 
  767    return (uint8_t) diagnostic_messages[diag_id].
level;
 
  776    if (diagnostic == NULL) 
return false;
 
  781        .message = pm_diagnostic_message(diag_id),
 
  783        .level = pm_diagnostic_level(diag_id)
 
 
  797    va_start(arguments, diag_id);
 
  799    const char *format = pm_diagnostic_message(diag_id);
 
  800    int result = vsnprintf(NULL, 0, format, arguments);
 
  808    if (diagnostic == NULL) {
 
  812    size_t length = (size_t) (result + 1);
 
  813    char *message = (
char *) 
xmalloc(length);
 
  814    if (message == NULL) {
 
  819    va_start(arguments, diag_id);
 
  820    vsnprintf(message, length, format, arguments);
 
  828        .level = pm_diagnostic_level(diag_id)
 
 
  842    while (node != NULL) {
 
 
A list of diagnostics generated during parsing.
pm_diagnostic_id_t
The diagnostic IDs of all of the diagnostics, used to communicate the types of errors between the par...
@ PM_WARNING_LEVEL_DEFAULT
For warnings which should be emitted if $VERBOSE != nil.
@ PM_WARNING_LEVEL_VERBOSE
For warnings which should be emitted if $VERBOSE == true.
@ PM_ERROR_LEVEL_ARGUMENT
For errors that should raise an argument error.
@ PM_ERROR_LEVEL_LOAD
For errors that should raise a load error.
@ PM_ERROR_LEVEL_SYNTAX
For errors that should raise a syntax error.
#define xfree
Old name of ruby_xfree.
#define xmalloc
Old name of ruby_xmalloc.
#define xcalloc
Old name of ruby_xcalloc.
This struct holds the data for each diagnostic.
uint8_t level
The level associated with the diagnostic.
const char * message
The message associated with the diagnostic.
This struct represents a diagnostic generated during parsing.
pm_location_t location
The location of the diagnostic in the source.
const char * message
The message associated with the diagnostic.
pm_list_node_t node
The embedded base node.
bool owned
Whether or not the memory related to the message of this diagnostic is owned by this diagnostic.
This struct represents an abstract linked list that provides common functionality.
struct pm_list_node * next
A pointer to the next node in the list.
This represents the overall linked list.
pm_list_node_t * head
A pointer to the head of the list.