PAWN Errors as PHP Array

$errorList = array(
    001 => array(
        'number' => 001,
        'category' => 'Error',
        'msg' => 'expected token: token, but found token',
        'desc' => 'A required token is omitted.'
    ),
    002 => array(
        'number' => 002,
        'category' => 'Error',
        'msg' => 'only a single statement (or expression) can follow each "case"',
        'desc' => 'Every case in a switch statement can hold exactly one statement. To put multiple statements in a case, enclose these statements between braces (which creates a compound statement).'
    ),
    003 => array(
        'number' => 003,
        'category' => 'Error',
        'msg' => 'declaration of a local variable must appear in a compound block',
        'desc' => 'The declaration of a local variable must appear between braces ("{. . .}") at the active scope level.'
    ),
    004 => array(
        'number' => 004,
        'category' => 'Error',
        'msg' => 'function name is not implemented',
        'desc' => 'There is no implementation for the designated function. The function may have been "forwardly" declared —or prototyped— but the full function definition including a statement, or statement block, is missing.'
    ),
    005 => array(
        'number' => 005,
        'category' => 'Error',
        'msg' => 'function may not have arguments',
        'desc' => 'The function main is the program entry point. It may not have arguments.'
    ),
    006 => array(
        'number' => 006,
        'category' => 'Error',
        'msg' => 'must be assigned to an array',
        'desc' => 'String literals or arrays must be assigned to an array. This error message may also indicate a missing index (or indices) at the array on the right side of the "=" sign.'
    ),
    007 => array(
        'number' => 007,
        'category' => 'Error',
        'msg' => 'operator cannot be redefined',
        'desc' => 'Only a select set of operators may be redefined, this operator is not one of them. See page 84 for details.'
    ),
    008 => array(
        'number' => 008,
        'category' => 'Error',
        'msg' => 'must be a constant expression; assumed zero',
        'desc' => 'The size of arrays and the parameters of most directives must be constant values.'
    ),
    009 => array(
        'number' => 009,
        'category' => 'Error',
        'msg' => 'invalid array size (negative, zero or out of bounds)',
        'desc' => 'The number of elements of an array must always be 1 or more. In addition, an array that big that it does exceeds the range of a cell is invalid too.'
    ),
    010 => array(
        'number' => 010,
        'category' => 'Error',
        'msg' => 'illegal function or declaration',
        'desc' => 'The compiler expects a declaration of a global variable or of a function at the current location, but it cannot interpret it as such.'
    ),
    011 => array(
        'number' => 011,
        'category' => 'Error',
        'msg' => 'invalid outside functions',
        'desc' => 'The instruction or statement is invalid at a global level. Local labels and (compound) statements are only valid if used within functions.'
    ),
    012 => array(
        'number' => 012,
        'category' => 'Error',
        'msg' => 'invalid function call, not a valid address',
        'desc' => 'The symbol is not a function.'
    ),
    013 => array(
        'number' => 013,
        'category' => 'Error',
        'msg' => 'no entry point (no public functions)',
        'desc' => 'The file does not contain a main function or any public function.'
    ),
    014 => array(
        'number' => 014,
        'category' => 'Error',
        'msg' => 'invalid statement; not in switch',
        'desc' => 'The statements case and default are only valid inside a switch statement.'
    ),
    015 => array(
        'number' => 015,
        'category' => 'clause to be the last clause in a ',
        'msg' => '"default" must be the last clause in switch statement pawn requires the ',
        'desc' => 'default '
    ),
    016 => array(
        'number' => 016,
        'category' => 'Error',
        'msg' => 'multiple defaults in "switch"',
        'desc' => 'Each switch statement may only have one default clause.'
    ),
    017 => array(
        'number' => 017,
        'category' => 'Error',
        'msg' => 'undefined symbol symbol',
        'desc' => 'The symbol (variable, constant or function) is not declared.'
    ),
    018 => array(
        'number' => 018,
        'category' => 'Error',
        'msg' => 'initialization data exceeds declared size',
        'desc' => 'An array with an explicit size is initialized, but the number of initiallers exceeds the number of elements specified. For example, in "arr[3]={1,2,3,4};" the array is specified to have three elements, but there are four initiallers.'
    ),
    019 => array(
        'number' => 019,
        'category' => 'Error',
        'msg' => 'not a label: name',
        'desc' => 'A goto statement branches to a symbol that is not a label.'
    ),
    020 => array(
        'number' => 020,
        'category' => 'Error',
        'msg' => 'invalid symbol name',
        'desc' => 'A symbol may start with a letter, an underscore or an "at" sign ("@") and may be followed by a series of letters, digits, underscore characters and "@" characters.'
    ),
    021 => array(
        'number' => 021,
        'category' => 'Error',
        'msg' => 'symbol already defined: identifier',
        'desc' => 'The symbol was already defined at the current level.'
    ),
    022 => array(
        'number' => 022,
        'category' => 'Error',
        'msg' => 'must be lvalue (non-constant)',
        'desc' => 'The symbol that is altered (incremented, decremented, assigned a value, etc.) must be a variable that can be modified (this kind of variable is called an lvalue). Functions, string literals, arrays and constants are no lvalues. Variables declared with the "const" attribute are no lvalues either.'
    ),
    023 => array(
        'number' => 023,
        'category' => 'Error',
        'msg' => 'array assignment must be simple assignment',
        'desc' => 'When assigning one array to another, you cannot combine an arithmetic operation with the assignment (e.g., you cannot use the "+=" operator).'
    ),
    024 => array(
        'number' => 024,
        'category' => 'Error',
        'msg' => '"break" or "continue" is out of context',
        'desc' => 'The statements break and continue are only valid inside the context of a loop (a do, for or while statement). Unlike the languages C/C++ and Java, break does not jump out of a switch statement.'
    ),
    025 => array(
        'number' => 025,
        'category' => 'Error',
        'msg' => 'function heading di ers from prototype',
        'desc' => 'The number of arguments given at a previous declaration of the function does not match the number of arguments given at the current declaration.'
    ),
    026 => array(
        'number' => 026,
        'category' => 'Error',
        'msg' => 'no matching "#if..."',
        'desc' => 'The directive #else or #endif was encountered, but no matching #if directive was found.'
    ),
    027 => array(
        'number' => 027,
        'category' => 'Error',
        'msg' => 'invalid character constant',
        'desc' => 'One likely cause for this error is the occurrence of an unknown escape sequence, like "\x". Putting multiple characters between single quotes, as in ’abc’ also issues this error message. A third cause for this error is a situation where a character constant was expected, but none (or a non-character expression) were provided.'
    ),
    028 => array(
        'number' => 028,
        'category' => 'Error',
        'msg' => 'invalid subscript (not an array or too many subscripts): identifier',
        'desc' => 'The subscript operators "[" and "]" are only valid with arrays. The number of square bracket pairs may not exceed the number of dimensions of the array.'
    ),
    029 => array(
        'number' => 029,
        'category' => 'Error',
        'msg' => 'invalid expression, assumed zero',
        'desc' => 'The compiler could not interpret the expression.'
    ),
    030 => array(
        'number' => 030,
        'category' => 'Error',
        'msg' => 'compound statement not closed at the end of file (started at line number)',
        'desc' => 'An unexpected end of file occurred. One or more compound statements are still unfinished (i.e. the closing brace "}" has not been found). The line number where the compound statement started is given in the message.'
    ),
    031 => array(
        'number' => 031,
        'category' => 'Error',
        'msg' => 'unknown directive',
        'desc' => 'The character "#" appears first at a line, but no valid directive was specified.'
    ),
    032 => array(
        'number' => 032,
        'category' => 'Error',
        'msg' => 'array index out of bounds',
        'desc' => 'The array index is larger than the highest valid entry of the array.'
    ),
    033 => array(
        'number' => 033,
        'category' => 'Error',
        'msg' => 'array must be indexed (variable name)',
        'desc' => 'An array as a whole cannot be used in a expression; you must indicate an element of the array between square brackets.'
    ),
    034 => array(
        'number' => 034,
        'category' => 'Error',
        'msg' => 'argument does not have a default value (argument index)',
        'desc' => 'You can only use the argument placeholder when the function definition specifies a default value for the argument.'
    ),
    035 => array(
        'number' => 035,
        'category' => 'Error',
        'msg' => 'argument type mismatch (argument index)',
        'desc' => 'The argument that you pass is di erent from the argument that the function expects, and the compiler cannot convert the passed-in argument to the required type. For example, you cannot pass the literal value "1" as an argument when the function expects an array or a reference.'
    ),
    036 => array(
        'number' => 036,
        'category' => 'Error',
        'msg' => 'empty statement',
        'desc' => 'The line contains a semicolon that is not preceded by an expression. pawn does not support a semicolon as an empty statement, use an empty compound block instead.'
    ),
    037 => array(
        'number' => 037,
        'category' => 'Error',
        'msg' => 'invalid string (possibly non-terminated string)',
        'desc' => 'A string was not well-formed; for example, the final quote that ends a string is missing, or the filename for the #include directive was not enclosed in double quotes or angle brackets.'
    ),
    038 => array(
        'number' => 038,
        'category' => 'Error',
        'msg' => 'extra characters on line',
        'desc' => 'There were trailing characters on a line that contained a directive (a directive starts with a # symbol, see page 116).'
    ),
    039 => array(
        'number' => 039,
        'category' => 'Error',
        'msg' => 'constant symbol has no size',
        'desc' => 'A variable has a size (measured in a number of cells), a constant has no size. That is, you cannot use a (symbolic) constant with the sizeof operator, for example.'
    ),
    040 => array(
        'number' => 040,
        'category' => 'Error',
        'msg' => 'duplicate "case" label (value value)',
        'desc' => 'A preceding "case label" in the list of the switch statement evaluates to the same value.'
    ),
    041 => array(
        'number' => 041,
        'category' => 'Error',
        'msg' => 'invalid ellipsis, array size is not known',
        'desc' => 'You used a syntax like "arr[] = { 1, ... };", which is invalid, because the compiler cannot deduce the size of the array from the declaration.'
    ),
    042 => array(
        'number' => 042,
        'category' => 'Error',
        'msg' => 'invalid combination of class specifiers',
        'desc' => 'A function or variable is denoted as both "public" and "native", which is unsupported. Other combinations may also be unsup- ported; for example, a function cannot be both "public" and "stock" (a variable may be declared both "public" and "stock").'
    ),
    043 => array(
        'number' => 043,
        'category' => 'Error',
        'msg' => 'character constant value exceeds range for a packed string/array',
        'desc' => 'When the error occurs on a literal string, it is usually an attempt to store a Unicode character in a packed string where a packed character is 8-bits. For a literal array, one of the constants does not fit in the range for packed characters.'
    ),
    044 => array(
        'number' => 044,
        'category' => 'Error',
        'msg' => 'positional parameters must precede all named parameters',
        'desc' => 'When you mix positional parameters and named parameters in a function call, the positional parameters must come first.'
    ),
    045 => array(
        'number' => 045,
        'category' => 'Error',
        'msg' => 'too many function arguments',
        'desc' => 'The maximum number of function arguments is currently limited to 64.'
    ),
    046 => array(
        'number' => 046,
        'category' => 'Error',
        'msg' => 'unknown array size (variable name)',
        'desc' => 'For array assignment, the size of both arrays must be explicitly defined, also if they are passed as function arguments.'
    ),
    047 => array(
        'number' => 047,
        'category' => 'Error',
        'msg' => 'array sizes do not match, or destination array is too small',
        'desc' => 'For array assignment, the arrays on the left and the right side of the assignment operator must have the same number of dimensions. In addition:'
    ),
    048 => array(
        'number' => 048,
        'category' => 'Error',
        'msg' => 'array dimensions do not match',
        'desc' => 'For an array assignment, the dimensions of the arrays on both sides of the "=" sign must match; when passing arrays to a function argument, the arrays passed to the function (in the function call) must match with the definition of the function arguments.'
    ),
    049 => array(
        'number' => 049,
        'category' => 'Error',
        'msg' => 'invalid line continuation',
        'desc' => 'A line continuation character (a backslash at the end of a line) is at an invalid position, for example at the end of a file or in a single line comment.'
    ),
    050 => array(
        'number' => 050,
        'category' => 'Error',
        'msg' => 'invalid range',
        'desc' => 'A numeric range with the syntax "n1 .. n2", where n1 and n2 are numeric constants, is invalid. Either one of the values in not a valid number, or n1 is not smaller than n2.'
    ),
    051 => array(
        'number' => 051,
        'category' => 'Error',
        'msg' => 'invalid subscript, use "[ ]" operators on major dimensions and for named indices',
        'desc' => 'You can use the "character array index" operator (braces: "{ }" only for the last dimension, and only when indexing the array with a number. For other dimensions, and when indexing the array with a "symbolic index" (one that starts with a "."), you must use the cell index operator (square brackets: "[ ]").'
    ),
    052 => array(
        'number' => 052,
        'category' => 'Error',
        'msg' => 'multi-dimensional arrays must be fully initialized',
        'desc' => 'If an array with more than one dimension is initialized at its declaration, then there must be equally many literal vectors/sub- arrays at the right of the equal sign ("=") as specified for the major dimension(s) of the array.'
    ),
    053 => array(
        'number' => 053,
        'category' => 'Error',
        'msg' => 'exceeding maximum number of dimensions',
        'desc' => 'The current implementation of the pawn compiler only supports arrays with one or two dimensions.'
    ),
    054 => array(
        'number' => 054,
        'category' => 'Error',
        'msg' => 'unmatched closing brace',
        'desc' => 'A closing brace ("}") was found without matching opening brace ("{").'
    ),
    055 => array(
        'number' => 055,
        'category' => 'Error',
        'msg' => 'start of function body without function header',
        'desc' => 'An opening brace ("{") was found outside the scope of a function.'
    ),
    056 => array(
        'number' => 056,
        'category' => 'Error',
        'msg' => 'arrays, local variables and function arguments cannot be public',
        'desc' => 'A local variable or a function argument starts with the character "@", which is invalid.'
    ),
    057 => array(
        'number' => 057,
        'category' => 'Error',
        'msg' => 'Unfinished expression before compiler directive',
        'desc' => 'Compiler directives may only occur between statements, not inside a statement. This error typically occurs when an expression statement is split over multiple lines and a compiler directive appears between the start and the end of the expression. This is not supported.'
    ),
    058 => array(
        'number' => 058,
        'category' => 'Error',
        'msg' => 'duplicate argument; same argument is passed twice',
        'desc' => 'In the function call, the same argument appears twice, possibly through a mixture of named and positional parameters.'
    ),
    059 => array(
        'number' => 059,
        'category' => 'Error',
        'msg' => 'function argument may not have a default value (variable name)',
        'desc' => 'All arguments of public functions must be passed explicitly. Public functions are typically called from the host application, who has no knowledge of the default parameter values. Arguments of user defined operators are implied from the expression and cannot be inferred from the default value of an argument.'
    ),
    060 => array(
        'number' => 060,
        'category' => 'Error',
        'msg' => 'multiple "#else" directives between "#if . . . #endif',
        'desc' => 'Two or more #else directives appear in the body between the matching #if and #endif.'
    ),
    061 => array(
        'number' => 061,
        'category' => 'Error',
        'msg' => '"#elseif" directive follows an "#else" directive',
        'desc' => 'All #elseif directives must appear before the #else directive. This error may also indicate that an #endif directive for a higher level is missing.'
    ),
    062 => array(
        'number' => 062,
        'category' => 'Error',
        'msg' => 'number of operands does not fit the operator',
        'desc' => 'When redefining an operator, the number of operands that the operator has (1 for unary operators and 2 for binary operators) must be equal to the number of arguments of the operator function.'
    ),
    063 => array(
        'number' => 063,
        'category' => 'Error',
        'msg' => 'function result tag of operator name must be name',
        'desc' => 'Logical and relational operators are defined as having a result that is either true (1) or false (0) and having a "bool:" tag. A user defined operator should adhere to this definition.'
    ),
    064 => array(
        'number' => 064,
        'category' => 'Error',
        'msg' => 'cannot change predefined operators',
        'desc' => 'One cannot define operators to work on untagged values, for example, because pawn already defines this operation.'
    ),
    065 => array(
        'number' => 065,
        'category' => 'Error',
        'msg' => 'function argument may only have a single tag (argument number)',
        'desc' => 'In a user defined operator, a function argument may not have multiple tags.'
    ),
    066 => array(
        'number' => 066,
        'category' => 'Error',
        'msg' => 'function argument may not be a reference argument or an array (argument number)',
        'desc' => 'In a user defined operator, all arguments must be cells (non-arrays) that are passed "by value".'
    ),
    067 => array(
        'number' => 067,
        'category' => 'Error',
        'msg' => 'variable cannot be both a reference and an array (variable name)',
        'desc' => 'A function argument may be denoted as a "reference" or as an array, but not as both.'
    ),
    068 => array(
        'number' => 068,
        'category' => 'Error',
        'msg' => 'invalid rational number precision in #pragma',
        'desc' => 'The precision was negative or too high. For fioating point rational numbers, the precision specification should be omitted.'
    ),
    069 => array(
        'number' => 069,
        'category' => 'Error',
        'msg' => 'rational number format already defined',
        'desc' => 'This #pragma confiicts with an earlier #pragma that specified a di erent format.'
    ),
    070 => array(
        'number' => 070,
        'category' => 'Error',
        'msg' => 'rational number support was not enabled',
        'desc' => 'A rational literal number was encountered, but the format for rational numbers was not specified.'
    ),
    071 => array(
        'number' => 071,
        'category' => 'Error',
        'msg' => 'user-defined operator must be declared before use (func- tion name)',
        'desc' => 'Like a variable, a user-defined operator must be declared before its first use. This message indicates that prior to the declaration of the user-defined operator, an instance where the operator was used on operands with the same tags occurred. This may either indicate that the program tries to make mixed use of the default operator and a user-defined operator (which is unsupported), or that the user-defined operator must be "forwardly declared".'
    ),
    072 => array(
        'number' => 072,
        'category' => 'Error',
        'msg' => '"sizeof" operator is invalid on "function" symbols',
        'desc' => 'You used something like "sizeof MyCounter" where the symbol "MyCounter" is not a variable, but a function. You cannot request the size of a function.'
    ),
    073 => array(
        'number' => 073,
        'category' => 'Error',
        'msg' => 'function argument must be an array (argument name)',
        'desc' => 'The function argument is a constant or a simple variable, but the function requires that you pass an array.'
    ),
    074 => array(
        'number' => 074,
        'category' => 'Error',
        'msg' => '#define pattern must start with an alphabetic character',
        'desc' => 'Any pattern for the #define directive must start with a letter, an underscore ("_") or an "@"-character. The pattern is the first word that follows the #define keyword.'
    ),
    075 => array(
        'number' => 075,
        'category' => 'Error',
        'msg' => 'input line too long (after substitutions)',
        'desc' => 'Either the source file contains a very long line, or text substitutions make a line that was initially of acceptable length grow beyond its bounds. This may be caused by a text substitution that causes recursive substitution (the pattern matching a portion of the replacement text, so that this part of the replacement text is also matched and replaced, and so forth).'
    ),
    076 => array(
        'number' => 076,
        'category' => 'Error',
        'msg' => 'syntax error in the expression, or invalid function call',
        'desc' => 'The expression statement was not recognized as a valid statement (so it is a "syntax error"). From the part of the string that was parsed, it looks as if the source line contains a function call in a "procedure call" syntax (omitting the parentheses), but the function result is used —assigned to a variable, passed as a parameter, used in an expression. . .'
    ),
    077 => array(
        'number' => 077,
        'category' => 'Error',
        'msg' => 'malformed UTF-8 encoding, or corrupted file: filename',
        'desc' => 'The file starts with an UTF-8 signature, but it contains encodings that are invalid UTF-8. If the source file was created by an editor or converter that supports UTF-8, the UTF-8 support is non-conforming.'
    ),
    078 => array(
        'number' => 078,
        'category' => 'Error',
        'msg' => 'function uses both "return" and "return <value>"',
        'desc' => 'The function returns both with and without a return value. The function should be consistent in always returning with a function result, or in never returning a function result.'
    ),
    079 => array(
        'number' => 079,
        'category' => 'Error',
        'msg' => 'inconsistent return types (array &amp; non-array)',
        'desc' => 'The function returns both values and arrays, which is not allowed. If a function returns an array, all return statements must specify an array (of the same size and dimensions).'
    ),
    080 => array(
        'number' => 080,
        'category' => 'Error',
        'msg' => 'unknown symbol, or not a constant symbol (symbol name)',
        'desc' => 'Where a constant value was expected, an unknown symbol or a non-constant symbol (variable) was found.'
    ),
    083 => array(
        'number' => 083,
        'category' => 'Error',
        'msg' => 'a function or variable may only belong to a single automa- ton (symbol name)',
        'desc' => 'There are multiple automatons in the state declaration for the indicated function or variable, which is not supported. In the case of a function: all instances of the function must belong to the same automaton. In the case of a variable: it is allowed to have several variables with the same name belonging to di erent automatons, but only in separate declarations —these are distinct variables.'
    ),
    084 => array(
        'number' => 084,
        'category' => 'Error',
        'msg' => 'state confiict: one of the states is already assigned to another implementation (symbol name)',
        'desc' => 'The specified state appears in the state specifier of two implemen- tations of the same function.'
    ),
    085 => array(
        'number' => 085,
        'category' => 'Error',
        'msg' => 'no states are defined for symbol name',
        'desc' => 'When this error occurs on a function, this function has a fall-back implementation, but no other states. If the error refers to a variable, this variable does not have a list of states between the &lt; and > characters. Use a state-less function or variable instead.'
    ),
    086 => array(
        'number' => 086,
        'category' => 'Error',
        'msg' => 'unknown automaton name',
        'desc' => 'The "state" statement refers to an unknown automaton.'
    ),
    087 => array(
        'number' => 087,
        'category' => 'Error',
        'msg' => 'unknown state name for automaton name',
        'desc' => 'The "state" statement refers to an unknown state (for the specified automaton).'
    ),
    088 => array(
        'number' => 088,
        'category' => 'Error',
        'msg' => 'public variables and local variables may not have states (symbol name)',
        'desc' => 'Only standard (global) variables may have a list of states (and an automaton) at the end of a declaration.'
    ),
    089 => array(
        'number' => 089,
        'category' => 'Error',
        'msg' => 'state variables may not be initialized (symbol name)',
        'desc' => 'Variables with a state list may not have initializers. State variables should always be initialized through an assignment (instead of at their declaration), because their initial value is indeterminate.'
    ),
    090 => array(
        'number' => 090,
        'category' => 'Error',
        'msg' => 'public functions may not return arrays (symbol name)',
        'desc' => 'A public function may not return an array. Returning arrays is allowed only for normal functions.'
    ),
    091 => array(
        'number' => 091,
        'category' => 'Error',
        'msg' => 'first constant in an enumerated list must be initialized (symbol name)',
        'desc' => 'The first constant in a list of enumerated symbolic constants must be set to a value. Any subsequent symbol is automatically set the the value of the preceding symbol +1.'
    ),
    092 => array(
        'number' => 092,
        'category' => 'Error',
        'msg' => 'invalid number format',
        'desc' => 'A symbol started with a digit, but is is not a valid number.'
    ),
    093 => array(
        'number' => 093,
        'category' => 'Error',
        'msg' => 'array fields with a size may only appear in the final dimension',
        'desc' => 'In the final dimension (the "minor" dimension), the fields of an array may optionally be declared with a size that is di erent from a single cell. On the major dimensions of an array, this is not valid, however.'
    ),
    094 => array(
        'number' => 094,
        'category' => 'Error',
        'msg' => 'invalid subscript, subscript does not match array definition regarding named indices (symbol name)',
        'desc' => 'Either the array was declared with symbolic subscripts and you are indexing it with an expression, or you are indexing the array with a symbolic subscript which is not defined for the array.'
    ),
    100 => array(
        'number' => 100,
        'category' => 'Fatal Error',
        'msg' => 'cannot read from file: filename',
        'desc' => 'The compiler cannot find the specified file or does not have access to it.'
    ),
    101 => array(
        'number' => 101,
        'category' => 'Fatal Error',
        'msg' => 'cannot write to file: filename',
        'desc' => 'The compiler cannot write to the specified output file, probably caused by insu cient disk space or restricted access rights (the file could be read-only, for example).'
    ),
    102 => array(
        'number' => 102,
        'category' => 'Fatal Error',
        'msg' => 'table overfiow: table name',
        'desc' => 'An internal table in the pawn parser is too small to hold the required data. Some tables are dynamically growable, which means that there was insu cient memory to resize the table. The "table name" is one of the following:'
    ),
    103 => array(
        'number' => 103,
        'category' => 'Fatal Error',
        'msg' => 'insu cient memory',
        'desc' => 'General "out of memory" error.'
    ),
    104 => array(
        'number' => 104,
        'category' => 'Fatal Error',
        'msg' => 'incompatible options: option versus option',
        'desc' => 'Two option that are passed to the pawn compiler confiict with each other, or an option confiicts with the configuration of the pawn compiler.'
    ),
    105 => array(
        'number' => 105,
        'category' => 'Fatal Error',
        'msg' => 'numeric overfiow, exceeding capacity',
        'desc' => 'A numeric constant, notably a dimension of an array, is too large for the compiler to handle. For example, when compiled as a 16-bit application, the compiler cannot handle arrays with more than 32767 elements.'
    ),
    106 => array(
        'number' => 106,
        'category' => 'Fatal Error',
        'msg' => 'compiled script exceeds the maximum memory size',
        'desc' => '(number bytes)'
    ),
    107 => array(
        'number' => 107,
        'category' => 'Fatal Error',
        'msg' => 'too many error/warning messages on one line',
        'desc' => 'A single line that causes several error/warning messages is often an indication that the pawn parser is unable to "recover" from an earlier error. In this situation, the parser is unlikely to make any sense of the source code that follows —producing only (more) inappropriate error messages. Therefore, compilation is halted.'
    ),
    108 => array(
        'number' => 108,
        'category' => 'Fatal Error',
        'msg' => 'codepage mapping file not found',
        'desc' => 'The file for the codepage translation that was specified with the -c compiler option or the #pragma codepage directive could not be loaded.'
    ),
    109 => array(
        'number' => 109,
        'category' => 'Fatal Error',
        'msg' => 'invalid path: path name',
        'desc' => 'A path, for example for include files or codepage files, is invalid. Check the compiler options and, if used, the configuration file.'
    ),
    110 => array(
        'number' => 110,
        'category' => 'Fatal Error',
        'msg' => 'assertion failed: expression',
        'desc' => 'Compile-time assertion failed.'
    ),
    111 => array(
        'number' => 111,
        'category' => 'Fatal Error',
        'msg' => 'user error: message',
        'desc' => 'The parser fell on an #error directive.'
    ),
    200 => array(
        'number' => 200,
        'category' => 'Warning',
        'msg' => 'symbol is truncated to number characters',
        'desc' => 'The symbol is longer than the maximum symbol length. The maximum length of a symbol depends on whether the symbol is native, public or neither. Truncation may cause di erent symbol names to become equal, which may cause error 021 or warning 219.'
    ),
    201 => array(
        'number' => 201,
        'category' => 'Warning',
        'msg' => 'redefinition of constant/macro (symbol name)',
        'desc' => 'The symbol was previously defined to a di erent value, or the text substitution macro that starts with the prefix name was redefined with a di erent substitution text.'
    ),
    202 => array(
        'number' => 202,
        'category' => 'Warning',
        'msg' => 'number of arguments does not match definition',
        'desc' => 'At a function call, the number of arguments passed to the function (actual arguments) di ers from the number of formal arguments declared in the function heading. To declare functions with variable argument lists, use an ellipsis (...) behind the last known argument in the function heading; for example: print(formatstring,...); (see page 78).'
    ),
    203 => array(
        'number' => 203,
        'category' => 'Warning',
        'msg' => 'symbol is never used: identifier',
        'desc' => 'Asymbol is defined but never used. Public functions are excluded from the symbol usage check (since these may be called from the outside).'
    ),
    204 => array(
        'number' => 204,
        'category' => 'Warning',
        'msg' => 'symbol is assigned a value that is never used: identifier',
        'desc' => 'Avalue is assigned to a symbol, but the contents of the symbol are never accessed.'
    ),
    205 => array(
        'number' => 205,
        'category' => 'Warning',
        'msg' => 'redundant code: constant expression is zero',
        'desc' => 'Where a conditional expression was expected, a constant expression with the value zero was found, e.g. "while (0)" or "if (0)".'
    ),
    206 => array(
        'number' => 206,
        'category' => 'Warning',
        'msg' => 'redundant test: constant expression is non-zero',
        'desc' => 'Where a conditional expression was expected, a constant expression with a non-zero value was found, e.g. if (1). The test is redundant, because the conditional code is always executed.'
    ),
    207 => array(
        'number' => 207,
        'category' => 'Warning',
        'msg' => 'unknown "#pragma"',
        'desc' => 'The compiler ignores the pragma. The #pragma directives may change between compilers of di erent vendors and between di erent versions of a compiler of the same version.'
    ),
    208 => array(
        'number' => 208,
        'category' => 'Warning',
        'msg' => 'function with tag result used before definition, forcing',
        'desc' => 'reparse'
    ),
    209 => array(
        'number' => 209,
        'category' => 'Warning',
        'msg' => 'function should return a value',
        'desc' => 'The function does not have a return statement, or it does not have an expression behind the return statement, but the function’s result is used in a expression.'
    ),
    210 => array(
        'number' => 210,
        'category' => 'Warning',
        'msg' => 'possible use of symbol before initialization: identifier',
        'desc' => 'A local (uninitialized) variable appears to be read before a value is assigned to it. The compiler cannot determine the actual order of reading from and storing into variables and bases its assumption of the execution order on the physical appearance order of statements an expressions in the source file.'
    ),
    211 => array(
        'number' => 211,
        'category' => 'Warning',
        'msg' => 'possibly unintended assignment',
        'desc' => 'Where a conditional expression was expected, the assignment operator (=) was found instead of the equality operator (==). As this is a frequent mistake, the compiler issues a warning. To avoid this message, put parentheses around the expression, e.g. if ( (a=2) ).'
    ),
    212 => array(
        'number' => 212,
        'category' => 'Warning',
        'msg' => 'possibly unintended bitwise operation',
        'desc' => 'Where a conditional expression was expected, a bitwise operator (&amp; or |) was found instead of a Boolean operator (&amp;&amp; or ||). In situations where a bitwise operation seems unlikely, the compiler issues this warning. To avoid this message, put parentheses around the expression.'
    ),
    213 => array(
        'number' => 213,
        'category' => 'Warning',
        'msg' => 'tag mismatch',
        'desc' => 'A tag mismatch occurs when:'
    ),
    214 => array(
        'number' => 214,
        'category' => 'Warning',
        'msg' => 'possibly a "const" array argument was intended: identifier',
        'desc' => 'Arrays are always passed by reference. If a function does not modify the array argument, however, the compiler can sometimes generate more compact and quicker code if the array argument is specifically marked as "const".'
    ),
    215 => array(
        'number' => 215,
        'category' => 'Warning',
        'msg' => 'expression has no e ect',
        'desc' => 'The result of the expression is apparently not stored in a variable or used in a test. The expression or expression statement is therefore redundant.'
    ),
    216 => array(
        'number' => 216,
        'category' => 'Warning',
        'msg' => 'nested comment',
        'desc' => 'pawn does not support nested comments.'
    ),
    217 => array(
        'number' => 217,
        'category' => 'Warning',
        'msg' => 'loose indentation',
        'desc' => 'Statements at the same logical level do not start in the same column; that is, the indents of the statements are di erent. Although pawn is a free format language, loose indentation frequently hides a logical error in the control fiow.'
    ),
    218 => array(
        'number' => 218,
        'category' => 'Warning',
        'msg' => 'old style prototypes used with optional semicolon',
        'desc' => 'When using "optional semicolons", it is preferred to explicitly declare forward functions with the forward keyword than using terminating semicolon.'
    ),
    219 => array(
        'number' => 219,
        'category' => 'Warning',
        'msg' => 'local variable identifier shadows a symbol at a preceding level',
        'desc' => 'A local variable has the same name as a global variable, a function, a function argument, or a local variable at a lower precedence level. This is called "shadowing", as the new local variable makes the previously defined function or variable inaccessible.'
    ),
    220 => array(
        'number' => 220,
        'category' => 'Warning',
        'msg' => 'expression with tag override must appear between paren- theses',
        'desc' => 'In a case statement and in expressions in the conditional operator (" fi : "), any expression that has a tag override should be en- closed between parentheses, to avoid the colon to be misinterpreted as a separator of the case statement or as part of the conditional operator.'
    ),
    221 => array(
        'number' => 221,
        'category' => 'Warning',
        'msg' => 'label name identifier shadows tag name',
        'desc' => 'Acode label (for the goto instruction) has the same name as a previously defined tag. This may indicate a faultily applied tag override; a typical case is an attempt to apply a tag override on the variable on the left of the = operator in an assignment statement.'
    ),
    222 => array(
        'number' => 222,
        'category' => 'Warning',
        'msg' => 'number of digits exceeds rational number precision',
        'desc' => 'Aliteral rational number has more decimals in its fractional part than the precision of a rational number supports. The remaining decimals are ignored.'
    ),
    223 => array(
        'number' => 223,
        'category' => 'Warning',
        'msg' => 'redundant "sizeof": argument size is always 1 (symbol name)',
        'desc' => 'Afunction argument has a as its default value the size of another argument of the same function. The "sizeof" default value is only useful when the size of the referred argument is unspecified in'
    ),
    224 => array(
        'number' => 224,
        'category' => 'Warning',
        'msg' => 'indeterminate array size in "sizeof" expression (symbol name)',
        'desc' => 'The operand of the sizeof operator is an array with an unspecified size. That is, the size of the variable cannot be determined'
    ),
    225 => array(
        'number' => 225,
        'category' => 'Warning',
        'msg' => 'unreachable code',
        'desc' => 'The indicated code will never run, because an instruction before (above) it causes a jump out of the function, out of a loop or elsewhere. Look for return, break, continue and goto instructions above the indicated line. Unreachable code can also be caused by an endless loop above the indicated line.'
    ),
    226 => array(
        'number' => 226,
        'category' => 'Warning',
        'msg' => 'a variable is assigned to itself (symbol name)',
        'desc' => 'There is a statement like "x = x" in the code. The parser checks for self assignments after performing any text and constant substitutions, so the left and right sides of an assignment may appear to be di erent at first sight. For example, if the symbol "TWO" is a constant with the value 2, then "var[TWO] = var[2]" is also a self-assignment.'
    ),
    227 => array(
        'number' => 227,
        'category' => 'Warning',
        'msg' => 'more initiallers than array fields',
        'desc' => 'An array that is declared with sumbolic subscripts contains more values/fields as initiallers than there are (symbolic) subscripts.'
    ),
    228 => array(
        'number' => 228,
        'category' => 'Warning',
        'msg' => 'length of initialler exceeds size of the array field',
        'desc' => 'The initialler for an array element contains more values than the size of that field allows. This occurs in an array that has symbolic subscripts, and where a particular subscript is declared with a size.'
    ),
    229 => array(
        'number' => 229,
        'category' => 'Warning',
        'msg' => 'mixing packed and unpacked array indexing or array assignment',
        'desc' => 'An array is declared as packed (with { and } braces) but indexed as unpacked (with [ and ]), or vice versa. Or one array is assigned to another and one is packed while the other is unpacked.'
    ),
    230 => array(
        'number' => 230,
        'category' => 'Warning',
        'msg' => 'no implementation for state name in function name, no fall-back',
        'desc' => 'A function is lacking an implementation for the indicated state. The compiler cannot (statically) check whether the function will ever be called in that state, and therefore it issues this warning. When the function would be called for the state for which no implementation exists, the abstract machine aborts with a run time error.'
    ),
    231 => array(
        'number' => 231,
        'category' => 'Warning',
        'msg' => 'state specification on forward declaration is ignored',
        'desc' => 'A state specification is redundant on forward declarations. The function signature must be equal for all states. Only the imple- mentations of the function are state-specific.'
    ),
    232 => array(
        'number' => 232,
        'category' => 'Warning',
        'msg' => 'native function lacks a predefined index (symbol name)',
        'desc' => 'The pawn compiler was configured with predefined indices for native functions, but it encountered a declaration for which it does not have an index declaration. This usually means that the script uses include files that arenot appropriate for the active configuration.'
    ),
    233 => array(
        'number' => 233,
        'category' => 'Warning',
        'msg' => 'state variable name shadows a global variable',
        'desc' => 'The state variable has the same name as a global variable (without state specifiers). This means that the global variable is inaccessible for a function with one of the same states as those of the variable.'
    ),
    234 => array(
        'number' => 234,
        'category' => 'Warning',
        'msg' => 'function is deprecated (symbol name)',
        'desc' => 'The script uses a function which as marked as "deprecated". The host application can mark (native) functions as deprecated when better alternatives for the function are available or if the function may not be supported in future versions of the host application.'
    ),
    235 => array(
        'number' => 235,
        'category' => 'Warning',
        'msg' => 'public function lacks forward declaration (symbol name)',
        'desc' => 'The script defines a public function, but no forward declaration of this function is present. Possibly the function name was written incorrectly. The requirement for forward declarations of public functions guards against a common error.'
    ),
    236 => array(
        'number' => 236,
        'category' => 'Warning',
        'msg' => 'unknown parameter in substitution (incorrect #define pattern)',
        'desc' => 'A #define pattern contains a parameter in the replacement (e.g.'//todo
    ),
    237 => array(
        'number' => 237,
        'category' => 'Warning',
        'msg' => 'recursive function name',
        'desc' => 'The specified function calls itself recursively. Although this is valid in pawn, a self-call is often an error. Note that this warning is only generated when the pawn parser/compiler is set to "verbose" mode.'
    ),
    238 => array(
        'number' => 238,
        'category' => 'Warning',
        'msg' => 'mixing string formats in concatenation',
        'desc' => 'In concatenating literals strings, strings with di erent formats (such as packed versus unpacked, and "plain" versus standard strings) were combined. This is usually an error. The parser uses the format of the first (left-most) string in the concatenation for the result.'
    )
);